如何让Spring @Repository结合MapStruct自动转换领域对象与DB实体

针对你在端口与适配器架构下，希望简化领域对象与数据库实体双向映射调用的需求，以下是几种可行的实现方案：

方案一：自定义Repository包装类（最直接落地） #

通过封装原生Spring Data Repository，把转换逻辑隐藏在适配器层，让业务层直接操作领域对象。

1. 定义面向领域的Repository接口

public interface ClientDomainRepository {
    Client save(Client client);
}

2. 实现包装类，注入原生Repository和映射器

@Repository
public class ClientDomainRepositoryImpl implements ClientDomainRepository {
    private final ClientRepository clientRepository;
    private final ClientMapper clientMapper;

    // 构造函数注入（Spring 4.3+支持无@Autowired）
    public ClientDomainRepositoryImpl(ClientRepository clientRepository, ClientMapper clientMapper) {
        this.clientRepository = clientRepository;
        this.clientMapper = clientMapper;
    }

    @Override
    public Client save(Client client) {
        ClientDocument entity = clientMapper.mapToClientDocument(client);
        ClientDocument savedEntity = clientRepository.save(entity);
        return clientMapper.mapToClient(savedEntity);
    }
}

3. 业务层直接调用包装后的Repository

public Client createClient(Client client) {
    return clientDomainRepository.save(client);
}

这种方式完全符合端口适配器架构，转换逻辑被封装在持久化适配器内部，业务层无需感知实体转换细节。

方案二：增强MapStruct映射器+通用转换方法 #

先统一MapStruct的映射方法名，再结合包装类进一步简化调用：

修改ClientMapper，使用统一的map方法名（MapStruct支持方法重载）：

@Mapper(componentModel = "spring")
public interface ClientMapper {
    Client map(ClientDocument clientDocument);
    ClientDocument map(Client client);
}

此时结合方案一的包装类，内部调用会更简洁，但核心简化逻辑还是依赖包装类的封装。

方案三：通用Spring Data Repository基类扩展 #

通过自定义Spring Data Repository的基类，实现通用的领域对象-实体转换逻辑，避免每个Repository都重复写包装代码。

1. 定义通用转换接口

public interface DomainEntityMapper<D, E> {
    E toEntity(D domainObject);
    D toDomain(E entity);
}

2. 实现通用Repository基类

public abstract class DomainMongoRepository<D, E, ID> implements MongoRepository<E, ID> {
    protected final DomainEntityMapper<D, E> mapper;

    protected DomainMongoRepository(DomainEntityMapper<D, E> mapper) {
        this.mapper = mapper;
    }

    // 新增面向领域对象的save方法
    public D saveDomain(D domainObject) {
        E entity = mapper.toEntity(domainObject);
        E savedEntity = save(entity);
        return mapper.toDomain(savedEntity);
    }
}

3. 改造ClientMapper和Repository
   让ClientMapper实现通用转换接口：

@Mapper(componentModel = "spring")
public interface ClientMapper extends DomainEntityMapper<Client, ClientDocument> {
    @Override
    Client toDomain(ClientDocument clientDocument);
    @Override
    ClientDocument toEntity(Client client);
}

让ClientRepository继承通用基类：

@Repository
public interface ClientRepository extends DomainMongoRepository<Client, ClientDocument, String> {
}

4. 业务层调用简化为：

public Client createClient(Client client) {
    return clientRepository.saveDomain(client);
}

这种方式适合多领域对象的项目，能减少重复代码，统一转换逻辑。

替代思路：领域服务封装持久化逻辑 #

如果偏向领域驱动设计（DDD），可以把转换+持久化逻辑封装在领域服务中：

@Service
public class ClientDomainService {
    private final ClientRepository clientRepository;
    private final ClientMapper clientMapper;

    public ClientDomainService(ClientRepository clientRepository, ClientMapper clientMapper) {
        this.clientRepository = clientRepository;
        this.clientMapper = clientMapper;
    }

    public Client saveClient(Client client) {
        ClientDocument entity = clientMapper.mapToClientDocument(client);
        ClientDocument savedEntity = clientRepository.save(entity);
        return clientMapper.mapToClient(savedEntity);
    }
}

业务层直接调用领域服务的方法，同样能达到简化代码的目的，且更符合DDD中领域服务的职责定位。

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