`
chenming47
  • 浏览: 94282 次
  • 性别: Icon_minigender_1
  • 来自: 厦门
社区版块
存档分类
最新评论

jaxb操作实例

    博客分类：
  • jaxb
JavaXML百度SVNGmail 
阅读更多

以下内容是个人对jaxb技术的总结及操作实例讲解:

1、什么是jaxb？ 

写道
"JAXB（Java Architecture for XML Binding) 是一个业界的标准，是一项可以根据XML Schema产生Java类的技术。该过程中，JAXB提供了将XML实例文档反向生成Java对象树的方法，并能将Java对象树的内容重新写到XML实例文档。从另一方面来讲，JAXB提供了快速而简便的方法将XML模式绑定到Java表示，从而使得Java开发者在Java应用程序中能方便地结合XML数据和处理函数。"--摘自《百度百科》


   也就是说jaxb是一项数据绑定技术，它将xml文件映射成一个个的java类，程序员通过操作这些类就可以对xml文件中的元素进行读取等操作，同样程序员也可以改变这些类的属性，最后映射到xml文件中，这样做可以把程序员的主要精力放在业务逻辑上，并且也更符合面向对象的思想，而无需像使用DOM4J等技术一样需要处理一个个的xml节点，但是jaxb技术还不够成熟，对于映射的数据类型的控制，以及对语义等价的实现的还不够完美。

2、使用xjc工具生成xml对应的java类

   如果xml结构比较简单，建议手动的编写java类即可，如下示例

command.xml文件为：

<?xml version="1.0" encoding="UTF-8"?>
<Command-Mappers>
	<Comand-Mapper>
		<CommandReg>shutdown</CommandReg>
		<ClassName>com.yinhoo.ca.command.ShutDownCmdExecutor</ClassName>
	</Comand-Mapper>
</Command-Mappers>

 对应的CommandMapper.java为：

 * @(#)CommandMapper.java 2011-2-12
package com.yinhoo.ca.dto;

import java.util.List;

import javax.xml.bind.annotation.XmlAccessType;
import javax.xml.bind.annotation.XmlAccessorType;
import javax.xml.bind.annotation.XmlElement;
import javax.xml.bind.annotation.XmlRootElement;
import javax.xml.bind.annotation.XmlType;

/**
 * Mapped for command.xml
 * 
 * @author chenming
 * @date 2011-2-12
 * @version $Revision$
 */
@XmlAccessorType(XmlAccessType.FIELD)
@XmlRootElement(name = "Command-Mappers")
public class CommandMapper {

    private List<ComandMapper> cmdMapperList;

    /**
     * @return the cmdMapperList
     */
    public List<ComandMapper> getCmdMapperList() {
        return cmdMapperList;
    }

    /**
     * @param cmdMapperList
     *            the cmdMapperList to set
     */
    public void setCmdMapperList(List<ComandMapper> cmdMapperList) {
        this.cmdMapperList = cmdMapperList;
    }

    @XmlElement(name = "Comand-Mapper")
    @XmlType(name = "Comand-Mapper")
    @XmlAccessorType(XmlAccessType.FIELD)
    public static class ComandMapper {

        @XmlElement(name = "CommandReg")
        private String commandReg;

        @XmlElement(name = "ClassName")
        private String className;

        /**
         * @return the commandReg
         */
        public String getCommandReg() {
            return commandReg;
        }

        /**
         * @param commandReg
         *            the commandReg to set
         */
        public void setCommandReg(String commandReg) {
            this.commandReg = commandReg;
        }

        /**
         * @return the className
         */
        public String getClassName() {
            return className;
        }

        /**
         * @param className
         *            the className to set
         */
        public void setClassName(String className) {
            this.className = className;
        }

    }

}

 稍微复杂的例子encrypt_list.xml为：

<?xml version="1.0" encoding="UTF-8"?>
<EncryptInfo>
  <DoEncrypt>true</DoEncrypt>
  
  <CaServer>10.10.10.40</CaServer>
  
  <CaPort>50000</CaPort>
  
	<EncryptList>
		<Encrypt>
			<type>FILE</type>
			<value>conf\configs.xml</value>
		</Encrypt>
		
		<Encrypt>
			<type>FOLD</type>
			<value>conf\domains\</value>
			<!-- 排除的文件列表,以 逗号分隔. -->
			<exclude>.svn,gmail.com.xml,china.com.xml</exclude>
		</Encrypt>
	</EncryptList>
</EncryptInfo>

 对应的EncryptMapper.java为：

 * @(#)EncryptMapper.java 2011-2-14
package com.yinhoo.ca.dto;

import java.io.Serializable;
import java.util.List;

import javax.xml.bind.annotation.XmlAccessType;
import javax.xml.bind.annotation.XmlAccessorType;
import javax.xml.bind.annotation.XmlElement;
import javax.xml.bind.annotation.XmlElementWrapper;
import javax.xml.bind.annotation.XmlRootElement;
import javax.xml.bind.annotation.XmlType;

/**
 * 对应encrypt_list.xml
 * 
 * @author chenming
 * @date 2011-2-14
 * @version $Revision$
 */
@XmlAccessorType(XmlAccessType.FIELD)
@XmlRootElement(name = "EncryptInfo")
public class EncryptMapper {

    @XmlElement(name = "DoEncrypt")
    private Boolean doEncrypt;

    @XmlElement(name = "CaServer")
    private String caServer;

    @XmlElement(name = "CaPort")
    private Integer caPort;

    @XmlElementWrapper(name = "EncryptList")
    private List<Encrypt> encryptList;

    /**
     * @return the doEncrypt
     */
    public Boolean getDoEncrypt() {
        return doEncrypt;
    }

    /**
     * @param doEncrypt
     *            the doEncrypt to set
     */
    public void setDoEncrypt(Boolean doEncrypt) {
        this.doEncrypt = doEncrypt;
    }

    /**
     * @return the caServer
     */
    public String getCaServer() {
        return caServer;
    }

    /**
     * @param caServer
     *            the caServer to set
     */
    public void setCaServer(String caServer) {
        this.caServer = caServer;
    }

    /**
     * @return the caPort
     */
    public Integer getCaPort() {
        return caPort;
    }

    /**
     * @param caPort
     *            the caPort to set
     */
    public void setCaPort(Integer caPort) {
        this.caPort = caPort;
    }

    /**
     * @return the encryptList
     */
    public List<Encrypt> getEncryptList() {
        return encryptList;
    }

    /**
     * @param encryptList
     *            the encryptList to set
     */
    public void setEncryptList(List<Encrypt> encryptList) {
        this.encryptList = encryptList;
    }
    @XmlElement(name = "Encrypt")
    @XmlType(name = "Encrypt")
    @XmlAccessorType(XmlAccessType.FIELD)
    public static class Encrypt {
        @XmlElement(name = "type")
        private String type;
        @XmlElement(name = "value")
        private String value;
        @XmlElement(name = "exculde")
        private String exclude;

        /**
         * @return the type
         */
        public String getType() {
            return type;
        }

        /**
         * @param type
         *            the type to set
         */
        public void setType(String type) {
            this.type = type;
        }

        /**
         * @return the value
         */
        public String getValue() {
            return value;
        }

        /**
         * @param value
         *            the value to set
         */
        public void setValue(String value) {
            this.value = value;
        }

        /**
         * @return the exclude
         */
        public String getExclude() {
            return exclude;
        }

        /**
         * @param exclude
         *            the exclude to set
         */
        public void setExclude(String exclude) {
            this.exclude = exclude;
        }
    }
}

  

否则需生成xml对应的xsd文件，然后利用xsd文件生成xml对应的java类。关于如何利用xml生成对应的xsd文件可参考以下链接（待完善）： 

    http://sunxboy.iteye.com/blog/411513/  

   本文采用的xml文件为guitars.xml：

<?xml version="1.0" encoding="UTF-8" standalone="yes"?>  
<guitars> 
  <guitar id="10021"> 
    <builder luthier="true">Ryan</builder> 
    <model>Mission Grand Concert</model> 
    <back-sides>Brazilian Rosewood</back-sides> 
    <top>Adirondack Spruce</top> 
    <notes> 
      <![CDATA[ 
        Just unbelievable...   this guitar has all the tone & 
        resonance you could ever want. I mean, <<WOW!!!>> This 
        is a lifetime guitar. 
      ]]> 
    </notes> 
  </guitar> 
  <guitar id="0923"> 
    <builder smallShop="true">Bourgeois</builder> 
    <model>OMC</model> 
    <back-sides>Bubinga</back-sides> 
    <top>Adirondack Spruce</top> 
  </guitar> 
  <guitar id="11091"> 
    <builder>MartinCompany</builder> 
    <model>OM-28VR</model> 
    <back-sides>Indian Rosewood</back-sides> 
    <top bearclaw="true">Sitka Spruce</top> 
    <notes>It's certainly true that Martin isn't the only game in town anymore. 
           Still, the OM-28VR is one of their best models...     and this one 
           has some fabulous bearclaw to boot.              Nice specimen of a 
           still-important guitar manufacturer. 
    </notes> 
  </guitar> 
</guitars>

 

对应的guitars.xsd为：

<?xml version="1.0" encoding="UTF-8"?> 
<xs:schema xmlns:xs="http://www.w3.org/2001/XMLSchema" 
           elementFormDefault="qualified"> 
  <xs:element name="back-sides" type="xs:string"/> 
  <xs:element name="builder"> 
    <xs:complexType> 
      <xs:simpleContent> 
        <xs:extension base="xs:string"> 
          <xs:attribute name="luthier" default="false"> 
            <xs:simpleType> 
              <xs:restriction base="xs:NMTOKEN"> 
                <xs:enumeration value="true"/> 
                <xs:enumeration value="false"/> 
              </xs:restriction> 
            </xs:simpleType> 
          </xs:attribute> 
          <xs:attribute name="smallShop" default="false"> 
            <xs:simpleType> 
              <xs:restriction base="xs:NMTOKEN"> 
                <xs:enumeration value="true"/> 
                <xs:enumeration value="false"/> 
              </xs:restriction> 
            </xs:simpleType> 
          </xs:attribute> 
        </xs:extension> 
      </xs:simpleContent> 
    </xs:complexType> 
  </xs:element> 
  <xs:element name="guitar"> 
    <xs:complexType> 
      <xs:sequence> 
        <xs:element ref="builder"/> 
        <xs:element ref="model"/> 
        <xs:element ref="back-sides"/> 
        <xs:element ref="top"/> 
        <xs:element ref="notes" minOccurs="0"/> 
      </xs:sequence> 
      <xs:attribute name="id" type="xs:string" use="required"/> 
    </xs:complexType> 
  </xs:element> 
  <xs:element name="guitars"> 
    <xs:complexType> 
      <xs:sequence> 
        <xs:element ref="guitar" maxOccurs="unbounded"/> 
      </xs:sequence> 
    </xs:complexType> 
  </xs:element> 
  <xs:element name="model" type="xs:string"/> 
  <xs:element name="notes" type="xs:string"/> 
  <xs:element name="top"> 
    <xs:complexType> 
      <xs:simpleContent> 
        <xs:extension base="xs:string"> 
          <xs:attribute name="bearclaw" default="false"> 
            <xs:simpleType> 
              <xs:restriction base="xs:NMTOKEN"> 
                <xs:enumeration value="true"/> 
                <xs:enumeration value="false"/> 
              </xs:restriction> 
            </xs:simpleType> 
          </xs:attribute> 
        </xs:extension> 
      </xs:simpleContent> 
    </xs:complexType> 
  </xs:element>

 
1、新建一个名为jaxbDemo的项目；
2、将guitar.xsd文件及guitar.xml文件放至到项目的根目录下
3、下载xjc工具所需的JAXB2_20101209.jar包 

 

http://jaxb.java.net/2.2.3/JAXB2_20101209.jar


4、双击jar包后生成一个jaxb-ri-20101209文件夹，然后将环境变量中Path变量设置为这个文件的bin目录的路径，这样xjc命令就可以使用了。
5、在命令模式下进入项目根目录，然后执行：

   xjc -p test guitars.xsd -d src

命令这样所需的java类就生成了，以下为命令的详细说明：

xjc  [–p java文件所在的包] [-xmlschema] [–d 保存java文件的目录]

-xmlschema  xsd文件路径。
-d  指定了保存java文件的目录
-p  指定了生成的java文件所在的包

6、最后就可以写相应的xml2java和java2xml方法，对xml文件进行操作了代码如下Java2XML：

package test; 

import java.io.FileInputStream; 
import java.io.FileOutputStream; 

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

import dto.Guitars; 

/** 
* 从guitars.xml读取信息，保存到java的类中，然后又写入另一个java文件中 
* 
* @author ming.chen 
* @date 2011-2-25 
* @version $Revision$ 
*/ 
public class Java2XML { 
    private String inputFilename; 
    private String outputFilename; 
    private JAXBContext jc; 
    private final String PACKAGE_NAME = "dto"; 

    public Java2XML(String inputFilename, String outputFilename) throws Exception { 
        this.inputFilename = inputFilename; 
        this.outputFilename = outputFilename; 
        jc = JAXBContext.newInstance(PACKAGE_NAME); 
    } 

    public Guitars unmarshal() throws Exception { 
        Unmarshaller u = jc.createUnmarshaller(); 
        return (Guitars) u.unmarshal(new FileInputStream(inputFilename)); 
    } 

    public void marshal(Guitars guitars) throws Exception { 
        Marshaller m = jc.createMarshaller(); 
        m.marshal(guitars, new FileOutputStream(outputFilename)); 
    } 

    public static void main(String[] args) { 
        if (args.length < 2) { 
            System.err.println("Incorrect usage: java RoundTripper" + "[input XML filename] [output XML filename]"); 
            return; 
        } 
        try { 
            Java2XML rt = new Java2XML(args[0], args[1]); 
            Guitars guitars = rt.unmarshal(); 
            rt.marshal(guitars); 
        } 
        catch (Exception e) { 
            e.printStackTrace(); 
            return; 
        } 
    } 

}

 
XML2Java.java

package test; 

import java.io.FileInputStream; 
import java.util.List; 

import javax.xml.bind.JAXBContext; 
import javax.xml.bind.Unmarshaller; 

import dto.Guitar; 
import dto.Guitars; 

/** 
* 将guitars.xml的内容写入java内存 
* 
* @author ming.chen 
* @date 2011-2-25 
* @version $Revision$ 
*/ 
public class XML2Java { 
    private String inputFilename; 
    private JAXBContext jc; 
    private final String PACKAGE_NAME = "dto"; 

    public XML2Java(String inputFilename) throws Exception { 
        this.inputFilename = inputFilename; 
        jc = JAXBContext.newInstance(PACKAGE_NAME); 
    } 

    public Guitars unmarshal() throws Exception { 
        Unmarshaller u = jc.createUnmarshaller(); 
        return (Guitars) u.unmarshal(new FileInputStream(inputFilename)); 
    } 

    public static void main(String[] args) { 
        if (args.length < 1) { 
            System.err.println("Incorrect usage: java RoundTripper" + "[input XML filename] [output XML filename]"); 
            return; 
        } 
        try { 
            XML2Java rt = new XML2Java(args[0]); 
            Guitars guitars = rt.unmarshal(); 
            List<Guitar> guitarList = guitars.getGuitar(); 
            for (Guitar guitar : guitarList) { 
                System.out.println(guitar.getBackSides()); 
                System.out.println(guitar.getId()); 
                System.out.println(guitar.getNotes()); 
            } 
        } 
        catch (Exception e) { 
            e.printStackTrace(); 
            return; 
        } 
    } 

}

 

分享到：
| jaxb使用
评论
发表评论

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

相关推荐

    JAXB应用实例.zip_36ZP_gainrtu_java

    **JAXB应用实例** Java Architecture for XML Binding (JAXB) 是Java平台标准版（Java SE）和企业版（Java EE）的一部分，它提供了一种在Java对象和XML文档之间进行映射的机制。JAXB允许开发者在不关心底层XML语法...

    JAXB实例入门

    **JAXB实例入门** Java Architecture for XML Binding (JAXB) 是Java平台中用于XML和Java对象之间进行绑定的一个标准框架。它允许开发者在Java类和XML文档之间进行无缝转换，大大简化了XML数据的处理。在本文中，...

    jaxb (XML操作)

    2. **实例化（Unmarshalling）**：当需要将XML数据转换为Java对象时，JAXB使用Unmarshaller接口解析XML文档，生成对应的Java对象。这个过程是将XML数据"反序列化"为可操作的Java对象。 3. **序列化（Marshalling）*...

    jaxb资料及实例，里面还包含了其他资料地址3

    标题“jaxb资料及实例，里面还包含了其他资料地址3”暗示了这个压缩包可能包含有关JAXB的详细教程、示例代码以及指向更多学习资源的链接。这可能包括PDF文档、HTML页面、Java源代码或者视频教程等，帮助开发者深入...

    jaxb2 生产java类demo实例

    本教程将通过一个实际的demo实例来详细讲解如何使用JAXB2来生产Java类。 **1. JAXB2概述** JAXB2是Java SE 6及更高版本的标准组件，它允许开发者在不编写大量手动代码的情况下，将XML文档映射到Java对象，反之亦然...

    JAXB的使用JAXB的使用

    3. **绑定上下文（Context）**：创建`JAXBContext`对象，它是整个JAXB操作的核心，负责管理和维护Java类型与XML Schema之间的映射关系。 4. **反序列化（Unmarshalling）**：使用`Unmarshaller`对象的`unmarshal()`...

    webservice实例 CXF的JAXWS和JAXRS实现 及JAXB标准接口实现带jar包

    同时，JAXB（Java Architecture for XML Binding）是Java中处理XML和Java对象之间转换的标准接口。下面将详细介绍这些知识点。 首先，**JAX-WS** 是一种用于构建SOAP（Simple Object Access Protocol）Web服务的...

    idea 中用jaxb 读xml中数据

    5. **处理解析后的数据**：现在，你可以访问并操作解析出的Java对象，就像处理任何其他Java对象一样。 ```java System.out.println("Name: " + person.getName()); System.out.println("Age: " + person.getAge());...

    jaxb-impl.jar包

    JAXB允许开发人员将XML Schema转换为Java类，从而可以以面向对象的方式操作XML数据，极大地简化了XML的处理工作。 **JAXB的核心功能** 1. **XML到Java对象的转换**：JAXB提供了一种机制，可以将XML文档解析成Java...

    JAXB的例子

    **JAXB实例** 在"Test"这个例子中，我们可以假设有一个XML文档，描述了某个图书信息，例如： ```xml &lt;title&gt;Java编程思想 布鲁斯·艾克尔 机械工业出版社 ``` 对应地，我们有以下的Java类： ```java @...

    Jaxb webservice java调用

    - 创建JAXBContext实例，它是整个JAXB绑定的核心。 - 定义Java类来映射XML元素，使用`@XmlRootElement`和`@XmlElement`等注解。 - 使用`Unmarshaller`对象将XML字符串解析为Java对象。 - 使用`Marshaller`对象将Java...

    JAXB 生成XML文件

    通常，这个示例可能会定义一些带有JAXB注解的Java类，然后创建`JAXBContext`实例，生成`Marshaller`，最后将Java对象序列化为XML文件。 在实际开发中，JAXB广泛应用于各种场景，如Web服务的响应和请求、配置文件的...

    JAXB 利用xsd文件生成java类

    - Gradle则可以使用`jaxb`插件或自定义Task来执行相同的操作。 6. **使用示例**： - 创建一个简单的XSD文件，例如： ```xml ``` - 运行`xjc`命令，如`xjc person.xsd`，生成Java类。 - ...

    java学习之jaxb的学习一

    通过JAXBContext实例，我们可以进行 marshalling 和 unmarshalling 操作。 3. Marshalling：通过JAXBContext的marshal方法将Java对象转换为XML。 4. Unmarshalling：通过JAXBContext的unmarshal方法将XML文档解析...

    jaxb文件包

    6. **Context**：JAXBContext是整个JAXB操作的核心，它负责管理和维护XML与Java之间的映射关系，并提供Unmarshaller和Marshaller的实例。 在JAXB-RI（Reference Implementation）中，包含了完整的JAXB实现和相关...

    JAXB的HelloWorld源码

    接下来，我们需要创建一个`JAXBContext`实例，它是JAXB的核心，负责管理所有相关的类和它们的XML表示。然后，我们可以使用`Marshaller`和`Unmarshaller`对象来序列化（将Java对象转换为XML）和反序列化（从XML恢复...

    JAXB使用及代码示例

    - 对于大型项目，可能需要考虑性能问题，因为JAXB涉及大量的反射操作。 总之，JAXB为Java开发者提供了一种强大而便捷的方式来处理XML数据，它简化了XML和Java对象之间的转换，提升了开发效率。在实际开发中，理解并...

    jaxb解析xml

    2. 操作 API：提供了统一的基本操作（如 marshalling,unmarshalling），隐藏了 JAXB 内部操作的实现代码。 JAXB 的基本操作 ------------------- ### 3.1 XML 和 Java 类绑定 JAXB 提供了两种方式将 Java 对象...

    java使用jaxb操作xml示例

    在这个示例中，我们将探讨如何使用JAXB来操作XML。 首先，我们需要创建Java类来表示我们的数据模型。在本例中，我们有两个类 `ClassA` 和 `ClassB`。`ClassA` 包含一个 `classAId`、一个 `classAName` 以及一个 `...

    jaxb xml 转map

    然后，JAXB会使用这些类来解析XML并生成相应的对象实例。对于简单的XML，这通常很有效。但是，对于复杂的XML结构，转换为Map可能更为合适。 转换XML到Map的过程通常包括以下步骤： 1. 创建一个XML解析器：使用`...

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