JAXB注解 java 关于xml的注解，自动生成xml文件

Java和xml的互相转换,依靠强大的JAXBContext可以轻松实现。

http://jaxb.java.net/tutorial/

http://jackyrong.iteye.com/blog/1890669

上面这个是 JAXB 参考实现中 JAXB 的教程，有兴趣的话可以去看看。这个 JAXB 参考实现在 JDK 1.6 开始已经从 J2EE 加入到 J2SE 类库中去了。


下面通过一个简单案例学习一下JAXBContext


首先准备好一个JavaBean供实验:

注意

1、类文件注解：@XmlRootElement不可缺少

2、2个Student的构造方法不能少

[java]  view plain copy
  1. @XmlRootElement  
  2. public class Student {  
  3.     private String name;  
  4.     private String width;  
  5.     private String height;  
  6.     private int age;  
  7.       
  8.       
  9.     public Student(String name, String width, String height, int age) {  
  10.         super();  
  11.         this.name = name;  
  12.         this.width = width;  
  13.         this.height = height;  
  14.         this.age = age;  
  15.     }  
  16.     public String getName() {  
  17.         return name;  
  18.     }  
  19.     public void setName(String name) {  
  20.         this.name = name;  
  21.     }  
  22.     public String getWidth() {  
  23.         return width;  
  24.     }  
  25.     public void setWidth(String width) {  
  26.         this.width = width;  
  27.     }  
  28.     public String getHeight() {  
  29.         return height;  
  30.     }  
  31.     public void setHeight(String height) {  
  32.         this.height = height;  
  33.     }  
  34.     public int getAge() {  
  35.         return age;  
  36.     }  
  37.     public void setAge(int age) {  
  38.         this.age = age;  
  39.     }  
  40.     public Student() {  
  41.         super();  
  42.     }  
  43.       
  44. }  
[java]  view plain  copy
  在CODE上查看代码片 派生到我的代码片
  1. @XmlRootElement  
  2. public class Student {  
  3.     private String name;  
  4.     private String width;  
  5.     private String height;  
  6.     private int age;  
  7.       
  8.       
  9.     public Student(String name, String width, String height, int age) {  
  10.         super();  
  11.         this.name = name;  
  12.         this.width = width;  
  13.         this.height = height;  
  14.         this.age = age;  
  15.     }  
  16.     public String getName() {  
  17.         return name;  
  18.     }  
  19.     public void setName(String name) {  
  20.         this.name = name;  
  21.     }  
  22.     public String getWidth() {  
  23.         return width;  
  24.     }  
  25.     public void setWidth(String width) {  
  26.         this.width = width;  
  27.     }  
  28.     public String getHeight() {  
  29.         return height;  
  30.     }  
  31.     public void setHeight(String height) {  
  32.         this.height = height;  
  33.     }  
  34.     public int getAge() {  
  35.         return age;  
  36.     }  
  37.     public void setAge(int age) {  
  38.         this.age = age;  
  39.     }  
  40.     public Student() {  
  41.         super();  
  42.     }  
  43.       
  44. }  


JavaToXml：

[java]  view plain copy
  1. @Test  
  2. public void test01(){  
  3.     try {  
  4.         JAXBContext jc = JAXBContext.newInstance(Student.class);  
  5.         Marshaller ms = jc.createMarshaller();  
  6.         Student st = new Student("zhang", "w", "h", 11);  
  7.         ms.marshal(st, System.out);  
  8.     } catch (JAXBException e) {  
  9.         // TODO Auto-generated catch block  
  10.         e.printStackTrace();  
  11.     }  
  12. }  
[java]  view plain  copy
  在CODE上查看代码片 派生到我的代码片
  1. @Test  
  2. public void test01(){  
  3.     try {  
  4.         JAXBContext jc = JAXBContext.newInstance(Student.class);  
  5.         Marshaller ms = jc.createMarshaller();  
  6.         Student st = new Student("zhang", "w", "h", 11);  
  7.         ms.marshal(st, System.out);  
  8.     } catch (JAXBException e) {  
  9.         // TODO Auto-generated catch block  
  10.         e.printStackTrace();  
  11.     }  
  12. }  


 

XmlToJava

[java]  view plain copy
  1. //xml转换Java  
  2. @Test  
  3. public void test02() throws JAXBException{  
  4.     String xml = "<?xml version=\"1.0\" encoding=\"UTF-8\" standalone=\"yes\"?><student><age>11</age><height>h</height><name>zhang</name><width>w</width></student>";  
  5.     JAXBContext jc = JAXBContext.newInstance(Student.class);  
  6.     Unmarshaller unmar = jc.createUnmarshaller();  
  7.     Student stu = (Student) unmar.unmarshal(new StringReader(xml));  
  8.     System.out.println(stu.getName());  
  9. }  

 

 

 

用的是jdk自带的javax.xml.bind.JAXBContext将对象和xml字符串进行相互转换。

       如果对要生成的 xml 格式有点些许的限制，就会对生成xml的对象就需要进行些许控制，控制对象的一个最可行的办法就是用注解。
 
       比较常用的几个：
       @XmlRootElement：根节点
       @XmlAttribute：该属性作为xml的attribute
       @XmlElement：该属性作为xml的element，且可以增加属性(name="NewElementName")，那么生成的xml串的elment的标签是NewElementName

        示例：    
       
