`

利用JAXB将XML和Java对象进行转换

XMLXSDMarshalUnmarshalJAXBContext 
阅读更多

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

一、Marshal过程

定义Message.java

package com.jaxb;

import javax.xml.bind.annotation.*;


@SuppressWarnings("restriction")
@XmlRootElement(name="GC_MSG")
@XmlAccessorType(XmlAccessType.FIELD)
@XmlType(name="Message", propOrder={"messageId", "message"})
public class Message {
	
	@XmlElement(name="MSG_ID")
	private String messageId;
	
	@XmlElement(name="MESSAGE")
	private String message;
	
	public String getMessageId() {
		return messageId;
	}
	public void setMessageId(String messageId) {
		this.messageId = messageId;
	}
	public String getMessage() {
		return message;
	}
	public void setMessage(String message) {
		this.message = message;
	}
}

 

利用Java类生成XML

package com.jaxb;

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

@SuppressWarnings("restriction")
public class Java2XML {

	/**
	 * @param args
	 */
	public static void main(String[] args) {
		try {
			JAXBContext context = JAXBContext.newInstance(Message.class);
			Marshaller marshaller = context.createMarshaller();
			marshaller.setProperty(Marshaller.JAXB_FORMATTED_OUTPUT, true);

			Message mes = new Message();
			mes.setMessageId("007");
			mes.setMessage("Summer Test XML");
			marshaller.marshal(mes, System.out);

		} catch (JAXBException e) {
			e.printStackTrace();
		}

	}

}

通常我们会将marshal的信息写进Document中

package com.jaxb;

import java.io.ByteArrayOutputStream;
import java.io.OutputStream;

import javax.xml.bind.*;
import javax.xml.parsers.DocumentBuilder;
import javax.xml.parsers.DocumentBuilderFactory;
import javax.xml.parsers.ParserConfigurationException;
import javax.xml.transform.OutputKeys;
import javax.xml.transform.Transformer;
import javax.xml.transform.TransformerConfigurationException;
import javax.xml.transform.TransformerException;
import javax.xml.transform.TransformerFactory;
import javax.xml.transform.dom.DOMSource;
import javax.xml.transform.stream.StreamResult;

import org.apache.log4j.Logger;
import org.w3c.dom.Document;

public class Java2XMLInDoc {

	/**
	 * @param args
	 */
	@SuppressWarnings("restriction")
	public static void main(String[] args) {
		Logger log = Logger.getLogger(Java2XMLInDoc.class);
		OutputStream os = new ByteArrayOutputStream();
		try {
			JAXBContext context = JAXBContext.newInstance(Message.class);
			Marshaller marshaller = context.createMarshaller();
			
			// Create an empty DOM document
			// DocumentBuilderFactory is not thread-safe
			DocumentBuilderFactory dbFactory = DocumentBuilderFactory.newInstance();
			DocumentBuilder docBuilder = dbFactory.newDocumentBuilder();
			Document doc = docBuilder.newDocument();

			// Marshall the feed object into the empty document.
			Message msg = new Message();
			msg.setMessageId("008");
			msg.setMessage("Summer Test XML");
			marshaller.marshal(msg, doc);
			
			// Transform the DOM to the output stream
			// TransformerFactory is not thread-safe
			TransformerFactory tsfFacory = TransformerFactory.newInstance();
			Transformer transformer = tsfFacory.newTransformer();
			transformer.setOutputProperty(OutputKeys.INDENT, "yes");
			transformer.transform(new DOMSource(doc), new StreamResult(os));
			
			log.info(os);
		} catch (JAXBException e) {
			e.printStackTrace();
		} catch (ParserConfigurationException e) {
				e.printStackTrace();
		}catch (TransformerConfigurationException e) {
				e.printStackTrace();
		}catch (TransformerException e) {
				e.printStackTrace();
		}
		
	}

}

 

所得结果：

<?xml version="1.0" encoding="UTF-8" standalone="yes"?>
<GC_MSG>
    <MSG_ID>007</MSG_ID>
    <MESSAGE>Summer Test XML</MESSAGE>
</GC_MSG>

 

二、Unmarshal过程

定义message.xsd

<?xml version="1.0" encoding="UTF-8"?>
<xs:schema elementFormDefault="qualified"
	xmlns:xs="http://www.w3.org/2001/XMLSchema">

    <xs:element name="GC_MSG" type="Message"></xs:element>
    
    <xs:complexType name="Message">
    	<xs:sequence>
    		<xs:element name="MSG_ID"  type="xs:string"></xs:element>
    		<xs:element name="MESSAGE"  type="xs:string"></xs:element>
    	</xs:sequence>
    </xs:complexType>
</xs:schema>

 

定义message.xml

<?xml version="1.0" encoding="UTF-8" standalone="no"?>
<GC_MSG xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
		xsi:noNamespaceSchemaLocation="message.xsd">
<MSG_ID>009</MSG_ID>
<MESSAGE>Summer Test XML</MESSAGE>
</GC_MSG>

 

利用XML转成Java对象

package com.jaxb;

import java.io.FileInputStream;
import java.io.IOException;
import java.io.InputStream;

import javax.xml.XMLConstants;
import javax.xml.transform.Source;
import javax.xml.transform.stream.StreamSource;
import javax.xml.validation.Schema;
import javax.xml.validation.SchemaFactory;

import javax.xml.bind.*;

import org.apache.log4j.Logger;
import org.xml.sax.SAXException;

public class XML2JavaObject {
	/**
	 * @param args
	 */
	@SuppressWarnings("restriction")
	public static void main(String[] args) {
		Logger log = Logger.getLogger(XML2JavaObject.class);
		XML2JavaObject xml2Java = new XML2JavaObject();
		String schemaFileName = "message.xsd";
		String fileName = "message.xml";
		Schema schema = xml2Java.loadSchema(schemaFileName);
		try {
			JAXBContext context = JAXBContext.newInstance(Message.class);
			Unmarshaller unmarshaller = context.createUnmarshaller();
			unmarshaller.setSchema(schema);
			
			Message message = (Message)unmarshaller.unmarshal(xml2Java.getInputStream(fileName));
			log.info(message.getMessage());
			log.info(message.getMessageId());
						
		} catch (JAXBException e) {
			e.printStackTrace();
		}
		

	}
	
	private Schema loadSchema(String fileName){
		SchemaFactory schemeaFactory = SchemaFactory.newInstance(XMLConstants.W3C_XML_SCHEMA_NS_URI);
		InputStream inputStream = getInputStream(fileName);
		Source streamSource = new StreamSource(inputStream);
		Schema schema = null;
		try {
			schema = schemeaFactory.newSchema(streamSource);
			
		} catch (SAXException e) {
			e.printStackTrace();
		}finally{
			if(inputStream != null){
				try {
					inputStream.close();
				} catch (IOException ignored) {
				}
			}
		}
		return schema;
	}
	
	private InputStream getInputStream(String fileName){
		return XML2JavaObject.class.getResourceAsStream(fileName);
	}

}

 

所得结果：

2014-01-10 09:57:03 INFO  (XML2JavaObject.java:35)[main]  - Summer Test XML
2014-01-10 09:57:03 INFO  (XML2JavaObject.java:36)[main]  - 009

 其实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文件中。

 

最后推荐一个网页，可以验证xml对应的xsd是否正确：

http://www.xmlvalidation.com/index.php?id=1&L=0

分享到：
| JUnit Annotation——JUnit单元测试中批注 ...
评论
发表评论

您还没有登录,请您登录后再发表评论

相关推荐

    利用JAXB进行xml和javabean之间转换

    这篇博客将深入探讨如何利用JAXB进行xml和javabean之间的转换。 首先，我们需要了解JAXB的基本工作原理。JAXB通过元数据（如注解或XML绑定文件）来映射Java类到XML元素，以及XML元素到Java类。这使得XML文档能够被...

    JAXB技术实现xml与java对象互相转化代码教程

    使用java jdk的JAXB技术实现xml与java对象互相转化代码教程: JDK中JAXB相关的重要Class和Interface：(来源于百度百科JAXB) •JAXBContext类，是应用的入口，用于管理XML/Java绑定信息。 •Marshaller接口，将Java...

    JAXB工具类 xml转为java对象 java对象转为xml

    Java Architecture for XML Binding (JAXB) 是Java平台中用于处理XML和Java对象之间转换的一个标准API。它使得在Java应用程序中使用XML数据变得更加方便，无需手动编写大量的转换代码。本教程将详细介绍JAXB如何实现...

    通过JAXB实现完成java对象和xml的互相转换

    Java Architecture for XML Binding (JAXB) 是一个Java标准，它提供了在Java对象和XML文档之间进行自动转换的能力。这项技术极大地简化了XML数据处理，使得开发者可以方便地将Java对象序列化为XML，或者从XML数据中...

    JAXB完成XML和Java对象的互转

    该过程中，JAXB也提供了将XML实例文档反向生成Java对象树的方法，并能将Java对象树的内容重新写到XML实例文档。从另一方面来讲，JAXB提供了快速而简便的方法将XML模式绑定到Java表示，从而使得Java开发者在Java应用...

    利用jaxb实现xml和bean互转

    4. **Marshalling**: 使用`Marshaller`对象将Java Bean实例转换为XML字符串或写入文件。 5. **Unmarshalling**: 使用`Unmarshaller`对象将XML字符串或文件解析回Java Bean实例。 6. **绑定文件（bindings file）**...

    webservice之使用jaxb把xml转换Object或把对象转换成xml文件

    总结，JAXB是Java中实现XML数据和Java对象之间无缝转换的强大工具，尤其在WebService开发中扮演着重要角色。通过理解JAXB的工作原理和使用方式，开发者可以更高效地处理XML数据，提升应用程序的性能和可维护性。

    用jaxb 实现 xml转java对象技术

    3. **对象到XML的转换**: 使用`JAXBContext`实例化上下文，然后通过`Marshaller`对象将Java对象转换为XML字符串或文件。 4. **XML到对象的转换**: 类似地，使用`Unmarshaller`对象可以将XML数据恢复为Java对象。 *...

    JAVA JAXB 解析XML嵌套子节点为字符串

    在Java开发中，JAXB（Java Architecture for XML Binding）是一个标准的API，用于将XML文档与Java对象之间进行互相转换。这个技术对于处理XML数据，尤其是解析和生成XML文档非常有用。当我们面临XML文档中存在嵌套子...

    使用jaxb将XML转化为JAVA BEAN

    JAXB是Java标准API，它提供了将XML文档与Java对象之间进行自动转换的能力，极大地简化了XML的处理。 首先，我们需要理解JAXB的工作原理。JAXB基于Java反射机制，通过在Java类上使用特定的注解（如@XmlRootElement、...

    java 使用 JAXB 将xml转换为 bean 包含xml和dto和读取文件的util类

    Java中的JAXB（Java Architecture for XML Binding）是一个用于在Java对象和XML文档之间进行映射的标准API。这个技术使得开发者可以方便地将XML数据转换为Java对象，反之亦然。在给定的压缩包文件中，可能包含了实现...

    JAXB xml与对象转换

    它允许开发者将XML Schema定义的数据结构直接映射到Java类，从而方便地在XML和Java对象之间进行转换。JAXB简化了XML数据的处理，使得XML的读写操作变得更加直观和高效。 ### JAXB工作原理 JAXB的核心概念是两个主要...

    jaxb xml转化为对象，对象转化为xml，xml转化为xsd，表转化为对象

    Java Architecture for XML Binding (JAXB) 是Java平台中用于处理XML和Java对象之间转换的一个标准技术。它允许我们将XML文档转换为Java对象，反之亦然，这样就能方便地在XML和Java应用程序之间交换数据。在Java SE...

    jaxb生成XML例子

    JAXB (Java Architecture for XML Binding) 是 Java 中用于对象到XML以及XML到对象转换的API。它使得开发者能够轻松地将Java对象模型映射到XML文档，并反之亦然。在给定的例子中，我们将深入理解如何使用JAXB注解来...

    xml和java对象互相转换的两种方法

    本文将详细介绍两种主要的XML与Java对象互相转换的方法：DOM（Document Object Model）解析和JAXB（Java Architecture for XML Binding）。 1. DOM解析： DOM是一种W3C标准，它将XML文档解析成一棵由节点组成的树，...

    jaxb (XML操作)

    **JAXB（Java Architecture for XML Binding）** 是Java平台中用于处理XML的一种强大的工具，它提供了将XML文档与Java对象之间的映射，从而方便XML数据的解析和生成。通过JAXB，开发者可以轻松地实现XML数据到Java...

    stax+jaxb进行xml解析

    JAXB则是一种对象到XML和XML到对象的绑定框架，它可以将Java对象转换为XML，并将XML数据转换回相应的Java对象。JAXB的优势在于其自动化程度高，只需通过注解或配置文件，就能轻松地映射XML结构到Java对象。 结合...

    XML与Java对象互相转化Demo（Eclipse）

    在这个示例中，我们可能使用了JAXB（Java Architecture for XML Binding）框架，它是Java SE的一部分，用于自动将Java对象绑定到XML，以及将XML反序列化回Java对象。 1. **XML到Java对象的转化**：使用JAXB，首先...

    JAXB 利用xsd文件生成java类

    JAXB (Java Architecture for XML Binding) 是Java平台上的一个标准，用于将XML文档与Java对象之间进行绑定，实现XML数据的解析和序列化。在Java开发中，JAXB提供了一种方便的方式，允许开发者通过XML Schema (XSD) ...

Magicbox
Global site tag (gtag.js) - Google Analytics