xml和对象之间的互相转换以及json和对象之间的互相转换

首先先讲json和对象之间的互相转换，因为这个比较简单。

首先引入依赖

<dependency>

<groupId>com.alibaba</groupId>

<artifactId>fastjson</artifactId>

<version>1.2.47</version>

</dependency>

然后可以调用依赖里的方法

JSON.parseObject(str, ApprovalVo.class)是json字符串转化为java实体类; JSON.toJSONString(ApprovalVo)是把实体类转化成json字符串

str就是json字符串，ApprovalVo是实体类，如果这个实体类里面还包含了对象或者数组之类的也不用换方法，外面大的转了的话里面小的可以当作正常实体类取

接下来就是xml和对象之间的互相转换了

这是用jaxb来做的xml和对象互转，工具方法就是如下。除了用工具方法，还得在实体类上也做好注解，不然会报错

package com.hnykx.util;

import cn.hutool.core.util.XmlUtil;
import com.sun.xml.internal.bind.marshaller.CharacterEscapeHandler;
import javax.xml.bind.JAXBContext;
import javax.xml.bind.JAXBException;
import javax.xml.bind.Marshaller;
import javax.xml.bind.Unmarshaller;
import java.io.IOException;
import java.io.StringReader;
import java.io.StringWriter;
import java.io.Writer;

public class XmlToObject extends XmlUtil {
        /**
         * xml字符串转为bean
         *
         * @param xml   xml字符串
         * @param clazz 需要转成的对象
         * @return
         */
        @SuppressWarnings("unchecked")
        public static <T> T parseBean(String xml, Class<T> clazz) {
        try {
            JAXBContext context = JAXBContext.newInstance(clazz);
            Unmarshaller unmarshaller = context.createUnmarshaller();
            return (T) unmarshaller.unmarshal(new StringReader(xml));
        } catch (JAXBException e) {
            e.printStackTrace();
            return null;
        }
    }

        /**
         * 将对象转为xml字符串 编码为utf-8 不格式化 省略头部声明
         *
         * @param obj 待转的对象
         * @return
         */
        public static String toStr(Object obj) {
        return toStr(obj, false, true);
    }

        /**
         * 将对象转为xml字符串 编码为utf-8
         *
         * @param obj          待转的对象
         * @param isFormat     是否格式化
         * @param isIgnoreHead 是否忽略头部
         * @return
         */
        public static String toStr(Object obj, boolean isFormat, boolean isIgnoreHead) {
        try {
            JAXBContext context = JAXBContext.newInstance(obj.getClass());
            Marshaller marshaller = context.createMarshaller();
            marshaller.setProperty(Marshaller.JAXB_ENCODING, "UTF-8");// //编码格式
            marshaller.setProperty(Marshaller.JAXB_FORMATTED_OUTPUT, isFormat);// 是否格式化生成的xml串
            marshaller.setProperty(Marshaller.JAXB_FRAGMENT, isIgnoreHead);// 是否省略xm头声明信息

            // 不进行转义字符的处理
            marshaller.setProperty(CharacterEscapeHandler.class.getName(), new CharacterEscapeHandler() {
                @Override
                public void escape(char[] ch, int start, int length, boolean isAttVal, Writer writer)
                        throws IOException {
                    writer.write(ch, start, length);
                }
            });

            StringWriter writer = new StringWriter();
            marshaller.marshal(obj, writer);
            return writer.toString();
        } catch (JAXBException e) {
            e.printStackTrace();
            return null;
        }
    }

        /**
         * 将对象转为xml字符串 编码为utf-8 格式化 省略头部声明
         *
         * @param obj 待转的对象
         * @return
         */
        public static String toPrettyStr(Object obj) {
        return toStr(obj, true, true);
    }

        /**
         * 将对象转为xml字符串 编码为 GBK
         *
         * @param obj          待转的对象
         * @param isFormat     是否格式化
         * @param isIgnoreHead 是否忽略头部
         * @return
         */
        public static String toStrGF(Object obj, boolean isFormat, boolean isIgnoreHead) {
        try {
            JAXBContext context = JAXBContext.newInstance(obj.getClass());
            Marshaller marshaller = context.createMarshaller();
            marshaller.setProperty(Marshaller.JAXB_ENCODING, "GBK");// //编码格式
            marshaller.setProperty(Marshaller.JAXB_FORMATTED_OUTPUT, isFormat);// 是否格式化生成的xml串
            marshaller.setProperty(Marshaller.JAXB_FRAGMENT, isIgnoreHead);// 是否省略xm头声明信息

            // 不进行转义字符的处理
            marshaller.setProperty(CharacterEscapeHandler.class.getName(), new CharacterEscapeHandler() {
                @Override
                public void escape(char[] ch, int start, int length, boolean isAttVal, Writer writer)
                        throws IOException {
                    writer.write(ch, start, length);
                }
            });

            StringWriter writer = new StringWriter();
            marshaller.marshal(obj, writer);
            return writer.toString();
        } catch (JAXBException e) {
            e.printStackTrace();
            return null;
        }
    }

    }

实体类的注解

@Data
@XmlRootElement(name = "Response")
@XmlAccessorType(XmlAccessType.FIELD)
@XmlSeeAlso({AppAndDoadResBody.class})
public class AppAndDoadResBase {
    @XmlElement(name="Head",required = true)
    private ResHeadVO Head;
    @XmlElement(name="Body",required = true)
    private AppAndDoadResBody Body;
}

@XmlRootElement是用来标注外层是标签的，@XmlElement是用来标注外层标签里面的每个内容标签，注意，最好不要用泛型，因为jaxb有个小bug，绑定多个类的话会失效

@Data
@XmlAccessorType(XmlAccessType.FIELD)
public class ResHeadVO {
    private String	TxType;
    private String	TxTime;
    private String	Code;
    private String	Message;
}

如果是属性有复杂的带有list集合包对象的话，可以这样写注解

@Data
@XmlRootElement(name="Body")
@XmlAccessorType(XmlAccessType.FIELD)
public class QueryResBody {
    @XmlElement(name = "CertList",required = true)
    private List<ItemModel> CertList;
}

@Data
@XmlRootElement(name="ItemModel")
@XmlAccessorType(XmlAccessType.FIELD)
public class ItemModel {
    private String	SubscriberName;
}

下面是对象转xml和xml转对象的结果图

 

 觉得还行的话点个赞叭，有问题的也可以评论，看到会回复的哦

顺便再推荐个好用的工具wangzhan，可以用xml和json示例报文直接解析快速生成实体类

json转javaBean实体类在线生成工具—工具猫