Spring AOP场景下，如何让ObjectMapper序列化时跳过特定类型字段？

方案一：自定义ObjectMapper配置，序列化时跳过指定类型字段 #

不需要修改DTO的注解，给用于Kafka序列化的ObjectMapper单独配置规则，就能跳过MultipartFile这类目标类型的字段，同时不影响原DTO的返回逻辑。

可以通过自定义BeanSerializerModifier实现，它能在Jackson序列化过程中动态过滤字段：

import com.fasterxml.jackson.databind.BeanDescription;
import com.fasterxml.jackson.databind.SerializationConfig;
import com.fasterxml.jackson.databind.ser.BeanPropertyWriter;
import com.fasterxml.jackson.databind.ser.BeanSerializerModifier;
import org.springframework.web.multipart.MultipartFile;
import java.util.List;

public class SkipTypeSerializerModifier extends BeanSerializerModifier {
    private final Class<?>[] skipTypes;

    public SkipTypeSerializerModifier(Class<?>... skipTypes) {
        this.skipTypes = skipTypes;
    }

    @Override
    public List<BeanPropertyWriter> changeProperties(SerializationConfig config, BeanDescription beanDesc, List<BeanPropertyWriter> beanProperties) {
        beanProperties.removeIf(writer -> {
            for (Class<?> skipType : skipTypes) {
                if (skipType.isAssignableFrom(writer.getType().getRawClass())) {
                    return true;
                }
            }
            return false;
        });
        return beanProperties;
    }
}

然后给Kafka专用的ObjectMapper注册这个修改器：

import com.fasterxml.jackson.databind.ObjectMapper;
import com.fasterxml.jackson.databind.module.SimpleModule;
import org.springframework.web.multipart.MultipartFile;

// 初始化仅用于Kafka序列化的ObjectMapper
ObjectMapper kafkaObjectMapper = new ObjectMapper();
kafkaObjectMapper.registerModule(new SimpleModule()
        .setSerializerModifier(new SkipTypeSerializerModifier(MultipartFile.class)));

用这个kafkaObjectMapper序列化DTO时，所有MultipartFile类型的字段会被自动跳过；而返回前端时用默认的ObjectMapper（不做此配置），就能保持DTO原样返回。

方案二：反射复制DTO并清除特定类型字段 #

如果不想修改Jackson配置，可以先复制一份DTO对象，将其中特定类型的字段设为null，再序列化复制后的对象发Kafka，原DTO保持不变用于返回。

可以结合Spring的BeanUtils和反射实现：

import org.springframework.beans.BeanUtils;
import org.springframework.web.multipart.MultipartFile;
import java.lang.reflect.Field;

public class DtoUtils {
    public static <T> T copyAndClearSpecificFields(T original, Class<?>... clearTypes) throws IllegalAccessException, InstantiationException {
        T copy = original.getClass().newInstance();
        BeanUtils.copyProperties(original, copy);
        
        // 遍历字段，清除指定类型的属性
        Field[] fields = original.getClass().getDeclaredFields();
        for (Field field : fields) {
            field.setAccessible(true);
            for (Class<?> clearType : clearTypes) {
                if (clearType.isAssignableFrom(field.getType())) {
                    field.set(copy, null);
                    break;
                }
            }
        }
        // 若DTO有父类字段，可添加递归处理父类逻辑
        return copy;
    }
}

使用示例：

// 获取原DTO
ResultDto originalDto = ...;
// 复制并清除MultipartFile类型字段
ResultDto kafkaDto = DtoUtils.copyAndClearSpecificFields(originalDto, MultipartFile.class);
// 序列化复制后的对象发Kafka
kafkaObjectMapper.writeValueAsString(kafkaDto);
// 原DTO原样返回
return originalDto;

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