利用 Spring 自動類型轉換與回調模式寫出優雅的代碼

當我們使用 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 進行依賴注入的自動類型轉換來幫助我進行對象轉換。如果大家不清楚 Spring 的自動類型轉換可以看一下我之前的博客 – Spring COC TypeConverter。

在上面的一個方法當中涉及到兩次對象轉換：

• 業務對象轉換成 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 響應對象 -> 業務響應對象
• 遠程調用方法中統一使用模板加回調方式

當然這裏我只在接口中定義了一個方法，方法越多越能體現出這樣寫的好處。