jackson xml直接转json,不用手动写实体类

已于 2022-01-31 12:31:26 修改
阅读量2.2k 收藏 2
点赞数
分类专栏： java 文章标签： json xml java
于 2022-01-27 00:11:01 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/dj1955/article/details/122710678
版权

 警告：目前在不同的电脑测试不太稳定，庆幸小主是测试成功过的，有时候会出现中文乱码（idea工具配置有关），还有一个就是严重的问题是在解析带有数组的xml时，会将数组中的相同类型的元素当作一个解析，导致数据不完整，如本例中的student对象；

原因：springboot的版本过低导致，要求2.4.5以上；fastjson也有这样的问题，所以这里就不推荐使用它了，如果检坚持要用fastjson,可以按小主提供的1.2.76，好像1.2.75也可以，忘记了。

这里可以还有一种方式，就是引入org.json依赖 ，使用  XML.toJSONObject(String xml) 方法，解析的逻辑跟第一种纯  jackson 写法大同小异，代码虽然有点长但不复杂，如果小伙伴发现问题可以提出来，我会持续跟进。

坑一：当springboot父级工程依赖依赖版本为2.4.5时

JsonNode jsonNode = xmlMapper.readValue(newXML, JsonNode.class); 断点结果如下图

也有这样写的 JsonNode jsonNode = xmlMapper.readValue(newXML, ObjectNode.class);

由源码可知，ObjectNode是JsonNod 衍生继承类。

测试成功的依赖版本：

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>

    <groupId>com.jt</groupId>
    <artifactId>springboot_demo_4</artifactId>
    <version>1.0-SNAPSHOT</version>

    <!--引入父级工程-->
    <parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>2.5.0</version>
        <relativePath/>
    </parent>

    <properties>
        <java.version>1.8</java.version>
    </properties>

    <dependencies>
        <!--thymeleaf导入模版工具类-->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-thymeleaf</artifactId>
        </dependency>

        <!--SpringMVCjar包文件-->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>
        <!--热部署工具-->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-devtools</artifactId>
            <scope>runtime</scope>
            <optional>true</optional>
        </dependency>
        <!--lombok插件-->
        <dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
            <optional>true</optional>
        </dependency>

        <!--测试包-->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-test</artifactId>
            <scope>test</scope>
        </dependency>

        <!--引入jdbc包-->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-jdbc</artifactId>
        </dependency>

        <!--引入数据库驱动 -->
        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
            <scope>runtime</scope>
        </dependency>

        <!--spring整合mybatis-plus -->
        <dependency>
            <groupId>com.baomidou</groupId>
            <artifactId>mybatis-plus-boot-starter</artifactId>
            <version>3.4.2</version>
        </dependency>

        <!--fastjson-->
        <dependency>
            <groupId>com.alibaba</groupId>
            <artifactId>fastjson</artifactId>
            <version>1.2.76</version>
        </dependency>

        <dependency>
            <groupId>org.apache.httpcomponents</groupId>
            <artifactId>httpclient</artifactId>
            <version>4.5.13</version>
        </dependency>

        <dependency>
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>
            <version>4.13.1</version>
            <scope>test</scope>
        </dependency>

        <dependency>
            <groupId>com.fasterxml.jackson.dataformat</groupId>
            <artifactId>jackson-dataformat-xml</artifactId>
        </dependency>

        <!-- https://mvnrepository.com/artifact/org.json/json -->
        <dependency>
            <groupId>org.json</groupId>
            <artifactId>json</artifactId>
            <version>20180813</version>
        </dependency>

        <dependency>
            <groupId>org.apache.commons</groupId>
            <artifactId>commons-lang3</artifactId>
            <version>3.0</version>
        </dependency>

    </dependencies>

    <!--负责项目打包部署-->
    <build>
        <plugins>
            <plugin>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-maven-plugin</artifactId>
                <configuration>
                    <excludes>
                        <exclude>
                            <groupId>org.projectlombok</groupId>
                            <artifactId>lombok</artifactId>
                        </exclude>
                    </excludes>
                </configuration>
            </plugin>
        </plugins>
    </build>

</project>

package com.jt.test;

