xml操作

1.Dom4j

package Read;

import java.io.BufferedReader;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.io.OutputStream;
import java.util.HashMap;
import java.util.List;

import org.dom4j.Document;
import org.dom4j.DocumentHelper;
import org.dom4j.Element;
import org.dom4j.io.XMLWriter;

/** 
 * @author: 07
 * @date: 2017年9月8日 上午10:35:42 
 * @version 1.0
 * @parameter 使用dom4j操作，先使用io流读取所有的数据到字符串中，再使用dom4j.jar
 *                   进行解析。(可以加上日志打印)、适合配置文件下面都是符合key-Value的形式。优点：性能最好。
 * @return  hashmap key-value
 */
public class XmlUtilDom4j {
    /** 配置项的key,value映射map */
    private static HashMap<String, String> configs = null;
    /** 默认的配置文件 */
    public final static String DEFAULT_FILE = "/config.xml";
    
    static{
        // 加载默认的配置文件
        load(DEFAULT_FILE);
        insertXml(DEFAULT_FILE);
    }
    public static void load(String fileName){
        StringBuffer xml=new StringBuffer();
        InputStream is = XmlUtilDom4j.class.getResourceAsStream(fileName);
        BufferedReader reader = null;
        String line=null;
        try {
             reader = new BufferedReader(new InputStreamReader(is, "UTF-8"));
             while((line=reader.readLine())!=null){
                 xml.append(line);
             }
             // 保证在任何时候调用load方法时都能完重新加载配置
             configs = new HashMap<String, String>();
             //获取文档
             Document doc = DocumentHelper.parseText(xml.toString());
             Element root=doc.getRootElement();
             List<Element> lists = root.elements();
             for(Element element:lists){
                 /** <config key="rate_port">9988</config> */
                 String key=element.attributeValue("key");//获取标签里面key属性值
                 String value=element.attributeValue("value");//获取标签里面value的属性值
                 String text = element.getText();//获得节点值
                // 检查key是否重复，重复的就忽略，以免影响之前的配置
                 if(configs.containsKey(key)){
                     continue;
                 }
                 if(value != null && value.length()>0){
                     configs.put(key, value);
                 }else{
                     configs.put(key, text);
                 }
             }
        } catch (Exception e) {
            e.printStackTrace();
        }finally {
            try {
                //关闭资源。
                reader.close();
                is.close();
            } catch (IOException e) {
            }
        }
    }
    
    public static void insertXml(String fileName){
        StringBuffer xml=new StringBuffer();
        InputStream is = XmlUtilDom4j.class.getResourceAsStream(fileName);
        BufferedReader reader = null;
        String line=null;
        try {
             reader = new BufferedReader(new InputStreamReader(is, "UTF-8"));
             while((line=reader.readLine())!=null){
                 xml.append(line);
             }
             Document doc = DocumentHelper.parseText(xml.toString());
             Element root=doc.getRootElement();
             //创建标签元素并设置值
             Element myconfig = DocumentHelper.createElement("config");
             myconfig.addAttribute("key", "myconfig");
             myconfig.addText("这是我的config");
             root.add(myconfig);
             
             OutputStream os=new FileOutputStream("D:\JavaLearning\XML\source\config.xml");
             XMLWriter writer=new XMLWriter(os);
             writer.write(doc);
             writer.close();
        } catch (Exception e) {
            e.printStackTrace();
        }finally {
            try {
                //关闭资源。
                reader.close();
                is.close();
            } catch (IOException e) {
            }
        }
        
    }
    
    
    
    
    
    
    
    
    
    
    
    
    
    /**
     * 取得配置值
     * @param key
     * @return
     */
    public static String get(String key){
        return configs.get(key);
    }
    
    public static Integer getInteger(String key){
        return Integer.valueOf(get(key));
    }
    
    public static Double getDouble(String key){
        return Double.valueOf(get(key));
    }
    
    public static boolean getBoolean(String key){
        return Boolean.valueOf(get(key));
    }
    
    
    public static void main(String[] args) {
        String str="   ";//字符串空格也算长度
        System.out.println(configs.toString());
    }

}

2.dom4j读取xml文件获得文档的方式

package Read;

import java.io.BufferedReader;
import java.io.File;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.util.HashMap;
import java.util.List;

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

/** 
 * @author: 07
 * @date: 2017年9月8日 上午10:35:42 
 * @version 1.0
 * @parameter 使用dom4j操作，先使用io流读取所有的数据到字符串中，再使用dom4j.jar
 *                   进行解析。(可以加上日志打印)、适合配置文件下面都是符合key-Value的形式
 * @return  hashmap key-value
 */
