JAXB应用实例

2018-06-18 03:45:30来源：未知阅读 ()

　　过往的项目中数据存储都离不开数据库，不过最近做的一个项目的某些数据（比如人员信息、菜单、权限等等）却完全没有涉及任何数据库操作，直接XML搞定。这里无意比较优劣，因为数据库存储和XML存储本就有不同的适用场景，盲目比较毫无意义，只是因为业务需要，仅此而已。先来概念一下——XML，可扩展标记语言，设计宗旨是用来传输数据而非显示数据，其遵循W3C标准，是一种通用的数据交换格式,具有很强的跨平台性，并且数据无需转换，所以，如果你要将数据做跨平台传输，那么把数据保存在 XML 文件中是有好处的。当然，这里要说明，由于XML仅仅是作为一种文档模式的结构化存储，所以并不适用于大数据量的存储。现在的Java中有很多类库比如DOM、SAX、JDOM和DOM4J等等都可以操作XML，但如果仅仅是想做JavaBean和XML节点元素的互相转换，而不涉及动态XML的处理，那么JAXB绝对是一个不错的选择。在比较新的jdk版本中，JAXB都是jdk的扩展包javax中自带的类库，不需要你引入第三方jar包。下面，博主正式给看客上菜，详细介绍一下JAXB的实际用法——

一 JavaBean和XML相互转换初体验

  1 package model;
  2 
  3 import javax.xml.bind.annotation.*;
  4 import java.io.Serializable;
  5 
  6 //JavaBean代码
  7 
  8 @XmlType(propOrder = {})
  9 @XmlRootElement(name = "user")
 10 @XmlAccessorType(XmlAccessType.PROPERTY)
 11 @XmlAccessorOrder(XmlAccessOrder.ALPHABETICAL)
 12 public class User implements Serializable {
 13 
 14     private String userName;
 15     private int age;
 16     private String role;
 17     private String bibi;
 18 
 19     public User() {
 20     }
 21 
 22     public User(String userName, int age, String role, String bibi) {
 23         this.userName = userName;
 24         this.age = age;
 25         this.role = role;
 26         this.bibi = bibi;
 27     }
 28 
 29     public String getUserName() {
 30         return userName;
 31     }
 32 
 33     public void setUserName(String userName) {
 34         this.userName = userName;
 35     }
 36 
 37     @XmlAttribute
 38     public int getAge() {
 39         return age;
 40     }
 41 
 42     public void setAge(int age) {
 43         this.age = age;
 44     }
 45 
 46     @XmlElement
 47     public String getRole() {
 48         return role;
 49     }
 50 
 51     public void setRole(String role) {
 52         this.role = role;
 53     }
 54 
 55     @XmlTransient
 56     public String getBibi() {
 57         return bibi;
 58     }
 59 
 60     public void setBibi(String bibi) {
 61         this.bibi = bibi;
 62     }
 63 
 64     @Override
 65     public String toString() {
 66         return "User{" +
 67                 "userName='" + userName + '\'' +
 68                 ", age=" + age +
 69                 ", role='" + role + '\'' +
 70                 ", bibi='" + bibi + '\'' +
 71                 '}';
 72     }
 73 }
 74 
 75 //测试
 76 public class test {
 77     @Test
 78     public void saveXmlTest() {
 79         User user = new User("陈本布衣", 2018, "超级管理员","瞎哔哔");
 80         File file = new File("E://user.xml");
 81         try {
 82             JAXBContext jaxbContext = JAXBContext.newInstance(User.class);
 83             Marshaller marshaller = jaxbContext.createMarshaller();
 84             //格式化输出，即按标签自动换行，否则就是一行输出
 85             marshaller.setProperty(Marshaller.JAXB_FORMATTED_OUTPUT, true);
 86             //设置编码（默认编码就是utf-8）
 87             marshaller.setProperty(Marshaller.JAXB_ENCODING, "UTF-8");
 88             //是否省略xml头信息，默认不省略（false）
 89             marshaller.setProperty(Marshaller.JAXB_FRAGMENT, false);
 90             marshaller.marshal(user, file);
 91         } catch (JAXBException e) {
 92             e.printStackTrace();
 93         }
 94     }
 95 
 96     @Test
 97     public void getUserTest() {
 98         File file = new File("E://user.xml");
 99         try {
100             JAXBContext jaxbContext = JAXBContext.newInstance(User.class);
101             Unmarshaller unmarshaller = jaxbContext.createUnmarshaller();
102             User user = (User) unmarshaller.unmarshal(file);
103             System.out.println(user.toString());
104         } catch (JAXBException e) {
105             e.printStackTrace();
106         }
107     }
108 }

