jackson的使用

1、jackson能做什么？

Jackson 被称为 "Java JSON 库 "或 "Java 的最佳 JSON 解析器"。不仅如此，Jackson 还是一套适用于 Java（和 JVM 平台）的数据处理工具，除了能处理json格式数据以外，还能处理csv、xml、（java）properties等格式数据。

2、使用方法

核心类：ObjectMapper,XmlMapper、JavaPropsMapper都继承该类。
read开头系列方法：反序列化
write开头系列方法：序列化
官方文档：https://www.javadoc.io/doc/com.fasterxml.jackson.core/jackson-databind/latest/index.html

处理json数据

maven中加入依赖

<?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>maven_demo</artifactId>
    <version>1.0-SNAPSHOT</version>

    <properties>
        <maven.compiler.source>8</maven.compiler.source>
        <maven.compiler.target>8</maven.compiler.target>
        <jackson.version>2.13.3</jackson.version>
    </properties>
    <dependencies>
    <!--<dependency>
        <groupId>com.fasterxml.jackson.core</groupId>
        <artifactId>jackson-annotations</artifactId>
        <version>${jackson.version}</version>
    </dependency>
    <dependency>
        <groupId>com.fasterxml.jackson.core</groupId>
        <artifactId>jackson-core</artifactId>
        <version>${jackson.version}</version>
    </dependency>-->
        <!--处理json-->
        <dependency>
            <groupId>com.fasterxml.jackson.core</groupId>
            <artifactId>jackson-databind</artifactId>
            <version>${jackson.version}</version>
        </dependency>
        <!--处理xml-->
        <dependency>
            <groupId>com.fasterxml.jackson.dataformat</groupId>
            <artifactId>jackson-dataformat-xml</artifactId>
            <version>${jackson.version}</version>
        </dependency>
        <!--处理properties-->
        <dependency>
            <groupId>com.fasterxml.jackson.dataformat</groupId>
            <artifactId>jackson-dataformat-properties</artifactId>
            <version>${jackson.version}</version>
        </dependency>
        <dependency>
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>
            <version>RELEASE</version>
            <scope>compile</scope>
        </dependency>
    </dependencies>
</project>

序列化

import com.fasterxml.jackson.annotation.JsonInclude;
import com.fasterxml.jackson.core.JsonProcessingException;
import com.fasterxml.jackson.core.type.TypeReference;
import com.fasterxml.jackson.databind.DeserializationFeature;
import com.fasterxml.jackson.databind.ObjectMapper;
import com.fasterxml.jackson.databind.type.CollectionType;
import org.junit.Test;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

public class Test1 {
    static ObjectMapper objectMapper = new ObjectMapper();
    static {
        // 序列化时空值属性不序列化
        objectMapper.setSerializationInclusion(JsonInclude.Include.NON_EMPTY);
        // jackson在反序列化时默认如果遇到未知属性（没有映射到属性并且没有setter或者handler来处理它）时会报错，可以通过以下配置解决
        objectMapper.configure(DeserializationFeature.FAIL_ON_UNKNOWN_PROPERTIES,false);
    }
    @Test
    public void test1() throws JsonProcessingException {
        MyBean myBean = new MyBean();
        myBean.setId(1);
        myBean.setName("My name");
        // bean
        String s = objectMapper.writeValueAsString(myBean);
        System.out.println(s);
        List<MyBean> list = new ArrayList<>();
        list.add(myBean);
        // list
        String s1 = objectMapper.writeValueAsString(list);
        System.out.println(s1);
        // map
        Map<String,Object> map = new HashMap<>();
        map.put("id",2);
        map.put("name","your name");
        String s2 = objectMapper.writeValueAsString(map);
        System.out.println(s2);
    }
}

class MyBean {
    public Integer id;
    public String name;

    public Integer getId() {
        return id;
    }

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