[java]  view plain copy
  1. package test;  
  2.   
  3. import java.io.StringWriter;  
  4.   
  5. import javax.xml.bind.JAXBContext;  
  6. import javax.xml.bind.JAXBException;  
  7. import javax.xml.bind.Marshaller;  
  8.   
  9. import test.bean.EleClassA;  
  10. import test.bean.EleClassB;  
  11. import test.bean.RootClass;  
  12.   
  13. public class Test1 {  
  14.   
  15.     public static void main(String[] args) {  
  16.         RootClass rc = new RootClass();  
  17.         EleClassA a = new EleClassA();  
  18.         EleClassB b = new EleClassB();  
  19.           
  20.         a.setAttrC("attrc");  
  21.         a.setEleA("eleA");  
  22.         a.setEleB("eleB");  
  23.           
  24.         b.setAttrPassword("attrPassword");  
  25.         b.setAttrUserName("attrUsrName");  
  26.         b.setEleCode("eleCode");  
  27.           
  28.         rc.setA(a);  
  29.         rc.setB(b);  
  30.         rc.setRoot("root");  
  31.         rc.setRootA("rootA");  
  32.           
  33.           
  34.         JAXBContext context;  
  35.         try {  
  36.             context = JAXBContext.newInstance(RootClass.class);  
  37.             Marshaller mar = context.createMarshaller();  
  38.             mar.setProperty(Marshaller.JAXB_FORMATTED_OUTPUT, true);  
  39.             mar.setProperty(Marshaller.JAXB_ENCODING, "UTF-8");  
  40.               
  41.             StringWriter writer = new StringWriter();  
  42.               
  43.             mar.marshal(rc, writer);  
  44.               
  45.             System.out.println(writer.toString());  
  46.         } catch (JAXBException e) {  
  47.             e.printStackTrace();  
  48.         }  
  49.           
  50.     }  
  51. }  
  52.   
  53.   
  54. package test.bean;  
  55.   
  56. import javax.xml.bind.annotation.XmlElement;  
  57. import javax.xml.bind.annotation.XmlRootElement;  
  58.   
  59. @XmlRootElement(name="rootclass")  
  60. public class RootClass {  
  61.   
  62.     private EleClassA a;  
  63.     private EleClassB b;  
  64.     private String root;  
  65.     private String rootA;  
  66.       
  67.     @XmlElement(name="eleClassA")  
  68.     public EleClassA getA() {  
  69.         return a;  
  70.     }  
  71.     public void setA(EleClassA a) {  
  72.         this.a = a;  
  73.     }  
  74.     @XmlElement(name="EleclassA")  
  75.     public EleClassB getB() {  
  76.         return b;  
  77.     }  
  78.     public void setB(EleClassB b) {  
  79.         this.b = b;  
  80.     }  
  81.     public String getRoot() {  
  82.         return root;  
  83.     }  
  84.     public void setRoot(String root) {  
  85.         this.root = root;  
  86.     }  
  87.     public String getRootA() {  
  88.         return rootA;  
  89.     }  
  90.     public void setRootA(String rootA) {  
  91.         this.rootA = rootA;  
  92.     }  
  93.       
  94. }  
  95.   
  96.   
  97. package test.bean;  
  98.   
  99. import javax.xml.bind.annotation.XmlAttribute;  
  100. import javax.xml.bind.annotation.XmlElement;  
  101.   
  102. public class EleClassA {  
  103.   
  104.     private String eleA;  
  105.     private String eleB;  
  106.       
  107.     private String attrC;  
  108.   
  109.     @XmlElement  
  110.     public String getEleA() {  
  111.         return eleA;  
  112.     }  
  113.   
  114.     public void setEleA(String eleA) {  
  115.         this.eleA = eleA;  
  116.     }  
  117.   
  118.     @XmlElement(name="elebnewname")  
  119.     public String getEleB() {  
  120.         return eleB;  
  121.     }  
  122.   
  123.     public void setEleB(String eleB) {  
  124.         this.eleB = eleB;  
  125.     }  
  126.   
  127.     @XmlAttribute()  
  128.     public String getAttrC() {  
  129.         return attrC;  
  130.     }  
  131.   
  132.     public void setAttrC(String attrC) {  
  133.         this.attrC = attrC;  
  134.     }  
  135.       
  136. }  
  137.   
  138.   
  139. package test.bean;  
  140.   
  141. import javax.xml.bind.annotation.XmlAttribute;  
  142. import javax.xml.bind.annotation.XmlElement;  
  143.   
  144. public class EleClassB {  
  145.   
  146.     private String attrUserName;  
  147.     private String attrPassword;  
  148.       
  149.     private String eleCode;  
  150.       
  151.     @XmlAttribute  
  152.     public String getAttrUserName() {  
  153.         return attrUserName;  
  154.     }  
  155.     public void setAttrUserName(String attrUserName) {  
  156.         this.attrUserName = attrUserName;  
  157.     }  
  158.     @XmlAttribute(name="password")  
  159.     public String getAttrPassword() {  
  160.         return attrPassword;  
  161.     }  
  162.     public void setAttrPassword(String attrPassword) {  
  163.         this.attrPassword = attrPassword;  
  164.     }  
  165.     @XmlElement  
  166.     public String getEleCode() {  
  167.         return eleCode;  
  168.     }  
  169.     public void setEleCode(String eleCode) {  
  170.         this.eleCode = eleCode;  
  171.     }  
  172.       
  173.       
  174. }  
