Java解析XML文件（Dom,SAX)

XML 是可扩展标记语言（Extensible Markup Language）的简称

使用 DOM 解析 XML

1.创建解析器工厂，即 DocumentBuilderFactory 对象。

2.通过解析器工厂获得 DOM 解析器，即 DocumentBuilder 对象。

3.解析指定 XML 文档，得到 DOM 节点树。

4.对 DOM 节点树进行操作，完成对 XML 文档的增、删、改、查。

主要方法：

•NodeList getChildNodes()：返回此节点的所有子节点的 NodeList。

•Node getFirstChild()：返回此节点的第一个子节点。

•Node getLastChild()：返回此节点的最后一个子节点。

•Node getNextSibling()：返回此节点之后的节点。

•Node getPreviousSibling()：返回此节点之前的节点。

•Document getOwnerDocument()：返回与此节点相关的 Document 对象。

•Node getParentNode()：返回此节点的父节点。

•short getNodeType()：返回此节点的类型。

•String getNodeName()：根据此节点类型，返回节点名称。

String getNodeValue()：根据此节点类型，返回节点值

前面已经提到，DOM 中很多接口都是从 Node 接口继承的，所以 Node 接口拥有的方法这些接口都可以使用

•例如，Element（元素接口）的 getNodeType() 的返回值为 Node.ELEMENT_NODE 常量，getNodeName() 的返回值为标签名称，getNodeValue() 的返回值为 null。

•Element getDocumentElement()：返回代表这个 DOM 树根节点的 Element 对象。

NodeList getElementsByTagName(String tagname)：按文档顺序返回包含在文档中且具有给定标记名称的所有 Element 的 NodeList

NodeList常用方法：

•int getLength()：返回有序集合中的节点数。

•Node item(int index)：返回有序集合中的第 index 个项。
XML文件

    public static List<Dog> ParseDomXml(String FileName) throws ParserConfigurationException, IOException, SAXException {
        List<Dog> Dogs =new ArrayList<>();
//        DoM解析方式：入口 返回一个工厂示例
       DocumentBuilderFactory Factory= DocumentBuilderFactory.newInstance();
//       制造产品
        DocumentBuilder builder =Factory.newDocumentBuilder();
//        解析,可以用java处理的document对象
       Document document=  builder.parse(new FileInputStream(FileName));
        //获取文档所有节点
       Element element=document.getDocumentElement();
       //获得dog节点的集合
       NodeList nodeList =element.getElementsByTagName("dog");
        for (int i = 0; i < nodeList.getLength(); i++) {
            Dog dog =new Dog();
//            获取每个元素 获取每一个<dog>
           Element element1=(Element) nodeList.item(i);
//           获取dog的id,即获得他的属性
          int id=Integer.parseInt(element1.getAttribute("id"))  ;
          dog.setId(id);
//          获得dog的子节点
           NodeList childNodes= element1.getChildNodes();
//           遍历每一个子节点
           for(int j=0;j<childNodes.getLength();j++)
           {
//               每一个子节点
               Node dogChild =childNodes.item(j);
//               只拿<XXX>形式的子节点
               if(dogChild.getNodeType()==Node.ELEMENT_NODE)
               {
                   if(dogChild.getNodeName().equals("name")){
//
                       String name =dogChild.getFirstChild().getNodeValue();
                       dog.setName(name);
                   }else if(dogChild.getNodeName().equals("sorce"))
                   {
                       double sorce =Double.parseDouble(dogChild.getFirstChild().getNodeValue());
                       dog.setSorce(sorce);
                   }else {
                       int level =Integer.parseInt(dogChild.getFirstChild().getNodeValue());
                       dog.setLevel(level);
                   }
               }

           }
            Dogs.add(dog);
        }
        return Dogs;
    }

测试代码

public class Test {
    public static void main(String[] args) throws ParserConfigurationException, SAXException, IOException {
//         创建解析器
        SAXParser parser= SAXParserFactory.newInstance().newSAXParser();
        InputStream in =new FileInputStream("D:\\Decelop\\untitled1\\untitled33\\src\\Student.xml");
        SAXXmlParse saxXmlParse=new SAXXmlParse();
        parser.parse(in,saxXmlParse);
        List<Student> lists =saxXmlParse.getStudents();
        for (Student stu : lists) {
            System.out.println(stu);
        }
    }
}

使用 SAX 解析 XML

相比于 DOM，SAX（Simple API for XML）是一种速度更快、更有效的解析 XML 文档的方法。它不需要一次性建立一个完整的 DOM 树，而是读取文档时激活事件进行处理
XML文件

public class SAXXmlParse extends DefaultHandler {
    private List<Student> students ;
    private String TagName;
    private Student student;
     public List<Student> getStudents() {
        return students;
    }
    //  开始解析XML文件 开始（执行一次）
    @Override
    public void startDocument() throws SAXException {
        students=  new ArrayList<>();

    }
    //  开始解析XML文件 结束（执行一次）
    @Override
    public void endDocument() throws SAXException {
        System.out.println("SAX解析结束...");

    }
    //  开始解析XML元素（执行多次）
    @Override
    public void startElement(String uri, String localName, String qName, Attributes attributes) throws SAXException {
//        拿到的是整个标签
        if(qName.equals("student")){
            student =new Student();
            int id =Integer.parseInt(attributes.getValue(0));
            student.setId(id);

        }
        this.TagName=qName;
    }
    //  结束解析XML元素（执行多次）
    @Override
    public void endElement(String uri, String localName, String qName) throws SAXException {
        if(qName.equals("student")){
            students.add(student);
        }
        this.TagName=null;
    }
    //  在startElement，endElement之间执行多次
//    拿到真正的元素值
    @Override
    public void characters(char[] ch, int start, int length) throws SAXException {
        if(this.TagName!=null){
//            将字符转化为字符数组
            String data =new String(ch,start,length);
            if(this.TagName.equals("name")){
                student.setName(data);
            }
            if(this.TagName.equals("age"))
            {
                student.setAge(Integer.parseInt(data));
            }
            if(this.TagName.equals("birthday")){
                try {
                    SimpleDateFormat sdf =new SimpleDateFormat("yyyy-mm-dd");
                    student.setBirthday((sdf.parse(data)));
                } catch (ParseException e) {
                    e.printStackTrace();
                }
            }

        }
    }
}

测试代码

public class TestXml {
    public static void main(String[] args) throws IOException, SAXException, ParserConfigurationException {
       List<Dog> dogList= DOMparse.ParseDomXml("D:\\Decelop\\untitled1\\untitled33\\src\\dogs.xml");
        System.out.println(dogList);
    }
}