59、SpringBoot 自定义JSON的序列化器和反序列化器

Serialization(序列化)： 将java对象以一连串的字节码保存在磁盘文件中的过程，也可以说是保存java对象状态的过程。序列化可以将数据永久保存在磁盘上(通常保存在文件中)。

deserialization(反序列化)： 将保存在磁盘文件中的java字节码重新转换成java对象称为反序列化。

★ 自定义JSON的序列化器和反序列化器

▲ 注册自定义序列化器和反序列化器有两种方式：

- 方式1：利用Jackson的模块机制来注册自定义序列化器和反序列化器。

- 方式2：利用Spring Boot提供的@JsonComponent来注册自定义序列化器和反序列化器。

第一种方式是Jackson原生的注册方式，一般不推荐。推荐使用第二种方式。

★ 使用@JsonComponent注册序列化器或反序列化器

Spring Boot提供了@JsonComponent注解来注册自定义自定义序列化器和反序列化器，
该注解有两种使用方式：

-方式1： 直接使用 @JsonComponent 注解修饰JsonSerializer、JsonDeserializer或KeyDeserializer实现类，
  这些实现类将会由Spring Boot注册为自定义JSON序列化器和反序列化器。
  @JsonComponent 注解修饰 JsonSerializer，就是自定义 JSON 序列化器
  @JsonComponent 注解修饰 JsonDeserializer，就是自定义 JSON 反序列化器
  

-方式2：使用 @JsonComponent 修饰包含JsonSerializer/JsonDeserializer内部实现类的外部类，
  这些内部实现类将会由Spring Boot注册为自定义JSON序列化器和反序列化器。
  这种方式相当于将序列化器和反序列化器都定义在一个外部类中，这种方式具有更好的内聚性，
  通常推荐用方式2。

内部类（ Inner Class ）就是定义在另外一个类里面的类。与之对应，包含内部类的类被称为外部类

