XML详解与应用-优快云博客

1. XML的简介

* XML   可扩展的标记语言。（和HTML非常类似的）
    * 可扩展的。
    * 自定义的标签。   

* XML传输数据，HTML是显示数据。

XML的版本：

     XML1.0（使用该版本）      XML1.1（不向下兼容）

做什么用？

* 描述有关系的数据

应用

* 作为配置文件。

* 可以在系统与系统之间进行数据的传输。
    * webserivice   soap    XML封装数据
    * json  和XML概念

XML的语法

* 文档声明（*****）
    * 写法：   <?xml version="1.0"  ?>
    * 文档声明必须出现在xml文件的第一行和第一列的位置。

    * 属性：
        * version="1.0"             XML的版本  （必须写）
        * encoding="UTF-8"          编码集     （可选的）
        * standalone="yes或者no"  代表xml的文件是否是独立的。（如果是no，不独立，可以引入外部的文件）（可选的）
            * 因为不写该属性，可以引入外部的文件。

    * 乱码会伴随你们一生？
        * 产生的原因：保存文件时和打开文件时采用的编码不一致。
        * 解决办法：保存文件可打开文件采用的编码一致就ok。（MyEclipse不会产生乱码问题）


* 元素（***）
    * 开始标签和结束标签。
        * 包含标签主体：   <abc>文本</abc>
        * 不包含标签主体：  <abc/>

    * 不能交叉嵌套    
    * 只能有一个根元素（必须有，并且只能有一个）

    * 命名规范：
        * 区分大小写                 错误的：<a></A> 代表两个标签
        * 不能以数字和-中划线开头      错误的：<1a>        <-a>
        * 不能以XML（Xml    XML  xml）开头 错误的：<xmlaa>
        * 不能包含空格和冒号。


* 属性（***）
    * 自定义：命名规范同上。
    * 在同一个元素上，不能有相同的属性。（*****）
    * 可以使用双引号或者单引号。


* 注释（*）
    * 和HTML的注释相同
    <!-- XML的注释 -->

    * 注释不能嵌套。

* 特殊字符
    * <     &lt;
    * >     &gt;
    * &     &amp;
    * "     &quot;
    * '     &apos;

* CDATA区
    * 把标签中的内容作为字符串。
    * 语法：
        <![CDATA[
            内容：当成字符串
        ]]>

* PI（处理指令）（忘了）
    * 替换HTML

XML的约束

* DTD
* schema

<myspring>
    <bean>hello.java</bean>
    <猫/>
</myspring>

* 格式良好的XML：遵循语法规范。  
* 有效的XML：有约束。

DTD的约束

