Open Feign 底层原理剖析

Feign的简单介绍

Feign组件主要用于微服务项目中，用来简化服务之间的远程调用，相信大家对他的使用方法已经相当熟悉了。那么Feign到底是如何实现服务的远程调用的呢？又是如何发送请求的呢？发送的请求又是什么样子的呢？本文主要就针对这三个对Feign的原理做一个简单的分析。

上面这张图是我按照自己的理解简单的画了一下Feign的主要工作流程，下面将结合Feign底层的源码对工作原理进行详细的分析。

Feign的工作原理

根据上图我将流程分为主要的三个步骤：通过动态代理在本地实例化远程接口->封装Request对象并进行编码->发送请求并对获取结果进行解码。我写了一个简单Feign调用的Demo，代码如下，以此作为背景再结合底层源码来分析。

@FeignClient("product")
public interface ProductClient {
    /**
     * 根据商品id获取商品信息
     * @param id    商品id
     * @return  商品信息
     */
    @GetMapping("/product/getProductInfo/{id}")
    Result<ProductInfoDTO> getProductInfo(@PathVariable("id") Integer id);
}
复制代码

1.创建远程接口的本地代理实例

要使用Feign就必须在启动类上加上注解@EnableFeignCleints，这个注解就相当于Feign组件的一个入口，当使用@EnableFeignCleints后，程序启动后，会进行包扫描，扫描所有被@FeignCleint注解修饰的接口，通过JDK底层的动态代理来为远程接口创建代理实例，并且注册到IOC容器中。我们先来看看@EnableFeignCleints这个注解。

@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.TYPE)
@Documented
@Import(FeignClientsRegistrar.class)
public @interface EnableFeignClients {
    //一系列属性
    ......
}
复制代码

@EnableFeignCleints注解引入了FeignClientsRegistrar类，这个类会在启动时调用registerBeanDefinitions()方法，而这个方法里面只有两行调用其他方法的代码，分别是用来加载Feign的各项配置的方法registerDefaultConfiguration(metadata, registry)和注册实例化对象的方法registerFeignClients(metadata, registry)。我们重点来看一下registerFeignClients()方法，方法的主要的逻辑就是先扫描基础包路径然后，然后找出被@ FeignClient注解修饰的接口，放入Set中，接着遍历集合为每个接口逐一创建实例化对象，主要代码如下：

//获取扫描的包路径
Set<String> basePackages;
basePackages.add(ClassUtils.getPackageName(clazz));
clientClasses.add(clazz.getCanonicalName());
......
//遍历包路径搜索目标接口
for (String basePackage : basePackages) {
    Set<BeanDefinition> candidateComponents = scanner.findCandidateComponents(basePackage);
    for (BeanDefinition candidateComponent : candidateComponents) {
    Map<String, Object> attributes = annotationMetadata.getAnnotationAttributes(
                        FeignClient.class.getCanonicalName());
    registerClientConfiguration(registry, name,attributes.get("configuration"));
    //为接口创建代理对象的方法
    registerFeignClient(registry, annotationMetadata, attributes);
    }
}
复制代码

可以看到创建对象是交给registerFeignClient()方法来处理的，该方法会在创建对象前进行一系列的准备工作，比如IOC中对象对应的key值统一使用@FeignClient中的value值+”FeignClient”，本例中对应为productFeignClient等。而对于创建对象的所调用的方法一层层深入进去会发现，最终实际创建对象的核心代码是feign.ReflectiveFeign类中的newInstance()方法，其代码如下：

List<DefaultMethodHandler> defaultMethodHandlers = new LinkedList<DefaultMethodHandler>();
InvocationHandler handler = factory.create(target, methodToHandler);
    T proxy = (T) Proxy.newProxyInstance(target.type().getClassLoader(), new Class<?>[]{target.type()}, handler);
    for(DefaultMethodHandler defaultMethodHandler : defaultMethodHandlers) {
      defaultMethodHandler.bindTo(proxy);
    }
    return proxy;
复制代码

看到这段代码相信大家都很熟悉了吧，这不正是JDK底层典型的动态代理嘛，可见Feign也是基于代理模式来创建接口的实例化对象的。而代理工具类InvocationHandler，Feign也默认提供了两种实现，稍后会提到。

2.封装Request对象并进行编码

当调用ProductClient接口中的getProductInfo()方法时，底层通过JDK动态代理交由Feign的代理类FeignInvocationHandler进行处理，（Feign底层实现了两个调用处理器分别为FeignInvocationHandler和HystrixInvocationHandler，默认的调用处理器为FeignInvocationHandler，当和Hystrix结合使用时才会使用HystrixInvocationHandler，本篇基于默认的FeignInvocationHandler进行分析）根据方法的对象在映射集合中找到对应的MethodHandler方法处理器。

