Spring Boot中如何在JSON序列化时条件排除DTO字段？

针对你的需求，下面整理了几种实用的实现方案，涵盖注解配置和设计模式两种方向：

一、基于注解的实现方案 #

1. Jackson @JsonView 注解 #

这是最常用的按场景划分字段的方式，通过定义视图接口标记字段的可见范围：

// 定义视图接口，区分不同场景
public interface Views {
    interface Basic {} // 基础场景：不返回age
    interface Extended extends Basic {} // 扩展场景：返回全部字段
}

class Person {
    @JsonView(Views.Basic.class)
    private String firstName;
    
    @JsonView(Views.Basic.class)
    private String lastName;
    
    @JsonView(Views.Extended.class)
    private int age; // 仅在Extended视图下序列化
    
    // getter/setter 省略
}

在Controller方法中指定要使用的视图：

// 基础场景接口，返回不带age的Person
@GetMapping("/basic-person")
@JsonView(Views.Basic.class)
public Person getBasicPerson() {
    return new Person("John", "Doe", 30);
}

// 扩展场景接口，返回带age的Person
@GetMapping("/extended-person")
@JsonView(Views.Extended.class)
public Person getExtendedPerson() {
    return new Person("John", "Doe", 30);
}

2. Jackson @JsonFilter 动态过滤 #

如果需要根据请求参数或运行时条件动态决定字段是否排除，可以用这个方式：

@JsonFilter("personFieldFilter")
class Person {
    private String firstName;
    private String lastName;
    private int age;
    
    // getter/setter 省略
}

在Controller中动态配置过滤规则：

@GetMapping("/person")
public MappingJacksonValue getPerson(@RequestParam boolean includeAge) {
    Person person = new Person("John", "Doe", 30);
    MappingJacksonValue result = new MappingJacksonValue(person);
    
    SimpleFilterProvider filterProvider = new SimpleFilterProvider();
    if (!includeAge) {
        // 排除age字段
        filterProvider.addFilter("personFieldFilter", 
            SimpleBeanPropertyFilter.serializeAllExcept("age"));
    } else {
        filterProvider.addFilter("personFieldFilter", 
            SimpleBeanPropertyFilter.serializeAll());
    }
    
    result.setFilters(filterProvider);
    return result;
}

3. 自定义注解+序列化器 #

如果现有注解满足不了复杂的条件逻辑，可以自定义注解配合序列化器：

// 自定义注解，标记需要条件排除的字段
@Target(ElementType.FIELD)
@Retention(RetentionPolicy.RUNTIME)
public @interface ConditionalIgnore {
    // 可以定义条件标识，比如场景key
    String scenario() default "hideAge";
}

// 自定义序列化器，处理条件排除逻辑
public class ConditionalIgnoreSerializer extends JsonSerializer<Object> {
    @Override
    public void serialize(Object value, JsonGenerator gen, SerializerProvider serializers) throws IOException {
        // 从ThreadLocal获取当前场景标识（业务逻辑中提前设置）
        String currentScenario = ScenarioContext.getCurrentScenario();
        // 获取字段上的注解
        Field field = serializers.getContextualType().getRawClass().getDeclaredField("age");
        ConditionalIgnore annotation = field.getAnnotation(ConditionalIgnore.class);
        
        if (annotation != null && annotation.scenario().equals(currentScenario)) {
            return; // 不序列化该字段
        }
        gen.writeObject(value);
    }
}

// 应用到DTO字段
class Person {
    private String firstName;
    private String lastName;
    
    @JsonSerialize(using = ConditionalIgnoreSerializer.class)
    private int age;
    
    // getter/setter 省略
}

业务逻辑中通过ThreadLocal传递场景标识，控制字段是否排除。

二、基于设计模式的实现方案 #

1. 拆分DTO（单一职责原则） #

直接为不同场景定义独立的DTO类，避免在同一个类中处理条件逻辑：

// 基础场景DTO：仅包含必要字段
class BasicPersonDTO {
    private String firstName;
    private String lastName;
    
    public BasicPersonDTO(String firstName, String lastName) {
        this.firstName = firstName;
        this.lastName = lastName;
    }
    
    // getter/setter 省略
}

// 扩展场景DTO：继承基础DTO并添加age字段
class ExtendedPersonDTO extends BasicPersonDTO {
    private int age;
    
    public ExtendedPersonDTO(String firstName, String lastName, int age) {
        super(firstName, lastName);
        this.age = age;
    }
    
    // getter/setter 省略
}

在接口中返回对应场景的DTO：

@GetMapping("/basic-person")
public BasicPersonDTO getBasicPerson() {
    Person person = getPersonFromDB();
    return new BasicPersonDTO(person.getFirstName(), person.getLastName());
}

@GetMapping("/extended-person")
public ExtendedPersonDTO getExtendedPerson() {
    Person person = getPersonFromDB();
    return new ExtendedPersonDTO(person.getFirstName(), person.getLastName(), person.getAge());
}

2. 建造者模式动态构建DTO #

通过建造者模式灵活控制要设置的字段，未设置的null字段会被Jackson自动忽略：

class PersonDTO {
    private String firstName;
    private String lastName;
    private Integer age; // 用Integer允许为null
    
    private PersonDTO(Builder builder) {
        this.firstName = builder.firstName;
        this.lastName = builder.lastName;
        this.age = builder.age;
    }
    
    public static class Builder {
        private String firstName;
        private String lastName;
        private Integer age;
        
        public Builder firstName(String firstName) {
            this.firstName = firstName;
            return this;
        }
        
        public Builder lastName(String lastName) {
            this.lastName = lastName;
            return this;
        }
        
        public Builder age(int age) {
            this.age = age;
            return this;
        }
        
        public PersonDTO build() {
            return new PersonDTO(this);
        }
    }
    
    // getter/setter 省略
}

在接口中根据场景决定是否添加age字段：

@GetMapping("/person")
public PersonDTO getPerson(@RequestParam boolean includeAge) {
    Person person = getPersonFromDB();
    PersonDTO.Builder builder = new PersonDTO.Builder()
            .firstName(person.getFirstName())
            .lastName(person.getLastName());
    
    if (includeAge) {
        builder.age(person.getAge());
    }
    
    return builder.build();
}

3. 策略模式处理字段映射 #

定义不同的字段转换策略，根据场景选择对应的策略：

// 字段转换策略接口
interface PersonConvertStrategy {
    Map<String, Object> convertToResponse(Person person);
}

// 基础场景策略：不包含age
class BasicConvertStrategy implements PersonConvertStrategy {
    @Override
    public Map<String, Object> convertToResponse(Person person) {
        Map<String, Object> result = new HashMap<>();
        result.put("firstName", person.getFirstName());
        result.put("lastName", person.getLastName());
        return result;
    }
}

// 扩展场景策略：包含age
class ExtendedConvertStrategy implements PersonConvertStrategy {
    @Override
    public Map<String, Object> convertToResponse(Person person) {
        Map<String, Object> result = new BasicConvertStrategy().convertToResponse(person);
        result.put("age", person.getAge());
        return result;
    }
}

在Controller中选择策略返回结果：

@GetMapping("/person")
public Map<String, Object> getPerson(@RequestParam String scenario) {
    Person person = getPersonFromDB();
    PersonConvertStrategy strategy;
    
    if ("basic".equals(scenario)) {
        strategy = new BasicConvertStrategy();
    } else {
        strategy = new ExtendedConvertStrategy();
    }
    
    return strategy.convertToResponse(person);
}

内容的提问来源于stack exchange，提问作者Magic Developement