* 快速入门
* 快速入门的步骤：
    * 需要出现哪些标签？
    * 在DTD的文件中编写元素
        <!ELEMENT 元素名称 元素类型>
    * 判断元素是否是复杂还是简单元素？
        * 如果是简单元素：(#PCDATA) 代表是字符串
        * 如果是复杂元素：(子节点)

    * 需要在book.xml引入DTD的文件
        * <!DOCTYPE 根节点 SYSTEM "DTD文件的地址">

* DTD与XML文档的关联方式
    * 可以在XML的文件中直接书写DTD的代码。（经常使用）
        <!DOCTYPE 根节点 [
            DTD的代码
        ]>

    * 引入本地的DTD文件（经常使用）
        <!DOCTYPE 根节点 SYSTEM "DTD文件的地址">

    * 引入网络上的DTD文件
        <!DOCTYPE 根节点 PUBLIC "DTD文件名称" "DTD文件的地址">


* 元素定义
    * 语法：<!ELEMENT 元素名称 元素类型>

        * (#PCDATA)     字符串
        * EMPTY         空
        * ANY           任意的
        * (子元素)

        * 子元素：
            * 子元素之间的关系
                * ,     子元素出现是有顺序的
                * |     子元素只能出现一个

            * 子元素出现的次数
                *   +       子元素出现1次或多次
                *   *       子元素出现0次或多次
                *   ?       子元素出现0次或1次

    <!ELEMENT MYFILE ((TITLE*, AUTHOR?, EMAIL)* | COMMENT)>     

        <MYFILE>
            <TITLE></TITLE>
            <AUTHOR></AUTHOR>
            <EMAIL></EMAIL>
            <TITLE></TITLE>
            <AUTHOR></AUTHOR>
            <EMAIL></EMAIL>
            <TITLE></TITLE>
            <AUTHOR></AUTHOR>
            <EMAIL></EMAIL>
        </MYFILE>



* 属性定义(AttributeList)
    * 写法：   <!ATTLIST 元素名称 
                    属性名称 属性类型 属性约束 
                    属性名称 属性类型 属性约束
                >
    * 属性类型
        * CDATA     字符串
        * 枚举（没有提供关键字）   (男人|女人)
        * ID    代表唯一的值，不能只写数字

    * 属性的约束
        * #REQUIRED     必须出现的
        * #IMPLIED      可选的
        * #FIXED        固定值 #FIXED "值"
        * 默认值（不用）


* 实体定义（用的不多）    
    * <!ENTITY 别名 "值" >
    * 需要在xml中引入别名，浏览器打开文件后，在引入的位置上显示值的。

解析XML

* 解析XML的方式有哪些呢？
    * 常用的有两种？DOM和SAX 
    * 区别：
        DOM解析XML
          * 在内存中形成树状结构
          * 缺点：如果文档过大，容易产生内存溢出的问题。  
          * 优点：方便做增删改的操作    

        SAX解析
          * 基于事件驱动，边读边解析
          * 优点：不会产生内存溢出问题。
          * 缺点：不能做增删改操作。（DOM4J在内存生成树状结构）

*，只能使用DOM方式，如果SAX，只能做查询。
* JDOM（不讲了）  
* JAXP              SUN提供的
    * 想做增删改 企业都在用。DOM4J提供的
    * 全部都可以做。
* DOM4J（*****）非常非常优秀的Java XML API，hibernate底层采用。

dom4j的解析HTML

这里写图片描述

导入包
- 官网
- https://dom4j.github.io/
- 创建xml
  - 创建web.xml文件:

<?xml version="1.0" encoding="UTF-8"?>
        <web-app xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns="http://java.sun.com/xml/ns/javaee" xsi:schemaLocation="http://java.sun.com/xml/ns/javaee http://java.sun.com/xml/ns/javaee/web-app_2_5.xsd" id="WebApp_ID" version="2.5">
            <servlet>
            <servlet-name>s1</servlet-name><servlet-class>com.huaxin.servlet.S1</servlet-class>
            </servlet>

          <servlet-mapping>
              <servlet-name>s1</servlet-name>
              <url-pattern>/*</url-pattern>
          </servlet-mapping>
        </web-app>

创建 dom4j 核心对象 :SAXReader
- reader = new SAXReader()
- read(…) 加载执行xml文档
读取xml,获取文档对象:
- document= reader.read(file);
- getRootElement() 获得根元素
获取根节点元素 :
- rootElement = document.getRootElement();
- getName() 获得当前元素的元素名
- getText() 获得当前元素的文本内容
- attributeValue(…) 获得指定属性名的属性值
- elements(…) 获得指定名称的所有子元素。可以不指定名称
- element(…) 获得指定名称第一个子元素。可以不指定名称
- elementText(…) 获得指定名称子元素的文本值
元素点获取子元素
List eles = root.elements();
元素获取自己属性值
String value = ele.attributeValue(“”属性名);
元素获取子内容
String txt = ele.elementText(“标签名”);

@Test
        public void test1() throws DocumentException {
            /** 第一步： 核心对象 **/
            SAXReader saxReader = new SAXReader();
            /** 第二步： 读取配置文件,变成document树 **/
            Document document = saxReader.read("./src/web.xml");
            /** 第三步： 根节点 **/
            Element rootEle = document.getRootElement();
            List<Element> elements2 = rootEle.elements("servlet-name");
            System.out.println(elements2.size()); // 0 不能拿到孙子

            System.out.println(
                    "根节点名" + rootEle.getName() + "根节点文本(空行) " + rootEle.getText());
            System.out.println("根节点所有属性:");
            for (int i = 0; i < rootEle.attributeCount(); i++) {
                Attribute attribute = rootEle.attribute(i);
                System.out
                        .println(attribute.getName() + " = " + attribute.getText());
            }
            System.out.println("id属性:" + rootEle.attributeValue("id"));

            System.out.println("子元素~~~~<servlet> 和 <servlet-mapping>~~~~~~~");
            /** 第四步： 操作 **/
            List<Element> elements = rootEle.elements();
            for (Element ele : elements) {
                System.out.println("子元素:" + ele.getName());
                String text = ele.elementText("servlet-name"); // 子子元素的文本
                System.out.println(text);
                String elementText = ele.elementText("url-pattern");
                System.out.println("url-pattern:" + elementText);
            }
        }

JAXP的解析HTML

* DOM
    * DocumentBuilderFactory    ：解析器工厂类
    * DocumentBuilder   获取解析器对象
    * 解析XML（Document parse(String uri) ）
        // 获取解析器工厂类
        DocumentBuilderFactory factory = DocumentBuilderFactory.newInstance();
        // 获取解析器对象
        DocumentBuilder builder = factory.newDocumentBuilder();
        // 解析XML的文档，返回document对象
        Document document = builder.parse("src/book2.xml");


* 回写
    * 获取回写的工厂类
    * 获取回写对象
    * 调用回写的方法进行回写。
        // 创建回写类的工厂
        TransformerFactory transformerFactory =  TransformerFactory.newInstance();
        // 获取回写类
        Transformer transformer = transformerFactory.newTransformer();
        // 调用回写的方法
        transformer.transform(new DOMSource(document), new StreamResult("src/book2.xml"));

我的JAXP的解析HTML

导入jar包
- jaxen-1.1-beta-6.jar
创建xml

 <?xml version="1.0" encoding="ISO-8859-1"?>
    <bookstore>
        <book id="1">
          <title lang="eng">Harry Potter</title>
          <price>29.99</price>
        </book>
        <book id="2">
          <title lang="eng">Learning XML</title>
          <price>39.95</price>
        </book>
    </bookstore>

创建 dom4j 核心对象 :SAXReader
reader = new SAXReader()
读取xml,获取文档对象:
document= reader.read(file);
方法api:
*selectNodes(“表达式”)
*selectSingleNode(“表达式”)
表达式
*/ 从根节点选取
*// 从匹配选择的当前节点选择文档中的节点，而不考虑它们的位置
*@ 选取属性


   /**
     * xPath :多个节点
     */
    @Test
    public void test2() throws DocumentException {

        /** 第一步： 核心对象 **/
        /** 第二步： 读取配置文件,变成document树 **/
        Document document = new SAXReader().read("./src/book.xml");
        /** 第三步： 更节点 **/
        List<Node> selectNodes = document.selectNodes("/bookstore/book/title");
        Element node = (Element) selectNodes.get(0);
        String text = node.getText();
        System.out.println(text);
    }


        /**
         * xPath:单个节点 + 属性
         */
        @Test
        public void test3() throws DocumentException {
            /** 第一步： 核心对象 **/
            /** 第二步： 读取配置文件,变成document树 **/
            Document document = new SAXReader().read("./src/book.xml");
            /** 第三步： 更节点 **/
            Element node = (Element) document
                    .selectSingleNode("/bookstore/book[@id=2]");

            String text = node.elementText("title");
            System.out.println(text);
        }

工厂

*简单工厂

解决了层与层耦合度
但是层与工厂耦合度过高

*spring 工厂

定义一个容器(集合框架)map上来就解析xml,初始化容器数据 (任务)如果遇到,请从容器或者.xml中找到然后注入

未写完的

beanfactory.java 类
package com.huaxin.xml.bean;

import java.lang.reflect.Field;
import java.util.List;

import org.dom4j.Document;
import org.dom4j.Element;
import org.dom4j.io.SAXReader;

public class BeanFactory {

    public static Object getBean(String id) {
        Document document;
        Object newInstance = null;
        try {
            document = new SAXReader().read("./src/SpringFactory.xml");
            Element node = (Element) document.selectSingleNode("/beans/bean[@id='" + id + "']");
            // 创建service
            String nodId = node.attributeValue("id");
            String className = node.attributeValue("class");
            Class<?> forName = Class.forName(className);
            newInstance = forName.newInstance();
            // 注入Dao
            List<Element> elements = (List<Element>) node.elements("property");
            String name = elements.get(0).attributeValue("name");
            String ref = elements.get(0).attributeValue("ref");
            Class<?> refClazz = Class.forName(ref);
            Object dao = refClazz.newInstance();
            Field field = forName.getField(name);
            field.setAccessible(true);
            field.set(newInstance, dao);
        } catch (Exception e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
        return newInstance;
    }

    public static void main(String[] args) {
        BeanFactory beanFactory = new BeanFactory();
        UserService userService = (UserService) beanFactory.getBean("userService");
        userService.login();
    }
}

SpringFactory.xml

<?xml version="1.0" encoding="UTF-8"?>
<beans>
        <bean id="userDao" class="com.huaxin.xml.bean.UserDao"></bean>
        <bean id="userService" class="com.huaxin.xml.bean.UserService">
            <property name="userDao" ref="com.huaxin.xml.bean.UserDao">
            </property>
        </bean>
</beans>

xml约束忘记了

test.dtd

<?xml version="1.0" encoding="UTF-8"?>
<!ELEMENT note (to,from,heading,body)>
<!ELEMENT to (#PCDATA)>
<!ELEMENT from (#PCDATA)>
<!ELEMENT heading (#PCDATA)>
<!ELEMENT body (#PCDATA)>

xx.xsd

<?xml version="1.0"?>
<xs:schema xmlns:xs="http://www.w3.org/2001/XMLSchema"
targetNamespace="http://www.w3schools.com"
xmlns="http://www.w3schools.com"
elementFormDefault="qualified">
<xs:element name="note">
  <xs:complexType>
    <xs:sequence>
      <xs:element name="to" type="xs:string"/>
      <xs:element name="from" type="xs:string"/>
      <xs:element name="heading" type="xs:string"/>
      <xs:element name="body" type="xs:string"/>
    </xs:sequence>
  </xs:complexType>
</xs:element>
</xs:schema>

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE note SYSTEM "note.dtd">
<note>
  <to>Tove</to>
  <from>Jani</from>
  <heading>Reminder</heading>
  <body>Don't forget me this weekend!</body>
</note>