View Code

生成的XML:

二 JAXB使用基础介绍

　　① 常用API

JAXBContext类，是应用的入口，通过该类创建序列化和反序列化对象，也即编组对象和解组对象；
Marshaller 编组接口，将Java对象序列化为XML数据；
Unmarshaller 解组接口，将XML数据反序列化为Java对象。

　　② 常用注解

@XmlRootElement，将Java类或枚举映射成XML元素根节点，是唯一一个必须注解，name属性指定根节点名称，不指定默认为类名的小写；
@XmlElement，将Java类的一个属性映射为XML节点元素，name属性可自定义元素名；
@XmlAttribute，将Java类的一个属性映射为XML节点元素的属性，name属性可自定义属性名；
@XmlType，将Java类或枚举类型映射到XML模式类型，常与@XmlRootElement、@XmlAccessorType共用，propOrder属性定义字段生成的XML节点顺序；
@XmlAccessorType，控制字段或属性的序列化。属性XmlAccessType有4个常量值:FIELD表示JAXB将自动绑定Java类中的每个非静态的（static）、非瞬态的（由@XmlTransient标注）字段到XML；PROPERTY表示java对象中所有通过getter/setter方式绑定成属性到XML；PUBLIC_MEMBER表示Java对象中所有的public访问权限的成员变量和通过getter/setter方式访问的成员变量，该值为默认值；NONE表示Java对象的所有属性都不映射为XML的元素；
@XmlAccessorOrder，控制JAXB 绑定类中属性和字段的排序，有两个属性，AccessorOrder.ALPHABETICAL——对生成的XML元素按字母书序排序，XmlAccessOrder.UNDEFINED——不排序，默认为该值；
@XmlJavaTypeAdapter，自定义适配器（即扩展抽象类XmlAdapter并覆盖marshal()和unmarshal()方法），解决日期（Date）,数字（Number）格式化问题；
@XmlElementWrapper ，对于数组或集合（即包含多个元素的成员变量），生成一个包装该数组或集合的XML元素（称为包装器），该注解只能用在集合上；
@XmlTransient ，用于标示在由Java对象映射XML时，忽略此属性，在生成的XML文件中将不出现此元素。

　　③ 实际应用中注意的问题

　　① 如果JavaBean中定义了有参的构造器，那么必须同时定义无参构造器，否则转XML会抛无默认构造函数的异常;

　　② 成员变量值为NULL时，将不会映射成对应的XML元素——由于基本数据类型默认值不为空，所以基本数据类型不设值也会映射成XML元素，值为默认值,所以如果模型需要基本数据，在属性定义的时候尽量使用包装类型；

　　③ @XmlAccessorType 注解中如果属性值为XmlAccessType.FIELD，则表示通过成员变量来映射，set/get方法上的映射注解就是多余的，所以如果此时set/get方法上再标注元素或者属性映射注解，将抛属性重复性异常；属性值为XmlAccessType.NONE不映射为XML元素的前提是Java字段或set/get方法上都没有映射注解；

　　④ @XmlType propOrder属性能够自定义字段的排序，该属性如果设置，要么写成{}的形式，否则在就必须将所有@XmlElement标注或者没有@XmlElement标注的但实际上会被映射为XML节点的字段添加到排序列表，不然会抛异常；如果propOrder属性设置有值，@XmlAccessorOrder注解的元素排序规则将失效；

三应用实际

　　先准备好测试用的工具方法：

 1 package util;
 2 
 3 
 4 import model.User;
 5 
 6 import javax.xml.bind.JAXBContext;
 7 import javax.xml.bind.JAXBException;
 8 import javax.xml.bind.Marshaller;
 9 import javax.xml.bind.Unmarshaller;