    public String getName() {
        return name;
    }

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

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

反序列化

import com.fasterxml.jackson.annotation.JsonInclude;
import com.fasterxml.jackson.core.JsonProcessingException;
import com.fasterxml.jackson.core.type.TypeReference;
import com.fasterxml.jackson.databind.DeserializationFeature;
import com.fasterxml.jackson.databind.ObjectMapper;
import com.fasterxml.jackson.databind.type.CollectionType;
import org.junit.Test;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

public class Test1 {
    static ObjectMapper objectMapper = new ObjectMapper();
    static {
        // 序列化时空值属性不序列化
        objectMapper.setSerializationInclusion(JsonInclude.Include.NON_EMPTY);
        // jackson在反序列化时默认如果遇到未知属性（没有映射到属性并且没有setter或者handler来处理它）时会报错，可以通过以下配置解决
        objectMapper.configure(DeserializationFeature.FAIL_ON_UNKNOWN_PROPERTIES,false);
    }
    @Test
    public void test2() throws JsonProcessingException {
        String jsonStr = "{\"id\":1,\"name\":\"My name\"}";

        MyBean myBean = objectMapper.readValue(jsonStr, MyBean.class);
        System.out.println(myBean);
        String jsonStr1 = "[{\"id\":1,\"name\":\"My name\"}]";
        // 指定返回class为List.class的话，list中的类型是map类型
        List list = objectMapper.readValue(jsonStr1, List.class);
        System.out.println(list);
        // 使用TypeReference指定反序列化后的类型
        List<MyBean> list1 = objectMapper.readValue(jsonStr1, new TypeReference<List<MyBean>>() {});
        System.out.println(list1.get(0));

        // 使用TypeFactory构建反序列化后的类型
        CollectionType collectionType = objectMapper.getTypeFactory().constructCollectionType(List.class, MyBean.class);
        List<MyBean> list2 = objectMapper.readValue(jsonStr1, collectionType);
        System.out.println(list2.get(0));

    }
}

class MyBean {
    public Integer id;
    public String name;

    public Integer getId() {
        return id;
    }

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

    public String getName() {
        return name;
    }

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

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

处理xml数据

序列化

import com.ctc.wstx.api.WstxOutputProperties;
import com.fasterxml.jackson.dataformat.xml.annotation.JacksonXmlRootElement;
import com.fasterxml.jackson.core.JsonProcessingException;
import com.fasterxml.jackson.dataformat.xml.XmlMapper;
import com.fasterxml.jackson.dataformat.xml.annotation.JacksonXmlCData;
import com.fasterxml.jackson.dataformat.xml.ser.ToXmlGenerator;
import org.junit.Test;
import java.util.ArrayList;
import java.util.List;
import javax.xml.stream.XMLOutputFactory;
import com.fasterxml.jackson.dataformat.xml.XmlFactory;

public class JacksonXmlTest {

    static XmlMapper xmlMapper = null;

    static {
        xmlMapper = new XmlMapper();
        XmlFactory factory = xmlMapper.getFactory();
        XMLOutputFactory xmlOutputFactory = factory.getXMLOutputFactory();
        // 报文头中使用双引号<?xml version="1.0" encoding="UTF-8"?>，不设置该项，默认是单引号<?xml version='1.0' encoding='UTF-8'?>
        xmlOutputFactory.setProperty(WstxOutputProperties.P_USE_DOUBLE_QUOTES_IN_XML_DECL, true);
        // xml报文头
        xmlMapper.enable(ToXmlGenerator.Feature.WRITE_XML_1_1);
    }

    @Test
    public void test1() throws JsonProcessingException {

        MyXmlBean myXmlBean = generateMyXmlBean();
        String xml = xmlMapper.writerWithDefaultPrettyPrinter().writeValueAsString(myXmlBean);
        System.out.println(xml);
    }