static class FeignInvocationHandler implements InvocationHandler {
    private final Map<Method, MethodHandler> dispatch;
    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
    ......
      //找到对应的方法处理器
      return dispatch.get(method).invoke(args);
    }
}
复制代码

Feign中为MethodHandler接口提供了默认的实现类SynchronousMethodHandler，其中中核心的逻辑就是根据具体的配置先创建RequestTemplate请求模板对象，然后调用Target接口中的apply(RequestTemplate input)方法根据刚刚获取到的请求模板对象创建远程服务请求的Request对象。部分核心代码如下：

final class SynchronousMethodHandler implements MethodHandler {
    ......
    public Object invoke(Object[] argv) throws Throwable {
        //创建请求模板对象，同时使用Encode接口进行编码操作
        RequestTemplate template = buildTemplateFromArgs.create(argv);
        Retryer retryer = this.retryer.clone();
    //Feign默认提供的重试机制
        while (true) {
            try {
        //发送请求和获取响应结果的核心方法
            return executeAndDecode(template);
            } catch (RetryableException e) {
            retryer.continueOrPropagate(e);
            if (logLevel != Logger.Level.NONE) {
                logger.logRetry(metadata.configKey(), logLevel);
            }
            continue;
            }
    }
    }
​
    Object executeAndDecode(RequestTemplate template) throws Throwable {
    //多个方法层层调用这里简单贴出主要逻辑
    for (RequestInterceptor interceptor : requestInterceptors) {
            interceptor.apply(template);
        }
        Request request = target.apply(new RequestTemplate(template));
    if (logLevel != Logger.Level.NONE) {
            logger.logRequest(metadata.configKey(), logLevel, request);
        }
    ......
    }
}
复制代码

经过这一系列的操作后，Request对象就封装好了，我们来简单看一下这个对象的具体结构：

//请求方法，本例中对应为GET
private final String method;
//要访问的接口地址，本例中对应为/product/getProductInfo/22
private final String url;
//请求头部信息，本例对应的键值对为token=xingren
private final Map<String, Collection<String>> headers;
//请求体，一般POST请求下将复杂对象放入请求体，会被转换成字节数组进行传输
private final byte[] body;
//字符集
private final Charset charset;
复制代码

3.feign.Client发送请求并对获取结果进行解码

这一步骤Feign的代码量比较多，而且用了大量的try-catch和if-else，整段拿出来展示的话，可读性比较低，我在这里将源码分段进行分析。首先是调用feign.Client接口中的excute()方法执行请求并获取响应结果。对于Client接口，Feign提供了几个不同的实现：（1）默认的实现Default()类，内部使用JDK中的HttpURLConnnection完成URL请求处理，没有使用连接池，http连接的服用能力弱，性能低，一般不会采用这种方式。（2）当Feign配合Ribbon使用时提供的默认实现类LoadBalancerFeignClient，内部使用 Ribben 负载均衡技术完成URL请求处理的feign.Client客户端实现类。除此之外，我们也可以使用其他的http客户端来替代Feign底层默认的实现类。比如ApacheHttpClient，相比传统JDK自带的URLConnection，增加了易用性和灵活性，它不仅使客户端发送Http请求变得容易，而且也方便开发人员测试接口。既提高了开发的效率，也方便提高代码的健壮性。使用起来也很简单，只需引入依赖，然后增加配置feign.httpclient.enabled=true即可。这一步骤，源码简化之后如下：

Response response;
try { 
    response = client.execute(request, options);
    response.toBuilder().request(request).build();
} catch (IOException e) {
    //一系列的日志处理
}
复制代码

其次是对响应对象的null值处理、响应种类的判断以及响应对象消息体的处理，最后会将body转化成字节数组：

//判断返回的响应对象的类型是否正确
if (Response.class == metadata.returnType()) {
    //消息体的非空判断
    if (response.body() == null) {
        return response;
    }
    if (response.body().length() == null || response.body().length() > MAX_RESPONSE_BUFFER_SIZE) {
        shouldClose = false;
        return response;
    }
    //转换成字节数组
    byte[] bodyData = Util.toByteArray(response.body().asInputStream());
    return response.toBuilder().body(bodyData).build();
}
复制代码

最后一步是针对不同的http状态码来做不同的处理，如果http状态码为成功，再判断是否有返回值，如果有返回值就对响应对象进行解码操作，无返回值直接返回null；如果是404调用解码方法，最后Decoder底层会执行emptyValueOf()方法返回空的Response对象；如果状态码为其他类型，则返回异常。

if (response.status() >= 200 && response.status() < 300) {
    if (void.class == metadata.returnType()) {
        return null;
    } else {
        return decode(response);
    }
} else if (decode404 && response.status() == 404 && void.class != metadata.returnType()) {
    return decode(response);
} else {
    throw errorDecoder.decode(metadata.configKey(), response);
}
复制代码