XML Java编程

一、XML概述
1、XML是可扩展标记语言。是由W3C指定并维护的，目前最新的版本是1.0
2、XML作用：
2.1传输数据，它是一种通用的数据交换格式
2.2配置文件。
二、xml语法
1、XML的声明
1.1语法：<?xml version="1.0" encoding="UTF-8"?>
保存在磁盘上的文件编码要与声明的编码一致。
encoding属性的默认 编码是：UTF-8
1.2XML的声明必须出现在XML文档的第一行
2、XML的注释
2.1语法：<!--这是注释-->
2.2注释不能出现在声明之前
3、CDATA区
CDATA是Character Data的缩写
把标签当做普通文本内容；
示例：
<![CDATA[
<itcast>www.itcast.cn</itcast>
]]>
三、DTD约束
1、常用约束：DTD（Document Type Definition）文档类型定义
Schema
2、格式良好的XML：遵循XML语法的文档
  有效的XML：遵守约束的文档。
有效的XML文档一定是格式良好的，但格式良好的不一定是有效的
3、单独的DTD文档在保存时要以UTF-8编码进行保存
4、编写DTD
4.1在XML文档中直接编写：
<?xml version="1.0" encoding="gbk"?>
<!DOCTYPE 书架 [
<!ELEMENT 书架 (书+)>
<!ELEMENT 书 (书名,作者,售价)>
<!ELEMENT 书名 (#PCDATA)>
<!ELEMENT 作者 (#PCDATA)>
<!ELEMENT 售价 (#PCDATA)>
]>
<书架/>
4.2引入外部DTD 
4.2.1：当引用的DTD文档在本地时，采用如下方式：
<!DOCTYPE 根元素 SYSTEM “DTD文档路径”>
4.2.2：当引用的DTD文档在公共网络上时，采用如下方式：
<!DOCTYPE 根元素 PUBLIC “DTD名称” “DTD文档的URL”>
5、定义元素：
语法：<!ELEMENT 元素名称 使用规则>
使用规则：
(#PCDATA):表示标签主体内容为普通字符串
EMPTY:表示标签没有主体内容
ANY:主体为任意内容
(子元素)：标签中的子元素
用逗号分开：按顺序出现
用“|”：选择其中一个
出现次数：
如果元素后面没有+*?:表示必须且只能出现一次
+:表示至少出现一次，一次或多次
*：表示可有可无，零次、一次或多次
?:表示可以有也可以无，有的话只能有一次。零次或一次
6、定义元素的属性
语法：<!ATTLIST 元素名称
属性名称1 属性值类型 设置说明
属性名称2 属性值类型 设置说明
....
>
属性值类型：
CDATA：普通文本数据
A|B|C "A":表示枚举值，只能从A、B、C中取其中一个，A为默认值
ID：表示取值不能重复
设置说明：
#REQUIRED：表示该属性必须出现
#IMPLIED：表示该属性可有可无
#FIXED:表示属性的取值为一个固定值。语法：#FIXED "固定值"

直接值：表示属性的取值为该默认值

StudentDao：

  1. package com.it.dao;  
  2.   
  3. import java.io.IOException;  
  4.   
  5. import javax.xml.parsers.ParserConfigurationException;  
  6. import javax.xml.transform.TransformerException;  
  7.   
  8. import org.w3c.dom.Document;  
  9. import org.w3c.dom.Element;  
  10. import org.w3c.dom.Node;  
  11. import org.w3c.dom.NodeList;  
  12. import org.xml.sax.SAXException;  
  13.   
  14. import com.it.model.Student;  
  15. import com.it.xmlUtil.XMLUtil;  
  16.   
  17. public class StudentDao {  
  18.       
  19.     public void add(Student s) throws ParserConfigurationException, SAXException, IOException, TransformerException {  
  20.         //得到Document对象  
  21.         Document doc = XMLUtil.getDocument();  
  22.         //构建Student相关的所有Element  
  23.         Element e_student = doc.createElement("student");  
  24.         e_student.setAttribute("school_id", s.getSchool_id());  
  25.         e_student.setAttribute("card_id", s.getCard_id());  
  26.         Element e_name = doc.createElement("name");  
  27.         e_name.setTextContent(s.getName());  
  28.         Element e_add = doc.createElement("add");  
  29.         e_add.setTextContent(s.getAdd());  
  30.         Element e_phone = doc.createElement("phone");  
  31.         e_phone.setTextContent(s.getPhone());  
  32.         //建立Element之间的关系  
  33.         e_student.appendChild(e_name);  
  34.         e_student.appendChild(e_add);  
  35.         e_student.appendChild(e_phone);  
  36.         doc.getElementsByTagName("exam").item(0).appendChild(e_student);  
  37.         //将添加了学生的Element保存  
  38.         XMLUtil.saveXML(doc);  
  39.     }  
  40.       
  41.     public boolean delete(String school_id) throws ParserConfigurationException, SAXException, IOException, TransformerException {  
  42.         boolean result = false;  
  43.         //得到Document  
  44.         Document doc = XMLUtil.getDocument();  
  45.         //得到所有的Student节点  
  46.         NodeList list = doc.getElementsByTagName("exam").item(0).getChildNodes();  
  47.         //遍历所有的student  
  48.         for(int i = 0;i<list.getLength();i++) {  
  49.             Node node = list.item(i);  
  50.             if(node.getNodeType() == Node.ELEMENT_NODE) {  
  51.                 Element el = (Element)node;  
  52.                 //找到需要删除的节点，用他的父节点删除之  
  53.                 if(el.getAttribute("school_id").equals(school_id)) {  
  54.                     node.getParentNode().removeChild(node);  
  55.                     result = true;  
  56.                 }  
  57.             }  
  58.               
  59.         }  
  60.         XMLUtil.saveXML(doc);  
  61.         return result;  
  62.     }  
  63.       
  64.     public Student search(String school_id) throws ParserConfigurationException, SAXException, IOException {  
  65.         Student s = null;  
  66.         //得到Document  
  67.         Document doc = XMLUtil.getDocument();  
  68.         //得到所有的Student节点  
  69.         NodeList list = doc.getElementsByTagName("exam").item(0).getChildNodes();  
  70.         //遍历所有的student  
  71.         for(int i = 0;i<list.getLength();i++) {  
  72.             Node node = list.item(i);  
  73.             if(node.getNodeType() == Node.ELEMENT_NODE) {  
  74.                 Element el = (Element)node;  
  75.                 if(el.getAttribute("school_id").equals(school_id)) {  
  76.                     s = new Student();  
  77.                     s.setCard_id(el.getAttribute("card_id"));  
  78.                     s.setAdd(el.getChildNodes().item(1).getTextContent());  
  79.                     s.setName(el.getChildNodes().item(0).getTextContent());  
  80.                     s.setPhone(el.getChildNodes().item(2).getTextContent());  
  81.                     s.setSchool_id(school_id);  
  82.                 }  
  83.             }  
  84.               
  85.         }  
  86.         return s;  
  87.     }  
  88.       
  89.     public boolean update(Student s) throws ParserConfigurationException, SAXException, IOException {  
  90.         boolean result = false;  
  91.         //得到Document  
  92.         Document doc = XMLUtil.getDocument();  
  93.         //得到所有的Student节点  
  94.         NodeList list = doc.getElementsByTagName("exam").item(0).getChildNodes();  
  95.         //遍历所有的student  
  96.         for(int i = 0;i<list.getLength();i++) {  
  97.             Node node = list.item(i);  
  98.             if(node.getNodeType() == Node.ELEMENT_NODE) {  
  99.                 Element el = (Element)node;  
  100.                 if(el.getAttribute("school_id").equals(s.getSchool_id())) {  
  101.                     el.getChildNodes().item(0).setTextContent(s.getName());  
  102.                     //此处省略...  
  103.                 }  
  104.             }  
  105.               
  106.         }  
  107.         return result;  
  108.     }  
  109. }  


XMLUtil

  1. package com.it.xmlUtil;  
  2.   
  3. import java.io.IOException;  
  4.   
  5. import javax.xml.parsers.DocumentBuilder;  
  6. import javax.xml.parsers.DocumentBuilderFactory;  
  7. import javax.xml.parsers.ParserConfigurationException;  
  8. import javax.xml.transform.Transformer;  
  9. import javax.xml.transform.TransformerException;  
  10. import javax.xml.transform.TransformerFactory;  
  11. import javax.xml.transform.dom.DOMSource;  
  12. import javax.xml.transform.stream.StreamResult;  
  13.   
  14. import org.w3c.dom.Document;  
  15. import org.xml.sax.SAXException;  
  16.   
  17. public class XMLUtil {  
  18.     /** 
  19.      * 将内存中的Document保存到磁盘上 
  20.      * @param doc 
  21.      * @throws TransformerException 
  22.      */  
  23.     public static void saveXML(Document doc) throws TransformerException {  
  24.         TransformerFactory tff = TransformerFactory.newInstance();  
  25.         Transformer tf = tff.newTransformer();  
  26.         tf.transform(new DOMSource(doc), new StreamResult("resource/student.xml"));  
  27.     }  
  28.     /** 
  29.      * 返回Document 
  30.      * @return 
  31.      * @throws ParserConfigurationException 
  32.      * @throws SAXException 
  33.      * @throws IOException 
  34.      */  
  35.     public static Document getDocument() throws ParserConfigurationException, SAXException, IOException{  
  36.         DocumentBuilderFactory dbf = DocumentBuilderFactory.newInstance();  
  37.         DocumentBuilder db = dbf.newDocumentBuilder();  
  38.         Document doc = db.parse("resource/student.xml");  
  39.         return doc;  
  40.     }  
  41.       
  42. }  

使用SAX解析XML

  1. package com.it.sax;  
  2.   
  3. import java.io.IOException;  
  4. import java.util.ArrayList;  
  5. import java.util.List;  
  6.   
  7. import javax.xml.parsers.ParserConfigurationException;  
  8. import javax.xml.parsers.SAXParser;  
  9. import javax.xml.parsers.SAXParserFactory;  
  10.   
  11. import org.xml.sax.Attributes;  
  12. import org.xml.sax.SAXException;  
  13. import org.xml.sax.XMLReader;  
  14. import org.xml.sax.helpers.DefaultHandler;  
  15.   
  16. public class SaxXML {  
  17.       
  18.     public static void main(String[] args) throws ParserConfigurationException, SAXException, IOException {  
  19.         //新建ContentHandler用于解析xml  
  20.         BeanHandler bh = new BeanHandler();  
  21.         SAXParser sp = SAXParserFactory.newInstance().newSAXParser();  
  22.         XMLReader xr = sp.getXMLReader();  
  23.         xr.setContentHandler(bh);  
  24.         xr.parse("resource/book.xml");  
  25.         List<Book> list = bh.getList();  
  26.         for(Book b:list) {  
  27.             System.out.println("书名" + b.getName() + "|作者" +   
  28.                     b.getAuthor() + "|价格" + b.getPrice());  
  29.         }  
  30.           
  31.     }  
  32.       
  33.       
  34. }  
  35.   
  36. class BeanHandler extends DefaultHandler{  
  37.       
  38.     String currentTagName = null;  
  39.     List<Book> list = new ArrayList();  
  40.     Book book = null;  
  41.     //在遇到Element开始标签是进行的处理  
  42.     @Override  
  43.     public void startElement(String uri, String localName, String qName,  
  44.             Attributes attributes) throws SAXException {  
  45.         currentTagName = qName;  
  46.         if(currentTagName.equals("书")) {  
  47.             book = new Book();  
  48.         }   
  49.         super.startElement(uri, localName, qName, attributes);  
  50.     }  
  51.     //在遇到标题结束标志时进行的处理  
  52.     @Override  
  53.     public void endElement(String uri, String localName, String qName)  
  54.             throws SAXException {  
  55.         currentTagName = "";  
  56.         if("书".equals(qName)) {  
  57.             list.add(book);  
  58.         }  
  59.         super.endElement(uri, localName, qName);  
  60.     }  
  61.     //遇到需要处理的Textcontent时进行的处理，同时会处理换行，制表符等  
  62.     @Override  
  63.     public void characters(char[] ch, int start, int length)  
  64.             throws SAXException {  
  65.         super.characters(ch, start, length);  
  66.         if(currentTagName.equals("书名")){  
  67.             book.setName(new String(ch,start,length));  
  68.         }else if(currentTagName.equals("作者")){  
  69.             book.setAuthor(new String(ch,start,length));  
  70.         }else if(currentTagName.equals("售价")) {  
  71.             book.setPrice(new String(ch,start,length));  
  72.         }  
  73.     }  
  74.   
  75.     public List<Book> getList() {  
  76.         return list;  
  77.     }  
  78.       
  79.       
  80.       
  81. }  

利用Dom4j解析XML

    1. package com.itheima.dom4j;  
    2.   
    3. import java.io.FileOutputStream;  
    4. import java.util.List;  
    5.   
    6. import javax.xml.transform.sax.SAXResult;  
    7.   
    8. import org.dom4j.Document;  
    9. import org.dom4j.DocumentException;  
    10. import org.dom4j.DocumentHelper;  
    11. import org.dom4j.Element;  
    12. import org.dom4j.Node;  
    13. import org.dom4j.io.OutputFormat;  
    14. import org.dom4j.io.SAXReader;  
    15. import org.dom4j.io.XMLWriter;  
    16. import org.junit.Assert;  
    17. import org.junit.Test;  
    18.   
    19. public class Dom4jDemo {  
    20.     //得到某个具体的节点内容  
    21.     //得到第2本书的主体内容  
    22.     @Test  
    23.     public void test1() throws Exception{  
    24.         //1、得到解析器   xpath  
    25.         SAXReader reader = new SAXReader();  
    26.         //2、加载xml文档  
    27.         Document document = reader.read("src/book.xml");  
    28.         //3、获取根元素  
    29.         Element root = document.getRootElement();  
    30.         //4\得到第2本书元素  
    31.         Element book = (Element)root.elements("书").get(1);  
    32.         Element name = book.element("书名");  
    33.         Assert.assertEquals("JavaScript", name.getText());  
    34.           
    35.     }  
    36.     @SuppressWarnings("unchecked")  
    37.     @Test  
    38.     ////得到第2本书的书名主体内容  
    39.     public void test11() throws Exception{  
    40.         SAXReader reader = new SAXReader();  
    41.         //2、加载xml文档  
    42.         Document document = reader.read("src/book.xml");  
    43.         String xpath = "//书[2]/书名"; //书名[2]  
    44.         Node list = document.selectSingleNode(xpath);  
    45.         Assert.assertEquals("JavaScript", list.getText());  
    46.           
    47.     }  
    48. //  2、遍历所有元素节点,打印元素的名称  
    49.     @Test  
    50.     public void test2()throws Exception{  
    51.         SAXReader reader = new SAXReader();  
    52.         //2、加载xml文档  
    53.         Document document = reader.read("src/book.xml");  
    54.         //3、获取根元素  
    55.         Element root = document.getRootElement();  
    56.         treeWalk(root);  
    57.     }  
    58.     public void treeWalk(Element element){  
    59.         //直接打印它的名字  
    60.         System.out.println(element.getName());  
    61.         //2、获取它的孩子Node，循环遍历  
    62.         int size = element.nodeCount();  
    63.         for(int i=0;i<size;i++){  
    64.             Node node = element.node(i);  
    65.             //判断node是否是元素  
    66.             if(node.getNodeType()==Node.ELEMENT_NODE){  
    67.                 treeWalk((Element)node);  
    68.             }  
    69.         }  
    70.     }  
    71. //  3、修改某个元素节点的主体内容  
    72.     //更改第2本书的作者为wzhting  
    73.     @Test  
    74.     public void test3()throws Exception{  
    75.         SAXReader reader = new SAXReader();  
    76.         //2、加载xml文档  
    77.         Document document = reader.read("src/book.xml");  
    78.         //3、获取根元素  
    79.         Element root = document.getRootElement();  
    80.         //4、得到第2本书的作者  
    81.         Element book = (Element)root.elements("书").get(1);  
    82.         Element author = book.element("作者");  
    83.         //5、设置其内容  
    84.         author.setText("王昭珽");  
    85.         //更新xml文档  
    86.         OutputFormat format = OutputFormat.createPrettyPrint();  
    87. //      format.setEncoding("UTF-8");//设置编码     
    88.         XMLWriter writer = new XMLWriter(new FileOutputStream("src/book.xml"));  
    89.         //默认编码就是UTF-8  
    90.         writer.write(document);  
    91.         writer.close();  
    92.     }  
    93. //  4、向指定元素节点中增加子元素节点  
    94.     //向第1本书中增加一个新节点叫<内部价>60</内部价>  
    95.     @Test  
    96.     public void test4() throws Exception{  
    97.         SAXReader reader = new SAXReader();  
    98.         //2、加载xml文档  
    99.         Document document = reader.read("src/book.xml");  
    100.         //3、获取根元素  
    101.         Element root = document.getRootElement();  
    102.         //4、得到第1本书  
    103.         Element book = root.element("书");  
    104.         Element price = DocumentHelper.createElement("内部价");  
    105.         price.setText("60");  
    106.         book.add(price);  
    107.         OutputFormat format = OutputFormat.createPrettyPrint();  
    108.         XMLWriter writer = new XMLWriter(new FileOutputStream("src/book.xml"),format);  
    109.         //默认编码就是UTF-8  
    110.         writer.write(document);  
    111.         writer.close();  
    112.     }  
    113. //  5、向指定元素节点上增加同级元素节点  
    114.     //向第一本书的售价前面增加 批发价  
    115.     @Test  
    116.     public void test5() throws Exception{  
    117.         SAXReader reader = new SAXReader();  
    118.         //2、加载xml文档  
    119.         Document document = reader.read("src/book.xml");  
    120.         //3、获取根元素  
    121.         Element root = document.getRootElement();  
    122.         List list = root.element("书").elements();  
    123.           
    124.         Element price = DocumentHelper.createElement("批发价");  
    125.         price.setText("10");  
    126.           
    127.         list.add(2, price);  
    128.           
    129.         OutputFormat format = OutputFormat.createPrettyPrint();  
    130.         XMLWriter writer = new XMLWriter(new FileOutputStream("src/book.xml"),format);  
    131.         //默认编码就是UTF-8  
    132.         writer.write(document);  
    133.         writer.close();  
    134.     }  
    135. //  6、删除指定元素节点  
    136.     //删除第2本书的作者  
    137.     @Test  
    138.     public void test6() throws Exception{  
    139.         SAXReader reader = new SAXReader();  
    140.         //2、加载xml文档  
    141.         Document document = reader.read("src/book.xml");  
    142.         //3、获取根元素  
    143.         Element root = document.getRootElement();  
    144.         //通过爸爸删自己  
    145.         Element book = (Element)root.elements("书").get(1);  
    146.         Element author = book.element("作者");  
    147.         author.getParent().remove(author);  
    148.         OutputFormat format = OutputFormat.createPrettyPrint();  
    149.         XMLWriter writer = new XMLWriter(new FileOutputStream("src/book.xml"),format);  
    150.         //默认编码就是UTF-8  
    151.         writer.write(document);  
    152.         writer.close();  
    153.     }  
    154. //  7、操作XML文件属性  
    155.     @Test  
    156.     public void test7() throws Exception{  
    157.         SAXReader reader = new SAXReader();  
    158.         //2、加载xml文档  
    159.         Document document = reader.read("src/book.xml");  
    160.         //3、获取根元素  
    161.         Element root = document.getRootElement();  
    162.         Element book = (Element)root.elements("书").get(1);  
    163.         Assert.assertEquals("传智播客", book.attributeValue("出版社"));  
    164.     }  
    165.     //8、将xml文档转换为String  
    166.     @Test  
    167.     public void test8() throws Exception{  
    168.         SAXReader reader = new SAXReader();  
    169.         //2、加载xml文档  
    170.         Document document = reader.read("src/book.xml");  
    171.         String text = document.asXML();  
    172.         System.out.println(text);  
    173.     }  
    174.     @Test  
    175.     public void test9() throws Exception{  
    176.         String text = "<person> <name>James</name> </person>";  
    177.         Document document = DocumentHelper.parseText(text);  
    178.         OutputFormat format = OutputFormat.createPrettyPrint();  
    179.         XMLWriter writer = new XMLWriter(new FileOutputStream("D:/a.xml"),format);  
    180.         //默认编码就是UTF-8  
    181.         writer.write(document);  
    182.         writer.close();  
    183.     }  
    184. }  
【推广】 免费学中医，健康全家人
原文地址：https://www.cnblogs.com/srluv/p/3042053.html