SpringBoot之jackson之复杂XML和Object互转、泛型、List、传参/接参、忽略未知变量_jackson xmlmapper读取list结构

相关文章推荐
欢快的夕阳 · 经济发展-南阳市人民政府门户网站· 4 月前 ·
至今单身的青蛙 · PhotoShop用图片填充字体背景-阿里云 ...· 1 年前 ·
踏实的脆皮肠 · MirrorLink ...· 1 年前 ·
俊秀的小刀 · 暗海纪元24 - 抖音· 1 年前 ·
从容的椰子 · 哥布林洞窟 - 百度· 1 年前 ·
@JacksonXmlRootElement 注解用于对象，表示对象的名称节点
@JacksonXmlProperty注解用于变量，表示（反）序列化变量的名称
@JacksonXmlElementWrapper 注解用于集合变量，表示（反）序列化集合变量的名称。如：List<?>等
@JsonIgnoreProperties(ignoreUnknown = true) 注解表示忽略未知的反序列化的变量
		<!-- lombok插件 -->
        <dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
            <optional>true</optional>
        </dependency>
        <!-- jackson xml 转换工具 -->
        <dependency>
            <groupId>com.fasterxml.jackson.dataformat</groupId>
            <artifactId>jackson-dataformat-xml</artifactId>
        </dependency>
        <!-- web -->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>
创建第1层请求对象Bsxml
 