[java]  view plain  copy
  在CODE上查看代码片 派生到我的代码片
  1. package test;  
  2.   
  3. import java.io.StringWriter;  
  4.   
  5. import javax.xml.bind.JAXBContext;  
  6. import javax.xml.bind.JAXBException;  
  7. import javax.xml.bind.Marshaller;  
  8.   
  9. import test.bean.EleClassA;  
  10. import test.bean.EleClassB;  
  11. import test.bean.RootClass;  
  12.   
  13. public class Test1 {  
  14.   
  15.     public static void main(String[] args) {  
  16.         RootClass rc = new RootClass();  
  17.         EleClassA a = new EleClassA();  
  18.         EleClassB b = new EleClassB();  
  19.           
  20.         a.setAttrC("attrc");  
  21.         a.setEleA("eleA");  
  22.         a.setEleB("eleB");  
  23.           
  24.         b.setAttrPassword("attrPassword");  
  25.         b.setAttrUserName("attrUsrName");  
  26.         b.setEleCode("eleCode");  
  27.           
  28.         rc.setA(a);  
  29.         rc.setB(b);  
  30.         rc.setRoot("root");  
  31.         rc.setRootA("rootA");  
  32.           
  33.           
  34.         JAXBContext context;  
  35.         try {  
  36.             context = JAXBContext.newInstance(RootClass.class);  
  37.             Marshaller mar = context.createMarshaller();  
  38.             mar.setProperty(Marshaller.JAXB_FORMATTED_OUTPUT, true);  
  39.             mar.setProperty(Marshaller.JAXB_ENCODING, "UTF-8");  
  40.               
  41.             StringWriter writer = new StringWriter();  
  42.               
  43.             mar.marshal(rc, writer);  
  44.               
  45.             System.out.println(writer.toString());  
  46.         } catch (JAXBException e) {  
  47.             e.printStackTrace();  
  48.         }  
  49.           
  50.     }  
  51. }  
  52.   
  53.   
  54. package test.bean;  
  55.   
  56. import javax.xml.bind.annotation.XmlElement;  
  57. import javax.xml.bind.annotation.XmlRootElement;  
  58.   
  59. @XmlRootElement(name="rootclass")  
  60. public class RootClass {  
  61.   
  62.     private EleClassA a;  
  63.     private EleClassB b;  
  64.     private String root;  
  65.     private String rootA;  
  66.       
  67.     @XmlElement(name="eleClassA")  
  68.     public EleClassA getA() {  
  69.         return a;  
  70.     }  
  71.     public void setA(EleClassA a) {  
  72.         this.a = a;  
  73.     }  
  74.     @XmlElement(name="EleclassA")  
  75.     public EleClassB getB() {  
  76.         return b;  
  77.     }  
  78.     public void setB(EleClassB b) {  
  79.         this.b = b;  
  80.     }  
  81.     public String getRoot() {  
  82.         return root;  
  83.     }  
  84.     public void setRoot(String root) {  
  85.         this.root = root;  
  86.     }  
  87.     public String getRootA() {  
  88.         return rootA;  
  89.     }  
  90.     public void setRootA(String rootA) {  
  91.         this.rootA = rootA;  
  92.     }  
  93.       
  94. }  
  95.   
  96.   
  97. package test.bean;  
  98.   
  99. import javax.xml.bind.annotation.XmlAttribute;  
  100. import javax.xml.bind.annotation.XmlElement;  
  101.   
  102. public class EleClassA {  
  103.   
  104.     private String eleA;  
  105.     private String eleB;  
  106.       
  107.     private String attrC;  
  108.   
  109.     @XmlElement  
  110.     public String getEleA() {  
  111.         return eleA;  
  112.     }  
  113.   
  114.     public void setEleA(String eleA) {  
  115.         this.eleA = eleA;  
  116.     }  
  117.   
  118.     @XmlElement(name="elebnewname")  
  119.     public String getEleB() {  
  120.         return eleB;  
  121.     }  
  122.   
  123.     public void setEleB(String eleB) {  
  124.         this.eleB = eleB;  
  125.     }  
  126.   
  127.     @XmlAttribute()  
  128.     public String getAttrC() {  
  129.         return attrC;  
  130.     }  
  131.   
  132.     public void setAttrC(String attrC) {  
  133.         this.attrC = attrC;  
  134.     }  
  135.       
  136. }  
  137.   
  138.   
  139. package test.bean;  
  140.   
  141. import javax.xml.bind.annotation.XmlAttribute;  
  142. import javax.xml.bind.annotation.XmlElement;  
  143.   
  144. public class EleClassB {  
  145.   
  146.     private String attrUserName;  
  147.     private String attrPassword;  
  148.       
  149.     private String eleCode;  
  150.       
  151.     @XmlAttribute  
  152.     public String getAttrUserName() {  
  153.         return attrUserName;  
  154.     }  
  155.     public void setAttrUserName(String attrUserName) {  
  156.         this.attrUserName = attrUserName;  
  157.     }  
  158.     @XmlAttribute(name="password")  
  159.     public String getAttrPassword() {  
  160.         return attrPassword;  
  161.     }  
  162.     public void setAttrPassword(String attrPassword) {  
  163.         this.attrPassword = attrPassword;  
  164.     }  
  165.     @XmlElement  
  166.     public String getEleCode() {  
  167.         return eleCode;  
  168.     }  
  169.     public void setEleCode(String eleCode) {  
  170.         this.eleCode = eleCode;  
  171.     }  
  172.       
  173.       
  174. }  

运行Test1类中main方法，执行结果：
[html]  view plain copy
  1. <?xml version="1.0" encoding="UTF-8" standalone="yes"?>  
  2. <rootclass>  
  3.     <eleClassA attrC="attrc">  
  4.         <eleA>eleA</eleA>  
  5.         <elebnewname>eleB</elebnewname>  
  6.     </eleClassA>  
  7.     <EleclassA attrUserName="attrUsrName" password="attrPassword">  
  8.         <eleCode>eleCode</eleCode>  
  9.     </EleclassA>  
  10.     <root>root</root>  
  11.     <rootA>rootA</rootA>  
  12. </rootclass>  

 

 

