xml文档解析2019-9-23

4种文档解析

xml解析 可以对框架 的一些内部实现

解析一样读取任意节点，

有 4种：

1.DOM解析（Document Object Model）

DOM是html和xml的应用程序接口(API)，以层次结构（类似于树型）来组织节点和信息片段，映射XML文档的结构，允许获取和操作文档的任意部分，是W3C的官方标准dom( document) 将整个文档解析成倒置文档树 ，适用于解析少量xml文件 ，在大文件解析式需要消耗大量内存
【优点】
①允许应用程序对数据和结构做出更改。
②访问是双向的，可以在任何时候在树中上下导航，获取和操作任意部分的数据。
【缺点】
①通常需要加载整个XML文档来构造层次结构，消耗资源大。
【解析详解】
①构建Document对象：
DocumentBuilderFactory dbf = DocumentBuilderFactory.newInstance();
DocumentBuilder db = bdf.newDocumentBuilder();
InputStream is = Thread.currentThread().getContextClassLoader().getResourceAsStream(xml文件);
Document doc = bd.parse(is);
②遍历DOM对象
Document： XML文档对象，由解析器获取
NodeList： 节点数组
Node： 节点(包括element、#text)
Element： 元素，可用于获取属性参数

2.SAX解析 (Simple Api For XML)

sax(simle . . )采用流媒体加载方式即读取一部分解析一部分，解析完会释放内存 ，因此消耗内存少，但不能像Dom
流模型中的"推"模型分析方式。通过事件驱动，每发现一个节点就引发一个事件，事件推给事件处理器，通过回调方法
完成解析工作，解析XML文档的逻辑需要应用程序完成
【优势】
①不需要等待所有数据都被处理，分析就能立即开始。
②只在读取数据时检查数据，不需要保存在内存中。
③可以在某个条件得到满足时停止解析，不必解析整个文档。
④效率和性能较高，能解析大于系统内存的文档。
【缺点】
①需要应用程序自己负责TAG的处理逻辑（例如维护父/子关系等），文档越复杂程序就越复杂。
②单向导航，无法定位文档层次，很难同时访问同一文档的不同部分数据，不支持XPath。
【原理】
简单的说就是对文档进行顺序扫描，当扫描到文档(document)开始与结束、元素(element)开始与结束时通知事件
处理函数(回调函数)，进行相应处理，直到文档结束
【事件处理器类型】
①访问XML DTD：DTDHandler
②低级访问解析错误：ErrorHandler
③访问文档内容：ContextHandler
【DefaultHandler类】
SAX事件处理程序的默认基类，实现了DTDHandler、ErrorHandler、ContextHandler和EntityResolver接口，通常
做法是，继承该基类，重写需要的方法，如startDocument()
【创建SAX解析器】
SAXParserFactory saxf = SAXParserFactory.newInstance();
SAXParser sax = saxf.newSAXParser();
注：关于遍历
①深度优先遍历(Depthi-First Traserval)
②广度优先遍历(Width-First Traserval)

3.JDOM 解析 内部基于sax api ,通过 java 实现xml解析，使用一些具体类实现解析

Java特定的文档对象模型。自身不包含解析器，使用SAX
【优点】
①使用具体类而不是接口，简化了DOM的API。
②大量使用了Java集合类，方便了Java开发人员。
【缺点】
①没有较好的灵活性。
②性能较差。
【解析详解】
①指定解析器:
SAXBuilder builder =new SAXBuilder(false);//使用默认解析器
②得到Document对象
Document doc = builder.build(xmlpath);
③得到根节点:
Element rootElement = doc.getRootElement();
④得到节点元素集合
List list = rootElement.getChildren(tag);

4.DOM4J(document object for java) 基于JDOM优化分支 建议使用

 在jdom基础上大量使用java 的集合api实现解析，并且还具有快速节点检索解析

简单易用，采用Java集合框架，并完全支持DOM、SAX和JAXP
【优点】
①大量使用了Java集合类，方便Java开发人员，同时提供一些提高性能的替代方法。
②支持XPath。
③有很好的性能。
【缺点】
①大量使用了接口，API较为复杂。
【解析详解】
①指定解析器:
SAXReader reader = new SAXReader();
②得到Document对象:
Document doc = reader.read(xmlpath);

DOM4J例子

将config.xml写入数据库test

config.xm文件

<?xml version="1.0" encoding="UTF-8"?>


<configuration>
	<environments>
		<environment id="dev">
			<dataSource>
				<property name="driver" value="com.mysql.jdbc.Driver"/>
				<property name="url" value="jdbc:mysql://127.0.0.1:3306/test"/>
				<property name="username" value="root"/>
				<property name="password" value="123456"/>
			</dataSource>
		</environment>
	</environments>
	<mappers>
		<mapper resource="com/dao/Emp.xml"/>
		<mapper resource="com/dao/Dept.xml"/>
	</mappers>
</configuration> 

config.xml连接的dept.xml

<?xml version="1.0" encoding="UTF-8"?>
<!--
  ~ by softeem
  ~ copyrigrth(c) 2019
  -->

<Mapper>
	<table property="dept" name="dept">
		<property name="deptno" column="dno" type="int"/>
		<property name="deptname" column="dname" type="varchar" length="30"/>
		<property name="depttel" column="dtel" type="int" />

	</table>	
</Mapper>

config.xml连接的emp.xml

<?xml version="1.0" encoding="UTF-8"?>
<!--
  ~ by softeem
  ~ copyrigrth(c) 2019
  -->

<Mapper>
	<table property="emp" name="emp">
		<property name="empno" column="eno" type="int"/>
		<property name="empname" column="ename" type="varchar" length="30"/>
		<property name="empsex" column="sex" type="varchar" length="4"/>
		<property name="empage" column="age" type="int"/>
		<property name="birthday" column="birth" type="date"/>
	</table>	
</Mapper>

实体层entity

Colmum.class（用来显示创建表的列信息）

/*
 * by softeem
 * copyrigrth(c) 2019
 */

package com.dao.dto;


public class Colum {
    private String columName;
    private String columType;
    private int columlength;

    public String getColumName() {
        return columName;
    }

    public void setColumName(String columName) {
        this.columName = columName;
    }

    public String getColumType() {
        return columType;
    }

    public void setColumType(String columType) {
        this.columType = columType;
    }

    public int getColumlength() {
        return columlength;
    }

    public void setColumlength(int columlength) {
        this.columlength = columlength;
    }

    @Override
    public String toString() {
        return "Colum{" +
                "columName='" + columName + '\'' +
                ", columType='" + columType + '\'' +
                ", columlength=" + columlength +
                '}';
    }
}

config.class（对应config.xml）

/*
 * by softeem
 * copyrigrth(c) 2019
 */

package com.dao.dto;

import java.util.ArrayList;
import java.util.List;


public class Comfig {
    private String Driver;
    private String url;
    private String username;
    private String password;
    private List<Table> table =new ArrayList<>();

    public String getDriver() {
        return Driver;
    }

    public void setDriver(String driver) {
        Driver = driver;
    }

    public String getUrl() {
        return url;
    }

    public void setUrl(String url) {
        this.url = url;
    }

    public String getUsername() {
        return username;
    }

    public void setUsername(String username) {
        this.username = username;
    }

    public String getPassword() {
        return password;
    }

    public void setPassword(String password) {
        this.password = password;
    }

    public List<Table> getTable() {
        return table;
    }

    public void setTable(List<Table> table) {
        this.table = table;
    }

    @Override
    public String toString() {
        return "Comfig{" +
                "Driver='" + Driver + '\'' +
                ", url='" + url + '\'' +
                ", username='" + username + '\'' +
                ", password='" + password + '\'' +
                ", table=" + table +
                '}';
    }
}

Table表信息

/*
 * by softeem
 * copyrigrth(c) 2019
 */

package com.dao.dto;

import java.util.ArrayList;
import java.util.List;


public class Table {
    private String tablename;
    private List<Colum> colums =new ArrayList<>();

    public String getTablename() {
        return tablename;
    }

    public void setTablename(String tablename) {
        this.tablename = tablename;
    }

    public List<Colum> getColums() {
        return colums;
    }

    public void setColums(List<Colum> colums) {
        this.colums = colums;
    }

    @Override
    public String toString() {
        return "Table{" +
                "tablename='" + tablename + '\'' +
                ", colums=" + colums +
                '}';
    }
}
根据表配置文件得到 config对象
```java
/*
 * by softeem
 * copyrigrth(c) 2019
 */

package com.dao.xml;

import com.dao.dto.Colum;
import com.dao.dto.Comfig;
import com.dao.dto.Table;
import org.dom4j.Document;
import org.dom4j.DocumentException;
import org.dom4j.Node;
import org.dom4j.io.SAXReader;

import java.io.InputStream;
import java.util.List;
import java.util.Objects;

/**
 * Author Administrator
 * Date 2019/9/23 0023 上午 9:21
 */
public class Comfigxml {

    private static String config ="config.xml";
    
    public Document parse(String xmlFile) throws DocumentException {

        //
        SAXReader reader =new SAXReader();
        InputStream is = this.getClass().getResourceAsStream("/"+xmlFile);

        Document doc = reader.read(is);
        return doc;
    }

    /***
     * 读取配置文件信息成为Decument对象
     * @return
     */
    public Comfig read() throws DocumentException {
        Document doc = parse(config);
        List<Node> list = doc.selectNodes("configuration/environments/environment/dataSource/property");
        Comfig comfig = new Comfig();

        list.forEach(node -> {
            //获取节点中属性的值

            String name = node.valueOf("@name");

            String value = node.valueOf("@value");
            if (Objects.equals(name,"driver")){
                comfig.setDriver(value);
            }else if(Objects.equals(name,"url")){
                comfig.setUrl(value);
            }else if(Objects.equals(name,"username")){
                comfig.setUsername(value);
            }else if(Objects.equals(name,"password")){
                comfig.setPassword(value);
            }
        });

        //搜索mappers节点
        List<Node> list1 = doc.selectNodes("configuration/mappers/mapper");
        list1.forEach(node ->{
            String mapperPath =node.valueOf("@resource");

            Table table =readAsTable(mapperPath);

            comfig.getTable().add(table);

        });


        return comfig;
    }


    private Table readAsTable(String mapperPath) {
        Table table = new Table();
        try {
            Document doc = parse(mapperPath);
            Node nodeTab = doc.selectSingleNode("Mapper/table");
            String tableName =nodeTab.valueOf("@name");
            table.setTablename(tableName);
            List<Node> list = nodeTab.selectNodes("property");
            list.forEach(node -> {
                Colum colum=new Colum();
                String cname = node.valueOf("@column");
                String ctype = node.valueOf("@type");
                String len = node.valueOf("@length");

                colum.setColumName(cname);
                colum.setColumType(ctype);
                if(Objects.nonNull(len) && !Objects.equals(len,"")){
                    colum.setColumlength(Integer.parseInt(len));

                }

                table.getColums().add(colum);
            });



        } catch (DocumentException e) {
            e.printStackTrace();
        }

        return table;
    }

    public static void main(String[] args) throws DocumentException {
        Comfigxml cf = new Comfigxml();
        Comfig read = cf.read();
        System.out.println(read);

    }


}

根据config对象信息，将表写入数据库

/*
 * by softeem
 * copyrigrth(c) 2019
 */

package com.dao.xml;

import com.dao.dto.Colum;
import com.dao.dto.Comfig;
import com.dao.dto.Table;
import org.dom4j.DocumentException;

import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.PreparedStatement;
import java.sql.SQLException;
import java.util.List;

/**
 * Author Administrator
 * Date 2019/9/23 0023 上午 11:54
 */
public class TableGen {
    Comfig config=null;

    public TableGen(Comfig config) {
        this.config = config;
    }

    public void init() {

    }
    /**获取对象连接*/
    public Connection getConn(){
        return null;
    }

    //根据table获取sql
    public String getSql(Table table){
      String sql ="create table "+table.getTablename()+"(";
        List<Colum> colums=table.getColums();

        for (Colum c:colums) {
            sql +=c.getColumName()+" "+c.getColumType();
            if(c.getColumlength() != 0){
                sql +="("+c.getColumlength()+") ";
            }
            sql +=",";
        }
        sql =sql.substring(0,sql.length()-1) +")";
        return sql;
    }
    private void createTable(Connection conn,String sql){
        PreparedStatement  ps=null;
        try {
            ps =conn.prepareStatement(sql);

            boolean f= ps.execute();

            if(!f){
                System.out.println("建表完成："+sql);
            }
        } catch (SQLException e) {
            e.printStackTrace();
        }finally {

                try {
                    if(ps != null){
                    ps.close();
                    }
                } catch (SQLException e) {
                    e.printStackTrace();
                }

        }


    }

    public void execute(){
        String driverClass =config.getDriver();
        String url =config.getUrl();
        String username=config.getUsername();
        String password =config.getPassword();

        Connection conn=null;
        try {
           conn = DriverManager.getConnection(url,username,password);

            List<Table> tables =config.getTable();
            for(Table table :tables ){
                String sql =getSql(table);
                createTable(conn,sql);
            }

        } catch (SQLException e) {
            e.printStackTrace();
        }finally {

            try {
                if(conn != null){
                    conn.close();
                }
            } catch (SQLException e) {
                e.printStackTrace();
            }

        }


    }
}
程序入口
```java
/*
 * by softeem
 * copyrigrth(c) 2019
 */

package com.test;

import com.dao.dto.Comfig;
import com.dao.xml.Comfigxml;
import com.dao.xml.TableGen;
import org.dom4j.DocumentException;

/**
 * Author Administrator
 * Date 2019/9/23 0023 下午 2:14
 */
public class Test {

    public static void main(String[] args) throws DocumentException {
        Comfigxml cf = new Comfigxml();
        Comfig config = cf.read();
        TableGen tg = new TableGen(config);
        tg.execute();
    }
}

在这里我们解析config.xml连接数据库创建表已经完了~~！
来看看成果吧 ^ v ^！

成果展示