public class XmlUtilDom4j2 {
    /** 配置项的key,value映射map */
    private static HashMap<String, String> configs = null;
    /** 默认的配置文件 */
    public final static String DEFAULT_FILE = "D:\JavaLearning\XML\source\config.xml";
    
    static{
        // 加载默认的配置文件
        load(DEFAULT_FILE);
    }
    public static void load(String fileName){
        File file=new File(DEFAULT_FILE); //读绝对路径的内容！
        SAXReader reader=new SAXReader();
        try {
            Document doc = reader.read(file);
            Element root = doc.getRootElement();
            List<Element> list = root.elements();
            //赋予空间
            configs=new HashMap<>();
            for(Element e:list){
                String text = e.getText();
                String key = e.attributeValue("key");
                String value = e.attributeValue("value");
                //重复的去掉，留着之前的值
                if(configs.containsKey(key)){
                    continue;
                }
                //看下value是否为空
                if(value!=null&&value.length()>0){
                    configs.put(key, value);
                }else {
                    configs.put(key, text);
                }
            }
        } catch (DocumentException e) {
            e.printStackTrace();
        }
    }
    
    /**
     * 取得配置值
     * @param key
     * @return
     */
    public static String get(String key){
        return configs.get(key);
    }
    
    public static Integer getInteger(String key){
        return Integer.valueOf(get(key));
    }
    
    public static Double getDouble(String key){
        return Double.valueOf(get(key));
    }
    
    public static boolean getBoolean(String key){
        return Boolean.valueOf(get(key));
    }
    
    public static void main(String[] args) {
        String str="   ";//字符串空格也算长度
//        System.out.println(str.isEmpty()); //判断不了除非str.trim().isEmpty()
        System.out.println(configs.toString());
    }

}

xml文件：

<?xml version="1.0" encoding="UTF-8" ?>
<!-- 没有约束的xml文件 -->
<configs>

      <!-- 计费接口 -->
      <config key="rate_host">192.168.1.251</config>    
      <config key="rate_port">9988</config>
      <!-- end -->    
      
      <!-- 提现是否要审核 -->
      <config key="enable_check">false</config>
     
    <!--END -->
</configs>

3.dom

package Read;

import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.InputStream;
import java.io.OutputStream;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.Hashtable;
import java.util.Map;
import java.util.Vector;

import javax.xml.parsers.DocumentBuilder;
import javax.xml.parsers.DocumentBuilderFactory;
import javax.xml.parsers.ParserConfigurationException;
import javax.xml.transform.OutputKeys;
import javax.xml.transform.Transformer;
import javax.xml.transform.TransformerFactory;
import javax.xml.transform.dom.DOMSource;
import javax.xml.transform.stream.StreamResult;

import org.w3c.dom.Document;
import org.w3c.dom.Element;
import org.w3c.dom.Node;
import org.w3c.dom.NodeList;


/** 
 * @author: 07
 * @date: 2017年9月8日 下午1:49:56 
 * @version 1.0
 * @parameter test
 * @return  xml.jar
 */
public class XmlUtilDom {
    /** 配置项的key,value映射map */
    private static HashMap<String, String> configs = null;
    private static ArrayList<Object> array=new ArrayList<>();
    /** 默认的配置文件 */
    public final static String DEFAULT_FILE = "Student.xml";
    