JAXB（Java API for XML Binding），提供了一个快速便捷的方式将Java对象与XML进行转换。在JAX-WS（Java的WebService规范之一）中，JDK1.6 自带的版本JAX-WS2.1，其底层支持就是JAXB。

    JAXB 可以实现Java对象与XML的相互转换，在JAXB中，将一个Java对象转换为XML的过程称之为Marshal，将XML转换为Java对象的过程称之为UnMarshal。我们可以通过在 Java 类中标注注解的方式将一个Java对象绑定到一段XML，也就是说，在Java类中标注一些注解，这些注解定义了如何将这个类转换为XML，怎么转换，以及一段XML如何被解析成这个类所定义的对象；也可以使用JAXB的XJC工具，通过定义schema的方式实现Java对象与XML的绑定（这个下次研究）。

    下面来了解一下如何通过标注注解来完成 Marshal 和 UnMarshal 的过程。我用的是 JAXB2_20101209.jar ，可以到http://jaxb.java.net/下载最新版本。

 

首先看个小例子：



定义一个java类

Java代码
package com.why.jaxb;   
  
import javax.xml.bind.annotation.XmlRootElement;   
  
@XmlRootElement  
public class People {   
    public String id = "001";   
    public String name = "灰太狼";   
    public int age = 26;   
}  

//我们在实际中一般在get方法上添加相关注解
Java To XML（Marshal）

Java代码
package com.why.jaxb;   
  
import javax.xml.bind.JAXBContext;   
import javax.xml.bind.JAXBException;   
import javax.xml.bind.Marshaller;   
  
public class Java2XML {   
  
    /**  
     * @param args  
     * @throws JAXBException   
     */  
    public static void main(String[] args) throws JAXBException {   
        JAXBContext context = JAXBContext.newInstance(People.class);   
           
        Marshaller marshaller = context.createMarshaller();   
        marshaller.setProperty(Marshaller.JAXB_ENCODING,"gb2312");//编码格式

        //我在实际开发中重新封装了JAXB基本类，这里就使用到了该属性。不过默认的编码格式UTF-8

        marshaller.setProperty(Marshaller.JAXB_FORMATTED_OUTPUT, true);//是否格式化生成的xml串   
        marshaller.setProperty(Marshaller.JAXB_FRAGMENT, false);//是否省略xml头信息（<?xml version="1.0" encoding="gb2312" standalone="yes"?>）   
           
        People people = new People();   
        marshaller.marshal(people, System.out);   
    }   
  
}  

XML To Java（UnMarshal）

Java代码
package com.why.jaxb;   
  
import java.io.File;   
import javax.xml.bind.JAXBContext;   
import javax.xml.bind.JAXBException;   
import javax.xml.bind.Unmarshaller;   
import org.xml.sax.SAXException;   
  
public class XML2Java {   
    /**  
     * @param args  
     * @throws JAXBException   
     * @throws JAXBException   
     * @throws SAXException   
     */  
    public static void main(String[] args) throws JAXBException {   
        JAXBContext context = JAXBContext.newInstance(People.class);   
        Unmarshaller unmarshaller = context.createUnmarshaller();   
        File file = new File("src/people.xml");   
        People people = (People)unmarshaller.unmarshal(file);   
        System.out.println(people.id);   
        System.out.println(people.name);   
        System.out.println(people.age);   
    }   
}

 

       其实Marshal 和 UnMarshal的过程并不复杂，只需要从JAXBContext中获得Marshaller或Unmarshaller对象，就可以让JAXB帮我们来进行转换了。我们需要操作的主要内容是定义一个规则，告诉JAXB如何将一个类、按照什么样的格式转换为XML，下面是JAXB中主要的一些注解。



@XmlRootElement   将一个Java类映射为一段XML的根节点

参数：name            定义这个根节点的名称

          namespace   定义这个根节点命名空间



@XmlAccessorType  定义映射这个类中的何种类型需要映射到XML。可接收四个参数，分别是：

      XmlAccessType.FIELD：映射这个类中的所有字段到XML

      XmlAccessType.PROPERTY：映射这个类中的属性（get/set方法）到XML

      XmlAccessType.PUBLIC_MEMBER：将这个类中的所有public的field或property同时映射到XML（默认）

      XmlAccessType.NONE：不映射



@XmlElement  指定一个字段或get/set方法映射到XML的节点。如，当一个类的XmlAccessorType 被标注为PROPERTY时，在某一个没有get/set方法的字段上标注此注解，即可将该字段映射到XML。

参数：defaultValue  指定节点默认值

         name             指定节点名称

         namespace    指定节点命名空间

         required         是否必须（默认为false）

         nillable           该字段是否包含 nillable="true" 属性（默认为false）

         type               定义该字段或属性的关联类型



@XmlAttribute  指定一个字段或get/set方法映射到XML的属性。

参数：name             指定属性名称

         namespace    指定属性命名空间

         required         是否必须（默认为false）



@XmlTransient  定义某一字段或属性不需要被映射为XML。如，当一个类的XmlAccessorType 被标注为PROPERTY时，在某一get/set方法的字段上标注此注解，那么该属性则不会被映射。



@XmlType 定义映射的一些相关规则

参数：propOrder        指定映射XML时的节点顺序

         factoryClass     指定UnMarshal时生成映射类实例所需的工厂类，默认为这个类本身

         factoryMethod  指定工厂类的工厂方法

         name               定义XML Schema中type的名称

         namespace      指定Schema中的命名空间



@XmlElementWrapper  为数组元素或集合元素定义一个父节点。如，类中有一元素为List items，若不加此注解，该元素将被映射为

    <items>...</items>

    <items>...</items>

这种形式，此注解可将这个元素进行包装，如：

    @XmlElementWrapper(name="items")
    @XmlElement(name="item")
    public List items;