10 import java.io.File;
11 
12 public class JaxbUtil {
13 
14     public static void convertToXml(Object obj, File file) {
15         try {
16             JAXBContext jaxbContext = JAXBContext.newInstance(User.class);
17             Marshaller marshaller = jaxbContext.createMarshaller();
18             //格式化输出，即按标签自动换行，否则就是一行输出
19             marshaller.setProperty(Marshaller.JAXB_FORMATTED_OUTPUT, true);
20             //设置编码（默认编码就是utf-8）
21             marshaller.setProperty(Marshaller.JAXB_ENCODING, "UTF-8");
22             //是否省略xml头信息，默认不省略（false）
23             marshaller.setProperty(Marshaller.JAXB_FRAGMENT, false);
24             marshaller.marshal(obj, file);
25             //控制台输出
26             marshaller.marshal(obj,System.out);
27         } catch (JAXBException e) {
28             e.printStackTrace();
29         }
30     }
31 
32     public static <T> T convertToJavaBean(Class<T> clz, File file) {
33         try {
34             JAXBContext jaxbContext = JAXBContext.newInstance(clz);
35             Unmarshaller unmarshaller = jaxbContext.createUnmarshaller();
36             T t = (T) unmarshaller.unmarshal(file);
37             return t;
38         } catch (JAXBException e) {
39             e.printStackTrace();
40         }
41         return null;
42     }
43 }

　　① 简单对象处理

　　简单对象处理起来比较简单，譬如人员对象User中包含菜单Menu,只需将定义的普通Menu对象也按照JAXB的注解进行标注，在User对象中当成普通字段一样的定义即可——

@XmlType(propOrder = {"userName","role","menu"})
@XmlRootElement(name = "user")
@XmlAccessorOrder(XmlAccessOrder.ALPHABETICAL)
public class User implements Serializable {

    private String userName;
    private int age;
    private String role;
    private String bibi;
    private Menu menu;
    public User() {
    }

    public User(String userName, int age, String role, String bibi) {
        this.userName = userName;
        this.role = role;
        this.age = age;
        this.bibi = bibi;
    }

    public String getUserName() {
        return userName;
    }

    public void setUserName(String userName) {
        this.userName = userName;
    }

    @XmlAttribute
    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    @XmlElement(nillable=true)
    public String getRole() {
        return role;
    }

    public void setRole(String role) {
        this.role = role;
    }

    @XmlTransient
    public String getBibi() {
        return bibi;
    }

    public void setBibi(String bibi) {
        this.bibi = bibi;
    }

    @XmlElement
    public Menu getMenu() {
        return menu;
    }

    public void setMenu(Menu menu) {
        this.menu = menu;
    }

    @Override
    public String toString() {
        return "User{" +
                "userName='" + userName + '\'' +
                ", age=" + age +
                ", role='" + role + '\'' +
                ", menu=" + menu +
                '}';
    }
}


//菜单对象

@XmlRootElement
@XmlAccessorType(XmlAccessType.FIELD)
public class Menu {
    private String name;
    private String id;

    public Menu() {
    }

    public Menu(String name, String id) {
        this.name = name;
        this.id = id;
    }

    @Override
    public String toString() {
        return "Menu{" +
                "name='" + name + '\'' +
                ", id='" + id + '\'' +
                '}';
    }
}

View Code

　　② 集合处理

　　实际应用场景中集合应用要更常见一些，比如上面的用户菜单，一个用户肯定会有多个不同的菜单，所以，我们来将上面的菜单改用集合处理——

 1 package model;
 2 
 3 import javax.xml.bind.annotation.*;
 4 import java.io.Serializable;
 5 import java.util.Date;
 6 import java.util.List;
 7 
 8 @XmlType(propOrder = {"userName", "role", "menus"})
 9 @XmlRootElement(name = "user")
