Java中Xml文件和Bean互相转换

JAXB（Java Architecture for XML Binding) 是一个业界的标准，可以根据XML Schema产生Java类的技术。该过程中，JAXB也提供了将XML实例文档反向生成Java对象树的方法，并能将Java对象树的内容重新写到XML实例文档。JAXB提供了快速而简便的方法将XML模式绑定到Java表示，从而使得Java开发者在Java应用程序中能方便地结合XML数据和处理函数。

一、JAXB API介绍

① 常用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注解的元素排序规则将失效；

 二、JAXB的具体实践

Bean转Xml和Xml转Bean的工具类

import com.sun.xml.internal.bind.marshaller.CharacterEscapeHandler;
import com.xiaomi.mifi.scf.abc.errors.ABCException;
import org.apache.commons.lang3.StringUtils;
import org.springframework.http.converter.HttpMessageConversionException;
import org.springframework.util.Assert;

import javax.xml.bind.JAXBContext;
import javax.xml.bind.JAXBException;
import javax.xml.bind.Marshaller;
import javax.xml.bind.Unmarshaller;
import javax.xml.bind.annotation.XmlAnyElement;
import java.io.StringReader;
import java.io.StringWriter;
import java.util.Collection;
import java.util.concurrent.ConcurrentHashMap;
import java.util.concurrent.ConcurrentMap;


public final class XmlUtil {
    private static final ConcurrentMap<Class, JAXBContext> JAXB_TMP = new ConcurrentHashMap<>();

    public static String objectToXml(Object root) {
        Class clazz = root.getClass();
        return objectToXml(root, clazz, null);
    }

    public static String objectToXml(Object root, String encoding) {
        Class clazz = root.getClass();
        return objectToXml(root, clazz, encoding);
    }

    private static String objectToXml(Object root, Class clazz, String encoding) {
        try {
            StringWriter writer = new StringWriter();
            createMarshaller(clazz, encoding).marshal(root, writer);
            return writer.toString();
        } catch (JAXBException e) {
            throw new ABCException(e);
        }
    }

    // 对于有父类的子类，反序列化不能用这种方式，因为解析出来的是父类基本类，无法强转到子类
    public static <T> T xmlToObject(String xml, Class<T> clazz) {
        try {
            StringReader reader = new StringReader(xml);
            return (T) createUnmarshaller(clazz).unmarshal(reader);
        } catch (JAXBException e) {
            throw new ABCException(e);
        }
    }

    // 对上一个方法的补充，解析到父类后会继续解析到子类
    public static <T, S> T xmlToObject(String xml, Class<S> fatherClazz, Class<T> clazz) {
        try {
            StringReader reader = new StringReader(xml);
            return (T) getJaxbContext(fatherClazz, clazz).createUnmarshaller().unmarshal(reader);
        } catch (Exception e) {
            throw new ABCException(e);
        }
    }

    private static Marshaller createMarshaller(Class clazz, String encoding) throws JAXBException {
        JAXBContext jaxbContext = getJaxbContext(clazz);
        Marshaller marshaller = jaxbContext.createMarshaller();
        // xml格式
        marshaller.setProperty(Marshaller.JAXB_FORMATTED_OUTPUT, Boolean.TRUE);

        // 去掉生成xml的默认报文头
        marshaller.setProperty(Marshaller.JAXB_FRAGMENT, true);

        // 不进行转义字符的处理
        marshaller.setProperty(CharacterEscapeHandler.class.getName(), (CharacterEscapeHandler) (ch, start, length, isAttVal, writer) -> writer.write(ch, start, length));

        if (StringUtils.isNotBlank(encoding)) {
            marshaller.setProperty(Marshaller.JAXB_ENCODING, encoding);
        }
        return marshaller;
    }

    private static Unmarshaller createUnmarshaller(Class clazz) throws JAXBException {
        JAXBContext jaxbContext = getJaxbContext(clazz);
        return jaxbContext.createUnmarshaller();
    }

    private static JAXBContext getJaxbContext(Class clazz) {
        Assert.notNull(clazz, "'clazz' must not be null");
        JAXBContext jaxbContext = JAXB_TMP.get(clazz);
        if (jaxbContext == null) {
            try {
                jaxbContext = JAXBContext.newInstance(clazz, CollectionWrapper.class);
                JAXB_TMP.putIfAbsent(clazz, jaxbContext);
            } catch (JAXBException ex) {
                throw new HttpMessageConversionException("Could not instantiate JAXBContext for class [" + clazz
                        + "]: " + ex.getMessage(), ex);
            }
        }
        return jaxbContext;
    }

    private static JAXBContext getJaxbContext(Class fatherClazz, Class clazz) {
        Assert.notNull(clazz, "'clazz' must not be null");
        JAXBContext jaxbContext = JAXB_TMP.get(clazz);
        if (jaxbContext == null) {
            try {
                jaxbContext = JAXBContext.newInstance(fatherClazz, clazz, CollectionWrapper.class);
                JAXB_TMP.putIfAbsent(clazz, jaxbContext);
            } catch (JAXBException ex) {
                throw new HttpMessageConversionException("Could not instantiate JAXBContext for class [" + clazz
                        + "]: " + ex.getMessage(), ex);
            }
        }
        return jaxbContext;
    }

    private static class CollectionWrapper {
        @XmlAnyElement
        protected Collection<?> collection;
    }

}

定义java实体：

@Data
@XmlAccessorType(XmlAccessType.FIELD)
@XmlRootElement(name = "ap")
public class ABCBaseRespData implements Serializable {

    private static final long serialVersionUID = 8922189936461538311L;

    /**
     * 交易代码 C6
     */
    @XmlElement(name = "CCTransCode")
    private String cCtransCode;

    @XmlElement(name = "Cmp")
    private ABCBaseFiledData filedData;

    @Data
    @XmlAccessorType(XmlAccessType.FIELD)
    public static class ABCBaseFiledData implements Serializable {

        /**
         * <Cme>
         * <RecordNum>记录数</RecordNum>
         * <FieldNum>字段数</FieldNum>
         * </Cme>
         */
        @XmlElement(name = "RecordNum")
        private int recordNum;

        /** */
        @XmlElement(name = "fieldNum")
        private int fieldNum;
    }
}

import lombok.Data;

import javax.xml.bind.annotation.XmlAccessType;
import javax.xml.bind.annotation.XmlAccessorType;
import javax.xml.bind.annotation.XmlElement;
import javax.xml.bind.annotation.XmlRootElement;

@Data
@XmlAccessorType(XmlAccessType.FIELD)
@XmlRootElement(name = "ap")
public class ABCPayResultResp extends ABCBaseRespData {
    @XmlElement(name = "Cmp")
    private TransStatus transStatus;

    @Data
    @XmlAccessorType(XmlAccessType.FIELD)
    public static class TransStatus{
        /** 流水状态，参考TransStatusEnum*/
        @XmlElement(name = "TransSta")
        private String transSta;
    }

}

测试用例：