jackson学习之九：springboot整合(配置文件)

逃离我推掉我的手 2022-12-04 10:59 174阅读 0赞

### 欢迎访问我的GitHub ###

> 这里分类和汇总了欣宸的全部原创(含配套源码)：[https://github.com/zq2599/blog\_demos][https_github.com_zq2599_blog_demos]

### 系列文章汇总 ###

*  [jackson学习之一：基本信息][jackson]
 *  [jackson学习之二：jackson-core][jackson_jackson-core]
 *  [jackson学习之三：常用API操作][jackson_API]
 *  [jackson学习之四：WRAP\_ROOT\_VALUE（root对象）][jackson_WRAP_ROOT_VALUE_root]
 *  [jackson学习之五：JsonInclude注解][jackson_JsonInclude]
 *  [jackson学习之六：常用类注解][jackson 1]
 *  [jackson学习之七：常用Field注解][jackson_Field]
 *  [jackson学习之八：常用方法注解][jackson 2]
 *  [jackson学习之九：springboot整合(配置文件)][jackson_springboot]
 *  [jackson学习之十(终篇)：springboot整合(配置类)][jackson_springboot 1]

### 关于springboot整合jackson ###

*  本文是《jackson学习》系列的第九篇，学习如何在springboot项目中使用jackson，以springboot-2.3.3版本为例，jackson是springboot的默认json处理工具，如下图红框所示，jackson在maven配置中被spring-boot-starter-web间接依赖，可直接使用：  
    ![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2JvbGluZ19jYXZhbHJ5_size_16_color_FFFFFF_t_70_pic_center]
 *  在springboot项目中常用的配置方式有两种：

1.  用properties或yml配置文件来配置，即本篇的内容；
2.  用配置类来配置，这是下一篇文章的主题；

### 本篇概览 ###

今天实战内容如下：

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

### 源码下载 ###

1.  如果您不想编码，可以在GitHub下载所有源码，地址和链接信息如下表所示(https://github.com/zq2599/blog\_demos)：

<table> 
 <thead> 
  <tr> 
   <th align="left">名称</th> 
   <th align="left">链接</th> 
   <th align="left">备注</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td align="left">项目主页</td> 
   <td align="left">https://github.com/zq2599/blog_demos</td> 
   <td align="left">该项目在GitHub上的主页</td> 
  </tr> 
  <tr> 
   <td align="left">git仓库地址(https)</td> 
   <td align="left">https://github.com/zq2599/blog_demos.git</td> 
   <td align="left">该项目源码的仓库地址，https协议</td> 
  </tr> 
  <tr> 
   <td align="left">git仓库地址(ssh)</td> 
   <td align="left">git@github.com:zq2599/blog_demos.git</td> 
   <td align="left">该项目源码的仓库地址，ssh协议</td> 
  </tr> 
 </tbody> 
</table>

1.  这个git项目中有多个文件夹，本章的应用在jacksondemo文件夹下，如下图红框所示：  
    ![在这里插入图片描述][2020090516314153.png_pic_center]
2.  jacksondemo是父子结构的工程，本篇的代码在springbootproperties子工程中，如下图：  
    ![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2JvbGluZ19jYXZhbHJ5_size_16_color_FFFFFF_t_70_pic_center 1]

### 开始实战 ###

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>
    
    
        
        <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>
    
            
            <dependency>
                <groupId>io.springfox</groupId>
                <artifactId>springfox-swagger2</artifactId>
            </dependency>
            
            <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>

1.  启动类很平常：

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;
    
    @Configuration
    @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();
        }
    }

1.  序列化和反序列化用到的Bean类，可见使用了JsonProperty属性来设置序列化和反序列化时的json属性名，field0字段刻意没有get方法，是为了验证JsonProperty的序列化能力：

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;
    
    @RestController
    @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注解已经生效：  
    ![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2JvbGluZ19jYXZhbHJ5_size_16_color_FFFFFF_t_70_pic_center 2]
3.  点击上图的红框2，看看springboot引用返回的序列化结果，如下图：  
    ![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2JvbGluZ19jYXZhbHJ5_size_16_color_FFFFFF_t_70_pic_center 3]
4.  另外，上述红框中的json格式，每个属性单独一行，像是做了格式化调整的，这是springboot做的？还是swagger展示的时候做的？用浏览器访问http://localhost:8080/jsonproperty/serialization ，结果如下，可见springboot返回的是未经过格式化的json：  
    ![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2JvbGluZ19jYXZhbHJ5_size_16_color_FFFFFF_t_70_pic_center 4]

