在使用到XML的项目中，有时候会把子对象数组打平为单层XML，每一个对象都用一个序号表示。 但是这种XML结构在转换为对象的时候是不方便的，没办法去定义一个类似
property_$n的属性。本文利用Jackson和自定义注解可以实现单层XML到对象数组的转换
需求说明
- 假如需要把下面的XML转换为对象（后面定义的
Major）
<xml>
<name>计算机科学</name>
<year>4</year>
<name_0>离散数学</name_0>
<content_0>有点难</content_0>
<hours_0>64</hours_0>
<name_1>操作系统</name_1>
<content_1>计算机真奇妙</content_1>
<hours_1>48</hours_1>
</xml>
上面的XML中，有两个子结构(name, content, hours)，因为是单层结构所以都以序号结尾。 这种格式的XML，没办法定义一个完整的对象，再使用Jackson来直接转换。
- 目标对象
Major对象有一个Subject数组
/**
* 课程.
* @author tenmao
* @since 2019/12/9
*/
@Data
public class Subject {
private String name;
private String content;
private Integer hours;
}
/**
* 专业.
* @author tenmao
* @since 2019/12/9
*/
@Data
public class Major {
private String name;
private Integer years;
@SingleDeckXml
private List<Subject> subjectList;
}
//专业有多门课程
- 希望转换后的对象如下（单层的XML结构转换为对象数组了）
Major(name=计算机科学, years=4, subjectList=[Subject(name=离散数学, content=有点难, hours=64), Subject(name=操作系统, content=计算机真奇妙, hours=48)])
转换工具
- 注解
SingleDeckXml
@Target({ElementType.FIELD})
@Retention(RetentionPolicy.RUNTIME)
//Jackson内置注解，表明这里还有Jackson其他注解，需要被支持
@JacksonAnnotationsInside
//为了防止冲突，使用SingleDeckXml的注解的属性就不会被Jackson转换
@JsonIgnore
public @interface SingleDeckXml {
}
- 转换实现
XmlUtil
public class XmlUtil {
/**
* Jackson转换XML到对象时，支持把单级结构转换为子数据List.
*
* @param singleDeckXml 单层XML
* @param resultClass 对象
* @param xmlMapper 转换使用的Mapper
* @param <T> 对象类型
* @return 转换后的对象
*/
public static <T> T readSingleDeck(String singleDeckXml, Class<T> resultClass, XmlMapper xmlMapper) {
try {
final T refundResult = xmlMapper.readValue(singleDeckXml, resultClass);
//获取被压缩的对象
Set<Field> compressedField = new HashSet<>();
for (Field declaredField : resultClass.getDeclaredFields()) {
SingleDeckXml annotation = declaredField.getAnnotation(SingleDeckXml.class);
if (annotation == null) {
continue;
}
//暂时只支持List
if (declaredField.getType() != List.class) {
throw new RuntimeException(SingleDeckXml.class.toString() + " can only use on List.class");
}
compressedField.add(declaredField);
}
//获取所有属性值
TreeMap<String, String> allPropertyValueMap = xmlMapper.readValue(singleDeckXml, new TypeReference<TreeMap<String, String>>() {
});
//逐个处理被压缩的对象
for (Field field : compressedField) {
List<Object> compressedObjects = new ArrayList<>();
for (int i = 0; i < Integer.MAX_VALUE; i++) {
//构造被压缩的对象
boolean hasValue = false;
//关键：获取List的实际类型
Class<?> klass = (Class<?>) ((ParameterizedType) field.getGenericType()).getActualTypeArguments()[0];
final Object compressedObj = klass.newInstance();
//设置对象的属性值
for (Field declaredField : compressedObj.getClass().getDeclaredFields()) {
String propertyName = xmlMapper.getSerializationConfig().getPropertyNamingStrategy().nameForField(null, null, declaredField.getName()) + "_" + i;
String value = allPropertyValueMap.get(propertyName);
if (value == null) {
break;
} else {
declaredField.setAccessible(true);
declaredField.set(compressedObj, toObject(declaredField.getType(), value));
hasValue = true;
}
}
//没有匹配到值（说明已经没有更多的被压缩对象了）
if (!hasValue) {
break;
} else {
compressedObjects.add(compressedObj);
}
}
//返回被压缩对象
field.setAccessible(true);
field.set(refundResult, compressedObjects);
}
return refundResult;
} catch (JsonProcessingException | IllegalAccessException | InstantiationException e) {
throw new RuntimeException(e);
}
}
/**
* 把String类型转换为目标类型.
*
* @param clazz 目标类型
* @param value 被转换的值
* @return 转换后的值
*/
private static Object toObject(Class clazz, String value) {
if (Boolean.class == clazz || boolean.class == clazz) {
return Boolean.parseBoolean(value);
}
if (Byte.class == clazz || byte.class == clazz) {
return Byte.parseByte(value);
}
if (Short.class == clazz || short.class == clazz) {
return Short.parseShort(value);
}
if (Integer.class == clazz || int.class == clazz) {
return Integer.parseInt(value);
}
if (Long.class == clazz || long.class == clazz) {
return Long.parseLong(value);
}
if (Float.class == clazz || float.class == clazz) {
return Float.parseFloat(value);
}
if (Double.class == clazz || double.class == clazz) {
return Double.parseDouble(value);
}
return value;
}
}