    private MyXmlBean generateMyXmlBean() {
        MyXmlBean myXmlBean = new MyXmlBean();
        myXmlBean.setRemark("&<@$#==!!!>------");
        myXmlBean.setCode(1);
        myXmlBean.setMessage("success");
        XmlData xmlData = new XmlData();
        xmlData.setCode("1");
        xmlData.setId("1");
        xmlData.setName("my name");
        XmlData xmlData1 = new XmlData();
        xmlData1.setCode("2");
        xmlData1.setId("2");
        xmlData1.setName("your name");
        List<XmlData> list = new ArrayList<>();
        list.add(xmlData);
        list.add(xmlData1);
        myXmlBean.setDataList(list);
        return myXmlBean;
    }
}

//不使用这个注解的话，生成的xml根节点名与类名一致（MyXmlBean）
@JacksonXmlRootElement(localName = "myXmlBean")
class MyXmlBean{

    private int code;

    private String message;

    // 有特殊字符时可以用这个注解
    @JacksonXmlCData
    private String remark;

    private List<XmlData> dataList;

    public int getCode() {
        return code;
    }

    public void setCode(int code) {
        this.code = code;
    }

    public String getMessage() {
        return message;
    }

    public void setMessage(String message) {
        this.message = message;
    }

    public List<XmlData> getDataList() {
        return dataList;
    }

    public void setDataList(List<XmlData> dataList) {
        this.dataList = dataList;
    }

    public String getRemark() {
        return remark;
    }

    public void setRemark(String remark) {
        this.remark = remark;
    }
}

class XmlData{
    private String id;

    private String code;

    private String name;

    public String getId() {
        return id;
    }

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

    public String getCode() {
        return code;
    }

    public void setCode(String code) {
        this.code = code;
    }

