xml文件的介绍与使用

最新推荐文章于 2025-05-15 15:15:03 发布

猿小许

最新推荐文章于 2025-05-15 15:15:03 发布

阅读量2.7k

点赞数 2

分类专栏：框架

本文链接：https://blog.youkuaiyun.com/weixin_44205087/article/details/117918068

版权

框架专栏收录该内容

5 篇文章

订阅专栏

本文详细介绍了XML的基本概念，包括文档结构、命名空间、编写规范等，并重点讲解了DOM解析XML的过程，包括DOM的树形结构、解析步骤以及使用DOM4j进行XML操作的方法。此外，还探讨了DOM4j的主要接口和解析XML的步骤，展示了如何在Java中使用DOM4j进行XML的增删改查操作。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

一、xml简介

1.1 xml

可扩展标记语言，是一种简单的存储语言，使用一系列简单的标记来描述数据

特点：

（1）xml与操作系统，编程语言的开发平台无关

（2）可以实现不同系统间的数据交换作用：

（1）实现数据交换

（2）配置应用程序和网站

（3）Ajax基石

1.2 xml文档结构

1.2.1xml声明：

<?xml version="1.0" encoding="utf-8"?> 表示xml声明，用以标明这是一个xml文件，一般xml文件的第一行声明的几个组成部分： Version: 版本号 Encoding: 文档的字符编码格式

1.2.2 xml根标签

每个XML文件有且必须只有一个根元素根元素的开始标签：放在最前面根元素的结束标签：放在最后面标签内容在开始标签和结束标签之间

1.2.3 xml标签

XML文档内容由一系列标签元素组成。

1.2.4 语法

<?xml version="1.0" encoding="UTF-8"?> <元素名属性名=“属性值”>元素内容</元素名>

1.2.5 标签编写注意事项

所有XML元素都必须有结束标签 XML标签对大小写敏感 XML必须正确的嵌套同级标签以缩进对齐元素名称可以包含字母、数字或其他的字符元素名称不能以数字或者标点符号开始元素名称中不能含空格 4.XML中的转义符列表

1.3 编写xml文档

将如下衣服的尺码信息，使用XML文件保存衣服型号对应身高 S 身高<165 M 165<身高<170 L 170<身高<175 XL 175<身高<180 XXL 180<身高<185

<?xml version="1.0" encoding="UTF-8"?>
 <clothesSize>   
  <size type="height&lt;165">S</size>
   <size type="165&lt;height&lt;170">M</size>  
    <size type="170&lt;height&lt;175">L</size>    
    <size type="175&lt;height&lt;180">XL</size>   
     <size type="180&lt;height&lt;185">XXL</size> 
     </clothesSize>

1.4.XML命名空间

1.4.1 作用

解决在复杂、大型XML文件中，出现名称相同，但是含义不同的元素在一个文档中可以定义多个命名空间

<?xml version="1.0" encoding="UTF-8"?> 
<cameras xmlns:canon="http://www.canon"   
 xmlns:nikon="http://www.nikon.com">   
 <canon:camera prodID="P663" name="Camera傻瓜相机"/>  
  <nikon:camera prodID=“K29B3” name=“Camera超级35毫米相机"/> 
</cameras>

1.4.2 默认命名空间

没有指定前缀的命名空间会作为页面中元素的默认命名空间除非在标签中使用其它命名空间的前缀，否则解析器都会认为元素是在默认命名空间下存在一个文档中只能有一个默认的命名空间

<?xml version="1.0" encoding="UTF-8"?> 
<cameras xmlns="http://www.canon"    
xmlns:nikon="http://www.nikon.com">   
 <camera prodID="P663" name="Camera傻瓜相机"/>   
 <nikon:camera prodID=“K29B3” name=“Camera超级35毫米相机"/>
 </cameras>

1.4.3 属性命名空间

除非带有前缀，否则属性属于所属的元素的命名空间

<?xml version="1.0" encoding="UTF-8"?> 
<batchCompany xmlns="http://www.Aptech_edu.ac"   
 xmlns:tea="http://www.tea.org">    <batch-list>  
      <batch type="thirdbatch">第三批次</batch>        
<batch tea:type="thirdbatch">第三批茶</batch>        
<batch>午班批次</batch>   
 </batch-list>
 </batchCompany>

二、解析xml

2.1常用xml解析技术

DOM 基于xml文档树结构的解析适用于多次访问的xml文档特点：比较消耗资源 SAX 基于事件的解析适用于大数据的xml文档特点：占用资源少，内存消耗小 JODM jDOM的目的是直接为java编程服务，利用纯java技术对xml文档实现解析，生成，序列化及其他操作把SAX和DOM的功能有效结合起来，简化与xml交互并且比使用DOM更快 DOM4j 非常优秀的java XML API 性能优异，功能强大开放源代码

