dom4j结合Xpath实现java对象和xml文件之间相互转化
1.目标
提供一个工具类，实现xml和java实体类相互转化
- 将xml文件的数据能够自动解析到对应的实体类中
- 根据java实体，自动生成相应的xml文件
2.实现
1.导入jar表
<dependency>
<groupId>org.projectlombokgroupId>
<artifactId>lombokartifactId>
<version>1.18.20version>
dependency>
<dependency>
<groupId>org.dom4jgroupId>
<artifactId>dom4jartifactId>
<version>2.1.3version>
dependency>
<dependency>
<groupId>jaxengroupId>
<artifactId>jaxenartifactId>
<version>1.1.6version>
dependency>
2.代码实现
- xml转化的样例
<root>
<head>
<description>1description>
<detail>
<date>2022-12-17date>
<version>2.0version>
detail>
head>
<body>
<person>
<id>1id>
<name>张三name>
<age>18age>
<height>18.8height>
<hobby>
<order>1order>
<dec>篮球dec>
hobby>
<hobby>
<order>2order>
<dec>足球dec>
hobby>
<hobby>
<order>3order>
<dec>乒乓球dec>
hobby>
<score>12.8score>
<score>13.2score>
person>
body>
root>
- 自定义转化的两个注解
package annotation;
import java.lang.annotation.*;
/**
* @description: 用在xml对应的实体类上，主要是用来指定根目录的
* @author:
* @date: 2022/12/16 20:50
*/
@Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
@Documented
public @interface XmlClassDescription {
String path() default "root"; // 指定xml文件的根目录
}
package annotation;
import java.lang.annotation.*;
/**
1. @description: 自定义一个注解，用于指定属性对应xml上面的标签,且在运行时有效
2. @author:
3. @date: 2022/12/16 19:45
*/
@Target(ElementType.FIELD)
@Retention(RetentionPolicy.RUNTIME)
@Documented
public @interface XmlFiledDescription {
String tagName(); // 指定xml对应的标签名
boolean subTag() default false; // 是否有子标签，false代表没有，true代表有
String format() default ""; // 指定数据的格式，时间类型的时候需要指定
boolean isList () default false; // 标记当前标签是否有多个
int order() default 0; // 在将java对象转化成xml文件时决定顺序，order越小在前面
}
- 编写对应的java实体类
/**
* @description:
* @author:
* @date: 2022/12/16 19:51
*/
@XmlClassDescription
@Data
@ToString
public class MyDocument {
@XmlFiledDescription(tagName ="head",subTag = true, order = 2)
private Header header;
@XmlFiledDescription(tagName ="body",subTag = true, order = 4)
private Body body;
}
/**
* @description:
* @author:
* @date: 2022/12/16 19:37
*/
//@XmlClassDescription(path = "head")
@Data
@ToString
public class Header {
@XmlFiledDescription(tagName ="description")
private String description;
@XmlFiledDescription(tagName ="detail",subTag = true)
private Detail detail;
}
/**
* @description:
* @author:
* @date: 2022/12/16 19:39
*/
@Data
@ToString
public class Detail {
@XmlFiledDescription(tagName ="date", format = "yyyy-MM-dd")
private Date date;
@XmlFiledDescription(tagName ="version")
private String version;
}
/**
* @description:
* @author:
* @date: 2022/12/16 19:52
*/
@Data
@ToString
public class Body {
@XmlFiledDescription(tagName = "person",subTag = true)
private Person person;
}
/**
* @description:
* @author:
* @date: 2022/12/16 19:40
*/
@Data
@ToString
public class Person {
@XmlFiledDescription(tagName ="name", order = 2)
private String name;
@XmlFiledDescription(tagName ="id", order = 1)
private int id;
@XmlFiledDescription(tagName ="age", order = 3)
private int age;
@XmlFiledDescription(tagName ="height", order = 4)
private double height;
@XmlFiledDescription(tagName ="hobby",subTag = true, isList = true, order = 6)
private List<Hobby> hobbies;
@XmlFiledDescription(tagName ="score", isList = true, order = 5)
private List<Double> scores;
}
/**
1. @description:
2. @author:
3. @date: 2022/12/16 19:41
*/
@Data
@ToString
public class Hobby {
@XmlFiledDescription(tagName = "order")
private String order;
@XmlFiledDescription(tagName = "dec")
private String description;
}
- 工具类实现具体步骤
/**
5. @description: 提供一个xml和java实体类相互转化的工具类
6. @author:
7. @date: 2022/12/16 19:57
*/
public class XmlUtils {
public static final String ROOT_PATH = "//";
public static final String SUB_PATH = "./";
/**
* 该方法主要是将xml文件解析的字符串值转化成相关类型数据（感觉写的不好，暂时这样先实现）
*
* @param value tag标签里面解析的值
* @param tClass 标签对应实体的Class
* @param format 转化格式
* @return 返回对应的数据类型
*/
private static Object transferData(String value, Class tClass, String format) {
String name = tClass.getSimpleName();
try {
switch (name) {
case "Integer":
case "int":
return Integer.valueOf(value);
case "Double":
case "double":
return Double.valueOf(value);
case "Float":
case "float":
return Float.valueOf(value);
case "Byte":
case "byte":
return Byte.valueOf(value);
case "Short":
case "short":
return Short.valueOf(value);
case "Long":
case "long":
return Long.valueOf(value);
case "Character":
case "char":
return value.charAt(0);
case "Boolean":
case "boolean":
return Boolean.valueOf(value);
case "Date":
SimpleDateFormat simpleDateFormat = new SimpleDateFormat(format);
Date parse = simpleDateFormat.parse(value);
return parse;
default:
return value;
}
} catch (Exception e) {
throw new DataFormatException(value + "数据转化异常,请核对");
}
}
/**
* 该方法提供主要是为了处理java转xml文件时日期类型的处理(需要后面再补充)
*
* @param value 需要转化的值
* @param format 转化的格式
* @return 返回转化的字符串数据
*/
private static String transferString(Object value, String format) {
if (format.length() == 0) {
return String.valueOf(value);
}
SimpleDateFormat simpleDateFormat = new SimpleDateFormat(format);
String transData = simpleDateFormat.format(value);
return transData;
}
/**
* 详细的转化过程，采用递归方式去进行
*
* @param parentNode 父标签节点
* @param clazz 父标签对应当前实体的Class
* @param t 父标签对应的实体（未赋值）
* @param 泛型
* @return 返回构建的实体对象（赋值）
*/
private static <T> T handle(Node parentNode, Class<T> clazz, T t){
// 获取当前对象的所有属性
Field[] fields = clazz.getDeclaredFields();
Arrays.stream(fields).forEach(field -> {
field.setAccessible(true);
// 获取属性的XmlFiledDescription注解
XmlFiledDescription xmlFiled = field.getDeclaredAnnotation(XmlFiledDescription.class);
// 获取当前属性对应xml的标签名
String tagName = xmlFiled.tagName();
// 获取数据格式
String format = xmlFiled.format();
// 获取是否是一个集合
boolean isList = xmlFiled.isList();
// 判断当前属性是否有子标签
boolean isSubTag = xmlFiled.subTag();
Object value = null;
if (isList) {
try {
ParameterizedType parameterizedType = (ParameterizedType) field.getGenericType();
Class actualTypeArgument = (Class) parameterizedType.getActualTypeArguments()[0];
List<Node> nodes = parentNode.selectNodes(SUB_PATH + tagName);
if (isSubTag) {
Object instance = actualTypeArgument.newInstance();
value = nodes.stream()
.map(node -> handle(node, actualTypeArgument, instance))
.collect(Collectors.toList());
} else {
value = nodes.stream()
.map(node -> transferData(node.getText(), actualTypeArgument, format))
.collect(Collectors.toList());
}
field.set(t, value);
} catch (InstantiationException e) {
throw new DataFormatException(clazz + "获取实例失败，请提供无参构造");
} catch (IllegalAccessException e) {
throw new DataFormatException(clazz + "获取实例失败，访问权限不足");
}
} else {
try {
// 获取当前标签
Node currentNode = parentNode.selectSingleNode(SUB_PATH + tagName);
if (isSubTag) {
Class aClass = field.getType();
Object instance = aClass.newInstance();
value = handle(currentNode, aClass, instance);
} else {
value = transferData(currentNode.getText(), field.getType(), format);
}
field.set(t, value);
} catch (InstantiationException e) {
throw new DataFormatException(clazz + "获取实例失败，请提供无参构造");
} catch (IllegalAccessException e) {
throw new DataFormatException(clazz + "获取实例失败，访问权限不足");
}
}
});
return t;
}
/**
* 详细的构建过程，采用递归的方式来构建
*
* @param instance 工厂示例，用于创建元素
* @param parentElement 父标签元素
* @param object 父标签对应java实体对象
*/
private static void build(DocumentFactory instance, Element parentElement, Object object) {
Class aClass = object.getClass();
Field[] fields = aClass.getDeclaredFields();
Arrays.stream(fields).sorted((field1, field2) -> {
// 将属性按XmlFiledDescription的order进行排序
field1.setAccessible(true);
field2.setAccessible(true);
XmlFiledDescription xmlFiled1 = field1.getDeclaredAnnotation(XmlFiledDescription.class);
XmlFiledDescription xmlFiled2 = field2.getDeclaredAnnotation(XmlFiledDescription.class);
return xmlFiled1.order() - xmlFiled2.order();
}).forEach(field -> {
field.setAccessible(true);
XmlFiledDescription xmlFiled = field.getDeclaredAnnotation(XmlFiledDescription.class);
// 获取标签名
String tagName = xmlFiled.tagName();
// 获取转化类型(针对时间类型处理)
String format = xmlFiled.format();
// 判断是否有子标签
boolean isSubTag = xmlFiled.subTag();
// 判断是否是一个集合
boolean isList = xmlFiled.isList();
Object currentObject = null;
try {
currentObject = field.get(object);
} catch (IllegalAccessException e) {
e.printStackTrace();
}
if (isList) {
List<Object> currentList = (List<Object>) currentObject;
if (isSubTag) {
currentList.stream().forEach(item -> {
Element currentElement = instance.createElement(tagName);
parentElement.add(currentElement);
build(instance, currentElement, item);
});
} else {
currentList.stream().forEach(item -> {
Element currentElement = instance.createElement(tagName);
String value = transferString(item, format);
currentElement.setText(value);
parentElement.add(currentElement);
});
}
} else {
if (isSubTag) {
Element currentElement = instance.createElement(tagName);
parentElement.add(currentElement);
build(instance, currentElement, currentObject);
} else {
Element currentElement = instance.createElement(tagName);
String value = transferString(currentObject, format);
currentElement.setText(value);
parentElement.add(currentElement);
}
}
});
}
/**
* 将xml文件转化成对应的实体类
*
* @param filePath xml文件路径
* @param clazz 对应实体的Class
* @param 泛型
* @return 返回赋值的java实体
*/
public static <T> T xml2Object(String filePath, Class<T> clazz) {
SAXReader saxReader = new SAXReader();
try {
// 获取xml的document
Document document = saxReader.read(Dom4jXPath.class.getResource(filePath));
// 获取当前类的注解
XmlClassDescription declaredAnnotation = clazz.getDeclaredAnnotation(XmlClassDescription.class);
// 获取xml的根标签名称（从对应的实体类上自定义注解找）
Optional.ofNullable(declaredAnnotation)
.orElseThrow(() -> new DataFormatException("获取xml文件的根根标签名失败"));
String path = declaredAnnotation.path();
Node rootNode = document.selectSingleNode(ROOT_PATH + path);
return handle(rootNode, clazz, clazz.newInstance());
} catch (InstantiationException e) {
throw new DataFormatException(clazz + "获取实例失败，请提供无参构造");
} catch (IllegalAccessException e) {
throw new DataFormatException(clazz + "获取实例失败，访问权限不足");
} catch (DocumentException e) {
throw new DataFormatException(filePath + "获取文件失败，请核对");
}
}
/**
* 该方法是将java的实体对象转化成xml文件
*
* @param filePath 文件名
* @param object 实体对象
* @param 泛型
*/
public static <T> void object2Xml(String filePath, T object) {
XMLWriter xmlWriter = null;
try {
DocumentFactory instance = DocumentFactory.getInstance();
Document document = instance.createDocument();
Class aClass = object.getClass();
// 设置根标签
XmlClassDescription xmlClass =
(XmlClassDescription) aClass.getDeclaredAnnotation(XmlClassDescription.class);
String rootPath = xmlClass.path();
Element rootElement = instance.createElement(rootPath);
document.setRootElement(rootElement);
// 递归创建整个xml文档
build(instance, rootElement, object);
// 将生成的document写入到指定的文件中去
OutputFormat format = OutputFormat.createPrettyPrint();
format.setEncoding("UTF-8");
xmlWriter = new XMLWriter(new FileWriter(SUB_PATH + filePath), format);
xmlWriter.write(document);
} catch (IOException e) {
e.printStackTrace();
} finally {
try {
xmlWriter.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
}
- 测试数据
public static void main(String[] args) throws IOException {
MyDocument myDocument = XmlUtils.xml2Object("/test.xml", MyDocument.class);
System.out.println(myDocument);
// test2();
}
public static void test2() throws IOException {
MyDocument myDocument = new MyDocument();
Detail detail = new Detail();
detail.setDate(new Date());
detail.setVersion("3.0");
Header header = new Header();
header.setDescription("cs");
header.setDetail(detail);
Person person = new Person();
person.setId(1);
person.setAge(18);
person.setHeight(78.23);
person.setName("zhangsan");
ArrayList<Double> list = new ArrayList<>();
list.add(12.3);
list.add(13.7);
ArrayList<Hobby> list1 = new ArrayList<>();
Hobby hobby = new Hobby();
hobby.setDescription("ca1");
hobby.setOrder("222");
Hobby hobby1 = new Hobby();
hobby1.setDescription("ca2");
hobby1.setOrder("333");
list1.add(hobby);
list1.add(hobby1);
person.setHobbies(list1);
person.setScores(list);
Body body = new Body();
body.setPerson(person);
myDocument.setBody(body);
myDocument.setHeader(header);
XmlUtils.object2Xml("call.xml",myDocument);
}
- 生成的call.xml结果如下:
<root>
<head>
<description>csdescription>
<detail>
<date>2022-12-18date>
<version>3.0version>
detail>
head>
<body>
<person>
<id>1id>
<name>zhangsanname>
<age>18age>
<height>78.23height>
<score>12.3score>
<score>13.7score>
<hobby>
<order>222order>
<dec>ca1dec>
hobby>
<hobby>
<order>333order>
<dec>ca2dec>
hobby>
person>
body>
root>