#yyds干货盘点#jackson学习之九：springboot整合(配置文件)

Posted 程序员欣宸

tags:

篇首语：本文由小常识网(cha138.com)小编为大家整理，主要介绍了#yyds干货盘点#jackson学习之九：springboot整合(配置文件)相关的知识，希望对你有一定的参考价值。

欢迎访问我的GitHub

关于springboot整合jackson

  • 本文是《jackson学习》系列的第九篇，学习如何在springboot项目中使用jackson，以springboot-2.3.3版本为例，jackson是springboot的默认json处理工具，如下图红框所示，jackson在maven配置中被spring-boot-starter-web间接依赖，可直接使用：
  • 在springboot项目中常用的配置方式有两种：
    1. 用properties或yml配置文件来配置，即本篇的内容；
    2. 用配置类来配置，这是下一篇文章的主题；

      本篇概览

      今天实战内容如下：

    3. 开发springboot应用，体验springboot默认支持jackson，包括jackson注解和ObjectMapper实例的注入；
    4. 在==application.yml==中添加jackson配置，验证是否生效；

      源码下载

    5. 如果您不想编码，可以在GitHub下载所有源码，地址和链接信息如下表所示(https://github.com/zq2599/blog_demos)：
名称 链接 备注
项目主页 https://github.com/zq2599/blog_demos 该项目在GitHub上的主页
git仓库地址(https) https://github.com/zq2599/blog_demos.git 该项目源码的仓库地址，https协议
git仓库地址(ssh) git@github.com:zq2599/blog_demos.git 该项目源码的仓库地址，ssh协议

  1. 这个git项目中有多个文件夹，本章的应用在==jacksondemo==文件夹下，如下图红框所示：

  2. ==jacksondemo==是父子结构的工程，本篇的代码在==springbootproperties==子工程中，如下图：

开始实战

  1. 由于同属于《jackson学习》系列文章，因此本篇的springboot工程作为==jacksondemo==的子工程存在，pom.xml如下，需要注意的是parent不能使用spring-boot-starter-parent，而是通过dependencyManagement节点来引入springboot依赖：

    
<?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 https://maven.apache.org/xsd/maven-4.0.0.xsd">
<modelVersion>4.0.0</modelVersion>
<parent>
    <artifactId>jacksondemo</artifactId>
    <groupId>com.bolingcavalry</groupId>
    <version>1.0-SNAPSHOT</version>
    <relativePath>../pom.xml</relativePath>
</parent>
<groupId>com.bolingcavalry</groupId>
<artifactId>springbootproperties</artifactId>
<version>0.0.1-SNAPSHOT</version>
<name>springbootproperties</name>
<description>Demo project for Spring Boot</description>

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

<!--不用spring-boot-starter-parent作为parent时的配置-->
<dependencyManagement>
    <dependencies>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-dependencies</artifactId>
            <version>2.3.3.RELEASE</version>
            <type>pom</type>
            <scope>import</scope>
        </dependency>
    </dependencies>
</dependencyManagement>

<dependencies>
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-web</artifactId>
    </dependency>

    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-test</artifactId>
        <scope>test</scope>
        <exclusions>
            <exclusion>
                <groupId>org.junit.vintage</groupId>
                <artifactId>junit-vintage-engine</artifactId>
            </exclusion>
        </exclusions>
    </dependency>

    <!-- swagger依赖 -->
    <dependency>
        <groupId>io.springfox</groupId>
        <artifactId>springfox-swagger2</artifactId>
    </dependency>
    <!-- swagger-ui -->
    <dependency>
        <groupId>io.springfox</groupId>
        <artifactId>springfox-swagger-ui</artifactId>
    </dependency>
</dependencies>

<build>
    <plugins>
        <plugin>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-maven-plugin</artifactId>
        </plugin>
    </plugins>
</build>

</project>

2. 启动类很平常：
```java
package com.bolingcavalry.springbootproperties;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;

@SpringBootApplication
public class SpringbootpropertiesApplication 

    public static void main(String[] args) 
        SpringApplication.run(SpringbootpropertiesApplication.class, args);
  1. 由于用到了swagger，因此要添加swagger配置： 
    
package com.bolingcavalry.springbootproperties;

import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import springfox.documentation.builders.ApiInfoBuilder;
import springfox.documentation.builders.PathSelectors;
import springfox.documentation.builders.RequestHandlerSelectors;
import springfox.documentation.service.ApiInfo;
import springfox.documentation.service.Contact;
import springfox.documentation.service.Tag;
import springfox.documentation.spi.DocumentationType;
import springfox.documentation.spring.web.plugins.Docket;
import springfox.documentation.swagger2.annotations.EnableSwagger2;

@Configurationbr/>@EnableSwagger2
public class SwaggerConfig 

@Bean
public Docket createRestApi() 
    return new Docket(DocumentationType.SWAGGER_2)
            .apiInfo(apiInfo())
            .tags(new Tag("JsonPropertySerializationController", "JsonProperty相关测试"))
            .select()
            // 当前包路径
            .apis(RequestHandlerSelectors.basePackage("com.bolingcavalry.springbootproperties.controller"))
            .paths(PathSelectors.any())
            .build();


//构建 api文档的详细信息函数,注意这里的注解引用的是哪个
private ApiInfo apiInfo() 
    return new ApiInfoBuilder()
            //页面标题
            .title("SpringBoot整合Jackson(基于配置文件)")
            //创建人
            .contact(new Contact("程序员欣宸", "https://github.com/zq2599/blog_demos", "zq2599@gmail.com"))
            //版本号
            .version("1.0")
            //描述
            .description("API 描述")
            .build();


4. 序列化和反序列化用到的Bean类，可见使用了==JsonProperty==属性来设置序列化和反序列化时的json属性名，field0字段刻意没有get方法，是为了验证JsonProperty的序列化能力：
```java
package com.bolingcavalry.springbootproperties.bean;

import com.fasterxml.jackson.annotation.JsonProperty;
import io.swagger.annotations.ApiModel;
import io.swagger.annotations.ApiModelProperty;

import java.util.Date;

@ApiModel(description = "JsonProperty注解测试类")
public class Test 

    @ApiModelProperty(value = "私有成员变量")
    @JsonProperty(value = "json_field0", index = 1)
    private Date field0 = new Date();

    public void setField0(Date field0) 
        this.field0 = field0;
    

    @ApiModelProperty(value = "来自get方法的字符串")
    @JsonProperty(value = "json_field1", index = 0)
    public String getField1() 
        return "111";
    

    @Override
    public String toString() 
        return "Test" +
                "field0=" + field0 +
                ;
  1. 测试用的Controller代码如下，很简单只有两个接口，serialization返回序列化结果，deserialization接受客户端请求参数，反序列化成实例，通过toString()来检查反序列化的结果，另外，还通过Autowired注解从spring容器中将ObjectMapper实例直接拿来用： 
    
package com.bolingcavalry.springbootproperties.controller;

import com.bolingcavalry.springbootproperties.bean.Test;
import com.fasterxml.jackson.core.JsonProcessingException;
import com.fasterxml.jackson.databind.ObjectMapper;
import io.swagger.annotations.Api;
import io.swagger.annotations.ApiOperation;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.RequestBody;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestMethod;
import org.springframework.web.bind.annotation.RestController;

@RestControllerbr/>@RequestMapping("/jsonproperty")
@Api(tags = "JsonPropertySerializationController")
public class JsonPropertySerializationController 

private static final Logger logger = LoggerFactory.getLogger(JsonPropertySerializationController.class);

@Autowired
ObjectMapper mapper;

@ApiOperation(value = "测试序列化", notes = "测试序列化")
@RequestMapping(value = "/serialization", method = RequestMethod.GET)
public Test serialization() throws JsonProcessingException 

    Test test = new Test();
    logger.info(mapper.writeValueAsString(test));

    return test;


@ApiOperation(value = "测试反序列化", notes="测试反序列化")
@RequestMapping(value = "/deserialization",method = RequestMethod.PUT)
public String deserialization(@RequestBody Test test) 
    return test.toString();


### 验证(不用配置文件)
1. 先来看看没有配置文件时，默认的jackson配置的表现，直接在IDEA上运行SpringbootpropertiesApplication；
2. 浏览器访问http://localhost:8080/swagger-ui.html ，如下图红框1，json_field0和json_field1都是JsonProperty注释，出现在了swagger的model中，这证明jackson注解已经生效：
![在这里插入图片描述](https://s4.51cto.com/images/blog/202202/11221517_62066f75da96c71855.jpg?x-oss-process=image/watermark,size_14,text_QDUxQ1RP5Y2a5a6i,color_FFFFFF,t_100,g_se,x_10,y_10,shadow_20,type_ZmFuZ3poZW5naGVpdGk=)

3. 点击上图的红框2，看看springboot引用返回的序列化结果，如下图：
![在这里插入图片描述](https://s4.51cto.com/images/blog/202202/11221517_62066f75f045e40238.jpg?x-oss-process=image/watermark,size_14,text_QDUxQ1RP5Y2a5a6i,color_FFFFFF,t_100,g_se,x_10,y_10,shadow_20,type_ZmFuZ3poZW5naGVpdGk=)

4. 另外，上述红框中的json格式，每个属性单独一行，像是做了格式化调整的，这是springboot做的？还是swagger展示的时候做的？用浏览器访问http://localhost:8080/jsonproperty/serialization ，结果如下，可见==springboot返回的是未经过格式化的json==：
![在这里插入图片描述](https://s4.51cto.com/images/blog/202202/11221518_62066f7609b2012032.jpg?x-oss-process=image/watermark,size_14,text_QDUxQ1RP5Y2a5a6i,color_FFFFFF,t_100,g_se,x_10,y_10,shadow_20,type_ZmFuZ3poZW5naGVpdGk=)
- 接下来咱们添加jackson相关的配置信息并验证是否生效；
### 添加配置文件并验证
1. 在==resources==目录新增==application.yml==文件，内容如下：
```yml
spring:
  jackson:
    # 日期格式化
    date-format: yyyy-MM-dd HH:mm:ss
    # 序列化相关
    serialization:
      # 格式化输出
      indent_output: true
      # 忽略无法转换的对象
      fail_on_empty_beans: true
    # 反序列化相关
    deserialization:
      # 解析json时，遇到不存在的属性就忽略
      fail_on_unknown_properties: false
    # 设置空如何序列化
    defaultPropertyInclusion: NON_EMPTY
    parser:
      # 允许特殊和转义符
      allow_unquoted_control_chars: true
      # 允许单引号
      allow_single_quotes: true

  1. 将鼠标放置下图红框位置，再按住Ctlr键，IDEA会弹出一个浮层，提示该配置对应的jackson代码，如下图：

  2. 在上图中，按住Ctlr键，用鼠标点击红框位置即可打开此配置对应的jackson源码，如下图：
  3. 重新运行springboot应用，用浏览器访问：http://localhost:8080/jsonproperty/serialization ，结果如下图，可见==json_field0==的格式变成了==yyyy-MM-dd HH:mm:ss==，而且json输出也做了格式化，证明application.yml中的配置已经生效：
  4. 再来试试反序列化，打开swagger页面，操作和响应如下图所示，注意红框1里面请求参数的格式：
    • 至此，在springboot中通过yml配置jackson的操作实战就完成了，接下来的章节，咱们在配置类中用代码来完成yml的配置；

欢迎关注51CTO博客：程序员欣宸

以上是关于#yyds干货盘点#jackson学习之九：springboot整合(配置文件)的主要内容，如果未能解决你的问题，请参考以下文章

#yyds干货盘点#jackson学习之七：常用Field注解

#yyds干货盘点#jackson学习之五：JsonInclude注解

#yyds干货盘点# 滚雪球学 Python 之怎么玩转时间和日期库

#yyds干货盘点#JUnit5学习之二：Assumptions类

#yyds干货盘点# react笔记之学习之完成删除功能

#yyds干货盘点#JUnit5学习之八：综合进阶（终篇）