当我们使用 dubbo 或者 feign 进行 RPC 调用用时,通常的调用模板方式如下:
public BizResponse method(BizRequest request){
RpcRequest rpcRequest = buildRpcRequest();
RpcReponse reuslt = xxxFacade.invoke(rpcRequest);
// 判断响应码与响应对象
return buildResponse(result);
}
private RpcRequest convert(BizRequest reuest){
RpcRequest request = new RpcRequest();
// 处理过程
return request;
}
private BizResponse convert(RpcResponse response) {
BizResponse response = new BizResponse();
// 处理过程
return response:
}
其实这个一套模板处理模式,在最开始的时候我一般会把对象转换过程抽取到 XxxConverter 类使用静态方法进行处理。但是在上周写代码的时候就想到可以利用 Spring 进行依赖注入的自动类型转换来帮助我进行对象转换。
在上面的一个方法当中涉及到两次对象转换:
-
业务对象转换成 RPC 请求对象
-
RPC 响应对象转换成业务响应对象
在这里面我们需要实现 org.springframework.core.convert.converter.Converter
接口:
BizRequestToRpcRequestConverter.java
@Component
public class BizRequestToRpcRequestConverter implements Converter<BizRequest, RpcRequest> {
@Override
public RpcRequest convert(BizRequest source) {
Assert.notNull(source, "source must no null");
RpcRequest request = new RpcRequest();
request.setXxx(source.getXxx());
// ....
return request;
}
}
以及:
RpcResponseToBizResponseConverter.java
@Component
public class RpcResponseToBizResponseConverter implements Converter<RpcResponse, BizResponse> {
@Override
public BizResponse convert(RpcResponse source) {
Assert.notNull(source, "source must no null");
BizResponse response = new BizResponse();
response.setXxx(source.getXxx());
// ....
return response;
}
}
注意这 2 个实现类上面需要添加 @Component 注解,这样就可以把它们添加到 Spring 容器当中去了。下面我们就需要把这 2 个转换器添加到配置当中:
ConversionServiceConfig.java
@Configuration
public class ConversionServiceConfig {
@Bean
public GenericConversionService genericConversionService(List<Converter> converters){
GenericConversionService conversionService = new GenericConversionService();
converters.forEach(converter -> conversionService.addConverter(converter));
return conversionService;
}
}
因为我们进行 Dubbo 服务调用以及结果处理的时候处理逻辑是一致的,在这里我就借鉴了一下 TransactionTemplate 的思想,基于回调方式的处理。
@Slf4j
@Service("orderClientDubbo")
public class OrderClientDubbo implements OrderClient {
@Resource
protected ConversionService genericConversionService;
@Reference
private OrderFacade orderFacade;
@Override
public BaseResponse<OrderRes> orderApply(OrderReq request) {
log.info("OrderClientDubbo#orderApply request param is {}", JSON.toJSONString(request));
OrderApplyRequest remoteRequest = genericConversionService.convert(request, OrderApplyRequest.class);
BaseResponse<OrderRes> response = execute(OrderRes.class,
() -> orderFacade.orderApply(remoteRequest));
log.info("OrderClientDubbo#orderApply response is {}", JSON.toJSONString(response));
return response;
}
public <T> BaseResponse<T> execute(Class<T> dataClazz, InvokeCallback callback){
// 非空判断
Assert.notNull(dataClazz, "dataClazz must not null");
// 远程调用
CommonResponse response;
try {
response = callback.doInExecute();
} catch (Exception e) {
log.error("SecurityClientDubbo invoke security service fail", e);
return BaseResponse.error(EngineErrorCodeEnum.SYSTEM_ERROR);
}
// 处理结果
return processResponse(dataClazz, response);
}
private <T> BaseResponse<T> processResponse(Class<T> responseClazz, CommonResponse response) {
if(response == null) {
return BaseResponse.error(EngineErrorCodeEnum.SYSTEM_ERROR);
}
if(!SuccessCodeConstants.PAY_ENGINE_SUCCESS_CODE.equals(response.getCode())) {
return BaseResponse.error(response.getCode(), response.getMsg());
}
T result = genericConversionService.convert(response.getData(), responseClazz);
return BaseResponse.create(response.getCode(), response.getMsg(), result);
}
@FunctionalInterface
public interface InvokeCallback {
CommonResponse doInExecute();
}
}
上面就是整个代码实现,归纳起来需要实现以下几个步骤:
-
定义一个类型转换服务,只需要定义一次
-
每一个方法对应两个转换器实现:业务请求对象 -> RPC 请求对象 以及 RPC 响应对象 -> 业务响应对象
-
远程调用方法中统一使用模板加回调方式
当然这里我只在接口中定义了一个方法,方法越多越能体现出这样写的好处。