如何配置Spring Data MongoDB使用Builder反序列化文档？

你的问题很典型——当用Lombok的@SuperBuilder构建带继承结构的MongoDB文档实体时，Spring Data MongoDB默认的实例化逻辑找不到合适的构造器，导致查询操作报错。下面是两种可行的解决方案，帮你用Builder完成文档的反序列化：

方案一：集成Jackson的Builder反序列化支持 #

Spring Data MongoDB可以复用Jackson对Lombok Builder的成熟支持，只需要配置它使用Jackson2MongoConverter来处理文档的读写逻辑：

1. 确认依赖完整性
   确保项目中包含Spring Data MongoDB、Jackson Databind以及Lombok依赖（以Maven为例）：

<dependency>
    <groupId>org.springframework.data</groupId>
    <artifactId>spring-data-mongodb</artifactId>
</dependency>
<dependency>
    <groupId>com.fasterxml.jackson.core</groupId>
    <artifactId>jackson-databind</artifactId>
</dependency>
<dependency>
    <groupId>org.projectlombok</groupId>
    <artifactId>lombok</artifactId>
    <scope>provided</scope>
</dependency>

2. 配置Jackson2MongoConverter
   创建Spring配置类，定义Jackson2MongoConverter的Bean，让Spring Data MongoDB用它替代默认转换器：

import com.fasterxml.jackson.databind.ObjectMapper;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.data.mongodb.core.convert.Jackson2MongoConverter;
import org.springframework.data.mongodb.core.convert.MongoConverter;
import org.springframework.data.mongodb.core.mapping.MongoMappingContext;

@Configuration
public class MongoConfig {

    @Bean
    public MongoConverter mongoConverter(MongoMappingContext mappingContext, ObjectMapper objectMapper) {
        // 自动注册Lombok支持模块
        objectMapper.findAndRegisterModules();
        
        Jackson2MongoConverter converter = new Jackson2MongoConverter(mappingContext, objectMapper);
        // 可选：移除MongoDB默认添加的_type字段（如果不需要类型区分）
        converter.setTypeMapper(new DefaultMongoTypeMapper(null));
        return converter;
    }
}

3. 给实体类添加Jackson反序列化注解
   在子类Attachment上添加@JsonDeserialize，指定Lombok生成的Builder类：

import com.fasterxml.jackson.databind.annotation.JsonDeserialize;
import lombok.Data;
import lombok.RequiredArgsConstructor;
import lombok.SuperBuilder;
import lombok.Value;
import org.springframework.data.mongodb.core.mapping.Document;

@Data
@RequiredArgsConstructor
@SuperBuilder
public abstract class AttachmentBase {
    private String a;
    private final String b;
    private String c;
}

@Value
@SuperBuilder
@Document
@JsonDeserialize(builder = Attachment.AttachmentBuilder.class)
public class Attachment extends AttachmentBase {
    private String d;
}

这样Jackson会自动用生成的AttachmentBuilder反序列化MongoDB文档，Spring Data MongoDB通过Jackson转换器复用这一逻辑。

方案二：自定义Spring Data实例化策略 #

如果不想依赖Jackson，可以自定义Spring Data的InstantiationStrategy，让它优先识别Lombok生成的Builder：

1. 实现自定义InstantiationStrategy
   继承SimpleInstantiationStrategy，重写实例化逻辑，优先尝试用Builder创建对象：

import lombok.Builder;
import org.springframework.data.convert.InstantiationStrategy;
import org.springframework.data.mapping.PersistentEntity;
import org.springframework.data.mapping.model.ParameterValueProvider;
import org.springframework.data.mapping.model.SimpleInstantiationStrategy;

import java.lang.reflect.Method;
import java.util.Optional;

public class BuilderInstantiationStrategy extends SimpleInstantiationStrategy {

    @Override
    public <T> T instantiateInstance(PersistentEntity<?, ?> entity, ParameterValueProvider<?> provider) {
        // 尝试获取Builder的build方法
        Optional<Method> buildMethod = getBuilderBuildMethod(entity.getType());
        if (buildMethod.isPresent()) {
            try {
                // 调用builder()静态方法获取Builder实例
                Object builder = entity.getType().getMethod("builder").invoke(null);
                // 为Builder的属性赋值
                entity.getPersistentProperties().forEach(prop -> {
                    try {
                        Method setter = builder.getClass().getMethod(prop.getName(), prop.getType());
                        setter.invoke(builder, provider.getParameterValue(prop.getRequiredConstructorParameter()));
                    } catch (Exception e) {
                        throw new RuntimeException("Failed to set property on Builder", e);
                    }
                });
                // 调用build方法生成实体对象
                return (T) buildMethod.get().invoke(builder);
            } catch (Exception e) {
                throw new RuntimeException("Failed to instantiate entity via Builder", e);
            }
        }
        //  fallback到默认实例化逻辑
        return super.instantiateInstance(entity, provider);
    }

    private Optional<Method> getBuilderBuildMethod(Class<?> type) {
        return Optional.ofNullable(type.getAnnotation(Builder.class))
                .map(ann -> {
                    try {
                        Class<?> builderClass = Class.forName(type.getName() + "Builder");
                        return builderClass.getMethod("build");
                    } catch (Exception e) {
                        return null;
                    }
                });
    }
}

2. 配置MongoMappingContext使用自定义策略
   在配置类中设置MongoMappingContext的实例化策略：

import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.data.mongodb.core.mapping.MongoMappingContext;

@Configuration
public class MongoConfig {

    @Bean
    public MongoMappingContext mongoMappingContext() {
        MongoMappingContext context = new MongoMappingContext();
        context.setInstantiationStrategy(new BuilderInstantiationStrategy());
        return context;
    }
}

这种方式更贴近Spring Data底层实例化逻辑，但需要自己处理属性到Builder的映射，复杂度较高，适合不想引入Jackson依赖的场景。

注意事项 #

• 确保IDE和构建工具（Maven/Gradle）已正确配置Lombok注解处理器，否则Builder类不会生成。
• 父类中的final字段，Lombok的@SuperBuilder会自动处理初始化，无需额外配置。
• 方案一中，jackson-datatype-lombok模块会自动识别Lombok的Builder注解，Spring Boot项目通常会自动引入该模块。

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