Jackson定制化：如何阻止空值必填字段的对象序列化？

import com.fasterxml.jackson.core.JsonGenerator;
import com.fasterxml.jackson.databind.JsonGenerationException;
import com.fasterxml.jackson.databind.JsonSerializer;
import com.fasterxml.jackson.databind.SerializerProvider;
import java.io.IOException;
import java.util.Objects;
import java.util.function.Predicate;
import java.util.stream.Stream;

// 假设你的POJO类名为 BigJsonDto
public class BigJsonDtoSerializer extends JsonSerializer<BigJsonDto> {

    // 定义一个校验谓词，用于判断DTO实例是否无效（即存在必填字段为null）
    public static final Predicate<BigJsonDto> IS_NOT_VALID =
        dto -> Stream.of(dto.getField1(), // 假设field1和field2是必填字段
                         dto.getField2())
            .anyMatch(Objects::isNull); // 任意一个必填字段为null则视为无效

    @Override
    public void serialize(BigJsonDto value, JsonGenerator gen,
                          SerializerProvider serializers) throws IOException {

        // 1. 执行自定义校验逻辑
        if (IS_NOT_VALID.test(value)) {
            // 如果DTO实例无效，则抛出异常阻止序列化
            throw new JsonGenerationException("BigJsonDto instance is not valid: required fields are null", gen);
        }

        // 2. 如果校验通过，则手动序列化所有字段
        // 注意：这里需要手动写入每个字段，这对于字段较多的DTO可能比较繁琐
        gen.writeStartObject(); // 开始写入JSON对象
        gen.writeStringField("field1", value.getField1());
        gen.writeStringField("field2", value.getField2());
        // 假设还有更多字段，需要逐一写入
        // gen.writeStringField("field3", value.getField3());
        // ...
        // gen.writeStringField("field100", value.getField100());
        gen.writeEndObject(); // 结束写入JSON对象
    }

    /**
     * 当序列化器作为模块的一部分注册时，此方法是必需的，
     * 它告诉Jackson此序列化器处理哪种类型的对象。
     */
    @Override
    public Class<BigJsonDto> handledType() {
        return BigJsonDto.class;
    }
}

import lombok.Builder;
import lombok.Data;

@Data
@Builder
public class BigJsonDto {
    private String field1;
    private String field2;
    private String field3;
    // ... field100
}

import com.fasterxml.jackson.databind.annotation.JsonSerialize;
import lombok.Builder;
import lombok.Data;

@Data
@Builder
@JsonSerialize(using = BigJsonDtoSerializer.class) // 在POJO类上应用注解
public class BigJsonDto {
    private String field1;
    private String field2;
    private String field3;
    // ... field100
}

import com.fasterxml.jackson.databind.ObjectMapper;
import com.fasterxml.jackson.databind.module.SimpleModule;
import com.fasterxml.jackson.core.Version;
import java.util.List;
import java.util.Map;

public class JacksonConfiguration {

    public static ObjectMapper configureObjectMapper() {
        ObjectMapper mapper = new ObjectMapper();

        // 创建一个SimpleModule实例
        SimpleModule mySerializationModule = new SimpleModule(
            "MySerializationModule",
            new Version(1, 0, 0, null, "com.example", "my-app"),
            Map.of(), // 反序列化器列表 (此处为空，因为我们只关注序列化)
            List.of(new BigJsonDtoSerializer()) // 序列化器列表
        );

        // 将模块注册到ObjectMapper
        mapper.registerModule(mySerializationModule);
        return mapper;
    }

    // 如果你在Spring Boot项目中使用，可以将其注册为一个Bean
    /*
    @Bean
    public ObjectMapper objectMapper() {
        return configureObjectMapper();
    }
    */
}

import com.fasterxml.jackson.databind.ObjectMapper;
import com.fasterxml.jackson.core.JsonGenerationException;

public class SerializationDemo {

    public static void main(String[] args) {
        // 假设我们选择了通过@JsonSerialize注解在类上注册序列化器
        ObjectMapper mapper = new ObjectMapper();

        // 场景1：必填字段为null，预期序列化失败
        System.out.println("--- 场景1：必填字段为null ---");
        BigJsonDto invalidDto = BigJsonDto.builder()
                                    .field1(null) // field1是必填且为null
                                    .field2("Bob")
                                    .field3("Carol")
                                    .build();
        try {
            String resultingJson = mapper.writeValueAsString(invalidDto);
            System.out.println("序列化成功 (意外): " + resultingJson);
        } catch (JsonGenerationException e) {
            System.err.println("序列化失败 (预期): " + e.getMessage());
        } catch (Exception e) {
            System.err.println("发生其他错误: " + e.getMessage());
        }

        System.out.println("\n--- 场景2：所有必填字段都有效 ---");
        // 场景2：所有必填字段都有效，预期序列化成功
        BigJsonDto validDto = BigJsonDto.builder()
                                  .field1("Value1")
                                  .field2("Value2")
                                  .field3("Value3")
                                  .build();
        try {
            String resultingJson = mapper.writeValueAsString(validDto);
            System.out.println("序列化成功 (预期): " + resultingJson);
        } catch (JsonGenerationException e) {
            System.err.println("序列化失败 (意外): " + e.getMessage());
        } catch (Exception e) {
            System.err.println("发生其他错误: " + e.getMessage());
        }
    }
}

--- 场景1：必填字段为null ---
序列化失败 (预期): BigJsonDto instance is not valid: required fields are null

--- 场景2：所有必填字段都有效 ---
序列化成功 (预期): {"field1":"Value1","field2":"Value2","field3":"Value3"}