Token定义
Token是Fastjson中定义的json字符串的同类型字段，即”{“、”[“、数字、字符串等，用于分隔json字符串不同字段。
例如，{“姓名”：“张三”,“年龄”:“20”}是一个json字符串，在反序列化之前，需要先将其解析为
{ 、 姓名、 ：、 张三、 ,、 年龄、 ：、 20、 }这些字段的Token流，随后再根据class反序列化为响应的对象。
在进行Token解析之前，json字符串对程序而言只是一个无意义的字符串。需要将json字符串解析为一个个的Token，并以Token为单位解读json数据。

代码演示：

自定义序列化和反序列化器的代码

package cn.ljh.app.custom;


import cn.ljh.app.domain.Book;
import com.fasterxml.jackson.core.JsonGenerator;
import com.fasterxml.jackson.core.JsonParser;
import com.fasterxml.jackson.core.JsonProcessingException;
import com.fasterxml.jackson.core.JsonToken;
import com.fasterxml.jackson.databind.DeserializationContext;
import com.fasterxml.jackson.databind.JsonDeserializer;
import com.fasterxml.jackson.databind.JsonSerializer;
import com.fasterxml.jackson.databind.SerializerProvider;
import lombok.SneakyThrows;
import org.springframework.beans.BeanUtils;
import org.springframework.boot.jackson.JsonComponent;

import java.io.IOException;

//内部类就是定义在另外一个类里面的类。与之对应，包含内部类的类被称为外部类,这个 CustomSeDe 就是外部类
//使用 @JsonComponent 修饰包含JsonSerializer/JsonDeserializer内部实现类的外部类，
//这些内部实现类将会由Spring Boot注册为自定义JSON序列化器和反序列化器。
@JsonComponent
public class CustomSeDe
{
    //在该类中可定义自定义的序列化器和反序列化器


    //postman 用get请求时走这个方法
    //自定义序列化器，这个就是内部类
    public static class MySerializer extends JsonSerializer<Book>
    {

        @Override
        public void serialize(Book book, JsonGenerator jsonGenerator,
                              SerializerProvider serializerProvider) throws IOException
        {
            //在该方法中完成自定义的序列化输出，将对象输出成 json 或者是 xml 字符串

            jsonGenerator.writeStartObject(); //输出 {  这个花括号 ， 输出对象用这个括号
//            jsonGenerator.writeStartArray();  //输出 [ 这个中括号  ， 输出数值用这个括号
            jsonGenerator.writeNumberField("id", book.getId());
            //将book对象的name属性，序列化为title 属性
            jsonGenerator.writeStringField("title", book.getName());
            jsonGenerator.writeNumberField("price", book.getPrice());
            jsonGenerator.writeStringField("author", book.getAuthor());
//            jsonGenerator.writeEndArray();   // 输出这个 ] 中括号
            jsonGenerator.writeEndObject();  //输出这个 } 花括号
        }
    }

    //postman 用post的请求访问到这个方法
    //自定义反序列化器，这个就是内部类
    public static class MyDeserializer extends JsonDeserializer<Book>
    {
        //这个方法负责反序列化，就是将 json 或者是 xml 字符串 恢复成对象
        @SneakyThrows
        @Override
        public Book deserialize(JsonParser jsonParser, DeserializationContext deserializationContext) throws IOException, JsonProcessingException
        {

            Book book = new Book();

            //JsonToken采用顺序方式依次读取 JSON 或 XML 字符串中的每个 token
            //token：一个花括号也叫token，一个符号隔开一个内容就叫token
            JsonToken jsonToken = jsonParser.getCurrentToken();
            //只要这个 Json 或者 xml 字符串没有结束，都应该继续向下读取
            while (!jsonToken.equals(JsonToken.END_OBJECT))
            {
                //这个循环的作用，是去保证要找到代表 Field Name 的 Token
                //如果当前读取的Token 不是字段名
                if (!jsonToken.equals(JsonToken.FIELD_NAME))
                {
                    jsonToken = jsonParser.nextToken();//读取下一个token
                    continue;
                }
                //只要程序进到此处，就一定是读取到 field name 这种字段token
                //从 JSON 或者是 XML 字符串中读取得到的字段名，也就是Book 对象的属性名
                String fieldName = jsonParser.getCurrentName();
                //读取属性名之后，下一个Token就是属性值了
                JsonToken valueToken = jsonParser.nextToken();
                //获取当前token的值
                String value = jsonParser.getText();
                //对于要逻辑处理的属性，可以在这里进行判断处理
                if (fieldName.equals("title"))
                {
                    if (!value.startsWith("《"))
                    {
                        value = "《" + value;
                    }
                    if (!value.endsWith("》"))
                    {
                        value += "》";
                    }
                    //完成了对Book对象的name属性的设置
                    book.setName(value);
                } else if (fieldName.equals("price"))
                {
                    double price = Double.parseDouble(value);
                    //把从json或xml格式的价格数据拿出来，然后打折set进去
                    book.setPrice(price * 0.5);
                } else
                {
                    //对于其他属性，不需要额外处理的话，直接通过反射来调用Book对象的fieldName对应的setter方法
                    BeanUtils.getPropertyDescriptor(Book.class, fieldName)
                            .getWriteMethod()
                            .invoke(book, value);
                }
                //继续向下读取下一个 Token
                jsonToken = jsonParser.nextToken();
            }
            return book;
        }
    }

}

测试：

序列化输出，将对象输出成 json 或者是 xml 字符串
反序列化，就是将 json 或者是 xml 字符串 恢复成对象

前端发送 get 请求，会走序列化方法。
http://localhost:8080/books
（不知道是如何定义访问的方法是走序列化还是反序列化方法）
get 请求是获取对象，序列化方法，把对象序列化成json格式的数据返回

序列化输出，将对象输出成 json 或者是 xml 字符串
反序列化，就是将 json 或者是 xml 字符串 恢复成对象

用 post 请求，会走反序列化方法，
发送的请求是 json 格式的数据，所以走反序列化方法，将数据恢复成对象

不太懂如何怎么应用这个自定义的序列化和反序列化器。

完整代码：

Book

BookController

package cn.ljh.app.controller;


import cn.ljh.app.domain.Book;
import cn.ljh.app.service.BookService;
import org.springframework.http.HttpHeaders;
import org.springframework.http.HttpStatus;
import org.springframework.http.ResponseEntity;
import org.springframework.web.bind.annotation.*;

import java.util.List;

/*
 *     GET  /books/{id} - （获取数据） 获取指定id的图书
 *     GET  /books?参数  -（获取数据） 获取符合查询参数的图书
 *     GET  /books        -（获取数据） 获取所有图书
 *     POST /books        -（添加数据） 添加图书
 *     PUT  /books/{id}    -（更新数据） 更新指定ID的图书
 *     DELETE /books/{id}    -（删除数据） 删除指定ID的图书
 *     DELETE /books?参数    -（删除数据） 删除符合指定参数的图书
 *
 *  Restful处理方法的返回值通常都应该使用HttpEntity或ResponseEntity。
 *
 */

@RequestMapping("/books")
@RestController
public class BookController
{
    //有参构造器进行依赖注入
    private BookService bookService;

    public BookController(BookService bookService)
    {
        this.bookService = bookService;
    }


    //根据id查看图书
    @GetMapping("/{id}")
    public ResponseEntity<Book> viewBookById(@PathVariable Integer id)
    {
        Book book = bookService.getBookById(id);

        //参数1：响应数据体  参数2：需要添加的响应头，没有就给个null   参数3:响应码 ， OK 代表 200
        return new ResponseEntity<>(book, null, HttpStatus.OK);
    }

    //查看所有图书
    @GetMapping("")
    public ResponseEntity<List<Book>> viewBooks()
    {
        List<Book> allBooks = bookService.getAllBooks();

        return new ResponseEntity<>(allBooks, null, HttpStatus.OK);
    }

    //添加图书
    @PostMapping("")
    public ResponseEntity<Book> addBook(@RequestBody Book book)
    {
        Book b = bookService.addOrUpdateBook(book);
        //HttpStatus.CREATED 代表返回的状态码为 201
        return new ResponseEntity<>(b, null, HttpStatus.CREATED);
    }

    //根据id更新图书信息
    @PutMapping("/{id}")
    public ResponseEntity<Book> updateBookById(@PathVariable Integer id, @RequestBody Book book)
    {
        book.setId(id);
        Book b = bookService.addOrUpdateBook(book);

        return new ResponseEntity<>(b, null, HttpStatus.OK);
    }

    //根据id删除图书
    @DeleteMapping("/{id}")
    public ResponseEntity<Book> deleteBookById(@PathVariable Integer id)
    {
        Book book = bookService.deleteBookById(id);
        return new ResponseEntity<>(book, null, HttpStatus.OK);
    }

}

BookService

package cn.ljh.app.service;

import cn.ljh.app.domain.Book;

import java.util.List;

public interface BookService
{
    //根据id查看图书
    Book getBookById(Integer id);

    //查看所有图书
    List<Book> getAllBooks();

    //添加/修改图书
    Book addOrUpdateBook(Book book);

    //根据id删除图书
    Book deleteBookById(Integer id);

}

BookServiceImpl

package cn.ljh.app.service.impl;

import cn.ljh.app.domain.Book;
import cn.ljh.app.service.BookService;
import org.springframework.stereotype.Service;

import java.util.*;
import java.util.concurrent.ConcurrentHashMap;


@Service
public class BookServiceImpl implements BookService
{
    //创建一个线程安全的map集合存数据，假设为数据库
    static Map<Integer, Book> bookDB = new ConcurrentHashMap<>();
    static int nextId = 1;

    //初始化数据库的数据
    static
    {
        bookDB.put(nextId, new Book(nextId++, "火影忍者", 120, "岸本"));
        bookDB.put(nextId, new Book(nextId++, "七龙珠", 121, "鸟山明"));
    }


    //根据id查看图书
    @Override
    public Book getBookById(Integer id)
    {
        if (id != null)
        {
            Book book = bookDB.get(id);
            if (book!=null){
                return book;
            }
        }
        throw new RuntimeException("根据id查看图书失败！");
    }

    //查看所有图书
    @Override
    public List<Book> getAllBooks()
    {
        //获取map中的所有数据
        Collection<Book> mapBooks = bookDB.values();
        //强转
        List<Book> books = new ArrayList<>(mapBooks);
        return books;
    }

    //添加/修改图书
    @Override
    public Book addOrUpdateBook(Book book)
    {
        if (book.getId() != null){
            //修改
            //map的key是唯一的，所以map里面有这个key的话，直接把原来的value覆盖掉
            bookDB.put(book.getId(),book);
            return book;
        }else {
            //新增
            //为新增的图书设置id
            book.setId(nextId);
            //book添加完之后，这个id才会自增
            bookDB.put(nextId++,book);
            return book;
        }
    }

    //根据id删除图书
    @Override
    public Book deleteBookById(Integer id)
    {
        Book book = bookDB.remove(id);
        return book;
    }
}

CustomSeDe

package cn.ljh.app.custom;


import cn.ljh.app.domain.Book;
import com.fasterxml.jackson.core.JsonGenerator;
import com.fasterxml.jackson.core.JsonParser;
import com.fasterxml.jackson.core.JsonProcessingException;
import com.fasterxml.jackson.core.JsonToken;
import com.fasterxml.jackson.databind.DeserializationContext;
import com.fasterxml.jackson.databind.JsonDeserializer;
import com.fasterxml.jackson.databind.JsonSerializer;
import com.fasterxml.jackson.databind.SerializerProvider;
import lombok.SneakyThrows;
import org.springframework.beans.BeanUtils;
import org.springframework.boot.jackson.JsonComponent;

import java.io.IOException;

//内部类就是定义在另外一个类里面的类。与之对应，包含内部类的类被称为外部类,这个 CustomSeDe 就是外部类
//使用 @JsonComponent 修饰包含JsonSerializer/JsonDeserializer内部实现类的外部类，
//这些内部实现类将会由Spring Boot注册为自定义JSON序列化器和反序列化器。
@JsonComponent
public class CustomSeDe
{
    //在该类中可定义自定义的序列化器和反序列化器


    //postman 用get请求时走这个方法
    //自定义序列化器，这个就是内部类
    public static class MySerializer extends JsonSerializer<Book>
    {

        @Override
        public void serialize(Book book, JsonGenerator jsonGenerator,
                              SerializerProvider serializerProvider) throws IOException
        {
            //在该方法中完成自定义的序列化输出，将对象输出成 json 或者是 xml 字符串

            jsonGenerator.writeStartObject(); //输出 {  这个花括号 ， 输出对象用这个括号
            //jsonGenerator.writeStartArray();  //输出 [ 这个中括号  ， 输出数值用这个括号
            jsonGenerator.writeNumberField("id", book.getId());
            //将book对象的name属性，序列化为title 属性
            jsonGenerator.writeStringField("title", book.getName());
            jsonGenerator.writeNumberField("price", book.getPrice());
            jsonGenerator.writeStringField("author", book.getAuthor());
            //jsonGenerator.writeEndArray();   // 输出这个 ] 中括号
            jsonGenerator.writeEndObject();  //输出这个 } 花括号
        }
    }

    //postman 用post的请求访问到这个方法
    //自定义反序列化器，这个就是内部类
    public static class MyDeserializer extends JsonDeserializer<Book>
    {
        //这个方法负责反序列化，就是将 json 或者是 xml 字符串 恢复成对象
        @SneakyThrows
        @Override
        public Book deserialize(JsonParser jsonParser, DeserializationContext deserializationContext) throws IOException, JsonProcessingException
        {

            Book book = new Book();

            //JsonToken采用顺序方式依次读取 JSON 或 XML 字符串中的每个 token
            //token：一个花括号也叫token，一个符号隔开一个内容就叫token
            JsonToken jsonToken = jsonParser.getCurrentToken();
            //只要这个 Json 或者 xml 字符串没有结束，都应该继续向下读取
            while (!jsonToken.equals(JsonToken.END_OBJECT))
            {
                //这个循环的作用，是去保证要找到代表 Field Name 的 Token
                //如果当前读取的Token 不是字段名
                if (!jsonToken.equals(JsonToken.FIELD_NAME))
                {
                    jsonToken = jsonParser.nextToken();//读取下一个token
                    continue;
                }
                //只要程序进到此处，就一定是读取到 field name 这种字段token
                //从 JSON 或者是 XML 字符串中读取得到的字段名，也就是Book 对象的属性名
                String fieldName = jsonParser.getCurrentName();
                //读取属性名之后，下一个Token就是属性值了
                JsonToken valueToken = jsonParser.nextToken();
                //获取当前token的值
                String value = jsonParser.getText();
                //对于要逻辑处理的属性，可以在这里进行判断处理
                if (fieldName.equals("title"))
                {
                    if (!value.startsWith("《"))
                    {
                        value = "《" + value;
                    }
                    if (!value.endsWith("》"))
                    {
                        value += "》";
                    }
                    //完成了对Book对象的name属性的设置
                    book.setName(value);
                } else if (fieldName.equals("price"))
                {
                    double price = Double.parseDouble(value);
                    //把从json或xml格式的价格数据拿出来，然后打折set进去
                    book.setPrice(price * 0.5);
                } else
                {
                    //对于其他属性，不需要额外处理的话，直接通过反射来调用Book对象的fieldName对应的setter方法
                    BeanUtils.getPropertyDescriptor(Book.class, fieldName)
                            .getWriteMethod()
                            .invoke(book, value);
                }
                //继续向下读取下一个 Token
                jsonToken = jsonParser.nextToken();
            }
            return book;
        }
    }

}

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 https://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>
    <parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>2.4.5</version>
    </parent>
    <groupId>cn.ljh</groupId>
    <artifactId>CustomSeDe</artifactId>
    <version>1.0.0</version>
    <name>CustomSeDe</name>
    <properties>
        <java.version>11</java.version>
        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
    </properties>
    <dependencies>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>

        <!-- 添加 Jackson format XML , 用于对象与XML之间的转换 -->
        <dependency>
            <groupId>com.fasterxml.jackson.dataformat</groupId>
            <artifactId>jackson-dataformat-xml</artifactId>
        </dependency>


        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-devtools</artifactId>
            <scope>runtime</scope>
            <optional>true</optional>
        </dependency>
        <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>
    </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>

代码007普通

打赏 收藏 海报 链接