1.HTTP工具使用流程及问题

1.1 使用OkHttp3流程示例

以常用的OkHttp3工具框架为例，其一个大致的流程如下：

其流程从下面的Java调用代码示例也可以看出来：

public static String doHttpPostReturnAsString(String url, String paramJson, int timeout, 
                        List<Interceptor> interceptors) {
    // 1.初始化客户端
    // 2.设置超时时间
    OkHttpClient client = CLIENT.newBuilder()
            .connectTimeout(timeout, TimeUnit.MILLISECONDS)
            .readTimeout(timeout, TimeUnit.MILLISECONDS)
            .writeTimeout(timeout, TimeUnit.MILLISECONDS)
            .build();
    // 3.设置拦截器
    if (!CollectionUtils.isEmpty(interceptors)) {
        for (Interceptor interceptor : interceptors) {
            client = client.newBuilder().addInterceptor(interceptor).build();
        }
    }
    // 4.根据url构建Request对象
    RequestBody body = RequestBody.create(JSON, paramJson);
    Request request = new Request.Builder()
            .url(url)
            .post(body)
            .build();
    // 5.调用并获取Response，提取信息后完成调用
    try (Response response = client.newCall(request).execute()) {
        if (response.isSuccessful()) {
            String string = response.body().string();
            return string;
        } else {
            LOGGER.error("doHttpGet error:{}", response.code());
        }
    } catch (Exception e) {
        LOGGER.error("doHttpGet error:", e);
    }
    return null;
}

1.2 存在的两大问题

这只是一个非常简单的实例，把调用方法写成工具类中的静态方法，就形成了一个可复用的静态工具类。其优点就是快速且较为简单维护，但最大缺点有二：

1. 硬编码实现：如果要支持动态参数就会导致入参臃肿，不便于扩展；
2. 现在的项目大部分都是用Spring管理对象的，静态工具类的方式也不便于将其纳入到Spring中进行管理，和Spring中大部分的框架没办法优雅的集成。

2.OpenFeign的优化

针对上面说的第一个硬编码实现问题，解决它就需要让每个功能模块分工明确，可替换性强，这样才可以做到不同场景使用不同组件实现以不同功能，避免硬编码问题。而Feign的做法便是使用了这种思路，针对HTTP工具的不同流程，抽象出了对应的组件，每个组件提供默认的实现，如果要针对某一流程实现特殊的逻辑，则替换对应的实现组件。

先看个使用Feign的简单示例：

public interface TestFeign {
    /**
     * 测试方法
     */
    @RequestLine("GET /test.json")
    String test();
}

public void test() {
    TestFeign testFeign = Feign.builder()
            // .contract(new XXXContract()) 可替换
            // .encoder(new XXXEncoder()) 可替换
            // .decoder(new XXXDecoder()) 可替换
            .client(new OkHttpClient())
            .requestInterceptors(new ArrayList<>())
            .target(TestFeign.class, "localhost:8080");
    // 调用HTTP API像调用方法一样，调用路径为：GET localhost:8080/test.json
    System.out.println(testFeign.test());
}

OpenFeign的调用流程相较于静态工具类变成了两步：

1. 先使用Feign构造实例化一个接口代理对象；
2. 调用接口对象的对应方法完成HTTP API的调用。

OpenFeign使用了大量组件来避免硬编码问题，向开发者屏蔽了操作HTTP工具的API操作。在传统的HTTP调用流程中Openfeign引入了如下变化：

从图中可以看到引入的组件非常多，针对HTTP工具执行一系列操作时引入了相应的组件，但关键核心的组件一共就5个：

1. Contract（协议）：表示Feign支持的协议，一般而言指的是注解，通过替换不同的Contract以支持解析不同的注解。如果需要支持Spring的MVC注解，则需要替换该组件；
2. Client（客户端）：Feign是简化HTTP调用的框架，本身不提供调用HTTP功能，依赖于客户端的具体实现类。如果要使用不同的HTTP工具，替换Client即可；
3. RequestTemplate（请求模板）：接口方法在编写后，其参数注解等信息基本不会再改动，而请求模板保存的就是实例化时解析注解的信息。如请求头信息、参数对应填充位置等，保证后续填充数据时可直接获取对应位置的对象数据；
4. Encoder（编码器）：将传入的参数进行编码获得body、headers或文件流，负责把方法传入的对象转成对应的编码形式。最常见的是把@ReqeustBody转成json串放到body中；
5. Decoder（解码器）：在获得响应的内容后，需要用解码器把响应内容转成接口方法返回类型的对象。如把常用的json返回串转成对应字段对象。

理解了Feign抽象出这些组件的初衷，就可以很容易理解Feign各个组件的作用了。

3.OpenFeign实现原理

由上节可知，OpenFeign的实现原理分为了两个大的步骤：

1. 使用Feign构造获得JDK动态代理对象；
2. 调用动态代理对象的方法执行代理逻辑，并填入请求参数及解析响应数据。

接下来以这两个步骤分别分析一下OpenFeign的实现原理。

3.1 使用Feign构造动态代理对象

相较于原来的静态工具类，这个步骤是多出来的，Feign这样的做法是为了让相同的调用场景下构造出来的对象可以重复使用，提升使用效率。

根据上面的流程构造出来的代理对象可以反复使用，一次构造解析，终身使用。因此在使用Spring等容器框架时，通常会把构造出来的代理对象以单例形式放入到容器中，以便使用时直接获取。如下代码：

@Configuration
public class FeignConfiguration {
    @Bean
    public TestFeign testFeign() {
        return Feign.builder()
            // .contract(new XXXContract()) 可替换
            // .encoder(new XXXEncoder()) 可替换
            // .decoder(new XXXDecoder()) 可替换
            .client(new OkHttpClient())
            .requestInterceptors(new ArrayList<>())
            .target(TestFeign.class, "localhost:8080");
    }
}

// 使用时
@Autowired
private TestFeign testFeign;

3.2 Feign动态代理的实现原理

获得构造出来的JDK动态代理对象后，调用接口方法将会触发Feign的动态代理逻辑，帮我们完成HTTP API的调用。

图中只写了主流程中比较重要的部分组件及组件在流程中的执行时间，只要知道了不同的组件在Feign工作流程中的生效时机，就可以自定义实现组件替换默认的组件，实现功能的扩展。

Feign解决与容器框架的集成问题便是基于上面两点实现的，把HTTP API写到一个个的接口中，使用JDK动态代理对接口方法完成代理，这样便可以把接口交给容器框架管理，需要使用时把代理对象取出来调用对应的方法即可。

如果框架便于集成，且扩展性很强，那么使用场景便可以得到扩充，如Springcloud便将Feign的组件进行替换，实现了Springcloud-openfeign框架，这也是Feign关键功能抽象组件带来的好处。