Jaxb是JavaEE的規範.全稱Java Architecture for XML Binding. 
可以根據XML Schema產生Java類的技術.JAXB也提供了將XML例項文件反向生成Java物件樹的方法，並能將Java物件樹的內容重新寫到XML例項文件. 
JAXB 2.0是JDK 1.6的組成部分。JAXB 2.2.3是JDK 1.7的組成部分。在實際使用不需要引入新的jar. 
我一般使用都是配合JPA使用,下面例子也是按JPA+JAXB來說明. 
因此我需要引入jpa的實現包.hibernate-validator隨便.做驗證用的.

<dependency>
    <
 
groupId>org.hibernate.javax.persistence</groupId>
    <artifactId>hibernate-jpa-2.0-api</artifactId>
    <version>1.0.1.Final</version>
</dependency>
<dependency>
    <groupId>org.hibernate</groupId>
    <artifactId>hibernate-validator</artifactId
 
>
    <version>5.0.1.Final</version>
</dependency>

1. JDK中JAXB相關的重要Class和Interface：

• JAXBContext類，是應用的入口，用於管理XML/Java繫結資訊。
• Marshaller介面，將Java物件序列化為XML資料。
• Unmarshaller介面，將XML資料反序列化為Java物件。

http://my.oschina.net/zhaoqian/blog/89763 這個是簡單的入門demo.可以先執行試試,對JAXB有個大概的使用方法.下面例子將是系統正常做的.並對併發性進行處理的一個例子.

2. 常用註解說明

常用的annotation有：
@XmlType
@XmlElement
@XmlRootElement
@XmlAttribute
@XmlAccessorType
@XmlAccessorOrder
@XmlTransient
@XmlJavaTypeAdapter
@Temporal(TemporalType.XXXX) -->JPA中的時間處理註解,非JAXB
@XmlElementWrapper

