java JAXB + STAX（是一种针对XML的流式拉分析API）读取xml

JDK1.5需要添加jar包，1.6以后就不需要了
<dependency>
    <groupId>stax</groupId>
    <artifactId>stax-api</artifactId>
    <version>1.0.1</version>
</dependency>
<dependency>
    <groupId>javax.xml.bind</groupId>
    <artifactId>jaxb-api</artifactId>
    <version>2.2.12</version>
</dependency>

JAXB：JAXB 的全名是Java ™ Architecture for XML Binding

Classroom.java

 public class Classroom {
     private int id;
     private String name;
     private int grade;

     public Classroom() {
         super();
         // TODO Auto-generated constructor stub
     }

     public Classroom(int id, String name, int grade) {
         super();
         this.id = id;
         this.name = name;
         this.grade = grade;
     }

     public int getId() {
         return id;
     }

     public void setId(int id) {
         this.id = id;
     }

     public String getName() {
         return name;
     }

     public void setName(String name) {
         this.name = name;
     }

     public int getGrade() {
         return grade;
     }

     public void setGrade(int grade) {
         this.grade = grade;
     }

     @Override
     public String toString() {
         // TODO Auto-generated method stub
         return String.format("id:%d, name:%s, grade:%d", this.id, this.name, this.grade);
     }
 }

Student.java

 @XmlRootElement
 public class Student {
     public int getId() {
         return id;
     }

     public void setId(int id) {
         this.id = id;
     }

     public String getName() {
         return name;
     }

     public void setName(String name) {
         this.name = name;
     }

     public int getAge() {
         return age;
     }

     public void setAge(int age) {
         this.age = age;
     }

     public Classroom getClassroom() {
         return classroom;
     }

     public void setClassroom(Classroom classroom) {
         this.classroom = classroom;
     }

     private int id;
     private String name;
     private int age;
     private Classroom classroom;

     public Student() {
         super();
         // TODO Auto-generated constructor stub
     }

     public Student(int id, String name, int age, Classroom classroom) {
         super();
         this.id = id;
         this.name = name;
         this.age = age;
         this.classroom = classroom;
     }

     @Override
     public String toString() {
         // TODO Auto-generated method stub
         return String.format("id:%d, name:%s, Classroom=>%s", this.id, this.name, this.classroom.toString());
     }
 }

main方法：

 public static void main(String[] args) throws JAXBException {
         Student student = new Student(, "大帅哥", , new Classroom(, "计算机", ));
         JAXBContext jaxbContext = JAXBContext.newInstance(Student.class);
         Marshaller marshaller = jaxbContext.createMarshaller();
         marshaller.setProperty(Marshaller.JAXB_FORMATTED_OUTPUT, true); //格式化输出
         marshaller.marshal(student, System.out);
         StringWriter stringWriter = new StringWriter();
         marshaller.marshal(student, stringWriter);
         String xml = stringWriter.toString();
         Unmarshaller unmarshaller = jaxbContext.createUnmarshaller();
         student = (Student) unmarshaller.unmarshal(new StringReader(xml));
         System.out.println(student.toString());
     }

STAX：StAX是Streaming API for XML的缩写，是一种针对XML的流式拉分析API。

使用XMLStreamReader和XMLEventReader读取XML文件

     <?xml version="1.0" encoding="UTF-8"?>
     <company>
         <depart title="Develop Group">
             <user name="Tom" age="28" gender="male" >Manager</user>
             <user name="Lily" age="26" gender="female" />
         </depart>
         <depart title="Test Group">
             <user name="Frank" age="32" gender="male" >Team Leader</user>
             <user name="Bob" age="45" gender="male" />
             <user name="Kate" age="25" gender="female" />
         </depart>
     </company>  