将会生成这样的XML样式：

    <items>

        <item>...</item>

        <item>...</item>

    </items>



@XmlJavaTypeAdapter  自定义某一字段或属性映射到XML的适配器。如，类中包含一个接口，我们可以定义一个适配器（继承自 javax.xml.bind.annotation.adapters.XmlAdapter类），指定这个接口如何映射到XML。



@XmlSchema 配置整个包的namespace，这个注解需放在package-info.java文件中。

jaxb编码：

           JAXBContext jaxbContext = JAXBContext.newInstance(clazz);
            Unmarshaller unmarshaller = jaxbContext.createUnmarshaller();
            InputStreamReader reader=new InputStreamReader(inputStream,"GBK");   //在此修改编码
            return unmarshaller.unmarshal(reader);

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

在JAXB中(用于JAVA对象和xml之间的转换),经常出现各类的 @XmlElement这样的标记, 
下面就来以一个例子小结下,加深学习: 

Java代码
  1.   
  2. import java.util.*;   
  3. import javax.xml.bind.annotation.*;   
  4.     
  5. @XmlRootElement  
  6. @XmlAccessorType(XmlAccessType.FIELD)   
  7. public class Customer {   
  8.     
  9.     private List<String> emailAddresses;   
  10.         
  11.     public Customer() {   
  12.         emailAddresses = new ArrayList<String>();   
  13.     }   
  14.     
  15.     public List<String> getEmailAddresses() {   
  16.         return emailAddresses;   
  17.     }   
  18.     
  19.     public void setEmailAddresses(List<String> emailAddresses) {   
  20.         this.emailAddresses = emailAddresses;   
  21.     }   
  22.     
  23. }  
[java]  view plain  copy
  在CODE上查看代码片 派生到我的代码片
  1. import java.util.*;  
  2. import javax.xml.bind.annotation.*;  
  3.    
  4. @XmlRootElement  
  5. @XmlAccessorType(XmlAccessType.FIELD)  
  6. public class Customer {  
  7.    
  8.     private List<String> emailAddresses;  
  9.        
  10.     public Customer() {  
  11.         emailAddresses = new ArrayList<String>();  
  12.     }  
  13.    
  14.     public List<String> getEmailAddresses() {  
  15.         return emailAddresses;  
  16.     }  
  17.    
  18.     public void setEmailAddresses(List<String> emailAddresses) {  
  19.         this.emailAddresses = emailAddresses;  
  20.     }  
  21.    
  22. }  



这个是一个典型的POJO了,其中引用了对象emailAddress,是一个List,那么下面演示各类用法: 
  先看默认的调用代码如下: 

Java代码
  1. import javax.xml.bind.JAXBContext;   
  2. import javax.xml.bind.Marshaller;   
  3.     
  4. public class Demo {   
  5.     
  6.     public static void main(String[] args) throws Exception {   
  7.         JAXBContext jc = JAXBContext.newInstance(Customer.class);   
  8.     
  9.         Customer customer = new Customer();   
  10.         customer.getEmailAddresses().add("janed@example.com");   
  11.         customer.getEmailAddresses().add("jdoe@example.org");   
  12.     
  13.         Marshaller marshaller = jc.createMarshaller();   
  14.         marshaller.setProperty(Marshaller.JAXB_FORMATTED_OUTPUT, true);   
  15.         marshaller.marshal(customer, System.out);   
  16.     }   
  17. }  
[java]  view plain  copy
  在CODE上查看代码片 派生到我的代码片
  1. import javax.xml.bind.JAXBContext;  
  2. import javax.xml.bind.Marshaller;  
  3.    
  4. public class Demo {  
  5.    
  6.     public static void main(String[] args) throws Exception {  
  7.         JAXBContext jc = JAXBContext.newInstance(Customer.class);  
  8.    
  9.         Customer customer = new Customer();  
  10.         customer.getEmailAddresses().add("janed@example.com");  
  11.         customer.getEmailAddresses().add("jdoe@example.org");  
  12.    
  13.         Marshaller marshaller = jc.createMarshaller();  
  14.         marshaller.setProperty(Marshaller.JAXB_FORMATTED_OUTPUT, true);  
  15.         marshaller.marshal(customer, System.out);  
  16.     }  
  17. }  



  默认的把这个对象输出为一般的XML: 
<customer> 
    <emailAddresses>janed@example.com</emailAddresses> 
    <emailAddresses>jdoe@example.org</emailAddresses> 
</customer> 

下面逐一看每个注解的用法 
1) @XmlElement 
   
@XmlElement(name="email-address") 
    private List<String> emailAddresses; 
加上这个注解的话,则按自定义的xml标签名去输出某个属性,如下: 
<customer> 
    <email-address>janed@example.com</email-address> 
    <email-address>jdoe@example.org</email-address> 
</customer> 

2) @XmlElementWrapper 
  这个注解等于在最外面再包一层了, 
@XmlRootElement 
@XmlAccessorType(XmlAccessType.FIELD) 
public class Customer { 

    @XmlElementWrapper(name="email-addresses") 
    @XmlElement(name="email-address") 
    private List<String> emailAddresses; 

} 
  输出: 
<customer> 
    <email-addresses> 
        <email-address>janed@example.com</email-address> 
        <email-address>jdoe@example.org</email-address> 
    </email-addresses> 
</customer> 


3) @XmlList 
  这个等于是在同一行中,把list中的输出,以空格形式分隔开来, 

Java代码
  1. @XmlRootElement  
  2. @XmlAccessorType(XmlAccessType.FIELD)   
  3. public class Customer {   
  4.     
  5.     @XmlList  
  6.     private List<String> emailAddresses;   
  7.     
  8. }  
