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

@Service
public class FaqService {

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

    // ... 其他业务逻辑

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

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

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

@Service
@Slf4j
@AllArgsConstructor
@Component("commonService")
public class CommonServiceImpl implements CommonService {

   private static Logger logger = LoggerFactory.getLogger(CommonServiceImpl.class);

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

   @Override
    public Object mapToEntity(Object type) {
        // 问题在于这里，ModelMapper需要明确的目标类型
        Object entityObject = modelMapper.map(type, Object.class); 
        return entityObject;
    }

   @Override
    public Object mapToDto(Object type) {
        // 同样，ModelMapper需要明确的目标类型
        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的Class类型
     * @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) {
        // 使用传入的entityClass进行映射
        return modelMapper.map(dto, entityClass);
    }

    @Override
    public D mapToDto(E entity) {
        // 使用传入的dtoClass进行映射
        return modelMapper.map(entity, dtoClass);
    }
}

import org.modelmapper.ModelMapper;
import org.springframework.stereotype.Service;
import lombok.extern.slf4j.Slf4j;
import org.springframework.stereotype.Component;

// 假设我们有SpecificEntity和SpecificDto类
class SpecificEntity { /* ... */ }
class SpecificDto { /* ... */ }

@Service
@Slf4j
@Component("specificService") // 可以选择性地指定bean名称
public class SpecificService extends AbstractCommonService<SpecificEntity, SpecificDto> {

    /**
     * SpecificService的构造函数。
     * 负责将ModelMapper实例以及SpecificEntity和SpecificDto的Class对象传递给父类构造函数。
     * @param modelMapper 注入的ModelMapper实例
     */
    public SpecificService(ModelMapper modelMapper) {
        // 调用父类构造函数，传入具体的实体类和DTO类
        super(modelMapper, SpecificEntity.class, SpecificDto.class);
    }

    /**
     * 示例业务方法，演示如何使用父类的映射功能。
     */
    public SpecificDto createSpecificItem(SpecificDto inputDto) {
        // 使用父类提供的mapToEntity方法，无需类型转换
        SpecificEntity entity = this.mapToEntity(inputDto);
        // ... 执行业务逻辑，例如保存entity到数据库
        System.out.println("Mapped DTO to Entity: " + entity.getClass().getSimpleName());

        // 假设这里有一些处理后的entity
        SpecificEntity processedEntity = new SpecificEntity(); // 模拟处理后的实体
        // 使用父类提供的mapToDto方法，无需类型转换
        SpecificDto resultDto = this.mapToDto(processedEntity);
        System.out.println("Mapped Entity to DTO: " + resultDto.getClass().getSimpleName());
        return resultDto;
    }

    // 可以在这里添加其他SpecificService特有的业务方法
}