引言
Hello 大家好，这里是Anyin。
在上一篇 关于OpenFeign那点事儿 - 使用篇[1] 我们聊了关于OpenFeign的使用以及在某些特殊场景下的解决方案。
今天我们来聊一聊，OpenFeign的底层是怎么实现的，为什么一个接口 加 一个注解就可以实现远程的接口调用。
基础知识：Java动态代理
在我们日常开发中，最常见到的代码就是一个接口，一个实现类，通过实现类来执行具体的逻辑。如下：
public interface FeignApi {
ApiResponse infoByMobile(String mobile);
}
public class FeignApiImpl implements FeignApi{
public ApiResponse infoByMobile(String mobile){
log.info("this is execute impl method");
return ApiResponse.success("impl method");
}
}而OpenFeign的使用方法却是只使用了一个接口和一个注解，并没有实现类，即可实现了远程调用。神奇吗 ？
其实在我们的Java基础当中，Java动态代理即可实现该功能。这里，我们来自己手动实现下。
首先，我们先创建一个接口：
public interface FeignApi {
ApiResponse infoByMobile(String mobile);
}接着，创建一个实现类FeignApiProxy，并实现InvocationHandler接口，在这个实现类来实现我们具体要执行的操作，其实就是用来代替FeignApi接口的实现类。
@Slf4j
public static class FeignApiProxy implements InvocationHandler{
@Override
public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
// 如果进来是一个实现的具体类，直接调用
if(Object.class.equals(method.getDeclaringClass())){
return method.invoke(this, args);
}else{ // 如果是一个接口
log.info("this is execute proxy method");
return ApiResponse.success("proxy method");
}
}
}然后，我们再创建一个创建动态代理对象的类ProxyFactory，它根据传递进来的类型，进行动态代理，创建代理对象。
public class ProxyFactory {
public <T> T getInstance(Class<T> clazz){
// 自定义实现的代理类
FeignApiProxy proxy = new FeignApiProxy();
// 返回代理对象
return (T) Proxy.newProxyInstance(clazz.getClassLoader(), new Class[] { clazz }, proxy);
}
}最后，我们来测试下：
@Test
public void test(){
// 创建代理工厂
ProxyFactory factory = new ProxyFactory();
// 创建代理对象
FeignApi api = factory.getInstance(FeignApi.class);
// 执行方法
ApiResponse response = api.infoByMobile("anyin");
log.info("response: {}", JSONUtil.toJsonStr(response));
}结果显示：
通过以上方法，我们就实现了一个简单的代理功能，只有接口，没有实现类的情况下，可以通过代理对象来执行具体的逻辑。
有人可能会疑问，虽然我们没有FeignApi接口的实现类，但是我们却额外实现了InvocationHandler接口的实现类，类的数量并没有变少，好像也没有省事多少。其实不然，FeignApi接口的实现类是具体的某个类型类，而InvocationHandler实现类是抽象的，我们可以在实现方法中处理各种逻辑。
例如：具体的使用场景就是我们场景的Mybatis的Dao层接口，OpenFeign组件的FeignClien接口。
基础知识：Spring Cloud NamedContextFactory
在了解了Java动态代理之后，我们再了解下Spring Cloud 的父子容器机制。
Spring Cloud 它为了实现不同的微服务具有不同的配置，例如不同的FeignClient会使用不同的ApplicationContext，从各自的上下文中获取不同配置进行实例化。在什么场景下我们会需要这种机制呢？ 例如，认证服务是会高频访问的服务，它的客户端超时时间应该要设置得比较小；而报表服务因为涉及到大量的数据查询和统计，它的超时时间就应该设置得比较大。
在Spring Cloud 中NamedContextFactory就是为了实现该机制而设计的。我们可以自己手动实现下这个机制。
首先，创建AnyinContext类和AnyinSpecification类。AnyinContext就是我们的上下文类，或者容器类，它是一个子容器。AnyinSpecification类是对应的配置类保存类，根据不通过的上下文名称(name字段）来获取配置类。
public static class AnyinSpecification implements NamedContextFactory.Specification {
private String name;
private Class<?>[] configurations;
public AnyinSpecification(String name, Class<?>[] configurations) {
this.name = name;
this.configurations = configurations;
}
@Override
public String getName() {
return name;
}
@Override
public Class<?>[] getConfiguration() {
return configurations;
}
}
public static class AnyinContext extends NamedContextFactory<AnyinSpecification>{
private static final String PROPERTY_SOURCE_NAME = "anyin";
private static final String PROPERTY_NAME = PROPERTY_SOURCE_NAME + ".context.name";
public AnyinContext(Class<?> defaultConfigType) {
super(defaultConfigType, PROPERTY_SOURCE_NAME, PROPERTY_NAME);
}
}接着，我们创建三个bean类，它们会分别置于父容器配置、子容器公共配置、子容器配置类中。如下：
public static class Parent {}
public static class AnyinCommon{}
@Getter
public static class Anyin {
private String context;
public Anyin(String context) {
this.context = context;
}
}然后，再创建三个配置类，如下：
// 父容器配置类
@Configuration(proxyBeanMethods = false)
public static class ParentConfig {
@Bean
public Parent parent(){
return new Parent();
}
@Bean
public Anyin anyin(){
return new Anyin("anyin parent=============");
}
}
// 子容器公共配置类
@Configuration(proxyBeanMethods = false)
public static class AnyinCommonCnofig{
@Bean
public AnyinCommon anyinCommon(){
return new AnyinCommon();
}
}
// 子容器1配置类
@Configuration(proxyBeanMethods = false)
public static class Anyin1Config{
@Bean
public Anyin anyin(){
return new Anyin("anyin1=============");
}
}
// 子容器2配置类
@Configuration(proxyBeanMethods = false)
public static class Anyin2Config{
@Bean
public Anyin anyin(){
return new Anyin("anyin2=============");
}
} 最后，我们来做下代码测试。
@Test
public void test(){
// 创建父容器
AnnotationConfigApplicationContext parent = new AnnotationConfigApplicationContext();
// 注册父容器配置类
parent.register(ParentConfig.class);
parent.refresh();
// 创建子容器，并且注入默认的功能配置类
AnyinContext context = new AnyinContext(AnyinCommonCnofig.class);
// 子容器1配置类
AnyinSpecification spec1 = new AnyinSpecification("anyin1", new Class[]{Anyin1Config.class});
// 子容器2配置类
AnyinSpecification spec2 = new AnyinSpecification("anyin2", new Class[]{Anyin2Config.class});
// 子容器和父容器绑定关系
context.setApplicationContext(parent);
// 子容器注入子容器1/2配置类
context.setConfigurations(Lists.newArrayList(spec1, spec2));
// 获取子容器1的Parent实例
Parent parentBean1 = context.getInstance("anyin1", Parent.class);
// 获取子容器2的Parent实例
Parent parentBean2 = context.getInstance("anyin2", Parent.class);
// 获取父容器的Parent实例
Parent parentBean3 = parent.getBean(Parent.class);
// true
log.info("parentBean1 == parentBean2: {}", parentBean1.equals(parentBean2));
// true
log.info("parentBean1 == parentBean3: {}", parentBean1.equals(parentBean3));
// true
log.info("parentBean2 == parentBean3: {}", parentBean2.equals(parentBean3));
// 获取子容器1的AnyinCommon实例
AnyinCommon anyinCommon1 = context.getInstance("anyin1", AnyinCommon.class);
// 获取子容器2的AnyinCommon实例
AnyinCommon anyinCommon2 = context.getInstance("anyin1", AnyinCommon.class);
// true
log.info("anyinCommon1 == anyinCommon2: {}", anyinCommon1.equals(anyinCommon2));
// 报错，没有找到对应的bean
// AnyinCommon anyinCommon3 = parent.getBean(AnyinCommon.class);
// 获取子容器1的Anyin对象
Anyin anyin1 = context.getInstance("anyin1", Anyin.class);
// anyin1 context: anyin1=============
log.info("anyin1 context: {}", anyin1.getContext());
// anyin2 context: anyin2=============
Anyin anyin2 = context.getInstance("anyin2", Anyin.class);
log.info("anyin2 context: {}", anyin2.getContext());
// false
log.info("anyin1 == anyin2: {}", anyin1.equals(anyin2));
// anyinParent: anyin parent=============
Anyin anyinParent = parent.getBean(Anyin.class);
log.info("anyinParent: {}", anyinParent.getContext());
}以上代码可能会比较长，请详细查阅。通过以上测试，我们可以总结以下几点：
?子容器可以拿到父容器的实例
?父容器无法拿到子容器的实例
?实例优先从公共配置类中获取（这点需要在AnyinCommonCnofig配置类添加Anyin实例配置）
源码解析
了解了以上2个基本的机制，这时候我们再来看源码，可能会容易理解一些。
OpenFeign组件的入口就是从@EnableFeignClients注解开始的。它导入了一个FeignClientsRegistrar类，具体的FeignClient就是在这个类内进行初始化和注册的。
在FeignClientsRegistrar内，它先注册了默认的配置类，然后再注册具体的FeignClient。这个默认的配置类是需要在@EnableFeignClients注解内进行配置的，一般我们都不会配置，所以这里就暂时不管它。
接下来，我们看看注册具体的FeignClient是如何实现的。
我们主要看看registerFeignClient方法，该方法内通过FeignClientFactoryBean来进行实例的创建，主要代码如下：
接着，我们看看FeignClientFactoryBean的getObject()方法，该方法返回了代理对象。
通过feign方法获取了Feign.Builder实例，它是在FeignClientsConfiguration类中进行配置的。
在loadBalance方法中，获取Client实例，该实例用于做客户端负载均衡，Targeter实例是DefaultTargeter，它同样是在FeignClientsConfiguration中进行装配的。
接着代码会回到Feign类的target方法。
我们直接看下ReflectiveFeign类的newInstance方法。
到这里，是不是看到了熟悉的场景，Java动态代理就是在这里处理的。target.type()返回的就是我们的定义的FeignClient接口。InvocationHandler的实现类就是ReflectiveFeign#FeignInvocationHandler，它的invoke方法就是我们在调用FeignClient接口的方法代理的具体实现。
根据方法实例，拿到对应的MethodHandler进行调用。dispatch其实就是一个map数据结构，如下：
返回的MethodHandler接口的实现类就是SynchronousMethodHandler，它的invoke方法就是开始执行具体的http调用逻辑。
最后
以上，就是根据个人理解梳理的OpenFeign源码流程，如果有什么问题欢迎大家指正。
个人认为，只要理解底层的Java动态代理和Spring Cloud NamedContextFactory机制，然后再回过头过来梳理源码，整个流程会顺很多。
相关测试用例源码地址：Anyin Cloud[2]
References
[1] 关于OpenFeign那点事儿 - 使用篇: https://juejin.cn/post/7068179877047828517/
[2] Anyin Cloud: https://gitee.com/anyin/anyin-cloud/tree/master/anyin-center-modules/anyin-center-auth/src/test/java/org/anyin/gitee/cloud/center/auth/test
本文暂时没有评论，来添加一个吧(●'◡'●)