[java]  view plain  copy
  在CODE上查看代码片 派生到我的代码片
  1. @XmlRootElement  
  2. @XmlAccessorType(XmlAccessType.FIELD)  
  3. public class Customer {  
  4.    
  5.     @XmlList  
  6.     private List<String> emailAddresses;  
  7.    
  8. }  



  输出: 
  <customer> 
    <emailAddresses>janed@example.com jdoe@example.org</emailAddresses> 
</customer> 

4) 
@XmlList和 @XmlAttribute混合使用 
      @XmlList 
    @XmlAttribute 
    private List<String> emailAddresses; 

输出: 
   <customer 
    emailAddresses="janed@example.com jdoe@example.org"/> 

看到没?就是同一行中逗号输出,并作为customer的一个属性 


5) 
  @XmlList 和 @XmlValue混用 
    
    @XmlList 
    @XmlValue 
    private List<String> emailAddresses; 
  

就是把emailAddress的list的值,作为<customer>的value  输出,结果如下: 
<customer>janed@example.com jdoe@example.org</customer>

 

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

 

 

一.Jaxb处理java对象和xml之间转换常用的annotation有：

  1. @XmlType
  2. @XmlElement
  3. @XmlRootElement
  4. @XmlAttribute
  5. @XmlAccessorType
  6. @XmlAccessorOrder
  7. @XmlTransient
  8. @XmlJavaTypeAdapter

　二.常用annotation使用说明

 

  1. @XmlType

　　@XmlType用在class类的注解，常与@XmlRootElement，@XmlAccessorType一起使用。它有三个属性：name、propOrder、namespace，经常使用的只有前两个属性。如：

@XmlType(name = "basicStruct", propOrder = {
    "intValue",
    "stringArray",
    "stringValue"
)
在使用@XmlType的propOrder 属性时，必须列出JavaBean对象中的所有属性，否则会报错。

　　2.@XmlElement

　　@XmlElement将java对象的属性映射为xml的节点，在使用@XmlElement时，可通过name属性改变java对象属性在xml中显示的名称。如：

　　@XmlElement(name="Address") 　　
　　private String yourAddress;

　　3.@XmlRootElement

　　@XmlRootElement用于类级别的注解，对应xml的跟元素，常与 @XmlType 和 @XmlAccessorType一起使用。如：

　　@XmlType
　　@XmlAccessorType(XmlAccessType.FIELD)
　　@XmlRootElement
　　public class Address {}

　　4.@XmlAttribute

　　@XmlAttribute用于把java对象的属性映射为xml的属性,并可通过name属性为生成的xml属性指定别名。如：
　　@XmlAttribute(name="Country")
　　private String state;

　　5.@XmlAccessorType

　　@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文件。

　　6.@XmlAccessorOrder

　　@XmlAccessorOrder用于对java对象生成的xml元素进行排序。它有两个属性值：

　　AccessorOrder.ALPHABETICAL：对生成的xml元素按字母书序排序

　　XmlAccessOrder.UNDEFINED:不排序

　　7.@XmlTransient

　　@XmlTransient用于标示在由java对象映射xml时，忽略此属性。即，在生成的xml文件中不出现此元素。

　　8.@XmlJavaTypeAdapter

　　@XmlJavaTypeAdapter常用在转换比较复杂的对象时，如map类型或者格式化日期等。使用此注解时，需要自己写一个adapter类继承<tt>XmlAdapter抽象类，并实现里面的方法。</tt>

　　@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);
 }

　三.示例

　　1.Shop.java

?
package  jaxb.shop;
 
import  java.util.Set;
 
import  javax.xml.bind.annotation.XmlAccessOrder;
import  javax.xml.bind.annotation.XmlAccessType;
import  javax.xml.bind.annotation.XmlAccessorType;
import  javax.xml.bind.annotation.XmlAttribute;
import  javax.xml.bind.annotation.XmlElement;
import  javax.xml.bind.annotation.XmlRootElement;
import  javax.xml.bind.annotation.XmlType;
import  javax.xml.bind.annotation.XmlElementWrapper;
import  javax.xml.bind.annotation.XmlAccessorOrder;
 
@XmlAccessorOrder (XmlAccessOrder.ALPHABETICAL)
@XmlAccessorType (XmlAccessType.FIELD)
@XmlType (name = "shop" , propOrder = { "name" ,  "number" , "describer" ,  "address" , "orders" })
?
@XmlRootElement (name = "CHMart" )
public  class  Shop {
 
     @XmlAttribute
     private String name;
 
     // @XmlElement
     private String number;
 
     @XmlElement
     private String describer;
 
     @XmlElementWrapper (name = "orders" )
     @XmlElement (name = "order" )
     private Set<Order> orders;
 
     @XmlElement
     private Address address;
 
     public Shop() {
     }
 
     public Shop(String name, String number, String describer, Address address) {
         this .name = name;
         this .number = number;
         this .describer = describer;
         this .address = address;
     }
 
     getter/setter略
?
//同时使用了@XmlType（propOrder={}）和@XmlAccessorOrder(XmlAccessOrder.ALPHABETICAL)，但是生成的xml只按照propOrder定义的顺序生成元素

　　2.Order.java

?
package  jaxb.shop;
 
import  java.math.BigDecimal;
import  java.util.Date;
 
import  javax.xml.bind.annotation.XmlAccessType;
import  javax.xml.bind.annotation.XmlAccessorType;
import  javax.xml.bind.annotation.XmlAttribute;
import  javax.xml.bind.annotation.XmlRootElement;
import  javax.xml.bind.annotation.XmlType;
import  javax.xml.bind.annotation.adapters.XmlJavaTypeAdapter;
 
@XmlType (name= "order" ,propOrder={ "shopName" , "orderNumber" , "price" , "amount" , "purDate" , "customer" })
@XmlAccessorType (XmlAccessType.FIELD)
@XmlRootElement
public  class  Order {
 
//  @XmlElement　　
     private String shopName;
 
