使用 Jackson 玩转 xml 的序列化和反序列化

最新推荐文章于 2024-06-10 16:10:08 发布
最新推荐文章于 2024-06-10 16:10:08 发布
阅读量3.3k 收藏 4
点赞数 1
分类专栏： Web开发 文章标签： java jackson xml
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/growl_jie_/article/details/105604358
版权

前期写了一篇关于 DOM4j 解析 XML 的，但是得知 Jackson 也支持解析 XML，所以打算也写一篇关于 Jackson 解析 XML 的，俗称 xml 的序列化和反序列化

这边我使用 maven 构建工程
在这里插入图片描述
找到 pom.xml 添加依赖

<?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>org.example</groupId>
  <artifactId>studyJackson</artifactId>
  <version>1.0-SNAPSHOT</version>

  <name>studyJackson</name>
  <!-- FIXME change it to the project's website -->
  <url>http://www.example.com</url>

  <properties>
    <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
    <maven.compiler.source>1.7</maven.compiler.source>
    <maven.compiler.target>1.7</maven.compiler.target>
  </properties>

  <dependencies>
    <!-- https://mvnrepository.com/artifact/com.fasterxml.jackson.dataformat/jackson-dataformat-xml -->
    <dependency>
      <groupId>com.fasterxml.jackson.dataformat</groupId>
      <artifactId>jackson-dataformat-xml</artifactId>
      <version>2.10.3</version>
    </dependency>
    <!-- https://mvnrepository.com/artifact/com.fasterxml.jackson.core/jackson-core -->
    <dependency>
      <groupId>com.fasterxml.jackson.core</groupId>
      <artifactId>jackson-core</artifactId>
      <version>2.10.3</version>
    </dependency>
    <!-- https://mvnrepository.com/artifact/com.fasterxml.jackson.core/jackson-annotations -->
    <dependency>
      <groupId>com.fasterxml.jackson.core</groupId>
      <artifactId>jackson-annotations</artifactId>
      <version>2.10.3</version>
    </dependency>
    <!-- https://mvnrepository.com/artifact/com.fasterxml.jackson.core/jackson-databind -->
    <dependency>
      <groupId>com.fasterxml.jackson.core</groupId>
      <artifactId>jackson-databind</artifactId>
      <version>2.10.3</version>
    </dependency>
    <!-- https://mvnrepository.com/artifact/com.fasterxml.jackson.module/jackson-module-jaxb-annotations -->
    <dependency>
      <groupId>com.fasterxml.jackson.module</groupId>
      <artifactId>jackson-module-jaxb-annotations</artifactId>
      <version>2.10.3</version>
    </dependency>
    <!-- https://mvnrepository.com/artifact/com.fasterxml.woodstox/woodstox-core -->
    <dependency>
      <groupId>com.fasterxml.woodstox</groupId>
      <artifactId>woodstox-core</artifactId>
      <version>6.1.1</version>
    </dependency>
    <!-- https://mvnrepository.com/artifact/org.codehaus.woodstox/stax2-api -->
    <dependency>
      <groupId>org.codehaus.woodstox</groupId>
      <artifactId>stax2-api</artifactId>
      <version>4.2</version>
    </dependency>
    <dependency>
      <groupId>junit</groupId>
      <artifactId>junit</artifactId>
      <version>4.11</version>
      <scope>test</scope>
    </dependency>
  </dependencies>

  <build>
    <pluginManagement><!-- lock down plugins versions to avoid using Maven defaults (may be moved to parent pom) -->
      <plugins>
        <!-- clean lifecycle, see https://maven.apache.org/ref/current/maven-core/lifecycles.html#clean_Lifecycle -->
        <plugin>
          <artifactId>maven-clean-plugin</artifactId>
          <version>3.1.0</version>
        </plugin>
        <!-- default lifecycle, jar packaging: see https://maven.apache.org/ref/current/maven-core/default-bindings.html#Plugin_bindings_for_jar_packaging -->
        <plugin>
          <artifactId>maven-resources-plugin</artifactId>
          <version>3.0.2</version>
        </plugin>
        <plugin>
          <artifactId>maven-compiler-plugin</artifactId>
          <version>3.8.0</version>
        </plugin>
        <plugin>
          <artifactId>maven-surefire-plugin</artifactId>
          <version>2.22.1</version>
        </plugin>
        <plugin>
          <artifactId>maven-jar-plugin</artifactId>
          <version>3.0.2</version>
        </plugin>
        <plugin>
          <artifactId>maven-install-plugin</artifactId>
          <version>2.5.2</version>
        </plugin>
        <plugin>
          <artifactId>maven-deploy-plugin</artifactId>
          <version>2.8.2</version>
        </plugin>
        <!-- site lifecycle, see https://maven.apache.org/ref/current/maven-core/lifecycles.html#site_Lifecycle -->
        <plugin>
          <artifactId>maven-site-plugin</artifactId>
          <version>3.7.1</version>
        </plugin>
        <plugin>
          <artifactId>maven-project-info-reports-plugin</artifactId>
          <version>3.0.0</version>
        </plugin>
      </plugins>
    </pluginManagement>
  </build>
