索取营销诊断书
021-80394720QQ
您的位置：上海毫米网络优化公司 > 小程序 > 百度小程序 >
相关推荐recommended
59、SpringBoot 自定义JSON的序列化器和反序列化器
作者：mmseoamin日期：2023-12-21

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
    {
        @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
    {
        //这个方法负责反序列化，就是将 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格式的数据返回

59、SpringBoot 自定义JSON的序列化器和反序列化器,在这里插入图片描述,第1张

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

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

用 post 请求，会走反序列化方法，

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

59、SpringBoot 自定义JSON的序列化器和反序列化器,在这里插入图片描述,第2张

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

完整代码：

Book

59、SpringBoot 自定义JSON的序列化器和反序列化器,在这里插入图片描述,第3张

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 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> viewBooks()
    {
        List allBooks = bookService.getAllBooks();
        return new ResponseEntity<>(allBooks, null, HttpStatus.OK);
    }
    //添加图书
    @PostMapping("")
    public ResponseEntity addBook(@RequestBody Book book)
    {
        Book b = bookService.addOrUpdateBook(book);
        //HttpStatus.CREATED 代表返回的状态码为 201
        return new ResponseEntity<>(b, null, HttpStatus.CREATED);
    }
    //根据id更新图书信息
    @PutMapping("/{id}")
    public ResponseEntity 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 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 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 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 getAllBooks()
    {
        //获取map中的所有数据
        Collection mapBooks = bookDB.values();
        //强转
        List 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
    {
        @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
    {
        //这个方法负责反序列化，就是将 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



    4.0.0
    
        org.springframework.boot
        spring-boot-starter-parent
        2.4.5
    
    cn.ljh
    CustomSeDe
    1.0.0
    CustomSeDe
    
        11
        UTF-8
    
    
        
            org.springframework.boot
            spring-boot-starter-web
        
        
        
            com.fasterxml.jackson.dataformat
            jackson-dataformat-xml
        
        
            org.springframework.boot
            spring-boot-devtools
            runtime
            true
        
        
            org.projectlombok
            lombok
            true
        
        
            org.springframework.boot
            spring-boot-starter-test
            test
        
    
    
        
            
                org.springframework.boot
                spring-boot-maven-plugin
                
                    
                        
                            org.projectlombok
                            lombok
 

上一篇：报错：The Tomcat connector configured to listen on port xxxx failed to start. The port may already be

下一篇：【SQL开发实战技巧】系列（七）：从有重复数据前提下如何比较出两个表中的差异数据及对应条数聊起

网站优化运营
整站seo优化
网络营销运营
成功案例
品牌创意网站
营销型网站
小程序
微信小程序
微信公众号
百度熊掌号
网站优化分享
关于我们
公司概况
公司新闻
公司文化
结构体系
企业资质
加入我们
关注我们
扫描二维码
获取更多信息
精彩一手掌握
Copyright © 2014-2019 seo,上海网站优化_网络制作_网站seo排名_网站建设推广_上海网络公司 版权所有 沪ICP备19022315号