import com.fasterxml.jackson.dataformat.xml.annotation.JacksonXmlElementWrapper;
import com.fasterxml.jackson.dataformat.xml.annotation.JacksonXmlProperty;
import com.fasterxml.jackson.dataformat.xml.annotation.JacksonXmlRootElement;
import lombok.Data;
import java.io.Serializable;
@Data
@JacksonXmlRootElement(localName = "Bsxml") //XML根节点名称
public class Bsxml<T> implements Serializable {
    @JacksonXmlProperty(localName = "MsgHeader")
    private MsgHeader msgHeader;//请求头对象
    @JacksonXmlProperty(localName = "MsgBody")
    private T msgBody;//泛型消息体，我这里的泛型是可以去掉的，直接用MsgBody对象，这里只是为了模拟复杂对象。
创建第2层请求头对象MsgHeader
 
import com.fasterxml.jackson.dataformat.xml.annotation.JacksonXmlElementWrapper;
import com.fasterxml.jackson.dataformat.xml.annotation.JacksonXmlProperty;
import com.fasterxml.jackson.dataformat.xml.annotation.JacksonXmlRootElement;
import lombok.Data;
import java.io.Serializable;
@Data
@ToString
@JacksonXmlRootElement(localName = "MsgHeader")
public class MsgHeader implements Serializable {
    @JacksonXmlProperty(localName = "Organization")
    private String organization;
    @JacksonXmlProperty(localName = "Sender")
    private String sender;
    @JacksonXmlProperty(localName = "ServiceType")
    private String serviceType;
    @JacksonXmlProperty(localName = "MsgType")
    private String msgType;
    @JacksonXmlProperty(localName = "MsgVersion")
    private String msgVersion;
创建第2层请求头体MsgData
 
import com.fasterxml.jackson.dataformat.xml.annotation.JacksonXmlElementWrapper;
import com.fasterxml.jackson.dataformat.xml.annotation.JacksonXmlProperty;
import com.fasterxml.jackson.dataformat.xml.annotation.JacksonXmlRootElement;
import lombok.Data;
 * MsgBody对象就是Bsxml里面的泛型T
@Data
@JacksonXmlRootElement(localName = "MsgBody")
public class MsgBody<D> {
    @JacksonXmlProperty(localName = "Status")
    private Boolean status;//状态
    @JacksonXmlProperty(localName = "Code")
    private Integer code;//成功状态码
    @JacksonXmlProperty(localName = "ErrCode")
    private Integer errCode;//错误状态码
    @JacksonXmlProperty(localName = "Detail")
    private String detail;//详细信息
    @JacksonXmlProperty(localName = "Data")
    private D data;//返回数据，泛型
创建第2层请求头体MsgData内层某个Data泛型对象
 
import com.fasterxml.jackson.dataformat.xml.annotation.JacksonXmlElementWrapper;
import com.fasterxml.jackson.dataformat.xml.annotation.JacksonXmlRootElement;
import lombok.Data;
 * LabReportAudit对象就是MsgBody里面的泛型 D
@Data
@JacksonXmlRootElement(localName = "Data")
public class LabReportAudit {
    @JacksonXmlProperty(localName = "Name")
    private String name;
模拟Controller接参传参
 
import com.fasterxml.jackson.core.JsonProcessingException;
import com.fasterxml.jackson.databind.ObjectMapper;
import com.fasterxml.jackson.dataformat.xml.XmlMapper;
import lombok.extern.slf4j.Slf4j;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.RequestBody;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;
@Slf4j
@RestController
@RequestMapping("test")
public class TestController {
     * 传xml转json,json转对象
     * @param bsxml Bsxml<T<D>>
    @PostMapping("xmlToObject")
    public void xmlToObject(@RequestBody Bsxml<MsgBody<LabReportAudit>> bsxml) throws JsonProcessingException {
        log.info("Bsxml转成实体后的信息：{}",bsxml);
        ObjectMapper objectMapper = new ObjectMapper();
        log.info("bsxml JSON：{}", objectMapper.writeValueAsString(bsxml));
     * 传json转成对象，对象转xml
     * @param bsxml 实体类json
    @PostMapping("objectToXml")
    public void objectToXml(@RequestBody Bsxml<MsgBody<LabReportAudit>> bsxml) throws JsonProcessingException {
        ObjectMapper objectMapper = new XmlMapper();
        String xmlString = objectMapper.writeValueAsString(bsxml);
        log.info("对象转xml：{}", xmlString);
Postman传参
 
xmlToObject
 
<Bsxml>
    <MsgHeader>
        <Organization>123456789</Organization>
        <Sender>Meta39</Sender>
        <ServiceType>service</ServiceType>
        <MsgType>msgType</MsgType>
        <MsgVersion>1.0</MsgVersion>
    </MsgHeader>
    <MsgBody>
        <Code>1</Code>
        <Status>true</Status>
        <Detail>描述信息</Detail>
            <Name>名称</Name>
        </Data>
    </MsgBody>
</Bsxml>
objectToXml
 
    "msgHeader": {
        "organization": "123456789",
        "sender": "Meta39",
        "serviceType": "service",
        "msgType": "msgType",
        "msgVersion": "1.0"
    "msgBody": {
        "status": true,
        "code": 1,
        "errCode": null,
        "detail": "描述信息",
        "data": {
            "name": "名称"
List的转换
 
import com.fasterxml.jackson.dataformat.xml.annotation.JacksonXmlElementWrapper;
import com.fasterxml.jackson.dataformat.xml.annotation.JacksonXmlProperty;
import com.fasterxml.jackson.dataformat.xml.annotation.JacksonXmlRootElement;
import lombok.Data;
import java.io.Serializable;
import java.util.List;
@Data
@JacksonXmlRootElement(localName = "Xml")//自定义根路径名称
public class XmlObeject implements Serializable {
    @JacksonXmlProperty(localName = "Name")
    private String name;
     * JacksonXmlElementWrapper注解用于指定列表或数组属性在XML中的包装元素，以提供更好的结构化层次和语义意义。
     * 简单理解就是外层用@JacksonXmlElementWrapper，内层用@JacksonXmlProperty。
    @JacksonXmlElementWrapper(localName = "XmlObejectInfos")//JacksonXmlElementWrapper用于集合
    private List<XmlObejectInfo> xmlObejectInfos;
import com.fasterxml.jackson.dataformat.xml.annotation.JacksonXmlProperty;
import com.fasterxml.jackson.dataformat.xml.annotation.JacksonXmlRootElement;
import lombok.Data;
import java.io.Serializable;
@Data
@JacksonXmlRootElement(localName = "XmlInfo")
public class XmlObejectInfo implements Serializable {
    @JacksonXmlProperty(localName = "Age")
    private Integer age;
import com.fasterxml.jackson.core.JsonProcessingException;
import com.fasterxml.jackson.dataformat.xml.XmlMapper;
import lombok.extern.slf4j.Slf4j;
import org.junit.jupiter.api.Test;
import java.util.ArrayList;
import java.util.List;
@Slf4j
public class JacksonXmlTests {
    @Test
    void test() throws JsonProcessingException {
        XmlMapper xmlMapper = new XmlMapper();
        XmlObeject xmlObeject = new XmlObeject();
        xmlObeject.setName("XML");
        List<XmlObejectInfo> xmlObejectInfos = new ArrayList<>();
        XmlObejectInfo xmlObejectInfo = new XmlObejectInfo();
        xmlObejectInfo.setAge(25);
        xmlObejectInfos.add(xmlObejectInfo);
        xmlObeject.setXmlObejectInfos(xmlObejectInfos);
        //序列化成XML字符串
        String xmlString = xmlMapper.writeValueAsString(xmlObeject);
        log.info("{}", xmlString);
        //反序列化成Java对象
        XmlObeject xmlObj = xmlMapper.readValue(xmlString, XmlObeject.class);
        log.info("{}", xmlObj);
有时候我们序列化内容可能无法转换成我们想要的，因为内层的@JacksonXmlRootElement(localName = “XXX”)，没有生效，我们可以用反射获取到传过来的类，然后获取JacksonXmlRootElement的注解，序列化成字符串后通过.replace(“”, “<”+otherHeader+“>”).replace(“”, “</”+otherHeader+“>”)的方式替换掉我们的请求头。




    
 
ObjectMapperUtils
 
工具类把泛型Data标签替换具体类的根别名 
     * 替换Data的名称为实体类的@JacksonXmlRootElement注解localName的值
     * @param object 实体类
    public static <T> String objectToXmlReplaceMsgBodyDataName(T object, Class<?> clazz){
        try {
            String JacksonXmlRootElementlocalNameValue = clazz.getAnnotation(JacksonXmlRootElement.class).localName();//获取类的@JacksonXmlRootElement注解localName的值
            String xmlMetaString = xmlMapper.writeValueAsString(object);//原始xml数据，替换<Data></Data>为clazz的@JacksonXmlRootElement注解localName的值
            return xmlMetaString
                    .replace("<Data>","<"+JacksonXmlRootElementlocalNameValue+">")
                    .replace("</Data>","</"+JacksonXmlRootElementlocalNameValue+">");
        } catch (JsonProcessingException e) {
            log.error("objectToXml error：", e);
            throw Err.msg("objectToXml error：" + e.getMessage());
@Data
@ToString
@JacksonXmlRootElement(localName = "LabBarcode")
public class LabBarcodeDTO {
上面这个@JacksonXmlRootElement(localName = “LabBarcode”)会不生效，因为会被上一层级的泛型Data所覆盖。所以要用通过传入具体的类，通过反射获取@JacksonXmlRootElement注解对应localName变量的值。 
//泛型类里默认是<Data> 》》》<LabBarcode>
ObjectMapperUtils.objectToXmlReplaceMsgBodyDataName(bsxml, LabBarcodeDTO.class));
头部追加<?xml version='1.0' encoding='UTF-8'?>
 
XmlMapper xmlMapper = new XmlMapper();
xmlMapper.configure(ToXmlGenerator.Feature.WRITE_XML_DECLARATION, true);
                                    1     public static void main(String[] args) throws Exception {
 2         XnServiceGetUserRequest xnServiceGetUserRequest = new XnServiceGetUserRequest();
 4         xnServiceGetUserRequest...
                                    Hi I need to create an XML from JAVA using Jackson-dataformat XMLMapper.The XML should be like1Mighty PulpoaustinTXHong KongHong KongBut I get it always like with an extra "< addresses> < /ad...
                                    Jackson 数据格式库 - XML 支持
Jackson 是一个流行的 Java 库，用于处理 JSON 数据。它提供了一套高效、灵活的 API 和模块，可以轻松地序列化和反序列化 JSON 数据。除了 JSON，Jackson 还支持其他数据格式，如 YAML 和 Smile。本文将介绍 Jackson 的一个子项目：jackson-dataformat-xml，它是对 XML 数据的支持。...
                                    用于指示要用于集合类型（数组，java.util.Collection）的包装元素（如果有的话）。如果定义了容器（包装器）元素，则使用单独的容器（包装器）元素；如果没有定义，则不包装条目。
                                    Jackson-操作XML
Jackson是一个处理JSON的类库，不过它也通过jackson-dataformat-xml包提供了处理XML的功能。Jackson建议我们在处理XML的时候使用woodstox-core包，它是一个XML的实现，比JDK自带XML实现更加高效，也更加安全。
Jackson常用注解
1、@JacksonXmlRootElement
@JacksonXmlRootElement注解有两个属性：
namespace属性：用于指定XML根元素命名空间的名称。
localna
要想灵活地进行转换，需要在实体上使用到Jackson提供的四个注解：
　　@JacksonXmlElementWrapper：可用于指定List等集合类，外围标签名；
　　@JacksonXmlProperty：指定包装标签名，或者指定标签内部属性名；
　　@JacksonXmlRootElement：指定生成xml根标签的名字；
　　@JacksonXmlTex...
                                    使用Jackson实现对象，json，xml，map的转换前言一、pom文件二、创建实体类三、对象、json、xml、map的转换四、运行结果
使用Jackson实现对象，json，xml，map的互相转换
                                    Jackson 生成xml格式文件
Jackson是java应用中流行的操作Json工具库，很快成为Java生态中事实标准，Spring boot默认也使用Jackson。从版本2开始，支持json的同时引入成熟的xml实现。
1. 环境依赖
增加Jackson xml 模块，仅需要一个依赖：
<dependency>
    <groupId>com.fasterxml.jackson.dataformat</groupId>
    <artifactId&gt
                                    本文简述了 JSON、泛型、泛型擦除、Jackson使用的基础知识。介绍了使用 JavaType 进行反序列化泛型类的方法。使用 Kotlin 封装了部分 Jackson 的方法，方便使用。举例说明泛型类嵌套时，封装方法的使用细节。