import com.fasterxml.jackson.databind.JsonNode;
import com.fasterxml.jackson.databind.ObjectMapper;
import com.fasterxml.jackson.databind.node.ObjectNode;
import com.fasterxml.jackson.dataformat.xml.XmlMapper;
import org.apache.commons.lang3.StringUtils;
import org.json.XML;

import java.util.HashMap;
import java.util.Map;

/**
 * User: ldj
 * Date: 2022/1/26
 * Time: 21:24
 * Description: xml直接转json
 */
public class XmlToJsonDemo {
    public static void main(String[] args) {

        //对象转xml
        String xml = "<Message>" +
                "        <School>" +
                "               <SchoolName>草帽中学</SchoolName>" +
                "        </School>" +
                "        <Class>" +
                "               <ClassName>高三7班</ClassName>" +
                "               <Level>" +
                "                    <A>1</A>" +
                "                    <B>2</B>" +
                "               </Level>" +
                "               <Person>" +
                "                       <Teacher>" +
                "                              <Name>LuLu</Name>" +
                "                              <Gender>女</Gender>" +
                "                              <Age>23</Age>" +
                "                       </Teacher>" +
                "                       <Student>" +
                "                              <Name>张三</Name>" +
                "                              <Gender>男</Gender>" +
                "                              <Age>16</Age>" +
                "                      </Student>" +
                "                       <Student>" +
                "                              <Name>李四</Name>" +
                "                              <Gender>男</Gender>" +
                "                              <Age>17</Age>" +
                "                      </Student>" +
                "                       <Student>" +
                "                              <Name>莉莉</Name>" +
                "                              <Gender>女</Gender>" +
                "                              <Age>16</Age>" +
                "                      </Student>" +
                "               </Person>" +
                "        </Class>" +
                "</Message>";

        String age = "18";
        int ages = Integer.parseInt(age);
        System.out.println(ages);


        System.out.println("\n");
        System.out.println("=============================== xml -> json 分节点解析================================");

        Map<String, String> responseMap = xmlToJson(xml);
        String schoolJSON = responseMap.get("schoolJSON");
        String classJSON = responseMap.get("classJSON");
        System.out.println(schoolJSON);
        System.out.println(classJSON);

        System.out.println("\n");
        System.out.println("=============================== xml -> json 全节点解析================================");

        System.out.println(getResponseJSON(xml, "Message"));

        System.out.println("\n");
        System.out.println("=================================org.json 分节点解析==========================================");

        Map<String, String> responseMap1 = xml2Json(xml, "Message");
        String schoolJSON1 = responseMap1.get("schoolJSON");
        String classJSON1 = responseMap1.get("classJSON");

        System.out.println(schoolJSON1);
        System.out.println(classJSON1);
        System.out.println("\n");

    }