[email protected]
　　@XmlType用在class類的註解，常與@XmlRootElement，@XmlAccessorType一起使用。它有三個屬性：name、propOrder、namespace，經常使用的只有前兩個屬性。如：
同時使用了@XmlType（propOrder={}）和@XmlAccessorOrder(XmlAccessOrder.ALPHABETICAL)的時候，生成的xml只按照propOrder定義的順序生成元素
@XmlType(name = "basicStruct", propOrder = {
    "intValue",
    "stringArray",
    "stringValue"
)
在使用@XmlType的propOrder 屬性時，必須列出JavaBean物件中的所有屬性，否則會報錯。

[email protected]
　　@XmlRootElement用於類級別的註解，對應xml的跟元素，常與 @XmlType 和 @XmlAccessorType一起使用。如：
　　@XmlType
　　@XmlAccessorType(XmlAccessType.FIELD)
　　@XmlRootElement
　　public class Address {}

[email protected]
　　@XmlElement將java物件的屬性對映為xml的節點，在使用@XmlElement時，可通過name屬性改變java物件屬性在xml中顯示的名稱。如：
　　@XmlElement(name="Address")　　
　　private String yourAddress;

[email protected]
　　@XmlAttribute用於把java物件的屬性對映為xml的屬性,並可通過name屬性為生成的xml屬性指定別名。如：
　　@XmlAttribute(name="Country")
　　private String state;
 
[email protected]
　　@XmlAccessorType用於指定由java物件生成xml檔案時對java物件屬性的訪問方式。常與@XmlRootElement、@XmlType一起使用。它的屬性值是XmlAccessType的4個列舉值，分別為:

• XmlAccessType.FIELD:java物件中的所有成員變數
• XmlAccessType.PROPERTY：java物件中所有通過getter/setter方式訪問的成員變數
• XmlAccessType.PUBLIC_MEMBER：java物件中所有的public訪問許可權的成員變數和通過getter/setter方式訪問的成員變數
• XmlAccessType.NONE:java物件的所有屬性都不對映為xml的元素

注意：@XmlAccessorType的預設訪問級別是XmlAccessType.PUBLIC_MEMBER，因此，如果java物件中的private成員變數設定了public許可權的getter/setter方法，就不要在private變數上使用@XmlElement和@XmlAttribute註解，否則在由java物件生成xml時會報同一個屬性在java類裡存在兩次的錯誤。同理，如果@XmlAccessorType的訪問許可權為XmlAccessType.NONE，如果在java的成員變數上使用了@XmlElement或@XmlAttribute註解，這些成員變數依然可以對映到xml檔案。

注意：雖然@XmlAccessorType為XmlAccessType.NONE,但是在java類的私有屬性上加了@XmlAttribute和@XmlElement註解後，這些私有成員會對映生成xml的元素

[email protected]
　　@XmlAccessorOrder用於對java物件生成的xml元素進行排序。它有兩個屬性值：
　　AccessorOrder.ALPHABETICAL：對生成的xml元素按字母書序排序
　　XmlAccessOrder.UNDEFINED:不排序

[email protected]
　　@XmlTransient用於標示在由java物件對映xml時，忽略此屬性。即，在生成的xml檔案中不出現此元素。

[email protected]
　　@XmlJavaTypeAdapter常用在轉換比較複雜的物件時，如map型別或者格式化日期等。使用此註解時，需要自己寫一個adapter類繼承XmlAdapter抽象類，並實現裡面的方法。
　　@XmlJavaTypeAdapter(value=xxx.class),value為自己定義的adapter類
　　XmlAdapter 抽象介面如下：

public abstract class XmlAdapter<ValueType,BoundType> {    // Do-nothing constructor for the derived classes.
    protected XmlAdapter() {}
    // Convert a value type to a bound type.
    public abstract BoundType unmarshal(ValueType v);
    // Convert a bound type to a value type.
    public abstract ValueType marshal(BoundType v);
 }

實際案例:

<i>package jaxb.shop;
  
import java.util.Date;
import java.text.SimpleDateFormat;
  
import javax.xml.bind.annotation.adapters.XmlAdapter;
  
public class DateAdapter extends XmlAdapter<String, Date> {
  
    private String pattern = "yyyy-MM-dd HH:mm:ss";
    SimpleDateFormat fmt = new SimpleDateFormat(pattern);
      
    @Override
    public Date unmarshal(String dateStr) throws Exception {
          
        return fmt.parse(dateStr);
    }
  
    @Override
    public String marshal(Date date) throws Exception {
          
        return fmt.format(date);
    }
  
}
//用於格式化日期在xml中的顯示格式，並且由xml unmarshal為java物件時，將字串解析為Date物件</i>

在某個類中如下使用,解析出對應的時間格式.必須過載那2個方法,用於JAXB marshal xml,xml unmarshal object時候使用.

   @XmlJavaTypeAdapter(value=DateAdapter.class)
    private Date purDate;

9.但如果是和JPA一起使用的話,可以使用@Temporal(TemporalType.DATE)來格式時間,預設為TemporalType.TIMESTAMP型別.TemporalType屬性如下:
public enum TemporalType {
    DATE, //java.sql.Date
    TIME, //java.sql.Time
    TIMESTAMP //java.sql.Timestamp
}
java.sql.Date
日期型，精確到年月日，例如“2008-08-08”
java.sql.Time
時間型，精確到時分秒，例如“20:00:00”
java.sql.Timestamp
時間戳，精確到納秒，例如“2008-08-08 20:00:00.000000001”

10.在JAXB標準中，@XmlElementWrapper註解表示生成一個包裝 XML 表示形式的包裝器元素。 此元素主要用於生成一個包裝集合的包裝器 XML 元素。
注：@XmlElementWrapper僅允許出現在集合屬性上。最後的案例將使用這個註解.

3. 最終案例(模擬XML--系統 --DB)

例子XML示例.

<?xml version="1.0" encoding="utf-8"?>
<userinfo xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:xsd="http://www.w3.org/2001/XMLSchema">
    <id>110</id>
    <name>Credo</name>
    <address>China BeiJing</address>
    <job>programmer</job>
    <overinfos>
        <overinfo>
            <hobby>Accompany my girlfriend.</hobby>
            <!--開始日期 dateTime-->
            <beginDate>2009-06-02T12:00:00</beginDate>
            <!--結束日期 dateTime-->
            <endDate>2109-06-02T12:00:00</endDate>
        </overinfo>
        <overinfo>
            <hobby>Write some code.</hobby>
            <!--開始日期 dateTime-->
            <beginDate>2009-06-02T12:00:00</beginDate>
            <!--結束日期 dateTime-->
            <endDate>2029-06-02T12:00:00</endDate>
        </overinfo>
    </overinfos>
</userinfo>

Model層(JAXB+JPA):

package org.credo.jaxb.model;
import java.io.Serializable;
import java.util.List;
import javax.persistence.CascadeType;
import javax.persistence.Column;
import javax.persistence.Entity;
import javax.persistence.Id;
import javax.persistence.OneToMany;
import javax.persistence.Table;
import javax.xml.bind.annotation.XmlAccessType;
import javax.xml.bind.annotation.XmlAccessorType;
import javax.xml.bind.annotation.XmlElement;
import javax.xml.bind.annotation.XmlElementWrapper;
import javax.xml.bind.annotation.XmlElements;
import javax.xml.bind.annotation.XmlRootElement;
import org.hibernate.validator.constraints.Length;
/**
 * @author Credo
 */
@XmlRootElement
@XmlAccessorType(XmlAccessType.FIELD)
@Entity
@Table(name = "USERINFO")
public class Userinfo implements Serializable{
     
    private static final long serialVersionUID = 7870351249722416047L;
     
    @Id
    @Column(name = "ID", nullable = false)
    private Long id;
     
    @Column(name = "NAME", length = 50)
    @Length(max = 50)
    private String name;
     
    @Column(name = "ADDRESS", length = 50)
    @Length(max = 50)
    private String address;
     
    @Column(name = "JOB", length = 50)
    @Length(max = 50)
    private String job;
     
    @XmlElementWrapper(name = "overinfos")
    @OneToMany(cascade = CascadeType.ALL)
    @XmlElements(value = { @XmlElement(name = "overinfo", type = Overinfo.class) })
    private List<Overinfo> overinfos;
     
    public Long getId() {
        return id;
    }
    public void setId(Long id) {
        this.id = id;
    }
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public String getAddress() {
        return address;
    }
    public void setAddress(String address) {
        this.address = address;
    }
    public String getJob() {
        return job;
    }
    public void setJob(String job) {
        this.job = job;
    }
    public List<Overinfo> getOverinfos() {
        return overinfos;
    }
    public void setOverinfos(List<Overinfo> overinfos) {
        this.overinfos = overinfos;
    }
     
}

Overinfo.class

package org.credo.jaxb.model;
import java.io.Serializable;
import java.util.Date;
import javax.persistence.CascadeType;
import javax.persistence.Column;
import javax.persistence.Entity;
import javax.persistence.GeneratedValue;
import javax.persistence.GenerationType;
import javax.persistence.Id;
import javax.persistence.JoinColumn;
import javax.persistence.ManyToOne;
import javax.persistence.Table;
import javax.persistence.Temporal;
import javax.persistence.TemporalType;
import javax.xml.bind.annotation.XmlAccessType;
import javax.xml.bind.annotation.XmlAccessorType;
import javax.xml.bind.annotation.XmlTransient;
import javax.xml.bind.annotation.XmlType;
@XmlAccessorType(XmlAccessType.FIELD)
@XmlType(name = "overinfo")
@Entity
@Table(name = "OVERINFO")
public class Overinfo implements Serializable {
    private static final long serialVersionUID = 2579971237985854291L;
    @XmlTransient
    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    @Column(name = "ID")
    private Long id;
     
    @XmlTransient
    @ManyToOne(cascade = CascadeType.ALL)
    @JoinColumn(name = "UserinfoId")
    private Userinfo userinfo;
     
    @Column(name = "hobby", length = 20)
    private String hobby;
     
    @Temporal(TemporalType.DATE)
    @Column(name = "beginDate", length = 20)
    private Date beginDate;
     
    @Temporal(TemporalType.DATE)
    @Column(name = "endDate", length = 20)
    private Date endDate;
    public String getHobby() {
        return hobby;
    }
    public void setHobby(String hobby) {
        this.hobby = hobby;
    }
    public Date getBeginDate() {
        return beginDate;
    }
    public void setBeginDate(Date beginDate) {
        this.beginDate = beginDate;
    }
    public Date getEndDate() {
        return endDate;
    }
    public void setEndDate(Date endDate) {
        this.endDate = endDate;
    }
    public Long getId() {
        return id;
    }
    public void setId(Long id) {
        this.id = id;
    }
    public Userinfo getUserinfo() {
        return userinfo;
    }
    public void setUserinfo(Userinfo userinfo) {
        this.userinfo = userinfo;
    }
}

JAXB併發處理:

package org.credo.jaxb;
import java.util.concurrent.ConcurrentHashMap;
import java.util.concurrent.ConcurrentMap;
import javax.xml.bind.JAXBContext;
import javax.xml.bind.JAXBException;
public final class JAXBCache {
    private static final JAXBCache instance = new JAXBCache();
    private final ConcurrentMap<String, JAXBContext> contextCache = new ConcurrentHashMap<String, JAXBContext>();
    private JAXBCache() {
    }
    public static JAXBCache instance() {
        return instance;
    }
    JAXBContext getJAXBContext(Class<?> clazz) throws JAXBException {
        JAXBContext context = contextCache.get(clazz.getName());
        if ( context == null )
        {
            context = JAXBContext.newInstance(clazz);
            contextCache.putIfAbsent(clazz.getName(), context);
        }
        return context;
    }
}

JAXBExportSchema 匯出JAXB的 class的 結構

package org.credo.jaxb;
import java.io.File;
import java.io.IOException;
import javax.xml.bind.JAXBContext;
import javax.xml.bind.SchemaOutputResolver;
import javax.xml.transform.Result;
import javax.xml.transform.stream.StreamResult;
import org.credo.jaxb.model.Userinfo;
/**
 * JAXB 匯出Schema。
 *
 * @author: Credo
 * @date: 2013-6-25
 */
public class JAXBExportSchema {
    public static void main(String[] args) {
        JAXBContext jct;
        try
        {
            jct = JAXBContext.newInstance(Userinfo.class);
            jct.generateSchema(new Resolver());
        }
        catch ( Exception ex )
        {
            ex.printStackTrace();
        }
    }
}
class Resolver extends SchemaOutputResolver {
    @Override
    public Result createOutput(String namespaceUri, String suggestedFileName) throws IOException {
        File file = new File("d:\\", suggestedFileName);
        StreamResult result = new StreamResult(file);
        result.setSystemId(file.toURI().toURL().toString());
        return result;
    }
}

JAXBUtil以及main方法測試:

package org.credo.jaxb;
import java.io.ByteArrayInputStream;
import java.io.ByteArrayOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.util.ArrayList;
import java.util.List;
import javax.xml.bind.JAXBContext;
import javax.xml.bind.JAXBException;
import javax.xml.bind.Marshaller;
import javax.xml.bind.Unmarshaller;
import org.apache.commons.io.IOUtils;
import org.credo.jaxb.model.Overinfo;
import org.credo.jaxb.model.Userinfo;
/**
 * marshal物件和unmarshal物件都是由JAXBContext建立.所以一開始需要初始化JAXBContext.
 * @author Credo
 */
public class JAXBUtil {
    /**
     * 生成xml檔案的二進位制資料
     * @param obj 物件
     */
    public static byte[] marshal(Object obj) throws JAXBException {
        JAXBContext context = JAXBCache.instance().getJAXBContext(obj.getClass());
        Marshaller m = context.createMarshaller();
        ByteArrayOutputStream outputStream = new ByteArrayOutputStream();
        m.setProperty(Marshaller.JAXB_FORMATTED_OUTPUT, Boolean.TRUE);
        m.marshal(obj, outputStream);
        byte[] result = outputStream.toByteArray();
        return result;
    }
    /**
     * @param data xml stream
     * @param classe 類
     * @return jaxb生成xml的java 類物件
     */
    public static Object unmarshal(byte[] data, Class<?> classe) throws JAXBException {
        JAXBContext context = JAXBCache.instance().getJAXBContext(classe);
        Unmarshaller m = context.createUnmarshaller();
        ByteArrayInputStream inputStream = new ByteArrayInputStream(data);
        Object obj = m.unmarshal(inputStream);
        return obj;
    }
    /**
     * @param data xml stream
     * @param classe 類
     * @return jaxb生成xml的java 類物件
     */
    public static Object unmarshal(InputStream in, Class<?> classe) throws JAXBException, IOException {
        JAXBContext context = JAXBCache.instance().getJAXBContext(classe);
        byte[] data = IOUtils.toByteArray(in);
        Unmarshaller m = context.createUnmarshaller();
        ByteArrayInputStream inputStream = new ByteArrayInputStream(data);
        Object obj = m.unmarshal(inputStream);
        return obj;
    }
    public static void main(String[] args) throws JAXBException {
        Userinfo userinfo = new Userinfo();
        userinfo.setId(Long.valueOf(11));
        List<Overinfo> list = new ArrayList<Overinfo>();
        Overinfo e = new Overinfo();
        e.setHobby("陪女友");
        list.add(e);
        Overinfo e1 = new Overinfo();
        e1.setHobby("寫程式碼");
        list.add(e1);
        userinfo.setOverinfos(list);
        byte[] b = JAXBUtil.marshal(userinfo);
        System.out.println(new String(b));
        userinfo = (Userinfo) JAXBUtil.unmarshal(b, Userinfo.class);
        System.out.println(userinfo.getOverinfos().get(0).getHobby());
    }
}

就不說明了,仔細看程式碼的,一會就明白了.不看的執行下也明白了.下面是上面main方法測試的輸出結果:

<?xml version="1.0" encoding="UTF-8" standalone="yes"?>
<userinfo>
    <id>11</id>
    <overinfos>
        <overinfo>
            <hobby>陪女友</hobby>
        </overinfo>
        <overinfo>
            <hobby>寫程式碼</hobby>
        </overinfo>
    </overinfos>
</userinfo>

陪女友

下面是使用JAXBExportSchema 匯出JAXB的 class的 結構

<?xml version="1.0" encoding="UTF-8" standalone="yes"?>
<xs:schema version="1.0" xmlns:xs="http://www.w3.org/2001/XMLSchema">
  <xs:element name="userinfo" type="userinfo"/>
  <xs:complexType name="userinfo">
    <xs:sequence>
      <xs:element name="id" type="xs:long" minOccurs="0"/>
      <xs:element name="name" type="xs:string" minOccurs="0"/>
      <xs:element name="address" type="xs:string" minOccurs="0"/>
      <xs:element name="job" type="xs:string" minOccurs="0"/>
      <xs:element name="overinfos" minOccurs="0">
        <xs:complexType>
          <xs:sequence>
            <xs:element name="overinfo" type="overinfo" minOccurs="0" maxOccurs="unbounded"/>
          </xs:sequence>
        </xs:complexType>
      </xs:element>
    </xs:sequence>
  </xs:complexType>
  <xs:complexType name="overinfo">
    <xs:sequence>
      <xs:element name="hobby" type="xs:string" minOccurs="0"/>
      <xs:element name="beginDate" type="xs:dateTime" minOccurs="0"/>
      <xs:element name="endDate" type="xs:dateTime" minOccurs="0"/>
    </xs:sequence>
  </xs:complexType>
</xs:schema>