精简控制器：设计与实现DTO映射与业务服务调用中间层

public class Controller {
    private Mapper mapper; // 假设使用某种DTO映射工具，如MapStruct或ModelMapper
    private Service1 service1;
    private Service2 service2;

    public Response1 test1(Request1 request1){
        // 1. 请求DTO到服务输入DTO的映射
        ServiceInputDto1 serviceInputDto1 = mapper.map(request1, ServiceInputDto1.class);
        // 2. 调用业务服务
        ServiceOutputDto1 serviceOutputDto1 = service1.test(serviceInputDto1);
        // 3. 服务输出DTO到响应DTO的映射
        Response1 response1 = mapper.map(serviceOutputDto1, Response1.class);
        return response1;
    }

    public Response2 test2(Request2 request2){
        // 1. 请求DTO到服务输入DTO的映射
        ServiceInputDto2 serviceInputDto2 = mapper.map(request2, ServiceInputDto2.class);
        // 2. 调用业务服务
        ServiceOutputDto2 serviceOutputDto2 = service2.test(serviceInputDto2);
        // 3. 服务输出DTO到响应DTO的映射
        Response2 response2 = mapper.map(serviceOutputDto2, Response2.class);
        return response2;
    }
}

import org.springframework.stereotype.Component;
import java.util.function.Function;

// 假设Mapper是一个通用的DTO映射接口或类，例如ModelMapper或MapStruct生成的Mapper
// 这里为了示例，我们简化其接口
interface Mapper {
    <S, D> D map(S source, Class<D> destinationType);
}

@Component // 标记为Spring组件，以便注入
public class InputOutputMapping {
    private final Mapper mapper; // 注入DTO映射工具

    public InputOutputMapping(Mapper mapper) {
        this.mapper = mapper;
    }

    /**
     * 通用方法，封装了请求DTO到服务输入DTO的映射、业务服务调用和服务输出DTO到响应DTO的映射。
     *
     * @param requestObject 请求对象 (例如 Controller接收的 Request DTO)
     * @param inDtoClass 业务服务输入DTO的Class对象
     * @param serviceFunction 业务服务调用函数，接收服务输入DTO，返回服务输出DTO
     * @param responseClass 响应DTO的Class对象
     * @param <REQ> 请求对象的类型
     * @param <IN_DTO> 业务服务输入DTO的类型
     * @param <OUT_DTO> 业务服务输出DTO的类型
     * @param <RESP> 响应对象的类型
     * @return 映射后的响应对象
     */
    public <REQ, IN_DTO, OUT_DTO, RESP> RESP apply(
        REQ requestObject,
        Class<IN_DTO> inDtoClass,
        Function<IN_DTO, OUT_DTO> serviceFunction,
        Class<RESP> responseClass
    ) {
        // 1. 将请求对象映射为业务服务所需的输入DTO
        final IN_DTO inputDto = mapper.map(requestObject, inDtoClass);
        // 2. 调用业务服务函数
        final OUT_DTO outputDto = serviceFunction.apply(inputDto);
        // 3. 将业务服务输出DTO映射为响应对象
        final RESP response = mapper.map(outputDto, responseClass);
        return response;
    }
}

import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.RequestBody;
import org.springframework.web.bind.annotation.RestController;

@RestController
public class OptimizedController {
    private final Service1 service1;
    private final Service2 service2;
    private final InputOutputMapping mapping; // 注入我们新创建的中间层组件

    public OptimizedController(Service1 service1, Service2 service2, InputOutputMapping mapping) {
        this.service1 = service1;
        this.service2 = service2;
        this.mapping = mapping;
    }

    @PostMapping("/test1")
    public Response1 test1(@RequestBody Request1 request1){
        return mapping.apply(
            request1,
            ServiceInputDto1.class,
            serviceInputDto1 -> service1.test(serviceInputDto1), // 使用Lambda表达式传递业务服务调用逻辑
            Response1.class
        );
    }

    @PostMapping("/test2")
    public Response2 test2(@RequestBody Request2 request2){
        return mapping.apply(
            request2,
            ServiceInputDto2.class,
            serviceInputDto2 -> service2.test(serviceInputDto2), // 同样使用Lambda表达式
            Response2.class
        );
    }
}

// 示例DTO和Service接口（实际应用中会更复杂）
class Request1 {}
class Response1 {}
class ServiceInputDto1 {}
class ServiceOutputDto1 {}
interface Service1 { ServiceOutputDto1 test(ServiceInputDto1 input); }

class Request2 {}
class Response2 {}
class ServiceInputDto2 {}
class ServiceOutputDto2 {}
interface Service2 { ServiceOutputDto2 test(ServiceInputDto2 input); }