Jaxb annotation使用

最新推荐文章于 2024-08-25 02:17:00 发布
最新推荐文章于 2024-08-25 02:17:00 发布
阅读量504 收藏
点赞数 2
分类专栏： WebService JAXB
一.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类继承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

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

　　以上是以一个简单的商店订单模型作为示例。

原文地址：http://www.cnblogs.com/fragranting/archive/2012/03/25/xml--jaxb.html

jungle依然
关注
专栏目录
JAXB 的注解
渴望飞的鱼的博客
09-17 1113
JAXB框架使得通过JAVA访问xml变得非常简单.JAXB（Java Architecture for XML Binding）是JSE和JEE平台的一部分，让开发者能够快速完成java类和XML的互相映射。常用的地方就是对象类和xml之间的映射，能够让bo自动生成节点，节点自动转成实体bo。 JAXB封装在jdk中，jdk1.7及以上都不需要引入多于的jar包就可以完成JAXB代码开发了。下...
jaxb 使用实例
08-14
4. **注解驱动的映射（Annotation-Based Mapping）**：JAXB允许使用Java注解来指定Java类与XML元素之间的对应关系，使得无需绑定文件就能完成映射。 ### JAXB使用步骤 1. **创建Java模型类**：定义要序列化的Java...
Jaxb annotation初步使用
weixin_33725239的博客
03-25 152
　一.Jaxb处理java对象和xml之间转换常用的annotation有： @XmlType @XmlElement @XmlRootElement @XmlAttribute @XmlAccessorType @XmlAccessorOrder @XmlTransient @XmlJavaTypeAdapter 　二.常用annotation使用说明 ...
JAXB注解
走在java的路途上
11-07 8882
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转换为J
jaxb.zip_jaxb
09-21
使用JAXB注解可以清晰地定义Java类和XML结构之间的关系，简化了代码并提高了可读性。在实际开发中，JAXB广泛应用于Web服务交互、数据持久化和配置文件解析等领域。了解并熟练掌握JAXB的基本使用，对于任何Java开发者...
jaxb解析xml
08-01
### 3.2 JAXB Annotation 使用说明 #### 3.2.1 @XmlType @XmlType 定义映射的一些规则，用在 class 类的注解，常与 @XmlRootElement，@XmlAccessorType 一起使用。 参数： * propOrder：指定映射 XML 时的节点...
JAXB注解命名空间使用到的jar包
09-24
5. **处理命名空间的jar包**：虽然JDK 1.6内置了基本的JAXB实现，但处理特定的命名空间或扩展功能可能需要额外的库，如`jaxb-api.jar`、`jaxb-impl.jar`和`javax.xml.bind.annotation.jar`等。这些jar包提供了完整的...
jaxb-api-2.1.jar 和 jaxb-impl-2.1.8.jar
05-02
在使用这两个库文件时，通常需要同时包含`jaxb-api.jar`和`jaxb-impl.jar`，因为API库提供了接口定义，而实现库提供了具体的实现。有时候，为了完整支持JAXB功能，可能还需要其他相关库，如`activation.jar`...
JAXB-XML注解
10-10
Jaxb annotation 使用 Jaxb annotation初步使用
Jaxb annotation
weixin_38169562的博客
07-21 57
Jaxb处理java对象和xml之间转换常用的annotation: 参考：http://blog.csdn.net/a9529lty/article/details/8232932 @XmlAccessorType @XmlType @XmlRootElement package com.cares.asis.sso.ws; import javax.xml.bind....
JAXB annotations
smile_juan
01-22 917
Here is an example I need to deal with, it looks complicated. With the help of JAXB, it's really easy to get all values from the xml file. For example: article.xml world World A co
CXF -- JAXB
Ferrerooo 成长
08-21 161
JAXB :  Java API for XML Binding   作用是 java对象 &lt;---&gt; xml文件   之间的转换   JAXB Annotation @XmlRootElement   // xml 文件的根元素 @XmlElement @XmlAccessorType  // 表明类内，什么样的成员 是 可以被xml 转化 传输的  可以是 FIEL...
JAXB相关Annotation
最新发布
weixin_42085677的博客
08-25 18
（1）@XmlRootElement，将Java类或枚举类型映射到XML元素；（2）@XmlElement，将Java类的一个属性映射到与属性同名的一个XML元素；（3）@XmlAttribute，将Java类的一个属性映射到与属性同名的一个XML属性；注意事项：（1）对于要序列化（marshal）为XML的Java类，...
JAXB常用注解讲解(超详细)
热门推荐
↓ ↓ ↓ ↓
06-30 6万+
JAXB（Java Architecture for XML Binding) 是一个业界的标准，是一项可以根据XML Schema产生Java类的技术。该过程中，JAXB也提供了将XML实例文档反向生成Java对象树的方法，并能将Java对象树的内容重新写到XML实例文档。从另一方面来讲，JAXB提供了快速而简便的方法将XML模式绑定到Java表示，从而使得Java开发者在Java应用程序中能方...
JAXB-2 JAXB Annotation 注解
怀旧豆酱味的专栏
02-02 1262
2 JAXB Annotation 注解2 JAXB Annotation 注解2.1 根节点注解 @XmlRootElement2.1.1 参数说明2.1.2 使用情景2.2 @XmlType2.2.1 参数说明2.2.2 使用情景2.3 @XmlAccessorType2.3.1 参数说明2.3.2 使用情景2.4 节点标注 @XmlElement2.4.1 参数说明2.4.2 使用场景2.5...
JAXB-XML注解详解与常用标签示例
"JAXB-XML注解是Java中用于对象到XML以及XML到对象转换的一种技术，通过使用特定的注解，可以方便地映射Java类和XML文档的结构。JAXB允许开发者使用注解来声明Java类与XML元素之间的对应关系，从而简化XML的处理。...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值