*  接下来咱们添加jackson相关的配置信息并验证是否生效；

### 添加配置文件并验证 ###

1.  在resources目录新增application.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代码，如下图：  
    ![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2JvbGluZ19jYXZhbHJ5_size_16_color_FFFFFF_t_70_pic_center 5]
2.  在上图中，按住Ctlr键，用鼠标点击红框位置即可打开此配置对应的jackson源码，如下图：  
    ![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2JvbGluZ19jYXZhbHJ5_size_16_color_FFFFFF_t_70_pic_center 6]
3.  重新运行springboot应用，用浏览器访问：http://localhost:8080/jsonproperty/serialization ，结果如下图，可见json\_field0的格式变成了yyyy-MM-dd HH:mm:ss，而且json输出也做了格式化，证明application.yml中的配置已经生效：  
    ![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2JvbGluZ19jYXZhbHJ5_size_16_color_FFFFFF_t_70_pic_center 7]
4.  再来试试反序列化，打开swagger页面，操作和响应如下图所示，注意红框1里面请求参数的格式：  
    ![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2JvbGluZ19jYXZhbHJ5_size_16_color_FFFFFF_t_70_pic_center 8]

*  至此，在springboot中通过yml配置jackson的操作实战就完成了，接下来的章节，咱们在配置类中用代码来完成yml的配置；

### 欢迎关注公众号：程序员欣宸 ###

> 微信搜索「程序员欣宸」，我是欣宸，期待与您一同畅游Java世界…

[https_github.com_zq2599_blog_demos]: https://github.com/zq2599/blog_demos
[jackson]: https://blog.csdn.net/boling_cavalry/article/details/107135958
[jackson_jackson-core]: https://blog.csdn.net/boling_cavalry/article/details/108571629
[jackson_API]: https://blog.csdn.net/boling_cavalry/article/details/108192174
[jackson_WRAP_ROOT_VALUE_root]: https://blog.csdn.net/boling_cavalry/article/details/108298858
[jackson_JsonInclude]: https://blog.csdn.net/boling_cavalry/article/details/108412558
[jackson 1]: https://blog.csdn.net/boling_cavalry/article/details/108333324
[jackson_Field]: https://blog.csdn.net/boling_cavalry/article/details/108589494
[jackson 2]: https://blog.csdn.net/boling_cavalry/article/details/108433330
[jackson_springboot]: https://blog.csdn.net/boling_cavalry/article/details/108460433
[jackson_springboot 1]: https://blog.csdn.net/boling_cavalry/article/details/108559056
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2JvbGluZ19jYXZhbHJ5_size_16_color_FFFFFF_t_70_pic_center]: /images/20221123/089d652fc5c5407cac1a065f57c66023.png
[2020090516314153.png_pic_center]: /images/20221123/d384262920d54331b4e701936932c009.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2JvbGluZ19jYXZhbHJ5_size_16_color_FFFFFF_t_70_pic_center 1]: /images/20221123/092fda7582e1474dacb2f831be1fc7dd.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2JvbGluZ19jYXZhbHJ5_size_16_color_FFFFFF_t_70_pic_center 2]: /images/20221123/4e9df4e2065545bbaf40e3b67cb58586.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2JvbGluZ19jYXZhbHJ5_size_16_color_FFFFFF_t_70_pic_center 3]: /images/20221123/e445df4937034765b32f48e5b52c38c7.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2JvbGluZ19jYXZhbHJ5_size_16_color_FFFFFF_t_70_pic_center 4]: /images/20221123/79cc047946624f1a96681cdef834ce89.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2JvbGluZ19jYXZhbHJ5_size_16_color_FFFFFF_t_70_pic_center 5]: /images/20221123/de9045736b334a34b82dc8a94f448c6b.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2JvbGluZ19jYXZhbHJ5_size_16_color_FFFFFF_t_70_pic_center 6]: /images/20221123/cc4e2e7215b2464885f0b2e826b07c34.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2JvbGluZ19jYXZhbHJ5_size_16_color_FFFFFF_t_70_pic_center 7]: /images/20221123/c176cea9d5874b5080da8d8eae5c6d88.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2JvbGluZ19jYXZhbHJ5_size_16_color_FFFFFF_t_70_pic_center 8]: /images/20221123/c2eb698d033b495fa46a5c9c4383ce18.png