JAXB xml生成与解析

JAXB（Java Architecture for XML Binding）是JSE和JEE平台的一部分，让开发者能够快速完成java类和XML的互相映射。常用的地方就是对象类和xml之间的映射，能够让bo自动生成节点，节点自动转成实体bo。

JAXB封装在jdk中，jdk1.7及以上都不需要引入多于的jar包就可以完成JAXB代码开发了。下面结合具体常用实例来看特性~

1.新建一个java工程，结构也比较简单，bo包下一个Student类， util包下是工具类JAXBUtils.java,test包下是测试类。 

1. bo类简单给上三个属性。关于注解引入的是javax.xml.bind.annotation下的类，类上注解对应xml的根节点，用@XmlRootElement注解，下面的成员变量对应根节点下的元素节点，用@XmlElement注解。

package com.wanmigaokong.bo;

import java.io.Serializable;

import javax.xml.bind.annotation.XmlElement;
import javax.xml.bind.annotation.XmlRootElement;

@XmlRootElement(name="studentBean")
public class Student implements Serializable {
    private static final long serialVersionUID = 1L;

    private String name;
    private int age;
    private String address;

//  @XmlElement(name="name")
    public String getName() {
        return name;
    }

    @XmlElement
    public int getAge() {
        return age;
    }

    @XmlElement(name="studentAddress")
    public String getAddress() {
        return address;
    }

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

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

    public void setAddress(String address) {
        this.address = address;
    }

}

bo类注解注意点：
@1. 类上的注解  @XmlRootElement 是必不可少的。注解的name属性是可选的，不给节点默认生成为和类名一样，不过全是小写的</student>。指定name="studentBean"这生成指定的节点名称,且和指定的大小写一致，有空格的话空格也会出现在标签中。Bean>
@2. 成员变量/属性上的注解 @XmlElement 可选的注解。不加或者只是加上@XmlElement,没有指定生成节点的名称，默认是和每个属性的名称一致，就是全变成小写。以age为例,</age>,如果给上name属性指定生成节点名称，则生成完全和name属性一致的节点出来，和类上的name属性一样。

2.工具类 JAXBUtils。知道一个点：序列化（marshal）是指从实体转成xml/节点的过程，而反序列化（unmarshal）反过来了，是xml/节点转成实体类的问题。工具类中常用的有三个方法—实体转node,实体转String类型xml，String类型xml转实体。大体上的思路都是从JAXBContext获取JAXBContext实例，然后通过这个实例获取序列化和反序列化实例。

package com.wanmigaokong.util;

import java.io.StringWriter;

import javax.xml.bind.JAXBContext;
import javax.xml.bind.JAXBException;
import javax.xml.bind.Marshaller;
import javax.xml.bind.Unmarshaller;

import org.w3c.dom.Node;

public class JAXBUtils {
    /**
     * 获取JAXBContext实例。
     * @param clazz
     * @return
     */
    @SuppressWarnings("unused")
    private static final JAXBContext getJAXBContext(Class c){
        JAXBContext jaxbContext=null;
        try {
            jaxbContext = JAXBContext.newInstance(c);
        } catch (JAXBException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
        return jaxbContext;
    }

    /**
     * 将报文节点反序列化为实体类
     * @param obj
     * @param node
     * @return
     */
    public static final Object documentToModel(Object obj,Node node){
        if(node == null){
            return null;
        }
        JAXBContext jaxbContext = getJAXBContext(obj.getClass());
        try {
            //得到反序列化实例Unmarshaller
            Unmarshaller unmarshaller = jaxbContext.createUnmarshaller();
            obj= unmarshaller.unmarshal(node);
        } catch (JAXBException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }

        return obj;
    }

    /**
     * 将实体类转序列化为对应String类型xml节点
     * @param obj
     * @return
     */
    public static final String modelToStringXML(Object obj){
        StringWriter writer= new StringWriter();
        JAXBContext jaxbContext = getJAXBContext(obj.getClass());
        try {
            Marshaller marshaller = jaxbContext.createMarshaller();
    //设置序列化的编码格式    
    marshaller.setProperty(Marshaller.JAXB_ENCODING, "UTF-8");
    //设置格式化输出   
    marshaller.setProperty(Marshaller.JAXB_FORMATTED_OUTPUT, true);
            marshaller.marshal(obj, writer);
        } catch (JAXBException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }

        return writer.toString();

    }



    /**
     * 将实体类转序列化为对应node节点
     * @param obj   实体类
     * @param node  创建的新节点
     * @return
     */
    public static final Node modelToNode(Object obj,Node node){
        JAXBContext jaxbContext = getJAXBContext(obj.getClass());
        try {
            Marshaller marshaller = jaxbContext.createMarshaller();
            marshaller.setProperty(Marshaller.JAXB_ENCODING, "UTF-8");
            marshaller.setProperty(Marshaller.JAXB_FORMATTED_OUTPUT, true);
            marshaller.marshal(obj, node);
        } catch (JAXBException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }

        return node;

    }
}

3.测试类 JAXBUtilsTest

package com.wanmigaokong.test;

import com.wanmigaokong.bo.Student;
import com.wanmigaokong.util.JAXBUtils;

public class JAXBUtilsTest {
    public static void main(String[] args) {
        Student student=new Student();
        student.setAddress("1");
        student.setName("1");
        student.setAge(1);
        String xml = JAXBUtils.modelToStringXML(student);
        System.out.println("-------------------------------");
        System.out.println(xml);
    }
}

4.控制台打印结果

-------------------------------------------

<studentBean>
    <studentAddress>1studentAddress>
    <age>1age>
    <name>1name>
studentBean>

5.把生成的xml放到本地一个文件，然后读取并转成实体Student

public static void main(String[] args) {
    File file = new File("F:/testFile/student.xml");
    Student stu = (Student) JAXBUtils.documentToModel(new Student(),
    XMLs.getDocFromStringXml(file));
    System.out.println(stu.getAddress()+"  "+stu.getAge()+" "+stu.getName()) ;
    }

把文件解析称document的工具类：XMLS.java

package com.wanmigaokong.util;

import java.io.File;

import javax.xml.parsers.DocumentBuilder;
import javax.xml.parsers.DocumentBuilderFactory;

import org.w3c.dom.Document;

public class XMLs {

    public static Document getDocFromStringXml(File file){
        DocumentBuilderFactory factory=DocumentBuilderFactory.newInstance();
        Document document = null;
        try {
            DocumentBuilder documentBuilder = factory.newDocumentBuilder();
             document=documentBuilder.parse(file);
        } catch (Exception e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
        return document;
    }
}

运行结果：

A  10 JOM

注意点：这里的解析都是知道节点只有一个的情况下，如果在程序中是要判断节点，然后拿到节点解析的。这里就一个节点，所以可以拿到整个报文进行解析。