单层XML结构转换为对象数组 - Jackson

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

/**
 * 课程.
 * @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;
}

//专业有多门课程

Major(name=计算机科学, years=4, subjectList=[Subject(name=离散数学, content=有点难, hours=64), Subject(name=操作系统, content=计算机真奇妙, hours=48)])

@Target({ElementType.FIELD})
@Retention(RetentionPolicy.RUNTIME)
//Jackson内置注解，表明这里还有Jackson其他注解，需要被支持
@JacksonAnnotationsInside
//为了防止冲突，使用SingleDeckXml的注解的属性就不会被Jackson转换
@JsonIgnore
public @interface SingleDeckXml {
}

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;
    }
}