</project>

日志工具 sfl4j + logback

<!-- 级别从高到低 OFF 、 FATAL 、 ERROR 、 WARN 、 INFO 、 DEBUG 、 TRACE 、 ALL -->
<!-- 日志输出规则 根据当前ROOT 级别，日志输出时，级别高于root默认的级别时 会输出 -->
<!-- 以下 每个配置的 filter 是过滤掉输出文件里面，会出现高级别文件，依然出现低级别的日志信息，通过filter 过滤只记录本级别的日志 -->
<!-- scan 当此属性设置为true时，配置文件如果发生改变，将会被重新加载，默认值为true。 -->
<!-- scanPeriod 设置监测配置文件是否有修改的时间间隔，如果没有给出时间单位，默认单位是毫秒。当scan为true时，此属性生效。默认的时间间隔为1分钟。 -->
<!-- debug 当此属性设置为true时，将打印出logback内部日志信息，实时查看logback运行状态。默认值为false。 -->
<configuration scan="true" scanPeriod="60 seconds" debug="false">
    <!-- 动态日志级别 -->
    <jmxConfigurator />
    <!-- 定义日志文件 输出位置 -->
    <!-- <property name="log_dir" value="C:/test" />-->
    <property name="log_dir" value="./log" />
    <!-- 日志最大的历史 30天 -->
    <property name="maxHistory" value="30" />

    <!-- ConsoleAppender 控制台输出日志 -->
    <appender name="console" class="ch.qos.logback.core.ConsoleAppender">
        <encoder>
            <pattern>
                <!-- 设置日志输出格式 -->
                %d{yyyy-MM-dd HH:mm:ss.SSS} %-5level %logger - %msg%n
            </pattern>
        </encoder>
    </appender>

    <!-- ERROR级别日志 -->
    <!-- 滚动记录文件，先将日志记录到指定文件，当符合某个条件时，将日志记录到其他文件 RollingFileAppender -->
    <appender name="ERROR" class="ch.qos.logback.core.rolling.RollingFileAppender">
        <!-- 过滤器，只记录WARN级别的日志 -->
        <!-- 果日志级别等于配置级别，过滤器会根据onMath 和 onMismatch接收或拒绝日志。 -->
        <filter class="ch.qos.logback.classic.filter.LevelFilter">
            <!-- 设置过滤级别 -->
            <level>ERROR</level>
            <!-- 用于配置符合过滤条件的操作 -->
            <onMatch>ACCEPT</onMatch>
            <!-- 用于配置不符合过滤条件的操作 -->
            <onMismatch>DENY</onMismatch>
        </filter>
        <!-- 最常用的滚动策略，它根据时间来制定滚动策略.既负责滚动也负责出发滚动 -->
        <rollingPolicy class="ch.qos.logback.core.rolling.TimeBasedRollingPolicy">
            <!--日志输出位置 可相对、和绝对路径 -->
            <fileNamePattern>
                ${log_dir}/error/%d{yyyy-MM-dd}/error-log.log
            </fileNamePattern>
            <!-- 可选节点，控制保留的归档文件的最大数量，超出数量就删除旧文件假设设置每个月滚动，且<maxHistory>是6， 则只保存最近6个月的文件，删除之前的旧文件。注意，删除旧文件是，那些为了归档而创建的目录也会被删除 -->
            <maxHistory>${maxHistory}</maxHistory>
        </rollingPolicy>
        <encoder>
            <pattern>
                <!-- 设置日志输出格式 -->
                %d{yyyy-MM-dd HH:mm:ss.SSS} %-5level %logger - %msg%n
            </pattern>
        </encoder>
    </appender>

    <!-- WARN级别日志 appender -->
    <appender name="WARN" class="ch.qos.logback.core.rolling.RollingFileAppender">
        <!-- 过滤器，只记录WARN级别的日志 -->
        <!-- 果日志级别等于配置级别，过滤器会根据onMath 和 onMismatch接收或拒绝日志。 -->
        <filter class="ch.qos.logback.classic.filter.LevelFilter">
            <!-- 设置过滤级别 -->
            <level>WARN</level>
            <!-- 用于配置符合过滤条件的操作 -->
            <onMatch>ACCEPT</onMatch>
            <!-- 用于配置不符合过滤条件的操作 -->
            <onMismatch>DENY</onMismatch>
        </filter>
        <rollingPolicy class="ch.qos.logback.core.rolling.TimeBasedRollingPolicy">
            <!--日志输出位置 可相对、和绝对路径 -->
            <fileNamePattern>${log_dir}/warn/%d{yyyy-MM-dd}/warn-log.log</fileNamePattern>
            <maxHistory>${maxHistory}</maxHistory>
        </rollingPolicy>
        <encoder>
            <pattern>%d{yyyy-MM-dd HH:mm:ss.SSS} %-5level %logger - %msg%n</pattern>
        </encoder>
    </appender>

    <!-- INFO级别日志 appender -->
    <appender name="INFO" class="ch.qos.logback.core.rolling.RollingFileAppender">
        <filter class="ch.qos.logback.classic.filter.LevelFilter">
            <level>INFO</level>
            <onMatch>ACCEPT</onMatch>
            <onMismatch>DENY</onMismatch>
        </filter>
        <rollingPolicy class="ch.qos.logback.core.rolling.TimeBasedRollingPolicy">
            <fileNamePattern>${log_dir}/info/%d{yyyy-MM-dd}/info-log.log</fileNamePattern>
            <maxHistory>${maxHistory}</maxHistory>
        </rollingPolicy>
        <encoder>
            <pattern>%d{yyyy-MM-dd HH:mm:ss.SSS} %-5level %logger - %msg%n</pattern>
        </encoder>
    </appender>

    <!-- DEBUG级别日志 appender -->
    <appender name="DEBUG" class="ch.qos.logback.core.rolling.RollingFileAppender">
        <filter class="ch.qos.logback.classic.filter.LevelFilter">
            <level>DEBUG</level>
            <onMatch>ACCEPT</onMatch>
            <onMismatch>DENY</onMismatch>
        </filter>
        <rollingPolicy class="ch.qos.logback.core.rolling.TimeBasedRollingPolicy">
            <fileNamePattern>${log_dir}/debug/%d{yyyy-MM-dd}/debug-log.log</fileNamePattern>
            <maxHistory>${maxHistory}</maxHistory>
        </rollingPolicy>
        <encoder>
            <pattern>%d{yyyy-MM-dd HH:mm:ss.SSS} %-5level %logger - %msg%n</pattern>
        </encoder>
    </appender>

    <!-- TRACE级别日志 appender -->
    <appender name="TRACE" class="ch.qos.logback.core.rolling.RollingFileAppender">
        <filter class="ch.qos.logback.classic.filter.LevelFilter">
            <level>TRACE</level>
            <onMatch>ACCEPT</onMatch>
            <onMismatch>DENY</onMismatch>
        </filter>
        <rollingPolicy class="ch.qos.logback.core.rolling.TimeBasedRollingPolicy">
            <fileNamePattern>${log_dir}/trace/%d{yyyy-MM-dd}/trace-log.log</fileNamePattern>
            <maxHistory>${maxHistory}</maxHistory>
        </rollingPolicy>
        <encoder>
            <pattern>%d{yyyy-MM-dd HH:mm:ss.SSS} %-5level %logger - %msg%n</pattern>
        </encoder>
    </appender>

    <!-- root级别 DEBUG -->
    <root>
        <!-- 打印debug级别日志及以上级别日志 -->
        <level value="debug" />
        <!-- 控制台输出 -->
        <appender-ref ref="console" />
        <!-- 文件输出 -->
        <appender-ref ref="ERROR" />
        <appender-ref ref="INFO" />
        <appender-ref ref="WARN" />
        <appender-ref ref="DEBUG" />
        <appender-ref ref="TRACE" />
    </root>
