SpringBoot序列化、反序列化空字符串为null的三种方式

合集 - SpringBoot的Demo(11)

1.SpringBoot自定义cron表达式注册定时任务2023-04-212.MongoDB + SpringBoot 的基础CRUD、聚合查询2023-05-183.SpringBoot实现WebSocket发送接收消息 + Vue实现SocketJs接收发送消息2023-05-194.SpringBoot获取Bean的工具类2023-10-125.Gradle8.4构建SpringBoot多模块项目2023-10-316.Gradle构建SpringBoot单模块项目2023-10-247.Java根据URL截图的4种方式2023-11-06

8.SpringBoot序列化、反序列化空字符串为null的三种方式2024-04-19

9.SpringBoot使用模版导出Word文件：poi-tl2024-12-2510.EasyExcel-读取多个sheet的方法2024-12-2511.SpringBoot将数据库中的数据导入到xml文件中2024-12-25

收起

一、需求：接收前端传入的""空字符串参数，有时候我们需要把它转为null

• SpringBoot项目
• 方式：①Jackson（推荐）、②切面+反射、③注解+切面+反射
• 后两种方式，未做返回值的处理。

二、三种方式

1、Jackson正反序列化（推荐）

• StdConverter 和 JsonSerializer的区别

两种方式都可以实现将空字符串修改为 null 值的逻辑，但它们之间有一些区别：
 
1. **继承的类不同**：
   - 使用 `StdConverter` 方式时，`StringToNullSerializer` 类继承自 `StdConverter<String, String>`，并实现了 `convert` 方法。
   - 使用 `JsonSerializer` 方式时，`StringToNullSerializer` 类直接继承自 `JsonSerializer<String>`，并实现了 `serialize` 方法。
 
2. **接口和方法不同**：
   - `StdConverter` 是 Jackson 库中提供的用于定义转换器的类，其中的 `convert` 方法用于将一个类型转换为另一个类型。
   - `JsonSerializer` 是 Jackson 库中用于定制序列化逻辑的接口，其中的 `serialize` 方法用于将 Java 对象序列化为 JSON 数据。
 
3. **对于序列化过程的处理不同**：
   - 在 `StdConverter` 方式中，你需要实现 `convert` 方法来定义如何将空字符串转换为 null 值。
   - 在 `JsonSerializer` 方式中，你需要实现 `serialize` 方法来定义如何将字段序列化为 JSON 数据，并在其中进行空字符串转换为 null 值的处理。
 
综上所述，两种方式都可以实现相同的功能，选择哪一种方式取决于个人偏好以及代码的整体结构和风格。通常来说，如果只需要定制序列化逻辑而不需要转换其他类型，直接实现 `JsonSerializer` 接口可能会更清晰和简洁。

• ENTITY

package com.cc.jxtd.entity;
 
import com.cc.jxtd.serializer.ConverterEmptyStringToNull;
import com.cc.jxtd.serializer.EmptyStringToNullDeserializer;
import com.cc.jxtd.serializer.ConverterEmptyStringToInteger0;
import com.cc.jxtd.serializer.EmptyStringToNullSerializer;
import com.fasterxml.jackson.databind.annotation.JsonDeserialize;
import com.fasterxml.jackson.databind.annotation.JsonSerialize;
import lombok.Data;
 
import javax.naming.Name;
 
/**
 * <p>请求，返回都用这个</p>
 *
 * @author --
 * @since 2024/4/19
 */
@Data
public class UserCs {
 
    private Long id;
 
    //反序列化（前端请求）：空字符串为null
    @JsonDeserialize(using = EmptyStringToNullDeserializer.class)
    private String name;
 
    //反序列化（前端请求）：转换：为其他类型的值（转换为int的0）
    @JsonDeserialize(converter = ConverterEmptyStringToInteger0.class)
    private Integer descConverter0;
 
    //序列化（后端返回）：空字符串为null
    @JsonSerialize(using = EmptyStringToNullSerializer.class)
    private String descSerialize;
 
    //序列化（后端返回）：转换：空字符串转为null
    @JsonSerialize(converter = ConverterEmptyStringToNull.class)
    private String descConverterNull;
    
}
 

• 序列化处理类

package com.cc.jxtd.serializer;
 
import com.fasterxml.jackson.core.JsonGenerator;
import com.fasterxml.jackson.databind.JsonSerializer;
import com.fasterxml.jackson.databind.SerializerProvider;
 
