都说Feign是RPC，没有侵入性，为什么我的代码越来越像 C++

1. 概览

随着 Spring Cloud 的流行性，Feign 已经成为 RPC 的事实标准，由于其构建与 Http 协议之上，对请求和返回值缺少规范约束，在日常开发过程中经常由于设计不当对系统造成一定的侵入性。比如，很多公司基于 Web 经验对 Feign 返回体进行了约束，大致要求如下：

所有的请求统一返回统一的 FeignResult
FeignResult 中的 code 代表处理状态，msg 代表异常信息，data 代表返回结果
所有请求统一返回 200，详细处理状态存储于 code

看规范定义，可以断定其出自于 Web 开发规范，但在使用过程中却为系统增加了太多的模板代码。

1.1. 背景

基于 Web 规范的 Feign 开发，让我们又回到了 C++ 时代，每次进行调用后，第一件事就是对 code 进行判断，示例如下：

public boolean login(Long userId){
     FeignResult<User> userFeignResult = this.userFeignClient.getByUserId(userId);
     if (userFeignResult.getCode() != SUCCESS){
         throw new BizException(userFeignResult.getMsg());
     }
     User user = userFeignResult.getData();
     return user.checkPassword(userId);
}

在拿到异常code后，往往读取 msg，然后抛出自定义异常，从而中断处理流程。这些代码分布在系统的各处，枯燥无味还降低了代码的可读性。

对此，更加怀念 Dubbo 的做法，在 Client 和 Server 实现异常的穿透，最大限度的模拟接口调用，让开发人员从重复代码中释放出来。

1.2. 目标

实现 Client 和 Server 间的异常穿透，使用 Java Exception 替代 Error Code 码，降低繁琐的模板代码。

区分 Web 和 Feign 请求，只对 Feign 请求进行处理
正常返回结果，不受任何影响
异常返回结果，直接抛出异常，在异常中保存详细的 code 和 msg 信息
可自定义异常，Client 调用失败时，抛出自定义异常

2. 快速入门

2.1. 准备环境

首先，引入 lego starter，在pom中增加依赖：

<groupId>com.geekhalo.lego</groupId>
<artifactId>lego-demo</artifactId>
<version>0.1.16-feign-SNAPSHOT</version>

FeignClientConfiuration 将自动完成核心 Bean 的注册，主要包括：

RpcRequestInterceptor。为 Feign 调用添加标记头
RpcHandlerExceptionResolver。对 Feign 调用进行异常处理
RpcErrorDecoder。Feign 调用发生异常后，从 RpcErrorResult 恢复异常
SimpleRpcExceptionResolver。将 RpcErrorResult 转化为 RpcException

2.2. 编写测试 Feign

首先，定义一个标准的 FeignApi ，具体如下：

public interface TestFeignApi { 
    @PostMapping("/test/postData/{key}")
    void postData(@PathVariable String key, @RequestBody List<Long> data);

    @PostMapping("/test/postDataForError/{key}")
    void postDataForError(@PathVariable String key, @RequestBody List<Long> data);

    @GetMapping("/test/getData/{key}")
    List<Long> getData(@PathVariable String key);

    @GetMapping("/test/getDataForError/{key}")
    List<Long> getDataForError(@PathVariable String key);
}

基于 TestFeignApi 实现 TestFeignClient，具体如下：

@FeignClient(name = "testFeignClient", url = "http://127.0.0.1:9090")
public interface TestFeignClient extends TestFeignApi{
}

最后，构建 TestFeignApi 实现 TestFeignService，具体如下：

@RestController
public class TestFeignService implements TestFeignApi{
    @Getter(AccessLevel.PRIVATE)
    public Map<String, List<Long>> cache = Maps.newHashMap();

    public List<Long> getByKey(String key){
        return this.cache.get(key);
    }
    @Override
    public void postData(String key, List<Long> data) {
        this.cache.put(key, data);
    }

    @Override
    public void postDataForError(String key, List<Long> data) {
        throw new TestPostException();
    }

    @Override
    public List<Long> getData(String key) {
        return this.cache.get(key);
    }