</configuration>

创建一个 XML 字符串记录学生的详细信息，并将其反序列化到学生对象中，然后再讲其序列化为 JSON 对象
org.example.pojo.Student

package org.example.pojo;

import com.fasterxml.jackson.annotation.JacksonAnnotation;
import com.fasterxml.jackson.dataformat.xml.annotation.JacksonXmlCData;
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 javax.xml.bind.annotation.XmlRootElement;
import java.util.List;

@JacksonXmlRootElement(localName = "student")
public class Student {
    private int id;
    private String name;
    private int age;
    private Classroom classroom;
    //  @JacksonXmlCData 解析 <![CDATA[ ]]>
    @JacksonXmlCData
    // @JacksonXmlProperty xml 名称
    @JacksonXmlProperty(localName = "cdata")
    private String cData;


    @JacksonXmlElementWrapper(useWrapping = false)
    private List<String> item;

    public int getId() {
        return id;
    }

    public void setId(int id) {
        this.id = id;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    public Classroom getClassroom() {
        return classroom;
    }

    public void setClassroom(Classroom classroom) {
        this.classroom = classroom;
    }

    public String getcData() {
        return cData;
    }

    public void setcData(String cData) {
        this.cData = cData;
    }

    public List<String> getItem() {
        return item;
    }

    public void setItem(List<String> item) {
        this.item = item;
    }

    @Override
    public String toString() {
        return "Student{" +
                "id=" + id +
                ", name='" + name + '\'' +
                ", age=" + age +
                ", classroom=" + classroom +
                ", cData='" + cData + '\'' +
                ", item=" + item +
                '}';
    }
}

org.example.pojo.Classroom

package org.example.pojo;

import com.fasterxml.jackson.dataformat.xml.annotation.JacksonXmlRootElement;

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


public class Classroom {
    private int id;
    private String name;
    private int grade;