10 @XmlAccessorOrder(XmlAccessOrder.ALPHABETICAL)
11 public class User implements Serializable {
12 
13     private String userName;
14     private int age;
15     private String role;
16     private String bibi;
17     private List<Menu> menus;
18 
19     public User() {
20     }
21 
22     public User(String userName, int age, String role, String bibi) {
23         this.userName = userName;
24         this.role = role;
25         this.age = age;
26         this.bibi = bibi;
27     }
28 
29     public String getUserName() {
30         return userName;
31     }
32 
33     public void setUserName(String userName) {
34         this.userName = userName;
35     }
36 
37     @XmlAttribute
38     public int getAge() {
39         return age;
40     }
41 
42     public void setAge(int age) {
43         this.age = age;
44     }
45 
46     @XmlElement
47     public String getRole() {
48         return role;
49     }
50 
51     public void setRole(String role) {
52         this.role = role;
53     }
54 
55     @XmlTransient
56     public String getBibi() {
57         return bibi;
58     }
59 
60     public void setBibi(String bibi) {
61         this.bibi = bibi;
62     }
63 
64     @XmlElement
65     public List<Menu> getMenus() {
66         return menus;
67     }
68 
69     public void setMenus(List<Menu> menus) {
70         this.menus = menus;
71     }
72 
73     @Override
74     public String toString() {
75         return "User{" +
76                 "userName='" + userName + '\'' +
77                 ", age=" + age +
78                 ", role='" + role + '\'' +
79                 ", menus=" + menus +
80                 '}';
81     }
82 }

View Code

 1 package model;
 2 
 3 import javax.xml.bind.annotation.XmlAttribute;
 4 import javax.xml.bind.annotation.XmlRootElement;
 5 import java.util.List;
 6 
 7 @XmlRootElement
 8 public class Menu {
 9     private String name;
10     private String id;
11     private List<Menu> child;
12 
13     public Menu() {
14     }
15 
16     public Menu(String name, String id) {
17         this.name = name;
18         this.id = id;
19     }
20     @XmlAttribute
21     public String getName() {
22         return name;
23     }
24 
25     public void setName(String name) {
26         this.name = name;
27     }
28     @XmlAttribute
29     public String getId() {
30         return id;
31     }
32 
33     public void setId(String id) {
34         this.id = id;
35     }
36 
37     public List<Menu> getChild() {
38         return child;
39     }
40 
41     public void setChild(List<Menu> child) {
42         this.child = child;
43     }
44 
45     @Override
46     public String toString() {
47         return "Menu{" +
48                 "name='" + name + '\'' +
49                 ", id='" + id + '\'' +
50                 '}';
51     }
52 }

View Code

 1 package test;
 2 
 3 
 4 import model.Menu;
 5 import model.User;
 6 import org.junit.Test;
 7 import util.JaxbUtil;
 8 import java.io.File;
 9 import java.util.ArrayList;
10 import java.util.List;
11 
12 public class test {
13     @Test
14     public void saveXmlTest() {
15         User user = new User("陈本布衣", 2018, "超级管理员","瞎哔哔");
16         List<Menu> list1 = new ArrayList<>();
17         Menu menu1 = new Menu("系统管理","9527");
18         Menu child1 = new Menu("权限管理","9999");
19         Menu child2 = new Menu("用户管理","2322");
20         list1.add(child1);
21         list1.add(child2);
22         menu1.setChild(list1);
23         List<Menu> list2 = new ArrayList<>();
24         Menu menu2 = new Menu("参数配置","2222");
25         Menu child3 = new Menu("权限管理","3333");
26         Menu child4 = new Menu("用户管理","4444");
27         list2.add(child3);
28         list2.add(child4);
29         menu2.setChild(list2);
30         List<Menu> menus = new ArrayList<>();
31         menus.add(menu1);
32         menus.add(menu2);
33         user.setMenus(menus);
34         File file = new File("E://user.xml");
35         JaxbUtil.convertToXml(user,file);
36     }
37 
38     @Test
39     public void getUserTest() {
40         File file = new File("E://user.xml");
41         User user = JaxbUtil.convertToJavaBean(User.class, file);
42         System.out.println(user);
43     }
44 }

View Code

　　上面的菜单中似乎少了点层次关系，这个时候可以使用集合包装器注解@XmlElementWrapper自定义一个包装节点，这样产生的XML文档才更有层次：

1     @XmlElementWrapper(name = "menu")
2     @XmlElement
3     public List<Menu> getMenus() {
4         return menus;
5     }

　　最终产生的XML文档就是这样的：

　　③ 格式化处理

