目录

XML文件解析

XML-DTD(document type defintion文档类型定义)

DTD元素定义:

元素类型又具体分为:

DTD修饰符:

DTD属性:

dtd使用步骤:

XML解析:

使用DOM解析XML的步骤:

使用DOM4J解析XML的步骤:



XML文件解析

什么是xml? 可扩展标记语言

html超文本标记语言 html遵循了xml的规范

xml区分大小写,对特殊符号有严格规范

xml声明:<?xml version="1.0" encoding="UTF-8"?> (定义xml版本和编码格式)

xml文档结构中包含哪些部分:声明,定义区,主体区

xml优势:基于文本格式,具有简单性,可扩展性,交互性和灵活性

xml作用:

        1.数据持久化存储

        2.数据配置(web.xml struts.xml hibernate.cfg.xml)

        3.数据交换

注:不要在xml文件中存储海量数据

良好的xml格式文档需满足:

  1. 必须有xml声明语句
  2. 必须有且仅有一个根元素
  3. 标签大小写敏感
  4. 属性值用双引号
  5. 标签成对
  6. 元素正确嵌套

XML-DTD(document type defintion文档类型定义)

对于xml文件dtd不是required

dtd用于约束xml应该有哪些标签哪些标签属性

DTD元素定义:

<!EMELENT NAME CONTENT>  ELEMENT关键字   NAME元素名称  CONTENT元素类型

元素类型又具体分为:

元素常量:#PCDATA,EMPTY,ANY,纯元素类型,混合类型

        1.#PCDATA---可包含任何字符数据,但不能在其中包含子元素。

                <!ELEMENT title (#PCDATA)

        2.EMPTY---该元素不能包含子元素和文本,但可以有属性(空元素)

        3.ANY---该元素可以包含任何在DTD中定义的元素内容

        4.纯元素类型---只包含子元素,并且这些子元素外没有文本。

                <!ELEMENT poems (poem*)

        5.混合类型---包含子元素和文本数据的混合体

DTD修饰符:

DTD属性:

基本语法
<!ATTLIST 元素名称

属性名称    类型    属性特性

属性名称    类型    属性特性…...

>

解释:

ATTLIST:属性列表,(必须大写)。

元素名称:对应的元素的名称。

属性:属性能够有多个,其格式是名称 类型 属性特性

类型:

PS:常用的有CDATA(字符型),枚举(枚举格式是(值1|值2|值3...)),ID(ID不能重复,不能以数字开头),IDREF(引用另一个ID值),IDREFS(可以引用多个ID值,以空格隔开)
 

属性特性:

dtd使用步骤:

1.Users.xml

<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE Users SYSTEM "Users.dtd">
<Users>
    <User>
        <id>1</id>
        <name>jialin</name>
        <age>18</age>
        <sex>0</sex>
    </User>
    <User>
        <id>2</id>
        <name>xuming</name>
        <age>16</age>
        <sex>1</sex>
    </User>
</Users>

2.Users.dtd

<!ELEMENT Users (User+) >
<!ELEMENT User (id,name,age,sex) >
<!ELEMENT id (#PCDATA)>
<!ELEMENT name (#PCDATA)>
<!ELEMENT age (#PCDATA)>
<!ELEMENT sex (#PCDATA)>


<!ELEMENT yxm (mjl+)
<!ELEMENT mjl (#PCDATA)>
<!ATTLIST mjl
        id CDATA #REQUIRED
        age CDATA #REQUIRED
        sex CDATA #REQUIRED>

XML解析:

回顾JAVASCRIPT组成:

        ECMAScript(js基础语法,var if for array parseInt() isNaN() function()) 

        DOM (document object model)

        BOM (window history location document Screen Navigator)

四种常见的xml解析技术

  1. DOM 
    1.  基于xml树结构
    2.  比较耗资源
    3.  适用于多次访问xml
  2. SAX 
    1.  基于事件
    2.  消耗资源小
    3.  适用于数据量较大的xml
  3. JDOM
    1.  比dom更快
    2.  jdom仅使用具体类而不使用接口
  4. DOM4J
    1.  非常优秀的Java XML API
    2.  性能优异,功能强大
    3.  开放源代码

使用DOM解析XML主要使用的对象

Document 代表整个xml文档 

使用DOM解析XML的步骤:

        String xmlPath = "Users.xml";
        try{
            //1.创建解析器工厂对象
            DocumentBuilderFactory factory = DocumentBuilderFactory.newInstance();
            //2.由解析器工厂对象创建解析器对象
            DocumentBuilder builder = factory.newDocumentBuilder();
            //3.将xml文件构建为倒状树形结构
            Document doc = builder.parse(xmlPath);
            //4.获取xml文件的根节点
            NodeList users = doc.getElementsByTagName(new File(xmlPath).getName().substring(0,new File(xmlPath).getName().lastIndexOf(".")));
            Node usersNode = users.item(0);//获取根节点
            System.out.println(usersNode.getNodeName());
            NodeList childNodes = usersNode.getChildNodes();//获取根节点的子节点
            for (int i = 0; i < childNodes.getLength(); i++) {
                if (childNodes.item(i).getNodeType()!=3){//元素节点1 属性节点2 文本节点3
                    NodeList secondChildNodes = childNodes.item(i).getChildNodes();//获取第i个User节点下所有子节点
                    for (int j = 0; j < secondChildNodes.getLength(); j++) {
                        if (secondChildNodes.item(j).getNodeType()!=3){
                            System.out.println(secondChildNodes.item(j).getNodeName()+":"+secondChildNodes.item(j).getTextContent());//读取根节点子元素的元素名称
                        }
                    }
                }
            }
        }catch(Exception ex){
            ex.printStackTrace();
        }

使用DOM存储元素

        String xmlPath = "Users.xml";
        try {
            //1.创建解析器工厂对象
            DocumentBuilderFactory factory = DocumentBuilderFactory.newInstance();
            //2.由解析器工厂对象创建解析器对象
            DocumentBuilder builder = factory.newDocumentBuilder();
            //3.将xml文件构建为倒状树形结构
            Document doc = builder.parse(xmlPath);
            //4.获取xml文件的根节点
            NodeList users = doc.getElementsByTagName(new File(xmlPath).getName().substring(0, new File(xmlPath).getName().lastIndexOf(".")));
            Node usersNode = users.item(0);//获取根节点
            //5.创建节点
            Element st = doc.createElement("User");
            Element id = doc.createElement("id");
            id.setTextContent("3");
            Element name = doc.createElement("name");
            name.setTextContent("ye");
            Element age = doc.createElement("age");
            age.setTextContent("18");
            Element sex = doc.createElement("sex");
            sex.setTextContent("0");
            //6.追加新创建的节点
            st.appendChild(id);
            st.appendChild(name);
            st.appendChild(age);
            st.appendChild(sex);
            usersNode.appendChild(st);
            //7.保存
            //7.1 创建传输工厂对象
            TransformerFactory factory1 = TransformerFactory.newInstance();
            //7.2 创建传输对象
            Transformer transformer = factory1.newTransformer();
            //7.3 DOM源
            DOMSource ds = new DOMSource(doc);
            //7.4 传输
            transformer.setOutputProperty(OutputKeys.ENCODING,"utf-8");
            StreamResult sr = new StreamResult(new FileOutputStream(xmlPath));
            transformer.transform(ds,sr);
        }catch (Exception e){
            e.printStackTrace();
        }

使用DOM删除元素

        String xmlPath = "Users.xml";
        try {
            //1.创建解析器工厂对象
            DocumentBuilderFactory factory = DocumentBuilderFactory.newInstance();
            //2.由解析器工厂对象创建解析器对象
            DocumentBuilder builder = factory.newDocumentBuilder();
            //3.将xml文件构建为倒状树形结构
            Document doc = builder.parse(xmlPath);
            //4.获取xml文件的根节点
            NodeList users = doc.getElementsByTagName(new File(xmlPath).getName().substring(0, new File(xmlPath).getName().lastIndexOf(".")));
            Node usersNode = users.item(0);//获取根节点
            NodeList childNodes = usersNode.getChildNodes();
            for (int i = 0; i < childNodes.getLength(); i++) {
                if (childNodes.item(i).getNodeType() == 1){
                    NodeList childNodes1 = childNodes.item(i).getChildNodes();
                    for (int j = 0; j < childNodes1.getLength(); j++) {
                        if (childNodes1.item(j).getNodeType() == 1) {
                            if (childNodes1.item(j).getNodeName().equals("id")){
                                if (childNodes1.item(j).getTextContent().equals("3")){
                                    usersNode.removeChild(childNodes.item(i));
                                    break;
                                }
                            }
                        }
                    }
                }
            }
            //5.保存
            //5.1 创建传输工厂对象
            TransformerFactory factory1 = TransformerFactory.newInstance();
            //5.2 创建传输对象
            Transformer transformer = factory1.newTransformer();
            //5.3 DOM源
            DOMSource ds = new DOMSource(doc);
            //5.4 传输
            transformer.setOutputProperty(OutputKeys.ENCODING,"utf-8");
            StreamResult sr = new StreamResult(new FileOutputStream(xmlPath));
            transformer.transform(ds,sr);
        }catch (Exception e){
            e.printStackTrace();
        }

使用DOM修改元素

        String xmlPath = "Users.xml";
        try {
            //1.创建解析器工厂对象
            DocumentBuilderFactory factory = DocumentBuilderFactory.newInstance();
            //2.由解析器工厂对象创建解析器对象
            DocumentBuilder builder = factory.newDocumentBuilder();
            //3.将xml文件构建为倒状树形结构
            Document doc = builder.parse(xmlPath);
            //4.获取xml文件的根节点
            NodeList users = doc.getElementsByTagName(new File(xmlPath).getName().substring(0, new File(xmlPath).getName().lastIndexOf(".")));
            Node usersNode = users.item(0);//获取根节点
            NodeList childNodes= usersNode.getChildNodes();
            for (int i = 0; i < childNodes.getLength(); i++) {
                if (childNodes.item(i).getNodeType() == 1) {//判断节点为元素节点
                    NodeList childNodes1 = childNodes.item(i).getChildNodes();//获取子节点
                    for (int j = 0; j < childNodes1.getLength(); j++) {
                        if (childNodes1.item(j).getNodeType() == 1) {
                            if (childNodes1.item(j).getNodeName().equals("name")){//获取子节点名称为name的节点
                                if (childNodes1.item(j).getTextContent().equals("xuming")){//判断节点内容是否为xuming
                                    childNodes1.item(j).setTextContent("yxuming");//修改该节点内容
                                    break;
                                }
                            }
                        }
                    }
                }
            }
            //5.保存
            //5.1 创建传输工厂对象
            TransformerFactory factory1 = TransformerFactory.newInstance();
            //5.2 创建传输对象
            Transformer transformer = factory1.newTransformer();
            //5.3 DOM源
            DOMSource ds = new DOMSource(doc);
            //5.4 传输
            transformer.setOutputProperty(OutputKeys.ENCODING,"utf-8");
            StreamResult sr = new StreamResult(new FileOutputStream(xmlPath));
            transformer.transform(ds,sr);
        }catch (Exception e){
            e.printStackTrace();
        }

使用DOM4J解析XML的步骤:

1.引入DOM4J的jar包

<dependency>
      <groupId>dom4j</groupId>
      <artifactId>dom4j</artifactId>
      <version>1.6.1</version>
</dependency>

2.编写以下代码

        try {
            SAXReader sax = new SAXReader();
            Document read = sax.read(new File("Users.xml"));
            Element rootElement = read.getRootElement();//获取根节点
            List list = rootElement.elements();//获取子元素
            for (Object o : list) {
                Element user = ((Element)o);//获取User元素
                System.out.println(user.getName());
                List<Element> secondElement = user.elements();//获取User节点下所有子节点
                for (Element element : secondElement) {
                    System.out.println(element.getName()+":"+element.getStringValue());
                }
            }
        } catch (DocumentException e) {
            e.printStackTrace();
        }

与以上效果相同(使用反射机制动态返回)

    public static <T> List<T> parse(String xmlPath,Class<T> tClass){
        List<T> resultList = new ArrayList<>();
        try {
            SAXReader sax = new SAXReader();
            Document read = sax.read(new File(xmlPath));
            Element rootElement = read.getRootElement();//获取根节点
            List<Element> list = rootElement.elements();//获取子元素
            for (Element t : list) {
                Object instance = tClass.newInstance();
                List<Element> secondElement = t.elements();
                for (int i = 0; i < secondElement.size(); i++) {
                    Field field = tClass.getDeclaredField(secondElement.get(i).getName());//获取节点名与属性名相同的属性
                    field.setAccessible(true);//设置私有属性允许访问
                    TypeConvert(field,instance,secondElement.get(i));//类型转换赋值
                }
                resultList.add((T) instance);
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
        return resultList;
    }
    /**
    ** 类型转换
    */
    private static void TypeConvert(Field field,Object instance,Element element) throws Exception{
        if (field.getType()==Integer.class){
            field.set(instance,Integer.parseInt(element.getStringValue()));
        }
        if (field.getType()==String.class){
            field.set(instance,element.getStringValue());
        }
        if (field.getType()==double.class){
            field.set(instance,Double.parseDouble(element.getStringValue()));
        }
        if (field.getType()==float.class){
            field.set(instance,Float.parseFloat(element.getStringValue()));
        }
        if (field.getType()==BigDecimal.class){
            field.set(instance,new BigDecimal(element.getStringValue()));
        }
        if (field.getType()== Date.class){
            field.set(instance,Date.parse(element.getStringValue()));
        }
        if (field.getType()== boolean.class){
            field.set(instance,Boolean.valueOf(element.getStringValue()));
        }
    }

使用DOM4J添加元素

        try {
            SAXReader sax = new SAXReader();
            Document read = sax.read(new File("Users.xml"));
            Element rootElement = read.getRootElement();//获取根节点
            //获取子节点赋值
            Element user = rootElement.addElement("User");
            Element id = user.addElement("id");
            id.setText("4");
            Element name = user.addElement("name");
            name.setText("harden");
            Element age = user.addElement("age");
            age.setText("25");
            Element sex = user.addElement("sex");
            sex.setText("1");

            //保存
            OutputFormat opf = OutputFormat.createCompactFormat();
            opf.setEncoding("utf-8");
            XMLWriter xmlWriter = new XMLWriter(new FileWriter("Users.xml"), opf);
            xmlWriter.write(read);
            xmlWriter.close();
        } catch (Exception e) {
            e.printStackTrace();
        }

使用DOM4J删除元素

        try {
            SAXReader sax = new SAXReader();
            Document read = sax.read(new File("Users.xml"));
            Element rootElement = read.getRootElement();//获取根节点
            //获取子节点
            List<Element> elements = rootElement.elements();
            for (Element element : elements) {
                List<Element> secondElement = element.elements();
                for (Element second : secondElement) {
                    if (second.getName().equals("id") && second.getStringValue().equals("4")){
                        rootElement.remove(element);
                        break;
                    }
                }
            }
            //保存
            OutputFormat opf = OutputFormat.createCompactFormat();
            opf.setEncoding("utf-8");
            XMLWriter xmlWriter = new XMLWriter(new FileWriter("Users.xml"), opf);
            xmlWriter.write(read);
            xmlWriter.close();
        } catch (Exception e) {
            e.printStackTrace();
        }