JAXB应用实例
程序员文章站
2022-03-07 16:41:19
过往的项目中数据存储都离不开数据库，不过最近做的一个项目的某些数据（比如人员信息、菜单、权限等等）却完全没有涉及任何数据库操作，直接XML搞定。这里无意比较优劣，因为数据库存储和XML存储本就有不同的适用场景，盲目比较毫无意义，只是因为业务需要，仅此而已。先来概念一下——XML，可扩展标记语言，设计 ......
过往的项目中数据存储都离不开数据库，不过最近做的一个项目的某些数据（比如人员信息、菜单、权限等等）却完全没有涉及任何数据库操作，直接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:
① 如果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 }
最后的时间就是按照格式化输出——
上述博文中描述的工具方法仅仅是出于学习中追根问本的目的写得稍微冗余了些，实际上，我所知道的是最迟从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 }
OK,对于JAXB的知识分享就差不多这么些了。对于这种比较单一技能点的学习，就是根据API多写点代码练习测试，从测试的结果对错中总结出自己的深层理解，并在实际项目学以致用，不变应万变，望看官读毕都有所收获！