    public int getId() {
        return id;
    }

    public void setId(int id) {
        this.id = id;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getGrade() {
        return grade;
    }

    public void setGrade(int grade) {
        this.grade = grade;
    }

    @Override
    public String toString() {
        return "Classroom{" +
                "id=" + id +
                ", name='" + name + '\'' +
                ", grade=" + grade +
                '}';
    }
}

org.example.App

package org.example;

import com.fasterxml.jackson.core.JsonProcessingException;
import com.fasterxml.jackson.databind.ObjectMapper;
import com.fasterxml.jackson.databind.SerializationFeature;
import com.fasterxml.jackson.databind.json.JsonMapper;
import com.fasterxml.jackson.dataformat.xml.XmlMapper;
import org.example.pojo.Student;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

import java.util.Arrays;

/**
 * Hello world!
 *
 */
public class App 
{
    private static Logger logger = LoggerFactory.getLogger(App.class);
    public static void main( String[] args )
    {
        // 创建一个 XML 字符串记录学生的详细信息，并将其反序列化到学生对象中，然后再讲其序列化为 JSON 对象
        useJacksonXMLStudent();
    }

    // 创建一个 XML 字符串记录学生的详细信息，并将其反序列化到学生对象中，然后再讲其序列化为 JSON 对象
    private static void useJacksonXMLStudent() {
        logger.info("useJacksonXMLStudent start");
        // 创建 ObjectMapper 对象，这里使用 XmlMapper 表示操作的是 xml 文件
        ObjectMapper xmlMapper = new XmlMapper();
        String xmlString = "<?xml version=\"1.0\" encoding=\"UTF-8\" standalone=\"yes\"?>" +
                "<student><cdata><![CDATA[中<a>文]]></cdata><age>22</age><classroom><grade>4</grade><id>1</id><name>软件工程</name></classroom><id>101</id><name>张三</name><item>1</item><item>2</item></student>";
        // map xml to student
        try {
            Student student = xmlMapper.readValue(xmlString, Student.class);
            System.out.println(student.getItem());
            System.out.println(student);
            xmlMapper.enable(SerializationFeature.INDENT_OUTPUT);
            xmlString = xmlMapper.writeValueAsString(student);
            System.out.println(xmlString);
        } catch (JsonProcessingException e) {
            e.printStackTrace();
        }

        logger.info("useJacksonXMLStudent end");
    }
}

输出

2020-04-18 22:03:16.476 INFO  org.example.App - useJacksonXMLStudent start
[1, 2]
Student{id=101, name='张三', age=22, classroom=Classroom{id=1, name='软件工程', grade=4}, cData='中<a>文', item=[1, 2]}
<student>
  <id>101</id>
  <name>张三</name>
  <age>22</age>
  <classroom>
    <id>1</id>
    <name>软件工程</name>
    <grade>4</grade>
  </classroom>
  <item>1</item>
  <item>2</item>
  <cdata><![CDATA[中<a>文]]></cdata>
</student>

2020-04-18 22:03:16.858 INFO  org.example.App - useJacksonXMLStudent end

源码地址：https://github.com/weijieqiu/iStudy/tree/master/studyJackson

AlterIt
关注
  • 1
    点赞
  • 踩
  • 4
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Jackson-操作XML
举世武双的博客
08-25 1万+
Jackson-操作XML 概述 Jackson是一个处理JSON的类库，不过它也通过jackson-dataformat-xml包提供了处理XML的功能。Jackson建议我们在处理XML的时候使用woodstox-core包，它是一个XML的实现，比JDK自带XML实现更加高效，也更加安全。 Jackson常用注解 1、@JacksonXmlRootElement @JacksonXmlRootElement注解有两个属性： namespace属性：用于指定XML根元素命名空间的名称。 localna
Json序列化和反序列化之jackson
sparkhuu的博客
12-17 5103
官方WIKI：https://github.com/FasterXML/jackson-databind/wiki jackson 1.x和2.x版本的注解是放置在不同的包下的 1.x是在jackson core jar包org.codehaus.jackson.annotate下 2.x是在jackson-databind包com.fasterxml.jackson.annot
利用jackson-dataformat-xml包中的XmlMapper类将xml解析成实体类对象
热门推荐
qq_27569237的博客
01-28 2万+
最近负责一个从第三方接口获取数据，并对数据封装的项目，项目中也有用到json格式数据，因此堪虑用Jackson中的jackson-dataformat-xml来解析xml，具体如下： maven引入jar包 实体类 GradeDomain public class GradeDomain { @JacksonXmlProperty(localName = &amp;quot;gradeId&amp;quot;,isAttri...
关于使用spring boot自带的jackson解析xml心得
最新发布
Phil Jing
06-10 550
JacksonXmlElementWrapper 标注在集合属性上。@JacksonXmlRootElement 标注在类上。添加如下依赖，因为需要用到jackson xml的注解。@JacksonXmlProperty 标注下属性上。项目负责版本管理的pom依赖如下声明引用。在定义share或者api的pom中。具体怎么使用网上比我写的详细。应用pom添加如下依赖。同理，xml转bean。
xml与bean，json互转
weixin_45256333的博客
03-16 815
1.导入xml与bean互转的jar包 <dependency> <groupId>com.fasterxml.jackson.dataformat</groupId> <artifactId>jackson-dataformat-xml</artifactId> <version>2.9.0</version> </dependency> 利用注解的方式进行转换 @Da
Jackson实现xml序列化和反序列化
neweastsun的专栏
08-23 1万+
Jackson实现xml序列化和反序列化 本文介绍Jackson 2.X中提供的xml序列化功能。仅介绍基本操作，不涉及复杂和自定义功能。 1. XmlMapper对象 XmlMapper是Jackson 2.x中提供我们实现xml序列化的主要类，因此首先需要创建其实例： XmlMapper mapper = new XmlMapper(); 想要maven依赖脚本为： <dependen...
java中XML格式转换
kkkkatoq的博客
12-27 1603
之前很少用xml格式，但是有些老系统还是需要使用xml格式进行对接，所以干脆总结一下，方便以后使用。关于xml:即，xml是互联网数据传输的重要工具，它可以跨越互联网任何的平台，不受编程语言和操作系统的限制，可以说它是一个拥有互联网最高级别通行证的数据携带者。xml是当前处理结构化文档信息中相当给力的技术，xml有助于在服务器之间穿梭结构化数据，这使得开发人员更加得心应手的控制数据的存储和传输。
Jackson实现json的序列化反序列化
怀揣梦想,永不止步.
11-03 568
package cn.veryjava.funny;import com.fasterxml.jackson.core.JsonProcessingException; import com.fasterxml.jackson.databind.ObjectMapper; import org.junit.Assert; import org.junit.Test;import java.io.IO
使用 Jackson 玩转 xml 的序列化和反序列化（二）【使用 流式API 操作】
01-08
昨天写了使用 Jackson 玩转 xml 的序列化和反序列化，主要使用的是 XmlMapper 对象去操作，今天打算尝试下使用流式 API 的方式去操作。公司墙很高，人总是在逆境中成长的对吧，墙高使得我不断输出，以便在公司里有...
SpringBoot2.0整合jackson配置日期格式化和反序列化的实现
08-26
最后，我们可以在Java Beans中使用jackson的注解来实现日期格式化和反序列化的功能。例如，我们可以在Java Beans中添加以下注解： @JsonFormat(shape = JsonFormat.Shape.STRING, pattern = "yyyy-MM-dd HH:mm:ss")...
jackson json序列化,反序列化所需jar包
12-08
Jackson是Java领域中广泛使用的JSON处理库，它提供了高效的JSON序列化和反序列化功能。在Java应用程序中，我们经常需要将Java对象转换为JSON字符串（序列化）或从JSON字符串恢复Java对象（反序列化），Jackson库就是...
使用fasterxml.jackson反序列化json串
01-20
本篇将详细介绍如何使用fasterxml.jackson库来反序列化JSON字符串，并解决反序列化过程中遇到的问题。 首先，我们来理解JSON和反序列化的基本概念。JSON（JavaScript Object Notation）是一种轻量级的数据交换格式...
java 常用序列化和反序列化框架使用demo
07-16
除了基础的JSON序列化，Jackson还支持`@JsonSerialize`和`@JsonDeserialize`注解来自定义序列化和反序列化行为。 ```java import com.fasterxml.jackson.databind.ObjectMapper; ObjectMapper mapper = new ...
序列化与反序列化
02-09
JSON序列化和反序列化库，如Jackson、Gson或org.json库，可能会在这个Demo中被使用。 例如，Jackson库提供了一个简单易用的API，可以通过`ObjectMapper`类实现JSON与Java对象之间的转换。要序列化一个Java对象，...
android XML文件解析和序列化 demo
09-23
Android并没有内置的XML序列化库，但可以借助第三方库如XStream或Jackson，或者手动实现序列化。手动实现通常涉及创建`toString()`方法，将对象属性转化为XML格式的字符串。 2. **Gson**: 虽然Gson主要用于JSON序列...
android XML简单序列化
06-06
掌握XML序列化和反序列化的方法，能够帮助我们更高效地处理数据，提高应用的性能和用户体验。通过实践上述案例，相信你对XML序列化有了更深入的理解。在实际项目中，可以根据需求选择适合的库或方法来实现XML操作。
Jackson序列化Xml声明
daodfs1的博客
12-18 2541
目录公共实体类最简单的序列化添加Xml声明Jackson生成xml声明源码第一步在XML声明中使用双引号创建 WstxOutputFactory 的子类创建XmlMapper对象完整代码优化 WstxOutputFactory 的子类 公共实体类 @JacksonXmlRootElement(localName = "stu") public class Stu { private String name; private String age; public String getName()
JAXB将JAVA对象转换为XML时CDATA的问题
泊川
02-16 6537
对Java对象转换为xml字符串时，如果有特殊字符如<>必须要是用<![CDATA[]]>来声明。我先尝试了使用XStream解决这个问题也有使用MOXy CDATA注解解决，最后发现，都存在一定的缺陷，甚至不能正常的实现该功能。 最终解决方案有两个，都可以解决这个问题，但是第一个方案由于引用了sun的专有API，在编译时会存在警告，使用了内部的API并不是值得推荐的。但是这里也贴出来，供大家参考。
使用jackson把java对象转成xml格式
qq_20161461的博客
12-25 5231
一、maven依赖引入 <dependency> <groupId>com.fasterxml.jackson.dataformat</groupId> <artifactId>jackson-dataformat-xml</artifactId> <version>2.12.0</version> </dependency>
java对象转xml序列化
05-17
1. 使用Java自带的XMLEncoder和XMLDecoder类进行序列化和反序列化。 示例代码： ```java import java.beans.XMLDecoder; import java.beans.XMLEncoder; import java.io.ByteArrayInputStream; import java.io....
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值