    @Override
    public List<Long> getDataForError(String key) {
        throw new TestGetException();
    }
}

2.3. 编写测试代码

编写单元测试如下：

@SpringBootTest(classes = DemoApplication.class, webEnvironment = DEFINED_PORT)
class TestFeignClientTest {
    @Autowired
    private TestFeignClient testFeignClient;
    @Autowired
    private TestFeignService testFeignService;

    private String key;
    private List<Long> data;

    @BeforeEach
    void setUp() {
        this.key = String.valueOf(RandomUtils.nextLong());
        this.data = Arrays.asList(RandomUtils.nextLong(), RandomUtils.nextLong(), RandomUtils.nextLong(), RandomUtils.nextLong());
    }

    @AfterEach
    void tearDown() {
    }

    @Test
    void postData(){

        this.testFeignClient.postData(key, data);
        Assertions.assertEquals(data, this.testFeignService.getData(key));
    }

    @Test
    void postDataForError(){
        Assertions.assertThrows(RpcException.class, ()->{
            this.testFeignClient.postDataForError(key, data);
        });
    }

    @Test
    void getData(){
        this.testFeignClient.postData(key, data);

        List<Long> data = this.testFeignService.getData(key);
        Assertions.assertEquals(data, this.data);

        List<Long> ds = this.testFeignClient.getData(key);
        Assertions.assertEquals(ds, this.data);
    }

    @Test
    void getDataForError(){
        this.testFeignClient.getData(key);
        Assertions.assertThrows(RpcException.class, ()->{
            this.testFeignClient.getDataForError(key);
        });
    }
}

执行单元测试，顺利通过，从测试结果中我们可得：

对于正常调用 postData 和 getData 方法，调用成功返回预期结果
对于异常调用 postDataForError 和 getDataForError 方法，直接抛出 RpcException

2.4. 定制异常

定制异常需要两个组件配合使用：

CodeBasedException。在 Service 端使用，用于提供异常 code 和 msg 信息；
RpcExceptionResolver。在 Client 端使用，基于 RpcErrorResult 将 code 恢复为指定异常；

首先，创建 CustomException，具体如下：

public class CustomException extends RuntimeException
    implements CodeBasedException {
    public static final int CODE = 550;

    @Override
    public int getErrorCode() {
        return CODE;
    }

    @Override
    public String getErrorMsg() {
        return "自定义异常";
    }
}

CutomException 实现CodeBasedException 接口，并对 getErrorCode 和 getErrorMsg 两个方法进行重写。

然后，增加 CustomExceptionResolver，具体如下：

@Component
public class CustomExceptionResolver implements RpcExceptionResolver {
    @Override
    public Exception resolve(String methodKey, int status, String remoteAppName, RpcErrorResult errorResult) {
        if (errorResult.getCode() == CustomException.CODE){
            throw new CustomException();
        }
        return null;
    }
}

CustomExceptionResolver 实现 RpcExceptionResolver 接口，对 CustomException.CODE 进行特殊处理，直接返回 CustomException。

最后，编写方法抛出 CustomException，具体如下：

@Override
public void customException() {
    throw new CustomException();
}

最后，编写并运行单元测试，具体如下：

@Test
void customException(){
    Assertions.assertThrows(CustomException.class, ()->{
        this.testFeignClient.customException();
    });
}

可见，客户端在调用时指教抛出 CustomException，而非 RpcException。

3. 设计&扩展

都说Feign是RPC，没有侵入性，为什么我的代码越来越像 C++ — image

为了对异常的管理，我们对 Feign 和 Spring MVC 的组件进行定制，包括：

RpcRequestInterceptor 实现 RequestInterceptor 接口。拦截 Feign 调用，在请求 Header 中添加 Feign 标签，用以标记该请求来自 Feign 调用
RpcHandlerExceptionResolver 实现 HandlerExceptionResolver 接口。对 Spring MVC 出现的异常进行拦截，将异常信息转换为 RpcErrorResult 进行返回
RpcErrorDecoder 实现 ErrorDecoder 接口。当请求返回码非 200 时进行调用，将 RpcErrorResult 转换为 RpcException 直接抛出

整个处理流程如下：