2.2 DOM

2.2.1 .简介

文档对象模型(Document Object Model) DOM把XML文档映射成一个倒挂的树

2.3 DOM解析xml步骤

1>创建解析器工厂对象

 DocumentBuilderFactory buildFactory=DocumentBuilderFactory.newInstance(); 

2>解析器工厂对象创建解析器对象

 DocumentBuilder builder = buildFactory.newDocumentBuilder(); 

3>解析器对象指定XML文件创建Document对象 

Document document = builder.parse("收藏信息.xml"); 

4>以Document对象为起点操作DOM树 NodeList brandNodes = document.getElementsByTagName("Brand");

2.4.使用DOM操作XML

需求显示“收藏信息.xml”文件中收藏的学生信息

<?xml version="1.0"?>
<exam>
    
    <student examid="444" idcard="333">
        <name>李四</name>
        <locality>洛阳</locality>
        <score>97.0</score>
    </student>

    <student examid="222222" idcard="111111">
    <name>张三</name>
    <locality>洛阳</locality>
    <score>99.0</score>
    </student>

    <student examid="123456" idcard="123456">
    <name>张三</name>
    <locality>洛阳</locality>
    <score>87.0</score>
    </student>
</exam>
操作xml数据
public class XMLutils {
    private static Document document;
    private static  final String fileName="resources/student.xml";
    /*
    * 存储所有的读取到的信息
    * */
    private static Map<String,Student> maps=new HashMap<>();
    static {
        //初始化信息
        DocumentBuilderFactory factory=DocumentBuilderFactory.newInstance();
        try {
            DocumentBuilder builder=factory.newDocumentBuilder();
            document=builder.parse(new File(fileName));
            NodeList nodeList=document.getElementsByTagName("student");
            for (int i = 0; i <nodeList.getLength() ; i++) {
                Student student=new Student();
                Element stuE= (Element) nodeList.item(i);
                String idcard=stuE.getAttribute("idcard");
                String examid=stuE.getAttribute("examid");
                String name =stuE.getElementsByTagName("name").item(0).getFirstChild().getNodeValue();
                String locality =stuE.getElementsByTagName("locality").item(0).getFirstChild().getNodeValue();
                Double score = Double.valueOf(stuE.getElementsByTagName("score").item(0).getFirstChild().getNodeValue());
                student.setExamId(examid);
                student.setIdCard(idcard);
                student.setName(name);
                student.setLocality(locality);
                student.setScore(score);
                maps.put(student.getExamId(),student);
            }
        } catch (ParserConfigurationException e) {
            e.printStackTrace();
        } catch (SAXException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
    /*
    * 根据学号查询信息
    * */
    public  static  Student  search(String examId){
        return maps.get(examId);
    }
    /*
    * 根据学号修改学生信息*/
    public boolean update(String examId,Student student){
        NodeList nodeList= document.getElementsByTagName("student");
        for (int i = 0; i <nodeList.getLength() ; i++) {
            Element e= (Element) nodeList.item(i);
            if(e.getAttribute("examid").equals(examId)){
                try {
                    save();
                    maps.remove(examId);
                    return  true;
                } catch (IOException ioException) {
                    ioException.printStackTrace();
                }
            }
        }
        return  false;
    }
    /*
    *增加学生信息
    *  */
    public static boolean add(Student student)  {
        Element stuE=document.createElement("student");
        stuE.setAttribute("idcard",student.getIdCard());
        stuE.setAttribute("examid",student.getExamId());
        Element nameE=document.createElement("name");
        nameE.setTextContent(student.getName());
        Element locality=document.createElement("locality");
        locality.setTextContent(student.getLocality());
        Element scoreE=document.createElement("score");
        scoreE.setTextContent(String.valueOf(student.getScore()));
        //追加节点
        stuE.appendChild(nameE);
        stuE.appendChild(locality);
        stuE.appendChild(scoreE);
        //将学生节点追加到根节点
        document.getFirstChild().appendChild(stuE);
        try {
            save();
            maps.put(student.getExamId(),student);
            return true;
        } catch (IOException e) {
            e.printStackTrace();
        }
        return  false;
    }
    /*
    * 删除学生信息
    * */
    public static boolean del(String examId){
        NodeList nodeList= document.getElementsByTagName("student");
        for (int i = 0; i <nodeList.getLength() ; i++) {
           Element e= (Element) nodeList.item(i);
            if(e.getAttribute("examid").equals(examId)){
                e.getParentNode().removeChild(e);
                try {
                    save();
                    maps.remove(examId);
                    return  true;
                } catch (IOException ioException) {
                    ioException.printStackTrace();
                }
            }
        }
        return  false;
    }

    public  static boolean isExist(String examId){
        boolean b = maps.containsKey(examId);
        return b;
    }

    public static void save() throws IOException {
        XMLSerializer xmlSerializer=new XMLSerializer(new FileWriter(new File(fileName)),null);
        xmlSerializer.serialize(document);
    }
    public static void searchScore(String examid){
        Student student = maps.get(examid);
        System.out.println(student.toString());

    }

}

2.4 DOM4j

2.4.1.简介

是一个开源易用的库，应用于java平台，采用了java集合框架并完全支持DOM、SAX和JAXP。使用非常简单，只要了解了基本的XML-DOM模型，就能使用，DOM4j最大的特色就是使用了大量接口。

2.4.2主要接口

Document：定义XML文档 Element：定义XML元素 Text：定义XML文本节点 Attribute：定义了XML 的属性

2.4.3DOM4j解析XML步骤

导入DOM4J的jar包创建SAXReader对象 SAXReader reader=new SAXReader(); 使用SAXReader对象的 read() 方法指定要解析的XML文件，将XML文件转换成 Document 对象 Document doc = reader.read(new File("收藏信息.xml")); 获取节点属性或文本的值

2.5 使用DOM4j

xml文件
<?xml version="1.0" encoding="utf-8"?>

<honeInfo>    
  <brand name="华为" id="1">        
    <type name="U86" color="blue"/>         
    <type name="HW123" color="blue"/>         
    <type name="HW321" color="blue"/>    
  </brand>     
  <brand name="苹果" id="2">        
    <type name="iPhone4" color="blue"/>    
  </brand> 
</honeInfo>

public class Dom4jParse {
    private  static final String filename="resources/phone.xml";
    private  static final String filename1="resources/phone2.xml";
    private  static   Document document;
    private  static   SAXReader saxReader;
    private  static  Element rootElement;
    public static void main(String[] args) throws DocumentException, IOException {

      // add();
        del();
        save();
        parse();
    }
static{
    saxReader=new SAXReader();
    try {
        document=saxReader.read(new File(filename));
        //获取到根元素节点
        rootElement = document.getRootElement();
    } catch (DocumentException e) {
        e.printStackTrace();
    }
}
    public static  void parse() throws DocumentException {

        //获取所有的brand元素节点，并返回一个list集合
        List<Element> brandroot = rootElement.elements("brand");
        brandroot.forEach(e->{
            Attribute name = e.attribute("name");
            String value=name.getValue();
            System.out.println(value);

            //获取单个子节点元素，无论有多个子节点，获取的都是第一个子节点
           /* Element type = e.element("type");
            System.out.println(type.attribute("name").getValue());*/
            //获取多个子节点，返回list集合
            List<Element> typelist= e.elements("type");
            typelist.forEach(te->{
                Attribute name1 = te.attribute(0);
                String value1 = name1.getValue();
                System.out.println(value1);

            });

        });
    }
    public  static  void save() throws IOException {

        OutputFormat format=OutputFormat.createPrettyPrint();
        format.setEncoding("utf-8");
        //创建一个XMLWriter对象
        XMLWriter xmlWriter=new XMLWriter(new FileOutputStream(new File(filename)),format);
        xmlWriter.write(document);
        xmlWriter.close();
    }

    //增加节点
    public static void add(){
         //创建品牌节点
        Element brandE = rootElement.addElement("brand");
        //设置属性
        brandE.addAttribute("name","三星");
        Element typeE1 = brandE.addElement("type");
        typeE1.addAttribute("name","Note4");
    }
    public static  void del(){
        /*//获取品牌节点集合
        List<Element> brandE = rootElement.elements("brand");
        brandE.forEach(be->{
            if(be.attribute("name").equals("三星")){
                List<Element>typeE = be.elements("type");
                typeE.forEach(te->{
                    if(te.attribute("name").equals("Note4")){
                       te.setText("Note10");
                       te.setName("Note10");
                       te.attribute(0).setValue("Note10");
                    }
                });
            }
        });*/
        List<Element> brandlist = rootElement.elements("brand");
        brandlist.forEach(bl->{
            if(bl.attributeValue("name").equals("华为")){
                ListIterator<Element> typelist = bl.elements("type").listIterator();
                int i=0;
                while(typelist.hasNext()){
                    Element next = typelist.next();
                    if(next.attributeValue("name").equals("Z8650")){
                        Attribute attribute = next.attribute("name");
                        attribute.setValue("U86");

                    }
                    i++;
                }



            }
            /*int i = bl.attributeCount();
            bl.attribute(0).setValue("wanger");
            System.out.println(i);*/

        });


    }
    public static  void update(){
        //如果没有选择指定标签，则选择第一个子标签
        Iterator<Element> elementIterator = rootElement.elementIterator();
        int count=0;
        while (elementIterator.hasNext()){
            Element e=elementIterator.next();
            e.addAttribute("id", String.valueOf(count++));
        }

    }
}