import java.io.IOException;
 
/** 序列化：String的空转为null
 * @author --
 * @since 2024/4/18
 **/
public class EmptyStringToNullSerializer extends JsonSerializer<String> {
 
    /**
     * 序列化为null
     */
    @Override
    public void serialize(String value, JsonGenerator gen, SerializerProvider serializerProvider) throws IOException {
        if (value == null || value.trim().isEmpty()) {
            gen.writeNull();
        }else {
            gen.writeString(value);
        }
    }
}

• 反序列化处理类

package com.cc.jxtd.serializer;
 
import com.fasterxml.jackson.core.JsonParser;
import com.fasterxml.jackson.databind.DeserializationContext;
import com.fasterxml.jackson.databind.JsonDeserializer;
 
import java.io.IOException;
 
/** 反序列化：空字符串转换为null
 * @author --
 * @since 2024/4/18
 **/
public class EmptyStringToNullDeserializer extends JsonDeserializer<String> {
 
    /**
     * 反序列化为null
     */
    @Override
    public String deserialize(JsonParser p, DeserializationContext ctxt) throws IOException {
        String value = p.getValueAsString();
        if (value == null || value.trim().isEmpty()) {
            return null;
        }
        return value;
    }
 
}

• 序列化-转换1

package com.cc.jxtd.serializer;
 
import com.fasterxml.jackson.databind.util.StdConverter;
 
/** 序列化-转换：将string的空转为null
 * @author --
 * @since 2024/4/18
 **/
public class ConverterEmptyStringToNull extends StdConverter<String, String> {
 
    @Override
    public String convert(String value) {
        //把空的string转为int的0
        if (value == null || value.trim().isEmpty()) {
            return null;
        }
        return value;
    }
 
}

• 序列化-转换2

package com.cc.jxtd.serializer;
 
import com.fasterxml.jackson.annotation.JsonPropertyOrder;
import com.fasterxml.jackson.databind.util.StdConverter;
 
/** 序列化：1将string转为int。
 *         2转换String的空或null -》 转为Integer的0
 * @author --
 * @since 2024/4/18
 **/
public class ConverterEmptyStringToInteger0 extends StdConverter<String, Integer> {
 
    @Override
    public Integer convert(String value) {
        //把空的string转为int的0
        if (value == null || value.trim().isEmpty()) {
            return 0;
        }
        return Integer.valueOf(value);
    }
 
}

• Controller

package com.cc.jxtd.web.controller;
 
import com.cc.jxtd.entity.UserCs;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.RequestBody;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;
 
/**
 * <p></p>
 *
 * @author --
 * @since 2024/4/19
 */
@RestController
@RequestMapping("/userCs")
public class UserController {
 
    @PostMapping
    public UserCs get(@RequestBody UserCs req){
        System.out.println("请求参数-id："   + req.getId());
        System.out.println("请求参数-name：" + req.getName());
        System.out.println("请求参数-desc1：" + req.getDescSerialize());
        System.out.println("请求参数-desc2：" + req.getDescConverterNull());
        System.out.println("请求参数-desc3：" + req.getDescConverter0());
 
        //返回：序列化
        return req;
    }
}

• 测试
  

2、切面+反射/3、注解+切面+反射

• 区别

2、切面+反射：所有空字符串的字段都转为null
3、注解+切面+反射：只有打了@EmptyToNull的字段才会转换

• 导入包

		<!--spring-boot-starter-aop-->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-aop</artifactId>
        </dependency>

• 切面

package com.cc.jxtd.aspect;
 
import com.cc.jxtd.annotation.EmptyToNull;
import org.aspectj.lang.ProceedingJoinPoint;
import org.aspectj.lang.annotation.Around;
import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.annotation.Pointcut;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.stereotype.Component;
 
import java.lang.reflect.Field;
import java.util.Objects;
 
/** 切面
 * @author --
 */
@Aspect
@Component
public class UpdateAspect {
 
    private static final Logger logger = LoggerFactory.getLogger(UpdateAspect.class);
 
    //切入点
    @Pointcut("@annotation(com.cc.jxtd.annotation.OptConverter)")
    public void validPointCut() {
    }
 
    /**
     * 环绕修改参数
     */
    @Around("validPointCut()")
    public Object around(ProceedingJoinPoint point) throws Throwable {
        Object[] args = point.getArgs();
        Object arg = args[0];
        //2、切面+反射：全部转换
        this.allEmptyToNull(arg);
        //3、注解+切面+反射：部分转换
//        this.assignEmptyToNull(arg);
 
        return point.proceed();
    }
 