     @XmlAttribute
     private String orderNumber;
 
//  @XmlElement
     @XmlJavaTypeAdapter (value=DateAdapter. class )
     private Date purDate;
 
//  @XmlElement
     private BigDecimal price;
 
//  @XmlElement
     private int  amount;
 
//  @XmlElement
     private Customer customer;
 
     public Order() {
     }
 
     public Order(String shopName, String orderNumber, Date purDate,
             BigDecimal price, int  amount) {
         this .shopName = shopName;
         this .orderNumber = orderNumber;
         this .purDate = purDate;
         this .price = price;
         this .amount = amount;
     }
?
getter/setter略
?
//@XmlAccessorType(XmlAccessType.FIELD)，所以此处注释掉了@XmlElement，xml中依然会生成这些元素

　　3.Customer.java

?
package  jaxb.shop;
 
import  java.util.Set;
import  javax.xml.bind.annotation.XmlType;
import  javax.xml.bind.annotation.XmlAttribute;
import  javax.xml.bind.annotation.XmlElement;
import  javax.xml.bind.annotation.XmlRootElement;
import  javax.xml.bind.annotation.XmlAccessType;
import  javax.xml.bind.annotation.XmlAccessorType;
 
@XmlType
@XmlAccessorType (XmlAccessType.FIELD)
@XmlRootElement
public  class  Customer {
 
     @XmlAttribute
     private String name;
 
     private String gender;
 
     private String phoneNo;
 
     private Address address;
 
     private Set<Order> orders;
 
     public Customer() {
     }
 
     public Customer(String name, String gender, String phoneNo, Address address) {
         this .name = name;
         this .gender = gender;
         this .phoneNo = phoneNo;
         this .address = address;
     }
?
getter/setter略

　　4.Address.java

?
package  jaxb.shop;
 
import  javax.xml.bind.annotation.XmlAttribute;
import  javax.xml.bind.annotation.XmlType;
import  javax.xml.bind.annotation.XmlElement;
import  javax.xml.bind.annotation.XmlRootElement;
import  javax.xml.bind.annotation.XmlAccessType;
import  javax.xml.bind.annotation.XmlAccessorType;
import  javax.xml.bind.annotation.XmlAccessOrder;
import  javax.xml.bind.annotation.XmlAccessorOrder;
 
@XmlType (propOrder={ "state" , "province" , "city" , "street" , "zip" })
@XmlAccessorOrder (XmlAccessOrder.ALPHABETICAL)
@XmlAccessorType (XmlAccessType.NONE)
@XmlRootElement
public  class  Address {
 
     @XmlAttribute 　
     private String state;
     
     @XmlElement
     private String province;
     
     @XmlElement
     private String city;
 
     @XmlElement
     private String street;
     
     @XmlElement
     private String zip;
 
     public Address() {
         super ();
     }
 
     public Address(String state, String province, String city, String street,
             String zip) {
         super ();
         this .state = state;
         this .province = province;
         this .city = city;
         this .street = street;
         this .zip = zip;
     }
?
getter/setter略
?
//注意：虽然@XmlAccessorType为XmlAccessType.NONE,但是在java类的私有属性上加了@XmlAttribute和@XmlElement注解后，这些私有成员会映射生成xml的元素

　　5.DateAdapter.java

?
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对象

　　6.ShopTest.java

?
package  jaxb.shop;
 
import  java.io.FileReader;
import  java.io.FileWriter;
import  java.io.IOException;
import  java.math.BigDecimal;
import  java.util.Date;
import  java.util.HashSet;
import  java.util.Set;
 
import  javax.xml.bind.JAXBContext;
import  javax.xml.bind.JAXBException;
import  javax.xml.bind.Marshaller;
import  javax.xml.bind.Unmarshaller;
 
public  class  ShopTest {
 