    //一个个节点解析
    private static Map<String, String> xmlToJson(String xml) {
        XmlMapper xmlMapper = new XmlMapper();
        HashMap<String, String> responseMap = new HashMap<>();
        try {
            JsonNode jsonNode = xmlMapper.readValue(xml, JsonNode.class);

            JsonNode schoolNode = jsonNode.get("School");
            JsonNode classNode = jsonNode.get("Class");

            ObjectMapper objectMapper = new ObjectMapper();

            if (schoolNode.isContainerNode()) {
                String schoolJSON = objectMapper.writeValueAsString(schoolNode);
                if (StringUtils.isNotBlank(schoolJSON)) {
                    responseMap.put("schoolJSON", schoolJSON);
                }
            }

            if (classNode.isContainerNode()) {
                String classJSON = objectMapper.writeValueAsString(classNode);
                if (StringUtils.isNotBlank(classJSON)) {
                    responseMap.put("classJSON", classJSON);
                }
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
        return responseMap;
    }

    //全部解析
    private static String getResponseJSON(String xml, String rootTag) {

        //对入参xml加根节点标签<Tag></Tag>
        String s1 = "<" + rootTag + ">";
        String s2 = "</" + rootTag + ">";

        StringBuilder sb = new StringBuilder(xml.replaceAll("\\s*", ""));

        int indexStart = sb.indexOf(s1);
        sb.insert(indexStart + (s1.length()), "<Tag>");

        int indexEnd = sb.indexOf(s2);
        sb.insert(indexEnd, "</Tag>");

        String newXML = sb.toString();
        String responseJSON = null;

        XmlMapper xmlMapper = new XmlMapper();
        try {
            //JsonNode jsonNode = xmlMapper.readValue(newXML, JsonNode.class);
            JsonNode jsonNode = xmlMapper.readValue(newXML, ObjectNode.class);

            JsonNode schoolNode = jsonNode.get("Tag");

            ObjectMapper objectMapper = new ObjectMapper();

            if (schoolNode.isContainerNode()) {
                String json = objectMapper.writeValueAsString(schoolNode);
                if (StringUtils.isNotBlank(json)) {
                    responseJSON = json;
                }
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
        return responseJSON;
    }

    //使用org.json +  jackson包 或者 org.json +  fastjson包<不推荐>
    private static Map<String, String> xml2Json(String xml, String rootTag) {

        HashMap<String, String> responseMap = new HashMap<>();

        //剔除根标签Message,如果不剔除根标签Message，生成的数据结构是"Message":{.....}
        if (StringUtils.isNotBlank(rootTag)) {
            xml = xml.replace("<" + rootTag + ">", "");
            xml = xml.replace("</" + rootTag + ">", "");
        }

        try {
            org.json.JSONObject json = XML.toJSONObject(xml);

            /**
             * 由于版本问题，在解析带有数组的xml时，将数组中的相同类型的元素当作一个解析，导致数据不完整,还是用原来的jackson包
             * com.alibaba.fastjson.JSONObject jsonObject = com.alibaba.fastjson.JSONObject.parseObject(json.toString());
             * String schoolNode = jsonObject.getString("School");
             * String classNode = jsonObject.getString("Class");
             */

            /*
             * 其实上面第一种方式的  XmlMapper() 是继承了 ObjectMapper 《源码》 因此下面两行代码相当于
             * XmlMapper xmlMapper = new XmlMapper();
             * JsonNode jsonNode = xmlMapper.readValue(xml, JsonNode.class);
             * ObjectNode是JsonNod 衍生继承类
             */

            ObjectMapper objectMapper = new ObjectMapper();
            JsonNode jsonNode = objectMapper.readValue(json.toString(), JsonNode.class);

            if (jsonNode.isContainerNode()) {

                JsonNode schoolNode = jsonNode.get("School");
                JsonNode classNode = jsonNode.get("Class");

                if (schoolNode.isContainerNode()) {
                    responseMap.put("schoolJSON", schoolNode.toString());
                }

                if (classNode.isContainerNode()) {
                    responseMap.put("classJSON", classNode.toString());
                }
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
        return responseMap;
    }
}


    //jason 还可以读成Tree，不知道性能会不变高，没测试过
    private static HashMap<String, String> getResponseTree(String xml){

        XmlMapper xmlMapper = new XmlMapper();
        HashMap<String, String> responseMap = new HashMap<>();

        try {
            JsonNode jsonNode = xmlMapper.readTree(xml.getBytes(StandardCharsets.UTF_8));

            if(jsonNode.isContainerNode()){

                JsonNode schoolNode = jsonNode.get("School");
                JsonNode classNode = jsonNode.get("Class");

                ObjectMapper objectMapper = new ObjectMapper();

                if (schoolNode.isContainerNode()) {
                    //responseMap.put("schoolJSON", schoolNode.toString());
                    String schoolJSON = objectMapper.writeValueAsString(schoolNode);
                    if (StringUtils.isNotBlank(schoolJSON)) {
                        responseMap.put("schoolJSON", schoolJSON);
                    }
                }

                if (classNode.isContainerNode()) {
                    String classJSON = objectMapper.writeValueAsString(classNode);
                    if (StringUtils.isNotBlank(classJSON)) {
                        responseMap.put("classJSON", classJSON);
                    }
                }
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
        return responseMap;
    }

 

 我就要数字类型的而我使用第一种方式，怎么办？

        String age = "18";
        int ages = Integer.parseInt(age);
        System.out.println(ages);

使用org.json

        <!-- https://mvnrepository.com/artifact/org.json/json -->
        <dependency>
            <groupId>org.json</groupId>
            <artifactId>json</artifactId>
            <version>20180813</version>
        </dependency>


    private static String xtj(String xml) {
        JSONObject json = XML.toJSONObject(xml);
        return json.toString();
    }

如果出现中文乱码可以这样设置下

ldj2020
关注
专栏目录
Xml、Json、实体类之间的转换案例
11-22
在IT行业中，数据交换和存储通常涉及XML（可扩展标记语言）和JSON（JavaScript Object Notation）这两种格式，以及实体类（Entity Class）的转换。本文将深入探讨XML与JSON的特性和它们与Java中的实体类之间的转换...
Jackson 学习笔记 XML转JSON
灵台方寸山斜月三星洞
06-22 1968
Jackson 学习笔记 XML转JSON依赖示例XML > JavaBean > JsonXML > JsonNode 利用jackson实现 xml 2 json。 依赖 SpringBoot 项目自带了 jackson-databind 省略。只需要添加jackson-dataformat-xml即可。另外version也可以省掉。 <dependency> <groupId>com.fasterxml.jackson.core&l
使用jackson 进行 xml、javaBean、json之间相互转换
li_tiantian的博客
01-18 873
一、pom依赖 <dependency> <groupId>com.fasterxml.jackson.dataformat</groupId> <artifactId>jackson-dataformat-xml</artifactId> &lt...
Java中XML到JSON的转换，两个子元素对应一个键值对
最新发布
qq_40697623的博客
08-12 501
XML转JSON，两个子元素对应一个键值对代码示例
XML格式转JSON格式
weixin_45934981的博客
09-08 9277
XML（可扩展标记语言）作为一种结构化标记语言，适合用于表示复杂层次结构的数据，具备自定义标签、属性和模式定义等特性。JSON（JavaScript对象表示）则是一种轻量级数据格式，以键值对的形式表示数据，广泛用于Web应用程序中。文章强调了了解这两种格式的优势和适用场景的重要性，以便在实际项目中做出明智的选择。无论您是开发人员、数据工程师还是系统架构师，对XML和JSON的理解都是关键的技能，有助于更好地满足不同项目的数据交换需求。
jackson使用xml转json
u013244038的博客
03-07 4744
package com.testtt.main.uu; import java.io.StringWriter; import com.fasterxml.jackson.core.JsonGenerator; import com.fasterxml.jackson.core.JsonParser; import com.fasterxml.jackson.databin
使用Jackson实现对象，json，xml，map的转换
qq_43548590的博客
06-01 4449
使用Jackson实现对象，json，xml，map的转换前言一、pom文件二、创建实体类三、对象、json、xml、map的转换四、运行结果 前言 使用Jackson实现对象，json，xml，map的互相转换 使用的包 包名 版本 jackson-databind 2.12.3 jackson-dataformat-xml 2.12.3 一、pom文件 <dependency> <groupId>com.faster
Java-Jackson序列化为JSON/XML/MessagePack
weixin_42145464的博客
10-02 1496
本文介绍了如何使用Jackson来实现JSON/ⅩML/MessagePack序列化。使用方法是类似的，主要是创建的ObjectMapper对象不一样，一般情况下，不需要做额外配置，但也有很多情况，需要做额外配置，配置方式主要是注解，本文介绍了Jackson中的很多典型注解，大部分注解适用于所有格式
关于Jackson中Xml和Json互转，Xml格式特殊处理问题
weixin_40863968的博客
11-15 5476
Jackson关于Xml和Json互转中，Xml特殊格式问题 Github地址：https://github.com/lingshr/jackson-xml-example
xmljson生成实体类
10-19
总结来说，"xmljson生成实体类"工具提供了从XML或JSON到Java实体类的便捷转换，它减少了手动编码的工作，提升了开发效率。通过将XML或JSON数据映射到JavaBean，开发者能够更加高效地处理数据，特别是在进行接口调用...
java对象转换为json字符串或字符串数组
07-12
在Java开发中，将Java对象转换为JSON字符串或字符串数组是一项常见的任务，特别是在与前端交互、...在实际项目中，根据具体需求，还可以结合使用其他JSON库，如Gson、Jackson等，它们各有特点，能满足不同的场景需求。
BookLibrary-jackson-1101：XML和JSON
02-09
2. **XML/JSON序列化（Serialization）**：展示如何使用Jackson将这些实体类实例转化为XML或JSON字符串。 3. **XML/JSON反序列化（Deserialization）**：演示如何从XML或JSON字符串中恢复出Java对象。 4. **配置和...
json转对象（java 多级嵌套）
01-05
Jackson库的主要类包括`JsonParser`和`ObjectMapper`，它们可以帮助我们将JSON数据映射到Java对象上。 1. **引入Jackson库** 首先，需要在项目中引入Jackson库。如果你使用的是Maven，可以在pom.xml文件中添加以下...
JAVA JSON;String 转换为 java类
12-23
总之，Java中将JSON字符串转换为Java实体类是通过JSON反序列化实现的，主要借助于像Jackson这样的库。理解JSON与Java对象之间的映射关系，以及如何处理嵌套结构、可选字段和数组，是进行有效转换的关键。熟练掌握...
读取文件数据并解析成bean实体类
08-19
"读取文件数据并解析成bean实体类"这一主题涉及到的核心知识点主要包括文件操作、数据解析以及对象映射。下面将详细阐述这些概念及其应用。 1. **文件操作**：文件是数据存储的基本单位，通常以二进制或文本格式...
实体类反射非空赋值，AjaxJson工具类
12-05
在“实体类反射非空赋值，AjaxJson工具类”这个主题中，我们将探讨如何使用反射来安全地为实体类的属性赋值，并结合Ajax与JSON进行数据的转换和交互。 首先，让我们深入了解反射的概念。Java反射API提供了Class类，...
【mybatis mapper XML】List类型入参参数处理
热门推荐
sayyy的专栏
08-06 1万+
前言 mybatis 3.4.6 如果 DAO 中这样传参，XML该如何处理呢？ List<Article> selectLatestArticleList( @Param("channelIdList")List<Long> channelIdList, @Param("maxDay")int maxDay); XML <select id="selectLatestArticleList" paramType="map" resultMa
求助！！！使用JAXB，XML转Java对象，读取连续相同标签时只创建了1个对象且返回最后1个标签内容
qq_40631357的博客
03-24 2627
返回对象只返回最后一个choice标签内的value 但是Text里放很多还是能够正常读取和转换，只是到了这个连续属性标签就出问题了 求解如何更改，Choc对象只创建了一个，我需要List<Choc> Quiz.xml; 想要把choice读取成对象。 前端目前输出，只有最后一个 quizchoices: Array(1) '0': {choices: "Test"} 后端输出...
java mapper.readtree_objectMapper.readTree(objectMapper.writeValueAsString(@params))
weixin_36446632的博客
02-16 712
public IDictionary @params;public IDictionary xParams;public BlockObject[] processes;public string mimeType;public long totalSize;public virtual JsonNode toJSON(){ObjectMapper objectMapper = new Objec...
JSON 实体类转Map
05-27
可以使用 Jackson 库将 JSON 实体类转换成 Map 对象。 首先，需要引入 Jackson 库的依赖，例如 Maven： ```xml <dependency> <groupId>com.fasterxml.jackson.core</groupId> <artifactId>jackson-databind</artifactId> <version>2.11.3</version> </dependency> ``` 然后，可以使用 ObjectMapper 类的 readValue 方法将 JSON 字符串转换成 Java 对象，再使用 TypeReference 类型引用将 Java 对象转换成 Map 对象。示例代码如下： ```java import com.fasterxml.jackson.core.type.TypeReference; import com.fasterxml.jackson.databind.ObjectMapper; import java.util.Map; public class JsonToMap { public static void main(String[] args) throws Exception { String json = "{\"name\":\"Alice\",\"age\":20}"; ObjectMapper objectMapper = new ObjectMapper(); Map<String, Object> map = objectMapper.readValue(json, new TypeReference<Map<String, Object>>(){}); System.out.println(map); } } ``` 输出结果为： ``` {name=Alice, age=20} ``` 注意，上述代码中，TypeReference 类型引用是匿名内部类的写法，也可以单独定义一个 TypeReference 类，例如： ```java public class MapTypeReference extends TypeReference<Map<String, Object>> {} ``` 然后在代码中使用： ```java Map<String, Object> map = objectMapper.readValue(json, new MapTypeReference()); ```
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值