    public String getName() {
        return name;
    }

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

以上用法输出的xml为：

<?xml version='1.1' encoding='UTF-8'?>
<myXmlBean>
  <code>1</code>
  <message>success</message>
  <remark><![CDATA[&<@$#==!!!>------]]></remark>
  <dataList>
    <dataList>
      <id>1</id>
      <code>1</code>
      <name>my name</name>
    </dataList>
    <dataList>
      <id>2</id>
      <code>2</code>
      <name>your name</name>
    </dataList>
  </dataList>
</myXmlBean>

xml中dataList节点不是想要的结果，使用注解JacksonXmlElementWrapper、JacksonXmlProperty对节点名改进：

import com.ctc.wstx.api.WstxOutputProperties;
import com.fasterxml.jackson.dataformat.xml.annotation.JacksonXmlRootElement;
import com.fasterxml.jackson.core.JsonProcessingException;
import com.fasterxml.jackson.dataformat.xml.XmlMapper;
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.ser.ToXmlGenerator;
import org.junit.Test;
import java.util.ArrayList;
import java.util.List;
import javax.xml.stream.XMLOutputFactory;
import com.fasterxml.jackson.dataformat.xml.XmlFactory;

public class JacksonXmlTest {

    static XmlMapper xmlMapper = null;

    static {
        xmlMapper = new XmlMapper();
        XmlFactory factory = xmlMapper.getFactory();
        XMLOutputFactory xmlOutputFactory = factory.getXMLOutputFactory();
        // 报文头中使用双引号<?xml version="1.0" encoding="UTF-8"?>，不设置该项，默认是单引号<?xml version='1.0' encoding='UTF-8'?>
        xmlOutputFactory.setProperty(WstxOutputProperties.P_USE_DOUBLE_QUOTES_IN_XML_DECL, true);
        // xml报文头
        xmlMapper.enable(ToXmlGenerator.Feature.WRITE_XML_1_1);
    }

    @Test
    public void test1() throws JsonProcessingException {

        MyXmlBean myXmlBean = generateMyXmlBean();
        String xml = xmlMapper.writerWithDefaultPrettyPrinter().writeValueAsString(myXmlBean);
        System.out.println(xml);
    }

    private MyXmlBean generateMyXmlBean() {
        MyXmlBean myXmlBean = new MyXmlBean();
        myXmlBean.setRemark("&<@$#==!!!>------");
        myXmlBean.setCode(1);
        myXmlBean.setMessage("success");
        XmlData xmlData = new XmlData();
        xmlData.setCode("1");
        xmlData.setId("1");
        xmlData.setName("my name");
        XmlData xmlData1 = new XmlData();
        xmlData1.setCode("2");
        xmlData1.setId("2");
        xmlData1.setName("your name");
        List<XmlData> list = new ArrayList<>();
        list.add(xmlData);
        list.add(xmlData1);
        myXmlBean.setDataList(list);
        return myXmlBean;
    }
}

//不使用这个注解的话，生成的xml根节点名与类名一致（MyXmlBean）
@JacksonXmlRootElement("myXmlBean")
class MyXmlBean{

    private int code;

    private String message;

    // 有特殊字符时可以用这个注解
    @JacksonXmlCData
    private String remark;

    @JacksonXmlElementWrapper(localName = "list")
    @JacksonXmlProperty(localName = "data")
    private List<XmlData> dataList;

    public int getCode() {
        return code;
    }

    public void setCode(int code) {
        this.code = code;
    }

    public String getMessage() {
        return message;
    }

    public void setMessage(String message) {
        this.message = message;
    }

    public List<XmlData> getDataList() {
        return dataList;
    }

    public void setDataList(List<XmlData> dataList) {
        this.dataList = dataList;
    }

    public String getRemark() {
        return remark;
    }

    public void setRemark(String remark) {
        this.remark = remark;
    }
}

class XmlData{
    private String id;

    private String code;

    private String name;

    public String getId() {
        return id;
    }

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

    public String getCode() {
        return code;
    }

    public void setCode(String code) {
        this.code = code;
    }

    public String getName() {
        return name;
    }

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

改后输出xml：

<?xml version='1.1' encoding='UTF-8'?>
<myXmlBean>
  <code>1</code>
  <message>success</message>
  <remark><![CDATA[&<@$#==!!!>------]]></remark>
  <list>
    <data>
      <id>1</id>
      <code>1</code>
      <name>my name</name>
    </data>
    <data>
      <id>2</id>
      <code>2</code>
      <name>your name</name>
    </data>
  </list>
</myXmlBean>

反序列化

import com.ctc.wstx.api.WstxOutputProperties;
import com.fasterxml.jackson.annotation.JsonRootName;
import com.fasterxml.jackson.core.JsonProcessingException;
import com.fasterxml.jackson.dataformat.xml.XmlMapper;
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.ser.ToXmlGenerator;
import org.junit.Test;
import java.util.ArrayList;
import java.util.List;
import javax.xml.stream.XMLOutputFactory;
import com.fasterxml.jackson.dataformat.xml.XmlFactory;

public class JacksonXmlTest {

    static XmlMapper xmlMapper = null;

    static {
        xmlMapper = new XmlMapper();
        XmlFactory factory = xmlMapper.getFactory();
        XMLOutputFactory xmlOutputFactory = factory.getXMLOutputFactory();
        // xml报文头
        xmlMapper.enable(ToXmlGenerator.Feature.WRITE_XML_1_1);
    }

    @Test
    public void test2() throws JsonProcessingException {
        String xml = "<?xml version='1.1' encoding='UTF-8'?>\n" +
                "<myXmlBean>\n" +
                "  <code>1</code>\n" +
                "  <remark><![CDATA[&<@$#==!!!>------]]></remark>\n" +
                "  <msg>success</msg>\n" +
                "  <list>\n" +
                "    <data>\n" +
                "      <id>1</id>\n" +
                "      <code>1</code>\n" +
                "      <name>my name</name>\n" +
                "    </data>\n" +
                "    <data>\n" +
                "      <id>2</id>\n" +
                "      <code>2</code>\n" +
                "      <name>your name</name>\n" +
                "    </data>\n" +
                "  </list>\n" +
                "</myXmlBean>";
        MyXmlBean myXmlBean = xmlMapper.readValue(xml, MyXmlBean.class);
        System.out.println(myXmlBean);
    }
}

//不使用这个注解的话，生成的xml根节点名与类名一致（MyXmlBean）
@JsonRootName("myXmlBean")
class MyXmlBean{

    private int code;

    @JacksonXmlProperty(localName = "msg")
    private String message;

    // 有特殊字符时可以用这个注解
    @JacksonXmlCData
    private String remark;

    @JacksonXmlElementWrapper(localName = "list")
    @JacksonXmlProperty(localName = "data")
    private List<XmlData> dataList;

    public int getCode() {
        return code;
    }

    public void setCode(int code) {
        this.code = code;
    }

    public String getMessage() {
        return message;
    }

    public void setMessage(String message) {
        this.message = message;
    }

    public List<XmlData> getDataList() {
        return dataList;
    }

    public void setDataList(List<XmlData> dataList) {
        this.dataList = dataList;
    }

    public String getRemark() {
        return remark;
    }

    public void setRemark(String remark) {
        this.remark = remark;
    }

    @Override
    public String toString() {
        return "MyXmlBean{" +
                "code=" + code +
                ", message='" + message + '\'' +
                ", remark='" + remark + '\'' +
                ", dataList=" + dataList +
                '}';
    }
}

class XmlData{
    private String id;

    private String code;

    private String name;

    public String getId() {
        return id;
    }

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

    public String getCode() {
        return code;
    }

    public void setCode(String code) {
        this.code = code;
    }

    public String getName() {
        return name;
    }

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

处理properties

import com.fasterxml.jackson.core.JsonProcessingException;
import com.fasterxml.jackson.dataformat.javaprop.JavaPropsMapper;
import org.junit.Test;

public class JacksonPropertyTest {
    static JavaPropsMapper mapper = null;
    static {
        mapper = new JavaPropsMapper();
    }

    @Test
    public void test1() throws JsonProcessingException {
        MyPropsBean myPropsBean = new MyPropsBean();
        myPropsBean.setUserName("root");
        myPropsBean.setPassword("root");
        myPropsBean.setUrl("jdbc:mysql://127.0.0.1:3306/mysql?characterEncoding=utf-8");
        String s = mapper.writeValueAsString(myPropsBean);
        System.out.println(s);
    }
    @Test
    public void test2() throws JsonProcessingException {
        String props = "userName=root\n" +
                "password=root\n" +
                "url=jdbc:mysql://127.0.0.1:3306/mysql?characterEncoding=utf-8";
        MyPropsBean myPropsBean = mapper.readValue(props, MyPropsBean.class);
        System.out.println(myPropsBean);
    }


}

class MyPropsBean{
    private String userName;

    private String password;

    private String url;

    public String getUserName() {
        return userName;
    }

    public void setUserName(String userName) {
        this.userName = userName;
    }

    public String getPassword() {
        return password;
    }

    public void setPassword(String password) {
        this.password = password;
    }

    public String getUrl() {
        return url;
    }

    public void setUrl(String url) {
        this.url = url;
    }

    @Override
    public String toString() {
        return "MyPropsBean{" +
                "userName='" + userName + '\'' +
                ", password='" + password + '\'' +
                ", url='" + url + '\'' +
                '}';
    }
}

posted @ 2023-08-27 11:18 EPIHPANY 阅读(130) 评论(0) 编辑收藏举报

刷新页面返回顶部

登录后才能查看或发表评论，立即登录或者逛逛博客园首页

相关博文：

· jackson处理标签中带属性的xml

· spring boot中使用quartz

· 高效的JSON和Java对象转换类库Jackson

· 放弃FastJson！一篇就够，Jackson的功能原来如此之牛（万字干货）

· Jackson注解大全(上)

公告

昵称： EPIHPANY
园龄： 4年9个月
粉丝： 0
关注： 4

+加关注

2025年3月

日

一

二

三

四

五

六

jackson的使用

1、jackson能做什么？

2、使用方法

公告

搜索

常用链接

我的标签

随笔分类

随笔档案

阅读排行榜