Spring Boot 中构建通用的 DTO 与实体映射服务

// 在每个具体服务中重复编写的映射方法
@Resource(name = "modelMapper")
private final ModelMapper modelMapper;

private FaqDto mapToDto(Faq faq){
    return modelMapper.map(faq, FaqDto.class);
}

private Faq mapToEntity(FaqDto faqDto){
    return modelMapper.map(faqDto, Faq.class);
}

public interface CommonService<T> {
   T mapToEntity(T type);
   T mapToDto(T type);
}

@Service
@Slf4j
@AllArgsConstructor
@Component("commonService")
public class CommonServiceImpl implements CommonService { // 注意：这里泛型丢失或不明确

   @Resource(name = "modelMapper")
   private final ModelMapper modelMapper;

   @Override
   public Object mapToEntity(Object type) {
       // 尝试将所有类型映射到 Object.class，这会导致类型信息丢失
       Object entityObject = modelMapper.map(type, Object.class); 
       return entityObject;
   }

   @Override
   public Object mapToDto(Object type) {
       // 尝试将所有类型映射到 Object.class，这会导致类型信息丢失
       Object dtoObject = modelMapper.map(type, Object.class);
       return dtoObject;
   }
}

// E for Entity and D for DTO
public interface CommonService<E, D> {

    /**
     * 将 DTO 对象映射为实体对象。
     * @param dto 要映射的 DTO 对象。
     * @return 映射后的实体对象。
     */
    E mapToEntity(D dto);

    /**
     * 将实体对象映射为 DTO 对象。
     * @param entity 要映射的实体对象。
     * @return 映射后的 DTO 对象。
     */
    D mapToDto(E entity);
}

import org.modelmapper.ModelMapper;

public abstract class AbstractCommonService<E, D> implements CommonService<E, D> {

    protected final ModelMapper modelMapper;
    private final Class<E> entityClass; // 存储实体类的 Class 对象
    private final Class<D> dtoClass;    // 存储 DTO 类的 Class 对象

    /**
     * 构造函数，用于注入 ModelMapper 实例和具体的实体/DTO 类。
     * @param modelMapper ModelMapper 实例
     * @param entityClass 实体类的 Class 对象
     * @param dtoClass DTO 类的 Class 对象
     */
    public AbstractCommonService(ModelMapper modelMapper, Class<E> entityClass, Class<D> dtoClass) {
        this.modelMapper = modelMapper;
        this.entityClass = entityClass;
        this.dtoClass = dtoClass;
    }

    @Override
    public E mapToEntity(D dto) {
        // 使用 ModelMapper 将 DTO 映射到具体的实体类
        return modelMapper.map(dto, entityClass);
    }

    @Override
    public D mapToDto(E entity) {
        // 使用 ModelMapper 将实体映射到具体的 DTO 类
        return modelMapper.map(entity, dtoClass);
    }
}

// 示例实体类
public class SpecificEntity {
    private Long id;
    private String name;
    // ... getters and setters
}

// 示例 DTO 类
public class SpecificDto {
    private Long id;
    private String name;
    // ... getters and setters
}

import org.modelmapper.ModelMapper;
import org.springframework.stereotype.Service;
import lombok.extern.slf4j.Slf4j; // 假设使用 Lombok

@Service
@Slf4j // 用于日志记录
public class SpecificService extends AbstractCommonService<SpecificEntity, SpecificDto> {

    /**
     * 构造函数，通过 Spring 自动注入 ModelMapper，并传入具体的实体和 DTO 类。
     * @param modelMapper Spring 容器中配置的 ModelMapper 实例
     */
    public SpecificService(ModelMapper modelMapper) {
        super(modelMapper, SpecificEntity.class, SpecificDto.class);
    }

    // 可以在这里添加 SpecificService 独有的业务方法
    public void performSpecificBusinessLogic() {
        SpecificDto dto = new SpecificDto();
        dto.setId(1L);
        dto.setName("Test Item");

        // 使用继承自 AbstractCommonService 的通用映射方法
        SpecificEntity entity = this.mapToEntity(dto);
        log.info("Mapped DTO to Entity: ID={}, Name={}", entity.getId(), entity.getName());

        SpecificDto mappedDto = this.mapToDto(entity);
        log.info("Mapped Entity to DTO: ID={}, Name={}", mappedDto.getId(), mappedDto.getName());
    }
}

import org.modelmapper.ModelMapper;
import org.modelmapper.convention.MatchingStrategies;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

@Configuration
public class ModelMapperConfig {

    @Bean
    public ModelMapper modelMapper() {
        ModelMapper modelMapper = new ModelMapper();
        // 可以根据需要配置 ModelMapper 的匹配策略、跳过字段等
        modelMapper.getConfiguration()
                .setMatchingStrategy(MatchingStrategies.STRICT) // 严格匹配策略
                .setFieldMatchingEnabled(true) // 启用字段匹配
                .setSkipNullEnabled(true); // 映射时跳过空值
        return modelMapper;
    }
}