    static{
        // 加载默认的配置文件
//        load(DEFAULT_FILE);
    }
    public static void load(String fileName){
        //实例化工厂
        DocumentBuilderFactory builderFactory = DocumentBuilderFactory.newInstance();
        DocumentBuilder builder=null;
        try {
            InputStream is=XmlUtilDom.class.getClassLoader().getResourceAsStream(DEFAULT_FILE);
            //构建解析器
            builder = builderFactory.newDocumentBuilder();
            Document doc = builder.parse(is);
//            Element element = doc.getDocumentElement();//获得根元素element.getTagName().toString()
            NodeList list = doc.getElementsByTagName("student");//根据节点名获取节点集合
            configs=new HashMap<>();
            for(int i=0;i<list.getLength();i++){
                Element ele = (Element)list.item(i);
                Hashtable<String, String> map=new Hashtable<>();
                String name=ele.getElementsByTagName("name").item(0).getFirstChild().getNodeValue();
                String sex=ele.getElementsByTagName("sex").item(0).getFirstChild().getNodeValue();
                String age=ele.getElementsByTagName("age").item(0).getFirstChild().getNodeValue();
                map.put("name", name);
                map.put("sex", sex);
                map.put("age", age);
                array.add(map);
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
    //加多一个student
    public static void insertXml(){
        DocumentBuilderFactory factory=DocumentBuilderFactory.newInstance();
        try {
            DocumentBuilder builder = factory.newDocumentBuilder();
            InputStream is=XmlUtilDom.class.getResourceAsStream("/Student.xml");
//            Document doc = builder.newDocument(); //创建新的
            Document doc = builder.parse(is);    //在原有的基础上增加
            
//            Element element = doc.createElement("root");//获得根节点
            Element element = doc.getDocumentElement();
            Element student = doc.createElement("student");
            Element name = doc.createElement("name");
            Element sex = doc.createElement("sex");
            Element age = doc.createElement("age");
            
            student.setAttribute("id","6");
            student.setAttribute("group", "6");
            
            name.setTextContent("test");
            sex.setTextContent("女");
            age.setTextContent("123");
            
            student.appendChild(name);
            student.appendChild(sex);
            student.appendChild(age);
            element.appendChild(student);
//            doc.appendChild(element); 
            /** 写入 */
            OutputStream os=new FileOutputStream("D:\JavaLearning\XML\source\Student1.xml");
            TransformerFactory ttf=TransformerFactory.newInstance();
            Transformer transformer = ttf.newTransformer();
            // 设置输出数据时换行
            transformer.setOutputProperty(OutputKeys.INDENT, "yes");
            transformer.transform(new DOMSource(doc), new StreamResult(os));
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
    
    public static void main(String[] args) {
//        load(DEFAULT_FILE);
        insertXml();
    }

}

xml文件

<?xml version="1.0" encoding="utf-8"?>
<root>
    <student id="1" group="1">
        <name>张三</name>
        <sex>男</sex>
        <age>18</age>
    </student>
    <student id="2" group="2">
        <name>李四</name>
        <sex>女</sex>
        <age>18</age>
    </student>
    <student id="3" group="3">
        <name>小王</name>
        <sex>男</sex>
        <age>18</age>
    </student>
    <student id="4" group="4">
        <name>小张</name>
        <sex>男</sex>
        <age>18</age>
    </student>
    <student id="5" group="5">
        <name>小明</name>
        <sex>男</sex>
        <age>18</age>
    </student>
</root>

4.sax

package Read;

import java.io.FileInputStream;
import java.io.InputStream;
import java.util.ArrayList;
import java.util.Iterator;

import javax.xml.parsers.SAXParser;
import javax.xml.parsers.SAXParserFactory;

/**
 * @author: 07
 * @date: 2017年9月8日 下午5:03:22
 * @version 1.0
 * @parameter test
 * @return SAX，全称Simple API for
 *         XML，既是一种接口，也是一种软件包。它是一种XML解析的替代方法。SAX不同于DOM解析，它逐行扫描文档，一边扫描一边解析。
 *         由于应用程序只是在读取数据时检查数据，因此不需要将数据存储在内存中，这对于大型文档的解析是个巨大优势。但是无法知道当前解析标签（节点）
 *         的上层标签，及其嵌套结构，仅仅知道当前解析的标签的名字和属性，要知道其他信息需要程序猿自己编码 只能读取XML，无法修改XML
 *         无法随机访问某个标签（节点）
 */
public class Sax {
    public static void load(String fileName) {
        SAXParserFactory factory = SAXParserFactory.newInstance();
        SAXParser parser = null;
        try {
            InputStream is=new FileInputStream("D:/JavaLearning/XML/source/Teacher.xml");
            parser = factory.newSAXParser();
            MySAXParserHandle handler = new MySAXParserHandle();
            parser.parse(is, handler);
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
    public static void main(String[] args) {
        load("");
//        ArrayList<String> list = MySAXParserHandle.array;
//        Iterator<String> it=list.iterator();
//        while(it.hasNext()){
//            System.err.println(it.next().toString());
//        }
    }

}

MySAXParserHandle

package Read;

import java.util.ArrayList;
import java.util.HashMap;

import org.xml.sax.Attributes;
import org.xml.sax.SAXException;
import org.xml.sax.helpers.DefaultHandler;

/** 
 * @author: 07
 * @date: 2017年9月8日 下午5:25:00 
 * @version 1.0
 * @parameter test
 * @return  
 */
public  class MySAXParserHandle extends DefaultHandler {
    private String str="";
    private StringBuffer result=new StringBuffer();//用来连接标签值
    private String result1="";
    int i=0;
    @Override
    public void startDocument() throws SAXException {
        super.startDocument();
    }

    @Override
    public void endDocument() throws SAXException {
        super.endDocument();
    }

    @Override 
    public void startElement(String uri, String localName, String qName, Attributes attributes) throws SAXException {
        if(!"test".equals(qName)){//去掉最外的标签
            int i=attributes.getLength();//有多少个属性
            str="<"+qName; 
            for(int j=0;j<i;j++){
                str+=" "+attributes.getQName(j)+"=""+attributes.getValue(j)+""";
            }
            str+=">"+"#"+"</"+qName+">";
        }
        super.startElement(uri, localName, qName, attributes); //qName=标签名，
    }

    @Override
    public void endElement(String uri, String localName, String qName) throws SAXException {
        super.endElement(uri, localName, qName);
//        String replaceAll = str.replaceAll("#", result1);
//        result1="";
//        str="";
    }
    /**
     * SAX解析器可以返回单个块中的所有连续字符数据，也可以将其分割成几个块。(我们看到会执行两次，把结果在读取标签结束时连起来就可以了，或者为空不要也行[一般第一个就是了，第二个基本都是空])
     */
    @Override
    public void characters(char[] ch, int start, int length) throws SAXException {
        super.characters(ch, start, length);
        String nodeValue = new String(ch, start, length);
//        if(!nodeValue.trim().equals("")){
//            result1=nodeValue;
//        }
        //*********************************************************************
        result.append(nodeValue);
        if(i==1){
            String replaceAll = str.replaceAll("#", result.toString());
            System.out.println(replaceAll);
            result.setLength(0);
            str="";
            i=0;
        }
        i++;
    }
    

}

读取的xml

<?xml version="1.0" encoding="UTF-8"?>
<test>
    <gg key="dd">dd</gg>
    <vic key="22" value="22">sss</vic>
    <ss key="my">看到手机</ss>
</test>

5.XmlPull用的也是很多的。

package Read;

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

import org.xmlpull.v1.XmlPullParser;
import org.xmlpull.v1.XmlPullParserFactory;

import entity.Student;

/** 
 * @author: 07
 * @date: 2017年9月11日 下午2:05:04 
 * @version 1.0
 * @parameter test
 * @return  导入xmlpull.jar.pull和sax很相似，区别在于：pull读取xml文件后触发相应的事件调用方法返回的是数字，且pull可以在程序中控制，想解析到哪里就可以停止解析。
 */
public class pullXmlUtil {
    public List<Student> load(){
        //定义容器
            List<Student> list = null;
            Student student = null;
        try {
            //new一个xmlPull工厂
            XmlPullParserFactory factory=XmlPullParserFactory.newInstance();
            //使用工厂类生成操作对象
            XmlPullParser pullParser = factory.newPullParser();
            //构建一个输入流
            InputStream is = this.getClass().getClassLoader().getResourceAsStream("Student.xml");
            //关联操作对象和流
            pullParser.setInput(is, "UTF-8");
            
            int eventType = pullParser.getEventType();//触发的事件
            while(eventType != XmlPullParser.END_DOCUMENT){
                String nodeName=pullParser.getName();//读取的值
                switch (eventType) {
                case XmlPullParser.START_DOCUMENT:
                    System.out.println("开始读取文档");
                    break;
                case XmlPullParser.START_TAG:
                    if("root".equals(nodeName)){
                        list = new ArrayList<Student>();
                    }else if("student".equals(nodeName)){
                        student = new Student();
                        student.setId(Integer.parseInt(pullParser.getAttributeValue(0)));
                        student.setGroup(pullParser.getAttributeValue(1));
                    }else if("name".equals(nodeName)){ //注意此处的nextText调用一次就下一个了，如有打印，日志等操作也会有影响，要先声明变量存储。
                        student.setName(pullParser.nextText());
                    }else if("age".equals(nodeName)){
                        student.setAge(Integer.parseInt(pullParser.nextText()));
                    }else if("sex".equals(nodeName)){
                        student.setSex(pullParser.nextText());
                    }
                    break;
                case XmlPullParser.END_TAG:
                    if("student".equals(nodeName)){
                        list.add(student);
                    }
                    break;
                default:
                    break;
                }
                // 手动的触发下一个事件
                eventType = pullParser.next();
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
        return list;
        
    }
    public static void main(String[] args) {
        pullXmlUtil pullXmlUtil=new pullXmlUtil();
        List<Student> list = pullXmlUtil.load();
        for(Student s:list){
            System.out.println(s.toString());
        }
    }

}

xml:

<?xml version="1.0" encoding="utf-8"?>
<root>
    <student id="1" group="1">
        <name>张三</name>
        <sex>男</sex>
        <age>18</age>
    </student>
    <student id="2" group="2">
        <name>李四</name>
        <sex>女</sex>
        <age>18</age>
    </student>
</root>