　　业务数据中日期、数值通常是必不可少的，在数据存储的时候，这些数据通常都需要做格式化处理，比如将日期格式化，货币型数值处理等等。JAXB中格式化处理需要继承适配器抽象类XmlAdapter，并覆写其序列化和反序列化的方法，这里仅用常用的日期格式化为例：

 1 package adapter;
 2 
 3 import javax.xml.bind.annotation.adapters.XmlAdapter;
 4 import java.text.DateFormat;
 5 import java.text.SimpleDateFormat;
 6 import java.util.Date;
 7 
 8 public class DateAdapter extends XmlAdapter<String, Date> {
 9     private static final DateFormat SDF = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
10 
11     @Override
12     public Date unmarshal(String date) throws Exception {
13         return SDF.parse(date);
14     }
15 
16     @Override
17     public String marshal(Date date) throws Exception {
18         return SDF.format(date);
19     }
20 }

　　将该适配器通过注解应用到User类表时间的date字段上：

1     @XmlJavaTypeAdapter(DateAdapter.class)
2     public Date getDate() {
3         return date;
4     }
5 
6     public void setDate(Date date) {
7         this.date = date;
8     }

　　最后的时间就是按照格式化输出——

　　④ 数据的修改

　　由于XML是文档数据类型，对于文档数据的修改操作，通常采用的都是先将文本内容全部读取到内存，修改完成后再写回去文本的方式——虽然Java中有RandomAccessFile类可以实现对文本任意位置的访问修改，但博主以为，在JAXB这种对象模型映射成XML的业务中并不适用。我们将上面的模型稍微简化一下，完成根据用户id修改用户数据的测试——

@XmlType(propOrder = {"users", "userName", "role", "remark"})
@XmlRootElement(name = "user")
@XmlAccessorOrder(XmlAccessOrder.ALPHABETICAL)
public class User implements Serializable {

    private String userName;
    private Integer id;
    private String role;
    private String remark;
    private List<User> users;

    public User() {
    }

    public User(String userName, Integer id, String role, String remark) {
        this.userName = userName;
        this.id = id;
        this.role = role;
        this.remark = remark;
    }

    public String getUserName() {
        return userName;
    }

    public void setUserName(String userName) {
        this.userName = userName;
    }

    @XmlAttribute
    public Integer getId() {
        return id;
    }

    public void setId(Integer id) {
        this.id = id;
    }

    @XmlElement
    public String getRole() {
        return role;
    }

    public void setRole(String role) {
        this.role = role;
    }

    public String getRemark() {
        return remark;
    }

    public void setRemark(String remark) {
        this.remark = remark;
    }

    public List<User> getUsers() {
        return users;
    }

    public void setUsers(List<User> users) {
        this.users = users;
    }
}

//测试代码
public class test {

    @Test
    public void editUser() {
        User root  = new User();
        File file = new File("E://user.xml");
        //模拟修改后的一条数据
        User editUser = new User("陈本布衣", 2018, "超级管理员","数据修改后");
        User user = JaxbUtil.convertToJavaBean(User.class, file);
        List<User> users = user.getUsers();
        for (int i = 0; i < users.size(); i++) {
            if(users.get(i).getId().equals(editUser.getId())){
                users.set(i,editUser);
            }
        }
        root.setUsers(users);
        JaxbUtil.convertToXml(root,file);
    }
}

View Code

　　最后，在XML文档中你可以看到文档内容已经被修改了——

四问题补充

　　上述博文中描述的工具方法仅仅是出于学习中追根问本的目的写得稍微冗余了些，实际上，我所知道的是最迟从jdk1.7开始，JAXB就对解组和编组的方法进行了更简单的封装，所以，实际项目中除非自己要进行个性化设置，否则大可不用自己再创建JAXBContext实例，直接通过JAXB静态调用相应的工具方法就行了，有兴趣的看官稍微跟踪一下源码就能了然，于是上面的工具方法可以写得更简单——

 1 package util;
 2 
 3 
 4 import javax.xml.bind.JAXB;
 5 import java.io.File;
 6 
 7 public class JaxbUtil {
 8 
 9     public static void convertToXml(Object obj, File file) {
10         JAXB.marshal(obj,file);
11     }
12 
13     public static <T> T convertToJavaBean(Class<T> clz, File file) {
14         return JAXB.unmarshal(file, clz);
15     }
16 }