    /**
     * 设置请求参数中 所有字段的空值（如：String的空字符串）为null
     * @param arg arg
     */
    public void allEmptyToNull(Object arg) {
        if (Objects.isNull(arg)) {
            return;
        }
        Field[] fields = arg.getClass().getDeclaredFields();
        for (Field field : fields) {
            // 设置字段可访问
            field.setAccessible(true);
            // 如果字段是 String 类型且值为空字符串，则设置为 null
            if (field.getType() == String.class) {
                try {
                    String value = (String) field.get(arg);
                    if (value != null && value.isEmpty()) {
                        field.set(arg, null);
                    }
                } catch (IllegalAccessException e) {
                    e.printStackTrace();
                }
            }
            // 可以扩展其他类型的参数……
 
        }
    }
 
    /** 指定空转null
     * @param arg arg
     * @since 2024/4/18
     **/
    private void assignEmptyToNull(Object arg) {
        if (Objects.isNull(arg)) {
            return;
        }
        Field[] fields = arg.getClass().getDeclaredFields();
        for (Field field : fields) {
            if (field.isAnnotationPresent(EmptyToNull.class)) {
                // 设置字段可访问
                field.setAccessible(true);
                // 如果字段是 String 类型且值为空字符串，则设置为 null
                if (field.getType() == String.class) {
                    try {
                        String value = (String) field.get(arg);
                        if (value != null && value.isEmpty()) {
                            field.set(arg, null);
                        }
                    } catch (IllegalAccessException e) {
                        e.printStackTrace();
                    }
                }
                // 可以扩展其他类型的参数……
 
            }
 
        }
    }
}

• 注解

package com.cc.jxtd.annotation;
 
import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;
 
/**
 * 转换
 * @author --
 */
@Target(ElementType.METHOD)
@Retention(RetentionPolicy.RUNTIME)
public @interface OptConverter {
    
}

• 注解2

package com.cc.jxtd.annotation;
 
import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;
 
/** 转化空为null
 * @author --
 * @since 2024/4/18
 **/
@Target(ElementType.FIELD)
@Retention(RetentionPolicy.RUNTIME)
public @interface EmptyToNull {
 
}

• entity

package com.cc.jxtd.entity;
 
import com.cc.jxtd.serializer.ConverterEmptyStringToInteger0;
import com.cc.jxtd.serializer.ConverterEmptyStringToNull;
import com.cc.jxtd.serializer.EmptyStringToNullDeserializer;
import com.cc.jxtd.serializer.EmptyStringToNullSerializer;
import com.fasterxml.jackson.databind.annotation.JsonDeserialize;
import com.fasterxml.jackson.databind.annotation.JsonSerialize;
import lombok.Data;
 
/**
 * <p>请求，返回都用这个</p>
 *
 * @author --
 * @since 2024/4/19
 */
@Data
public class UserCs2 {
 
    private Long id;
 
    private String name;
 
    private String desc;
 
}

• controller

package com.cc.jxtd.web.controller;
 
import com.cc.jxtd.annotation.OptConverter;
import com.cc.jxtd.entity.UserCs;
import com.cc.jxtd.entity.UserCs2;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.RequestBody;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;
 
/**
 * <p></p>
 *
 * @author --
 * @since 2024/4/19
 */
@RestController
@RequestMapping("/userCs")
public class UserController {
 
//    @PostMapping
//    public UserCs get(@RequestBody UserCs req){
//        System.out.println("请求参数-id："   + req.getId());
//        System.out.println("请求参数-name：" + req.getName());
//        System.out.println("请求参数-DescSerialize：" + req.getDescSerialize());
//        System.out.println("请求参数-DescConverterNull：" + req.getDescConverterNull());
//        System.out.println("请求参数-DescConverter0：" + req.getDescConverter0());
//
//        //返回：序列化
//        return req;
//    }
 
    @OptConverter
    @PostMapping
    public UserCs2 get(@RequestBody UserCs2 req){
        System.out.println("请求参数-id："   + req.getId());
        System.out.println("请求参数-name：" + req.getName());
        System.out.println("请求参数-desc：" + req.getDesc());
 
        //返回：序列化
        return req;
    }
 
}

• 测试2
  

• 测试3