     public static  void  main(String[] args)  throws  JAXBException, IOException{
         Set<Order> orders = new  HashSet<Order>();
         
         Address address1 = new  Address( "China" , "ShangHai" ,  "ShangHai" ,  "Huang" , "200000" );
         Customer customer1 = new  Customer( "Jim" , "male" ,  "13699990000" , address1);
         Order order1 = new  Order( "Mart" , "LH59900" ,  new  Date(),  new BigDecimal( 60 ), 1 );
         order1.setCustomer(customer1);
         
         Address address2 = new  Address( "China" , "JiangSu" ,  "NanJing" ,  "ZhongYangLu" , "210000" );
         Customer customer2 = new  Customer( "David" , "male" ,  "13699991000" , address2);
         Order order2 = new  Order( "Mart" , "LH59800" ,  new  Date(),  new BigDecimal( 80 ), 1 );
         order2.setCustomer(customer2);
         
         orders.add(order1);
         orders.add(order2);
         
         Address address3 = new  Address( "China" , "ZheJiang" ,  "HangZhou" ,  "XiHuRoad" , "310000" );
         Shop shop = new  Shop( "CHMart" , "100000" ,  "EveryThing" ,address3);
         shop.setOrder(orders);
         
         
         FileWriter writer = null ;
         JAXBContext context = JAXBContext.newInstance(Shop. class );
         try {
             Marshaller marshal = context.createMarshaller();
             marshal.setProperty(Marshaller.JAXB_FORMATTED_OUTPUT, true );
             marshal.marshal(shop, System.out);
             
             writer = new  FileWriter( "shop.xml" );
             marshal.marshal(shop, writer);
         } catch  (Exception e) {
             e.printStackTrace();
         }
         
         Unmarshaller unmarshal = context.createUnmarshaller();
         FileReader reader = new  FileReader( "shop.xml" ) ;
         Shop shop1 = (Shop)unmarshal.unmarshal(reader);
         
         Set<Order> orders1 = shop1.getOrder();
         for (Order order : orders1){
             System.out.println( "***************************" );
             System.out.println(order.getOrderNumber());
             System.out.println(order.getCustomer().getName());
             System.out.println( "***************************" );
         }
     }
}

　　7.生成的xml文件

?
<?xml version= "1.0" encoding= "UTF-8" standalone= "yes" ?>
<CHMart name= "CHMart" >
     <number> 100000 </number>
     <describer>EveryThing</describer>
     <address state= "China" >
         <province>ZheJiang</province>
         <city>HangZhou</city>
         <street>XiHuRoad</street>
         <zip> 310000 </zip>
     </address>
     <orders>
         <order orderNumber= "LH59800" >
             <shopName>Mart</shopName>
             <price> 80 </price>
             <amount> 1 </amount>
             <purDate> 2012 - 03 - 25 12 : 57 : 23 </purDate>
             <customer name= "David" >
                 <gender>male</gender>
                 <phoneNo> 13699991000 </phoneNo>
                 <address state= "China" >
                     <province>JiangSu</province>
                     <city>NanJing</city>
                     <street>ZhongYangLu</street>
                     <zip> 210000 </zip>
                 </address>
             </customer>
         </order>
         <order orderNumber= "LH59900" >
             <shopName>Mart</shopName>
             <price> 60 </price>
             <amount> 1 </amount>
             <purDate> 2012 - 03 - 25 12 : 57 : 23 </purDate>
             <customer name= "Jim" >
                 <gender>male</gender>
                 <phoneNo> 13699990000 </phoneNo>
                 <address state= "China" >
                     <province>ShangHai</province>
                     <city>ShangHai</city>
                     <street>Huang</street>
                     <zip> 200000 </zip>
                 </address>
             </customer>
         </order>
     </orders>
</CHMart>
全部评论

相关推荐

04-06 14:35
滴滴_产品经理(准入职员工)
滴滴内推
测试面经：一面自我介绍tcp和udp的区别http和https的区别对测试的理解出了一个测试用例题：假设平台每天都可以创建活动，用户领取这些活动进行参与，加入需要限制每个用户每天参与活动的时间不能超过8个小时，如果超过，就不能再领取参与，请你设计一个测试用例mysql查询语句：有一个成绩表(学号，姓名，科目，分数)存有学生各科成绩，查询学生的总成绩并进行排名你做测试的优势有哪些你对滴滴出行平台怎么做测试开发一个算法题：有x个台阶，每次可以走1-x步，打印每种走法的步数明细你在实习中遇到什么困难，怎么解决的会不会git，git命令会不会linux，常用linux命令栈和堆⭐关于职场氛围：真的很爱...
点赞 评论 收藏
分享
04-07 15:31
门头沟学院 Java
美团日常一面
面试30min就结束了，是不是被kpi了呀，问题都是很平常的八股，基本上也都答上来了，不过感觉结束的太突然了，项目拷打也没有，问题这么少的吗，我想象的八股大战呢面经奉上：自我介绍redis的缓存穿透和缓存击穿以及解决办法？布隆过滤器原理讲一下？MySQL聚簇索引和非聚簇索引的区别是什么？慢查询怎么解决，怎么优化?线程池的参数？如果核心线程满了，此时又来一个线程，会发生什么？mysql怎么解决幻读？如果某个接口的流量很高你会怎么做？MQ的事务有了解吗？手撕：力扣124.&nbsp;二叉树中的最大路径和反问（ps：忘记录音了，有些问题可能漏了）
美团一面1938人在聊 查看10道真题和解析 软件开发笔面经
点赞 评论 收藏
分享
02-21 15:43
山东大学 golang
点赞 评论 收藏
分享
04-10 15:04
腾讯_TEG_技术
点赞 评论 收藏
分享
评论
点赞
收藏
分享

全站热榜

更多

创作者周榜

更多
正在热议
更多
# 春招进度记录 #
14152次浏览 74人参与
# 机械人，你会为了哪家公司违约？ #
58597次浏览 269人参与
# 实习进度记录 #
15878次浏览 106人参与
# 校招求职有谈薪空间吗 #
125393次浏览 1750人参与
# 找工作如何保持松弛感？ #
39575次浏览 644人参与
# 2022毕业生求职现身说法 #
79131次浏览 673人参与
# 2022毕业的你对23届的寄语 #
39415次浏览 541人参与
# 工作经验重要还是工资重要？ #
42450次浏览 532人参与
# 机械制造秋招总结 #
46482次浏览 454人参与
# 秋招感动瞬间 #
17427次浏览 148人参与
# 初创公司值得加入吗？ #
17988次浏览 162人参与
# 参加完秋招的机械人，还参加春招吗？ #
36479次浏览 417人参与
# 摸鱼打卡站 #
34998次浏览 663人参与
# 如果没找到工作，考公是你的退路吗 #
22485次浏览 245人参与
# 新能源会是生化环材的春风吗 #
9869次浏览 80人参与
# 多益网络求职进展汇总 #
12532次浏览 72人参与
# 新凯来求职进展汇总 #
22252次浏览 73人参与
# 中美关税战对我们有哪些影响 #
19475次浏览 241人参与
# 电信求职进展汇总 #
3081次浏览 34人参与
# 我和xx公司的爱恨情仇 #
37956次浏览 314人参与
牛客网
牛客企业服务