JAVA代码

 // 获得Stream解析器(指针读取器对象)
     public static XMLStreamReader getStreamReader() {
         XMLStreamReader reader = null;
         String xmlFile = App.class.getResource("/").getFile() + "users.xml";
         XMLInputFactory factory = XMLInputFactory.newInstance();
         try {
             reader = factory.createXMLStreamReader(new FileReader(xmlFile));
         } catch (FileNotFoundException e) {
             e.printStackTrace();
         } catch (XMLStreamException e) {
             e.printStackTrace();
         }
         return reader;
     }

     // 获得Stream解析器(指针读取器对象),过滤器
     public static XMLStreamReader getStreamReader(StreamFilter streamFilter) {
         // 创建基于迭代器的指针读取器对象
         XMLStreamReader filterReader = null;
         String xmlFile = App.class.getResource("/").getFile() + "users.xml";
         XMLInputFactory factory = XMLInputFactory.newInstance();
         try {
             XMLStreamReader reader = factory.createXMLStreamReader(new FileReader(xmlFile));
             filterReader = factory.createFilteredReader(reader, streamFilter);
         } catch (FileNotFoundException e) {
             e.printStackTrace();
         } catch (XMLStreamException e) {
             e.printStackTrace();
         }
         return filterReader;
     }

     // 列出所有用户名称
     public static void listNames() {
         // 创建基于迭代器的指针读取器对象
         XMLStreamReader reader = App.getStreamReader();
         // 遍历XML文档
         try {
             while (reader.hasNext()) {
                 int event = reader.next();
                 // 如果是元素的开始
                 if (event == XMLStreamConstants.START_ELEMENT) {
                     // 列出所有用户名称
                     if ("user".equalsIgnoreCase(reader.getLocalName())) {
                         System.out.println("Name:" + reader.getAttributeValue(null, "name"));
                     }
                 }
             }
             reader.close();
         } catch (XMLStreamException e) {
             e.printStackTrace();
         }
     }

     public static void listNamesAndAges() {
         XMLStreamReader reader = App.getStreamReader();
         try {
             while (reader.hasNext()) {
                 // 跳过所有空白、注释或处理指令，到下一个START_ELEMENT
                 int event = reader.nextTag();
                 if (event == XMLStreamConstants.START_ELEMENT) {
                     if ("user".equalsIgnoreCase(reader.getLocalName())) {
                         System.out.println("Name:" + reader.getAttributeValue(null, "name") + ";Age:" + reader.getAttributeValue(null, "age"));
                     }
                 }
             }
             reader.close();
         } catch (XMLStreamException e) {
             e.printStackTrace();
         }
     }

     // 获得Event解析器(事件读取器对象)
     public static XMLEventReader getEventReader() {
         XMLEventReader reader = null;
         String xmlFile = App.class.getResource("/").getFile() + "users.xml";
         XMLInputFactory factory = XMLInputFactory.newInstance();
         try {
             reader = factory.createXMLEventReader(new FileReader(xmlFile));
         } catch (FileNotFoundException e) {
             e.printStackTrace();
         } catch (XMLStreamException e) {
             e.printStackTrace();
         }
         return reader;
     }

     // 获得Event解析器(指针读取器对象),过滤器
     public static XMLEventReader getEventReader(EventFilter eventFilter) {
         // 创建基于迭代器的指针读取器对象
         XMLEventReader filterReader = null;
         String xmlFile = App.class.getResource("/").getFile() + "users.xml";
         XMLInputFactory factory = XMLInputFactory.newInstance();
         try {
             XMLEventReader reader = factory.createXMLEventReader(new FileReader(xmlFile));
             filterReader = factory.createFilteredReader(reader, eventFilter);
         } catch (FileNotFoundException e) {
             e.printStackTrace();
         } catch (XMLStreamException e) {
             e.printStackTrace();
         }
         return filterReader;
     }

     @SuppressWarnings("rawtypes")
     public static void listAllByXMLEventReader() {
         // 创建基于迭代器的事件读取器对象
         XMLEventReader reader = App.getEventReader();
         try {
             // 遍历XML文档
             while (reader.hasNext()) {
                 XMLEvent event = reader.nextEvent();
                 // 如果事件对象是元素的开始
                 if (event.isStartElement()) {
                     // 转换成开始元素事件对象
                     StartElement start = event.asStartElement();
                     // 打印元素标签的本地名称
                     System.out.print(start.getName().getLocalPart());
                     // 取得所有属性
                     Iterator attrs = start.getAttributes();
                     while (attrs.hasNext()) {
                         // 打印所有属性信息
                         Attribute attr = (Attribute) attrs.next();
                         System.out.print(":" + attr.getName().getLocalPart() + "=" + attr.getValue());
                     }
                     System.out.println();
                 }
             }
             reader.close();
         } catch (XMLStreamException e) {
             e.printStackTrace();
         }
     }

     public static void listUsersByStreamFilter() {
         XMLStreamReader streamFilterReader = App.getStreamReader(new StreamFilter() {
             public boolean accept(XMLStreamReader reader) {
                 try {
                     while (reader.hasNext()) {
                         int event = reader.next();
                         // 只接受元素的开始
                         if (event == XMLStreamConstants.START_ELEMENT) {
                             // 只保留user元素
                             if ("user".equalsIgnoreCase(reader.getLocalName())) {
                                 return true;
                             }
                         }
                         if (event == XMLStreamConstants.END_DOCUMENT) {
                             return true;
                         }
                     }
                 } catch (XMLStreamException e) {
                     e.printStackTrace();
                 }
                 return false;
             }
         });
         try {
             // 列出所有用户的名称
             System.out.println(streamFilterReader.getLocalName());
             while (streamFilterReader.hasNext()) {
                 // 过滤工作已交由过滤器完成，这里不需要再做user的判断了
                 System.out.println("Name=" + streamFilterReader.getAttributeValue(null, "name"));
                 if (streamFilterReader.getEventType() != XMLStreamConstants.END_DOCUMENT) {
                     streamFilterReader.next();
                 }
             }
             streamFilterReader.close();
         } catch (XMLStreamException e) {
             e.printStackTrace();
         }
     }

     public static void listUsersByEventFilter() {
         XMLEventReader eventFilterReader = App.getEventReader(new EventFilter() {
             public boolean accept(XMLEvent event) {
                 // 如果事件对象是元素的开始
                 if (event.isStartElement()) {
                     // 转换成开始元素事件对象
                     StartElement start = event.asStartElement();
                     // 打印元素标签的本地名称
                     return "user".equals(start.getName().getLocalPart());
                 }
                 return false;
             }
         });
         try {
             // 列出所有用户的名称
             while (eventFilterReader.hasNext()) {
                 XMLEvent event = eventFilterReader.nextEvent();
                 StartElement start = event.asStartElement();
                 System.out.println(start.getName().getLocalPart());
                 // 过滤工作已交由过滤器完成，这里不需要再做user的判断了
                 System.out.println("Name=" + start.getAttributeByName(new QName("name")).getValue());
             }
             eventFilterReader.close();
         } catch (XMLStreamException e) {
             e.printStackTrace();
         }
     }

     public static void main(String[] args) {
         // listNames();
         // listNamesAndAges();
         // listAllByXMLEventReader();
         // listUsersByStreamFilter();
         // listUsersByEventFilter();
     }

转自：http://blog.chinaunix.net/uid-20749563-id-718396.html

转自：http://zangweiren.iteye.com/blog/647334