Spring和JAXB2.0结合使用
Spring和JAXB结合使用
本文是由大关整理编写所得，不保证内容正确性，转载请标明出处，谢谢！
由于XML在分布式系统中应用如此广泛，而java又是开发网络和分布式系统可选的最佳运行环境之一，因此，java提供了很多的库，使编程人员能够轻松处理XML数据。在早期，java主要以JAXP定义的相关接口和类处理XML文档。JAXP中包括基于树结构的DOM和基于流方式的SAX和StAX。随着面向对象技术的不断发展，像JAXP这样低层次的XML处理方式，无法满足日益增长的程序规模的需求，因此XOM（XML文档和对象映射）被提出，Java通过对XOM的需求的研究（JSR222），提出了JAXB框架。JAXB框架主要是解决java对象与XML文档映射问题。
Spring技术已经发展到3.0版本，在过去的几年里，Spring真的如其名字一样给计算机网络服务编程带来了春天。现在Spring技术已经得到了国内软件行业的认可，并且有继续扩展的趋势。Spring回避了EJB的缺陷，发扬了EJB的优点，已然成为JavaEE的一个经典框架。
最近在研究Restful服务技术，而XML是Restful的一个主要信息载体，使用JAXB完成XML与Java对象的映射又是比较常用的策略（实际使用Castor等框架也可完成XOM）。在Restful中，我们先定义一个通信两端的通信协议（一般是一个schema文件，描述了通信两端交换的数据格式和内容），之后两端各自根据通信协议完成各自的实现，因此，通信两端可以是编程环境和运行环境异构的。例如：通信两端中，一端是java程序，另一端是c程序，而他们之间的通信使用Restful（Http协议）并且信息载体是XML，java和c都可以处理XML文档，获取文档中需要的信息（XML信息的内容和格式由schema定义的），因此就完成了跨平台，跨执行环境的通信。在java端，JAXB可以通过Schema自动生成Java类对象，并且JAXB按照Schema的标准将java对象编组到XML文档中，也能从XML文档中解组出java对象，这样就大大提高了对通信信息的处理能力。
对于java来说，使用Restful服务的简单方法就是使用Spring的MVC，因为Spring的MVC本身就是基于Restful的目的编写的（实际上，JavaEE6提供的JAX-RS是java对Restful的实现框架，但是，我们希望应用更多的Spring特性（依赖注入和控制反转）来简化我们的服务搭建，因此使用的是SpringMVC来完成Restful服务）。
综上，我们看到了在Spring中使用JAXB的重要性，以及它在我们的Restful服务搭建环节上的地位，下面将简述如何在Spring中使用JAXB2.
1、编写schema文档
我们打算创建两个数据模型，一个是student.xsd，描述了关于student的定义，一个是teacher.xsd描述teacher的定义。定义两个xsd文件的目的是为了解释一个JAXBContent能包含多个根元素，并没有特殊意义。
Student.xsd
&?xml version="1.0" encoding="UTF-8"?&
&xsd:schema xmlns:xsd="http://www.w3.org/2001/XMLSchema"&
&xsd:element name="student"&
&xsd:complexType&
&&&&&&&&&&
&xsd:sequence&
&&&&&&&&&&&&&
&xsd:element name="name" type="xsd:string"/&&&&&&&&&
&&&&&&&&&&
&/xsd:sequence&
&&&&&&&&&&
&xsd:attribute name="id" type="xsd:int"/&
&/xsd:complexType&
&/xsd:element&
&/xsd:schema&
Teacher.xsd
&?xml version="1.0" encoding="UTF-8"?&
&xs:schema xmlns:xs="http://www.w3.org/2001/XMLSchema"&
&xs:element name="teacher"&
&xs:complexType&
&&&&&&&&&&
&xs:sequence&
&&&&&&&&&&&&&
&xs:element name="name" type="xs:string"/&
&&&&&&&&&&
&/xs:sequence&
&/xs:complexType&
&/xs:element&
&/xs:schema&
使用xjc编译生成java类
JAXB能够从schema转换出java的类，同时也能从java类转换出schema。根据我们前面的分析，schema实际是通信双方的标准，因此，先定义出schema，之后通过schema生成java类似乎更合理。因此我们采用xjc从schema生成java类。
使用命令行，转换出student类，输入如下信息：
I:\programs\eclipse\SpringJAXBTest\src&xjc
-p cn.edu.upc.upcgrid.guan.springjaxb
.student &&Student.xsd
（XML to Java
Compiler）是java提供的工具，在java安装后就可以使用这个工具（注意要将java的环境变量配置正确），-p
后面的参数是生成类的包名和转换的schema文件的路径。
同理使用命令行，将Teacher的schema转换成teacher类。
I:\programs\eclipse\SpringJAXBTest\src&xjc
-p com.upc.upcgrid.guan.springjaxb.st
Teacher.xsd
现在，刷新我们的工程，会出现有xjc生成的类。（注意，ObjectFactory没有用处，因此可以直接删除，ObjectFactory在某些情况下有用，不过那是复杂的schema映射，比如choice元素等，如果希望了解更多，请参考我的其他关于JAXB的博客）。
Student.java类的内容大致如下：
package com.upc.upcgrid.guan.springjaxb.
import javax.xml.bind.annotation.XmlAccessT
import javax.xml.bind.annotation.XmlAccessorT
import javax.xml.bind.annotation.XmlA
import javax.xml.bind.annotation.XmlE
import javax.xml.bind.annotation.XmlRootE
@XmlAccessorType(XmlAccessType.FIELD)
@XmlRootElement(name="student")
public class Student {
@XmlElement(required = true)
protected String name;
@XmlAttribute
protected Integer id;
public String getName() {
return name;
public void setName(String value) {
this.name =
public Integer getId() {
return id;
public void setId(Integer value) {
生成的Teacher.java类的大致内容如下：
package com.upc.upcgrid.guan.springjaxb.
import javax.xml.bind.annotation.XmlAccessT
import javax.xml.bind.annotation.XmlAccessorT
import javax.xml.bind.annotation.XmlE
import javax.xml.bind.annotation.XmlRootE
import javax.xml.bind.annotation.XmlT
@XmlAccessorType(XmlAccessType.FIELD)
@XmlType(name = "", propOrder = {
@XmlRootElement(name = "teacher")
public class Teacher {
@XmlElement(required = true)
protected String name;
public String getName() {
return name;
public void setName(String value) {
this.name =
可以看出，xjc生成的Teacher和Student类只不过是一些get和set方法，并且添加了一些标记（在JAXB中，如果会使用这些标记，可以在自定义的类中使用这些标记，就不用定义schema）。
配置Spring环境
这里为了简单起见，我们不使用XML方式配置Spring，而是采用Annotation的方式对Spring进行配置。
这里有两个类，SpringConfigure用来替代以前的spring-servlet.xml（就是spring的配置文档）。为了方便使用，我们又创建一个spring的注入类MarshalAndUnmarshalService，此类包含两个成员变量，分别为Marshaller和Unmarshaller，我们可以使用这两个变量完成对Java对象的编组和对XML文档的解组。根据Spring的注入规则，我们看到Spring的配置文档中有一个Jaxb2Marshaller类bean实例，这个实例有一个特点，它既是Marshaller类型，也是Unmarshaller类型，因此，在Spring依赖注入的过程中，MarshalAndUnmarshalService类中的marshaller和unmarshaller实际注入的是同一个实例（即：Jaxb2Marshaller类的实例）。
Spring的配置文件SpringConfigure.java
package com.upc.upcgrid.guan.
import java.util.HashM
import java.util.M
import org.springframework.context.annotation.B
import org.springframework.context.annotation.C
import org.springframework.oxm.jaxb.Jaxb2M
import com.upc.upcgrid.guan.springjaxb.student.S
import com.upc.upcgrid.guan.springjaxb.student.T
@Configuration
public class SpringConfigure {&
public @Bean Jaxb2Marshaller
jaxb2Marshaller()//配置JAXB2Context
Jaxb2Marshaller marshaller = new Jaxb2Marshaller();//创建JAXB上下文环境
Map&String,Object& properties
= new HashMap&String,
Object&();//创建映射，用于设置Marshaller属性
properties.put(javax.xml.bind.Marshaller.JAXB_FORMATTED_OUTPUT, Boolean.TRUE);&&
//放置xml自动缩进属性
marshaller.setClassesToBeBound(Student.class,Teacher.class);//映射的xml类放入JAXB环境中
marshaller.setMarshallerProperties(properties);//设置Marshaller属性
public @Bean MarshalAndUnmarshalService
marshalAndUnmarshalService()
return new MarshalAndUnmarshalService();//创建和使用JAXB
MarshalAndUnmarshalService.java
package com.upc.upcgrid.guan.
import org.springframework.beans.factory.annotation.A
import org.springframework.oxm.M
import org.springframework.oxm.U
import org.
@Component
public class MarshalAndUnmarshalService{
private Marshaller marshaller;//注入Marshaller
private Unmarshaller unmarshaller;//注入Unmarshaller
@Autowired
public void setMarshaller(Marshaller marshaller) {
this.marshaller =
public Marshaller getMarshaller() {
return marshaller;
@Autowired
public void setUnmarshaller(Unmarshaller unmarshaller)
this.unmarshaller =
public Unmarshaller getUnmarshaller() {
return unmarshaller;
编写测试程序。
现在我们的准备工作已经结束，剩下的就是测试，在MainTest.java中给出了如何使用Spring进行XOM映射。
在main函数中，先创建需要编组的对象，之后构建Spring环境，从Spring环境中获取到marshaller和unmarshaller，最后完成编组和解组。
package com.upc.upcgrid.guan.
import java.io.F
import java.io.IOE
import javax.xml.transform.stream.StreamR
import javax.xml.transform.stream.StreamS
import org.springframework.context.ApplicationC
import org.springframework.context.annotation.AnnotationConfigApplicationC
import org.springframework.oxm.XmlMappingE
import com.upc.upcgrid.guan.springjaxb.student.S
import com.upc.upcgrid.guan.springjaxb.student.T
public class MainTest {
public static void main(String[] args) throws XmlMappingException, IOException {
//创建两个文件，分别输出不同的对象
File file = new File("student.xml");
File tFile = new File("teacher.xml");
//创建学生
Student student =
new Student();
student.setId(21231);
student.setName("mary");
//创建teacher
Teacher teacher = new Teacher();
teacher.setName("Lucy");
//创建spring上下文（此时spring开始分析并创建单例类的对象）
ApplicationContext ac = new AnnotationConfigApplicationContext(SpringConfigure.class);
//获取到jaxb使用的工具
MarshalAndUnmarshalService maus =
ac.getBean(MarshalAndUnmarshalService.class);
//将学生和教师数据编组到文件
maus.getMarshaller().marshal(student,
new StreamResult(file));
maus.getMarshaller().marshal(teacher, new StreamResult(tFile));
//将学生和教师信息解组到对象
Student s = (Student)
maus.getUnmarshaller().unmarshal(new StreamSource(file));
Teacher t = (Teacher)
maus.getUnmarshaller().unmarshal(new StreamSource(tFile));
//输出学生和教师中的内容
System.out.println(s.getName());
System.out.println(t.getName());
标准输出：
org.springframework.context.support.AbstractApplicationContext
prepareRefresh
信息: Refreshing
org.springframework.context.annotation.AnnotationConfigApplicationContext@1113708:
startup date [Thu Jun 23 20:22:54 CST 2011]; root of context
org.springframework.beans.factory.support.DefaultListableBeanFactory
preInstantiateSingletons
信息: Pre-instantiating singletons in
org.springframework.beans.factory.support.DefaultListableBeanFactory@1f33675:
defining beans
[org.springframework.context.annotation.internalConfigurationAnnotationProcessor,org.springframework.context.annotation.internalAutowiredAnnotationProcessor,org.springframework.context.annotation.internalRequiredAnnotationProcessor,org.springframework.context.annotation.internalCommonAnnotationProcessor,springConfigure,jaxb2Marshaller,marshalAndUnmarshalService];
root of factory hierarchy
org.springframework.oxm.jaxb.Jaxb2Marshaller
createJaxbContextFromClasses
信息: Creating JAXBContext with classes to be bound
[class com.upc.upcgrid.guan.springjaxb.student.Student,class
com.upc.upcgrid.guan.springjaxb.student.Teacher]
生成的XML文档：
Student.xml
&?xml version="1.0" encoding="UTF-8" standalone="yes"?&
&student id="21231"&
&name&mary&/name&
&/student&
Teacher.xml
&?xml version="1.0" encoding="UTF-8" standalone="yes"?&
&name&Lucy&/name&
&/teacher&
程序结构：
Spring官方文档
JAXB官方文档：http://jaxb.java.net/tutorial/index.html
已投稿到：
以上网友发言只代表其个人观点，不代表新浪网的观点或立场。Error 404 (Not Found)!!1
404. That’s an error.
The requested URL /365392/ was not found on this server.
That’s all we know.5902人阅读
1、概念是什么：（Java Architecture for XML Binding) 是一个业界的标准，是一项可以根据XML Schema产生Java类的技术。是一种xml与object映射绑定技术标准，既然是标准就可以有不同实现.
2、JAXB中有什么：包含“xjc”工具和一个“schemagen”工具。
“xjc”工具可以用来将XML模式或其他类型模式文件（Java 1.6试验性地支持RELAX NG，DTD以及WSDL）转换为Java类。Java类使用javax.xml.bind.annotation包下的Java 标注，例如@XmlRootElement和@XmlElement。XML列表序列表示为java.util.List类型的属性， 通过JAXBContext可以创建Marshallers（将Java对象转换成XML）和Unmarshallers（将XML解析为Java对象）。 另外的“schemagen”工具，能够执行“xjc”的反向操作，通过一组标注的Java类创建一个XML模式。
二、JDK5以下开发需要的jar包：activation.jar、jaxb-api.jar、 jaxb-impl.jar、 jsr173-api. 如果是基于JDK6以上版本已经集成JAXB2的JAR，在目录{JDK_HOME}/jre/lib/rt.jar中。
三、标注相关
1、注解可在属性定义上，也可在getter()方法上，最好在方法上注解，修饰属性用private，方法是public，属性注解可能会出现问题（如：JAXB “Class has two properties of the same name”）。
2、对象中的属性可以不全部映射到xml中，xml中出现的元素也不一定与映射的实体一一对应，映射的双方可以灵活对应
3、类上注解后，类中元素也默认按默认名称映射，但是对象属性名称与xml节点元素名称不一致时或者不需要显示在xml节点中时，则必须做对应的映射配置。
4、注解实例：映射一般分分：类名与xml根节点的映射、普通属性与xml节点的映射、集合与xml中包含子元素的节点的映射。
*转换为xml的实体类
import javax.xml.bind.annotation.XmlE
import javax.xml.bind.annotation.XmlRootE
//类注解，一个类最多可以有一个根元素
@XmlRootElement(name=&Property&)
public class Property {
private Integer styleId;
private String elementN
private String entityF
//普通属性
@XmlElement
public String getSequence() {
public void setSequence(String sequence) {
this.sequence =
@XmlElement
public Integer getStyleId() {
return styleId;
public void setStyleId(Integer styleId) {
this.styleId = styleId;
@XmlElement
public String getElementName() {
return elementN
public void setElementName(String elementName) {
this.elementName = elementN
@XmlElement
public String getEntityField() {
return entityF
public void setEntityField(String entityField) {
this.entityField = entityF
*包含上面对象实体的类
import java.util.ArrayL
import java.util.L
import javax.xml.bind.annotation.XmlE
import javax.xml.bind.annotation.XmlE
import javax.xml.bind.annotation.XmlRootE
@XmlRootElement
public class Resouce {
private String picL
private List&Property& P
@XmlElement
public String getPicLarge() {
return picL
public void setPicLarge(String picLarge) {
this.picLarge = picL
// 如果想在节点外面包一层xml元素节点，可以用
// @XmlElementWrapper(name=&wrapper& )
@XmlElements( {
@XmlElement(name = &Property&, type = Property.class),
// @XmlElement(name = &adInfo&, type = AdInfo.class)一个集合可以放置多个xml元素名称和对象类型、在xml中是相互独立的集合元素，无包含关系
public List&Property& getProperties() {
public void setProperties(List&Property& properties) {
Properties =
public static void main(String [] args){
Property property = new Property();
property.setElementName(&elementName&);
property.setEntityField(&entityField&);
property.setSequence(&sequence&);
property.setStyleId(11111);
Property property1 = new Property();
property1.setElementName(&elementName111&);
property1.setEntityField(&entityField111&);
property1.setSequence(&sequence1111&);
property1.setStyleId(22222);
List&Property& list = new ArrayList&Property&();
list.add(property);
list.add(property1);
Resouce resouce = new Resouce();
resouce.setPicLarge(&picLarge&);
resouce.setProperties(list);
JAXB2Tester.bean2Xml(resouce);
import java.io.ByteArrayInputS
import java.io.InputS
import java.io.StringW
import java.io.UnsupportedEncodingE
import java.util.ArrayL
import java.util.L
import javax.xml.bind.JAXBC
import javax.xml.bind.JAXBE
import javax.xml.bind.M
import javax.xml.bind.U
*xml与JAVA对象相互转化
public class JAXB2Tester {
* 将生成的xml转换为对象
* @param zClass 转换为实例的对象类类型
* @param xmlPath 需要转换的xml路径
public static Object xml2Bean(Class&?& zClass, String xml) {
Object obj =
JAXBContext context =
if (null == xml || &&.equals(xml) || &null&.equalsIgnoreCase(xml)
|| xml.length() & 1)
context = JAXBContext.newInstance(zClass);
// if without &utf-8&, Invalid byte 2 of 2-byte UTF-8 sequence.
InputStream iStream = new ByteArrayInputStream(xml.getBytes(&utf-8&));
Unmarshaller um = context.createUnmarshaller();
obj = (Object) um.unmarshal(iStream);
} catch (JAXBException e) {
e.printStackTrace();
}catch (UnsupportedEncodingException e) {
e.printStackTrace();
public static String bean2Xml(Object bean) {
String xmlString =
if (null == bean)
return xmlS
//下面代码将对象转变为xml
context = JAXBContext.newInstance(bean.getClass());
Marshaller m = context.createMarshaller();
writer = new StringWriter();
m.marshal(bean, writer);
xmlString = writer.toString();
System.out.println(xmlString);
return xmlS
} catch (Exception e) {
e.printStackTrace();
return xmlS
&&相关文章推荐
* 以上用户言论只代表其个人观点，不代表CSDN网站的观点或立场
访问：15490次
排名：千里之外
(1)(1)(1)(1)(1)(1)(1)(1)下次自动登录
现在的位置:
& 综合 & 正文
JDK6的新特性之二:使用JAXB2来实现对象与XML之间的映射
JDK6的新特性之二:使用JAXB2来实现对象与XML之间的映射 JAXB是Java Architecture for XML Binding的缩写，可以将一个Java对象转变成为XML格式，反之亦然。我们把对象与关系数据库之间的映射称为ORM, 其实也可以把对象与XML之间的映射称为OXM(Object XML Mapping). 原来JAXB是Java EE的一部分，在JDK6中，SUN将其放到了Java SE中，这也是SUN的一贯做法。JDK6中自带的这个JAXB版本是2.0, 比起1.0(JSR 31)来，JAXB2(JSR 222)用JDK5的新特性Annotation来标识要作绑定的类和属性等，这就极大简化了开发的工作量。实际上，在Java EE 5.0中，EJB和Web Services也通过Annotation来简化开发工作。另外,JAXB2在底层是用StAX(JSR 173)来处理XML文档。 闲话不多说了，下面用演示在JDK6中如何来用JAXB2
public class JAXB2Tester {
public static void main(String[] args) throws JAXBException,IOException {
JAXBContext context = JAXBContext.newInstance(Person.class);
//下面代码演示将对象转变为xml
Marshaller m = context.createMarshaller();
Address address = new Address("China","Beijing","Beijing","ShangDi West","100080");
Person p = new Person(Calendar.getInstance(),"JAXB2",address,Gender.MALE,"SW");
FileWriter fw = new FileWriter("person.xml");
m.marshal(p,fw);
//下面代码演示将上面生成的xml转换为对象
FileReader fr = new FileReader("person.xml");
Unmarshaller um = context.createUnmarshaller();
Person p2 = (Person)um.unmarshal(fr);
System.out.println("Country:"+p2.getAddress().getCountry());
@XmlRootElement//表示person是一个根元素class Person {
@XmlElement
Calendar birthD //birthday将作为person的子元素
@XmlAttribute
S //name将作为person的的一个属性
public Address getAddress() {
@XmlElement
A //address将作为person的子元素
@XmlElement
G //gender将作为person的子元素
@XmlElement
S //job将作为person的子元素
public Person(){
public Person(Calendar birthDay, String name, Address address, Gender gender, String job) {
this.birthDay = birthD
this.name =
this.address =
this.gender =
this.job =
enum Gender{
MALE(true),
FEMALE (false);
Gender(boolean _value){
class Address {
@XmlAttribute
@XmlElement
@XmlElement
@XmlElement
S //由于没有添加@XmlElement,所以该元素不会出现在输出的xml中
public Address() {
public Address(String country, String state, String city, String street, String zipcode) {
this.country =
this.state =
this.city =
this.street =
this.zipcode =
public String getCountry() {
运行该，我们会得到一个person.xml的文件，如下：
&?xml version="1.0" encoding="UTF-8" standalone="yes" ?&
&person name="JAXB2"&
&birthDay&T08:49:27.203+00:00&/birthDay&
&address country="China"&
&state&Beijing&/state&
&city&Beijing&/city&
&street&ShangDi West&/street&
&/address&
&gender&MALE&/gender&
&job&SW&/job& &/person&控制台会输出
Country:China
最后，想说一点，除了JAXB之外，我们还可以通过XMLBeans和Castor等来实现同样的功能。
&&&&推荐文章:
【上篇】【下篇】jaxb2MarshallingView两种配置方式 - 流星雨 - ITeye技术网站
博客分类：
&-- xml视图,Jaxb2Marshaller,需要配置对象和对象添加Annotation xml注解，不需要添加额外的jar包 --&
&bean name="jaxb2MarshallingView" class="org.springframework.web.servlet.view.xml.MarshallingView"&
&constructor-arg&
&bean class="org.springframework.oxm.jaxb.Jaxb2Marshaller"&
&property name="classesToBeBound"&
&value&com.aa.User&/value&
&value&com.aa.AccountBean&/value&
&/property&
&/constructor-arg&
&bean name="jaxb2MarshallingView"
class="cn.meteor.spring.openApi.web.servlet.view.xml.MarshallingView"&
&property name="marshaller" ref="jaxbMarshall"&&/property&
&oxm:jaxb2-marshaller id="jaxbMarshall"&
&oxm:class-to-be-bound name="com.aa.User" /&
&oxm:class-to-be-bound name="com.aa.AccountBean" /&
&/oxm:jaxb2-marshaller&
shenjc2008
浏览: 97521 次
来自: 广州
写的很好啊～
写的很好～
cn.meteor.spring.openApi.web.se ...
请问下我本机有个html5的服务地址，我用手机连到同一个无线路 ...
写的很清晰，赞！