JAXB注解 java 关于xml的注解，自动生成xml文件 - @XML***
2013-09-18 09:40
537 查看
java和xml的互相转换,依靠强大的JAXBContext可以轻松实现。
下面通过一个简单案例学习一下JAXBContext
首先准备好一个JavaBean供实验:
注意
1、类文件注解：@XmlRootElement不可缺少
2、2个Student的构造方法不能少
[java]
view plaincopyprint?
@XmlRootElement
public class Student {
private String name;
private String width;
private String height;
private int age;
public Student(String name, String width, String height, int age) {
super();
this.name = name;
this.width = width;
this.height = height;
this.age = age;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public String getWidth() {
return width;
}
public void setWidth(String width) {
this.width = width;
}
public String getHeight() {
return height;
}
public void setHeight(String height) {
this.height = height;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
public Student() {
super();
}
}
JavaToXml：
[java]
view plaincopyprint?
@Test
public void test01(){
try {
JAXBContext jc = JAXBContext.newInstance(Student.class);
Marshaller ms = jc.createMarshaller();
Student st = new Student("zhang", "w", "h", 11);
ms.marshal(st, System.out);
} catch (JAXBException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
XmlToJava
[java]
view plaincopyprint?
//xml转换Java
@Test
public void test02() throws JAXBException{
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>";
JAXBContext jc = JAXBContext.newInstance(Student.class);
Unmarshaller unmar = jc.createUnmarshaller();
Student stu = (Student) unmar.unmarshal(new StringReader(xml));
System.out.println(stu.getName());
}
用的是jdk自带的javax.xml.bind.JAXBContext将对象和xml字符串进行相互转换。
如果对要生成的 xml 格式有点些许的限制，就会对生成xml的对象就需要进行些许控制，控制对象的一个最可行的办法就是用注解。
（jdk 1.6 api：http://www.cs.uic.edu/~mcpc/Java_Docs/api/index.html?javax/xml/bind/JAXBContext.html）
比较常用的几个：
@XmlRootElement：根节点
@XmlAttribute：该属性作为xml的attribute
@XmlElement：该属性作为xml的element，且可以增加属性(name="NewElementName")，那么生成的xml串的elment的标签是NewElementName
示例：
[java]
view plaincopyprint?
package test;
import java.io.StringWriter;
import javax.xml.bind.JAXBContext;
import javax.xml.bind.JAXBException;
import javax.xml.bind.Marshaller;
import test.bean.EleClassA;
import test.bean.EleClassB;
import test.bean.RootClass;
public class Test1 {
public static void main(String[] args) {
RootClass rc = new RootClass();
EleClassA a = new EleClassA();
EleClassB b = new EleClassB();
a.setAttrC("attrc");
a.setEleA("eleA");
a.setEleB("eleB");
b.setAttrPassword("attrPassword");
b.setAttrUserName("attrUsrName");
b.setEleCode("eleCode");
rc.setA(a);
rc.setB(b);
rc.setRoot("root");
rc.setRootA("rootA");
JAXBContext context;
try {
context = JAXBContext.newInstance(RootClass.class);
Marshaller mar = context.createMarshaller();
mar.setProperty(Marshaller.JAXB_FORMATTED_OUTPUT, true);
mar.setProperty(Marshaller.JAXB_ENCODING, "UTF-8");
StringWriter writer = new StringWriter();
mar.marshal(rc, writer);
System.out.println(writer.toString());
} catch (JAXBException e) {
e.printStackTrace();
}
}
}
package test.bean;
import javax.xml.bind.annotation.XmlElement;
import javax.xml.bind.annotation.XmlRootElement;
@XmlRootElement(name="rootclass")
public class RootClass {
private EleClassA a;
private EleClassB b;
private String root;
private String rootA;
@XmlElement(name="eleClassA")
public EleClassA getA() {
return a;
}
public void setA(EleClassA a) {
this.a = a;
}
@XmlElement(name="EleclassA")
public EleClassB getB() {
return b;
}
public void setB(EleClassB b) {
this.b = b;
}
public String getRoot() {
return root;
}
public void setRoot(String root) {
this.root = root;
}
public String getRootA() {
return rootA;
}
public void setRootA(String rootA) {
this.rootA = rootA;
}
}
package test.bean;
import javax.xml.bind.annotation.XmlAttribute;
import javax.xml.bind.annotation.XmlElement;
public class EleClassA {
private String eleA;
private String eleB;
private String attrC;
@XmlElement
public String getEleA() {
return eleA;
}
public void setEleA(String eleA) {
this.eleA = eleA;
}
@XmlElement(name="elebnewname")
public String getEleB() {
return eleB;
}
public void setEleB(String eleB) {
this.eleB = eleB;
}
@XmlAttribute()
public String getAttrC() {
return attrC;
}
public void setAttrC(String attrC) {
this.attrC = attrC;
}
}
package test.bean;
import javax.xml.bind.annotation.XmlAttribute;
import javax.xml.bind.annotation.XmlElement;
public class EleClassB {
private String attrUserName;
private String attrPassword;
private String eleCode;
@XmlAttribute
public String getAttrUserName() {
return attrUserName;
}
public void setAttrUserName(String attrUserName) {
this.attrUserName = attrUserName;
}
@XmlAttribute(name="password")
public String getAttrPassword() {
return attrPassword;
}
public void setAttrPassword(String attrPassword) {
this.attrPassword = attrPassword;
}
@XmlElement
public String getEleCode() {
return eleCode;
}
public void setEleCode(String eleCode) {
this.eleCode = eleCode;
}
}
运行Test1类中main方法，执行结果：
[html]
view plaincopyprint?
<?xml version="1.0" encoding="UTF-8" standalone="yes"?>
<rootclass>
<eleClassA attrC="attrc">
<eleA>eleA</eleA>
<elebnewname>eleB</elebnewname>
</eleClassA>
<EleclassA attrUserName="attrUsrName" password="attrPassword">
<eleCode>eleCode</eleCode>
</EleclassA>
<root>root</root>
<rootA>rootA</rootA>
</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代码
import java.util.*; import javax.xml.bind.annotation.*; @XmlRootElement @XmlAccessorType(XmlAccessType.FIELD) public class Customer { private List<String> emailAddresses; public Customer() { emailAddresses = new ArrayList<String>(); } public List<String> getEmailAddresses() { return emailAddresses; } public void setEmailAddresses(List<String> emailAddresses) { this.emailAddresses = emailAddresses; } }
这个是一个典型的POJO了,其中引用了对象emailAddress,是一个List,那么下面演示各类用法:
先看默认的调用代码如下:
Java代码
import javax.xml.bind.JAXBContext; import javax.xml.bind.Marshaller; public class Demo { public static void main(String[] args) throws Exception { JAXBContext jc = JAXBContext.newInstance(Customer.class); Customer customer = new Customer(); customer.getEmailAddresses().add("janed@example.com"); customer.getEmailAddresses().add("jdoe@example.org"); Marshaller marshaller = jc.createMarshaller(); marshaller.setProperty(Marshaller.JAXB_FORMATTED_OUTPUT, true); marshaller.marshal(customer, System.out); } }
默认的把这个对象输出为一般的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代码
@XmlRootElement @XmlAccessorType(XmlAccessType.FIELD) public class Customer { @XmlList private List<String> emailAddresses; }
输出:
<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>
------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
@XmlElement
@XmlRootElement
@XmlAttribute
@XmlAccessorType
@XmlAccessorOrder
@XmlTransient
@XmlJavaTypeAdapter
@XmlElement(name="Address")
private String yourAddress;
@XmlType
@XmlAccessorType(XmlAccessType.FIELD)
@XmlRootElement
public class Address {}
@XmlAttribute(name="Country")
private String state;
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文件。
AccessorOrder.ALPHABETICAL：对生成的xml元素按字母书序排序
XmlAccessOrder.UNDEFINED:不排序
@XmlJavaTypeAdapter(value=xxx.class),value为自己定义的adapter类
XmlAdapter如下：
?
?
?
2.Order.java
?
?
?
3.Customer.java
?
?
4.Address.java
?
?
?
5.DateAdapter.java
?
?
6.ShopTest.java
?
7.生成的xml文件
?
下面通过一个简单案例学习一下JAXBContext
首先准备好一个JavaBean供实验:
注意
1、类文件注解：@XmlRootElement不可缺少
2、2个Student的构造方法不能少
[java]
view plaincopyprint?
@XmlRootElement
public class Student {
private String name;
private String width;
private String height;
private int age;
public Student(String name, String width, String height, int age) {
super();
this.name = name;
this.width = width;
this.height = height;
this.age = age;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public String getWidth() {
return width;
}
public void setWidth(String width) {
this.width = width;
}
public String getHeight() {
return height;
}
public void setHeight(String height) {
this.height = height;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
public Student() {
super();
}
}
@XmlRootElement
public class Student {
private String name;
private String width;
private String height;
private int age;
public Student(String name, String width, String height, int age) {
super();
this.name = name;
this.width = width;
this.height = height;
this.age = age;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public String getWidth() {
return width;
}
public void setWidth(String width) {
this.width = width;
}
public String getHeight() {
return height;
}
public void setHeight(String height) {
this.height = height;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
public Student() {
super();
}
}JavaToXml：
[java]
view plaincopyprint?
@Test
public void test01(){
try {
JAXBContext jc = JAXBContext.newInstance(Student.class);
Marshaller ms = jc.createMarshaller();
Student st = new Student("zhang", "w", "h", 11);
ms.marshal(st, System.out);
} catch (JAXBException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
@Test
public void test01(){
try {
JAXBContext jc = JAXBContext.newInstance(Student.class);
Marshaller ms = jc.createMarshaller();
Student st = new Student("zhang", "w", "h", 11);
ms.marshal(st, System.out);
} catch (JAXBException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}XmlToJava
[java]
view plaincopyprint?
//xml转换Java
@Test
public void test02() throws JAXBException{
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>";
JAXBContext jc = JAXBContext.newInstance(Student.class);
Unmarshaller unmar = jc.createUnmarshaller();
Student stu = (Student) unmar.unmarshal(new StringReader(xml));
System.out.println(stu.getName());
}
用的是jdk自带的javax.xml.bind.JAXBContext将对象和xml字符串进行相互转换。
如果对要生成的 xml 格式有点些许的限制，就会对生成xml的对象就需要进行些许控制，控制对象的一个最可行的办法就是用注解。
（jdk 1.6 api：http://www.cs.uic.edu/~mcpc/Java_Docs/api/index.html?javax/xml/bind/JAXBContext.html）
比较常用的几个：
@XmlRootElement：根节点
@XmlAttribute：该属性作为xml的attribute
@XmlElement：该属性作为xml的element，且可以增加属性(name="NewElementName")，那么生成的xml串的elment的标签是NewElementName
示例：
[java]
view plaincopyprint?
package test;
import java.io.StringWriter;
import javax.xml.bind.JAXBContext;
import javax.xml.bind.JAXBException;
import javax.xml.bind.Marshaller;
import test.bean.EleClassA;
import test.bean.EleClassB;
import test.bean.RootClass;
public class Test1 {
public static void main(String[] args) {
RootClass rc = new RootClass();
EleClassA a = new EleClassA();
EleClassB b = new EleClassB();
a.setAttrC("attrc");
a.setEleA("eleA");
a.setEleB("eleB");
b.setAttrPassword("attrPassword");
b.setAttrUserName("attrUsrName");
b.setEleCode("eleCode");
rc.setA(a);
rc.setB(b);
rc.setRoot("root");
rc.setRootA("rootA");
JAXBContext context;
try {
context = JAXBContext.newInstance(RootClass.class);
Marshaller mar = context.createMarshaller();
mar.setProperty(Marshaller.JAXB_FORMATTED_OUTPUT, true);
mar.setProperty(Marshaller.JAXB_ENCODING, "UTF-8");
StringWriter writer = new StringWriter();
mar.marshal(rc, writer);
System.out.println(writer.toString());
} catch (JAXBException e) {
e.printStackTrace();
}
}
}
package test.bean;
import javax.xml.bind.annotation.XmlElement;
import javax.xml.bind.annotation.XmlRootElement;
@XmlRootElement(name="rootclass")
public class RootClass {
private EleClassA a;
private EleClassB b;
private String root;
private String rootA;
@XmlElement(name="eleClassA")
public EleClassA getA() {
return a;
}
public void setA(EleClassA a) {
this.a = a;
}
@XmlElement(name="EleclassA")
public EleClassB getB() {
return b;
}
public void setB(EleClassB b) {
this.b = b;
}
public String getRoot() {
return root;
}
public void setRoot(String root) {
this.root = root;
}
public String getRootA() {
return rootA;
}
public void setRootA(String rootA) {
this.rootA = rootA;
}
}
package test.bean;
import javax.xml.bind.annotation.XmlAttribute;
import javax.xml.bind.annotation.XmlElement;
public class EleClassA {
private String eleA;
private String eleB;
private String attrC;
@XmlElement
public String getEleA() {
return eleA;
}
public void setEleA(String eleA) {
this.eleA = eleA;
}
@XmlElement(name="elebnewname")
public String getEleB() {
return eleB;
}
public void setEleB(String eleB) {
this.eleB = eleB;
}
@XmlAttribute()
public String getAttrC() {
return attrC;
}
public void setAttrC(String attrC) {
this.attrC = attrC;
}
}
package test.bean;
import javax.xml.bind.annotation.XmlAttribute;
import javax.xml.bind.annotation.XmlElement;
public class EleClassB {
private String attrUserName;
private String attrPassword;
private String eleCode;
@XmlAttribute
public String getAttrUserName() {
return attrUserName;
}
public void setAttrUserName(String attrUserName) {
this.attrUserName = attrUserName;
}
@XmlAttribute(name="password")
public String getAttrPassword() {
return attrPassword;
}
public void setAttrPassword(String attrPassword) {
this.attrPassword = attrPassword;
}
@XmlElement
public String getEleCode() {
return eleCode;
}
public void setEleCode(String eleCode) {
this.eleCode = eleCode;
}
}
package test;
import java.io.StringWriter;
import javax.xml.bind.JAXBContext;
import javax.xml.bind.JAXBException;
import javax.xml.bind.Marshaller;
import test.bean.EleClassA;
import test.bean.EleClassB;
import test.bean.RootClass;
public class Test1 {
public static void main(String[] args) {
RootClass rc = new RootClass();
EleClassA a = new EleClassA();
EleClassB b = new EleClassB();
a.setAttrC("attrc");
a.setEleA("eleA");
a.setEleB("eleB");
b.setAttrPassword("attrPassword");
b.setAttrUserName("attrUsrName");
b.setEleCode("eleCode");
rc.setA(a);
rc.setB(b);
rc.setRoot("root");
rc.setRootA("rootA");
JAXBContext context;
try {
context = JAXBContext.newInstance(RootClass.class);
Marshaller mar = context.createMarshaller();
mar.setProperty(Marshaller.JAXB_FORMATTED_OUTPUT, true);
mar.setProperty(Marshaller.JAXB_ENCODING, "UTF-8");
StringWriter writer = new StringWriter();
mar.marshal(rc, writer);
System.out.println(writer.toString());
} catch (JAXBException e) {
e.printStackTrace();
}
}
}
package test.bean;
import javax.xml.bind.annotation.XmlElement;
import javax.xml.bind.annotation.XmlRootElement;
@XmlRootElement(name="rootclass")
public class RootClass {
private EleClassA a;
private EleClassB b;
private String root;
private String rootA;
@XmlElement(name="eleClassA")
public EleClassA getA() {
return a;
}
public void setA(EleClassA a) {
this.a = a;
}
@XmlElement(name="EleclassA")
public EleClassB getB() {
return b;
}
public void setB(EleClassB b) {
this.b = b;
}
public String getRoot() {
return root;
}
public void setRoot(String root) {
this.root = root;
}
public String getRootA() {
return rootA;
}
public void setRootA(String rootA) {
this.rootA = rootA;
}
}
package test.bean;
import javax.xml.bind.annotation.XmlAttribute;
import javax.xml.bind.annotation.XmlElement;
public class EleClassA {
private String eleA;
private String eleB;
private String attrC;
@XmlElement
public String getEleA() {
return eleA;
}
public void setEleA(String eleA) {
this.eleA = eleA;
}
@XmlElement(name="elebnewname")
public String getEleB() {
return eleB;
}
public void setEleB(String eleB) {
this.eleB = eleB;
}
@XmlAttribute()
public String getAttrC() {
return attrC;
}
public void setAttrC(String attrC) {
this.attrC = attrC;
}
}
package test.bean;
import javax.xml.bind.annotation.XmlAttribute;
import javax.xml.bind.annotation.XmlElement;
public class EleClassB {
private String attrUserName;
private String attrPassword;
private String eleCode;
@XmlAttribute
public String getAttrUserName() {
return attrUserName;
}
public void setAttrUserName(String attrUserName) {
this.attrUserName = attrUserName;
}
@XmlAttribute(name="password")
public String getAttrPassword() {
return attrPassword;
}
public void setAttrPassword(String attrPassword) {
this.attrPassword = attrPassword;
}
@XmlElement
public String getEleCode() {
return eleCode;
}
public void setEleCode(String eleCode) {
this.eleCode = eleCode;
}
}运行Test1类中main方法，执行结果：
[html]
view plaincopyprint?
<?xml version="1.0" encoding="UTF-8" standalone="yes"?>
<rootclass>
<eleClassA attrC="attrc">
<eleA>eleA</eleA>
<elebnewname>eleB</elebnewname>
</eleClassA>
<EleclassA attrUserName="attrUsrName" password="attrPassword">
<eleCode>eleCode</eleCode>
</EleclassA>
<root>root</root>
<rootA>rootA</rootA>
</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代码
import java.util.*; import javax.xml.bind.annotation.*; @XmlRootElement @XmlAccessorType(XmlAccessType.FIELD) public class Customer { private List<String> emailAddresses; public Customer() { emailAddresses = new ArrayList<String>(); } public List<String> getEmailAddresses() { return emailAddresses; } public void setEmailAddresses(List<String> emailAddresses) { this.emailAddresses = emailAddresses; } }
import java.util.*;
import javax.xml.bind.annotation.*;
@XmlRootElement
@XmlAccessorType(XmlAccessType.FIELD)
public class Customer {
private List<String> emailAddresses;
public Customer() {
emailAddresses = new ArrayList<String>();
}
public List<String> getEmailAddresses() {
return emailAddresses;
}
public void setEmailAddresses(List<String> emailAddresses) {
this.emailAddresses = emailAddresses;
}
}这个是一个典型的POJO了,其中引用了对象emailAddress,是一个List,那么下面演示各类用法:
先看默认的调用代码如下:
Java代码
import javax.xml.bind.JAXBContext; import javax.xml.bind.Marshaller; public class Demo { public static void main(String[] args) throws Exception { JAXBContext jc = JAXBContext.newInstance(Customer.class); Customer customer = new Customer(); customer.getEmailAddresses().add("janed@example.com"); customer.getEmailAddresses().add("jdoe@example.org"); Marshaller marshaller = jc.createMarshaller(); marshaller.setProperty(Marshaller.JAXB_FORMATTED_OUTPUT, true); marshaller.marshal(customer, System.out); } }
import javax.xml.bind.JAXBContext;
import javax.xml.bind.Marshaller;
public class Demo {
public static void main(String[] args) throws Exception {
JAXBContext jc = JAXBContext.newInstance(Customer.class);
Customer customer = new Customer();
customer.getEmailAddresses().add("janed@example.com");
customer.getEmailAddresses().add("jdoe@example.org");
Marshaller marshaller = jc.createMarshaller();
marshaller.setProperty(Marshaller.JAXB_FORMATTED_OUTPUT, true);
marshaller.marshal(customer, System.out);
}
}默认的把这个对象输出为一般的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代码
@XmlRootElement @XmlAccessorType(XmlAccessType.FIELD) public class Customer { @XmlList private List<String> emailAddresses; }
@XmlRootElement
@XmlAccessorType(XmlAccessType.FIELD)
public class Customer {
@XmlList
private List<String> emailAddresses;
}输出:
<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有：
@XmlType@XmlElement
@XmlRootElement
@XmlAttribute
@XmlAccessorType
@XmlAccessorOrder
@XmlTransient
@XmlJavaTypeAdapter
二.常用annotation使用说明
@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类继承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);
}三.示例
1.Shop.java?
?
?
?
?
?
?
内容来自用户分享和网络整理，不保证内容的准确性，如有侵权内容，可联系管理员处理 
相关文章推荐
- java关于xml的注解： JAXB（自动生成xml文件）
- JAXB注解 java 关于xml的注解，自动生成xml文件 - @XML***
- JAXB注解 java 关于xml的注解，自动生成xml文件
- JAXB注解 java 关于xml的注解，自动生成xml文件 - @XML***
- JAXB注解 java 关于xml的注解，自动生成xml文件 - @XML***
- JAXB注解 java 关于xml的注解，自动生成xml文件
- JAXB注解 java 关于xml的注解，自动生成xml文件
- JAXB注解 java 关于xml的注解，自动生成xml文件 - @XML***
- JAXB注解 java 关于xml的注解，自动生成xml文件 - @XML***
- JAXB注解 java 关于xml的注解，自动生成xml文件 - @XML***
- java 关于xml的注解，自动生成xml文件 - @XML
- java 关于xml的注解，自动生成xml文件 - @XML***
- JAXB注解 java 关于xml的注解，自动生成xml文件
- JAXB注解 java 关于xml的注解，自动生成xml文件
- java 关于xml的注解，自动生成xml文件 - @XML***
- java 关于xml的注解，自动生成xml文件 - @XML***
- java 关于xml的注解，自动生成xml文件 - @XML***
- JaxbContext生成xml文件或java类对象转化注解
- 关于使用JAXB读取xml文档转换为java对象出现非法注解异常
- 通过JAXB注解，根据java类生成xml内容