图解+源码讲解 动态代理获取 FeignClient 代理对象

成功永远属于那些爱拼搏的人

相关文章
​图解+源码讲解 Feign 如何将客户端注入到容器中

从哪里开始分析

    我们在客户端进行注册的时候注册了一个客户端工厂类 FeignClientFactoryBean ，所以我们获取 FeignClient 指定是从这个工厂里面获取的了，所以我们就看看是怎么获取的这个FeignClient，一般用到了工厂的时候那么getObject方法就是获取实例的方法

@Override
public Object getObject() throws Exception {
// 获取目标实例
return getTarget();
}

getTarget()

// 返回一个 feign构造器客户端，通过 feingContext
<T> T getTarget() {
FeignContext context = this.applicationContext.getBean(FeignContext.class);
// 获取 feign 构造器
Feign.Builder builder = feign(context);

    这个构造器里面都构造了哪些东西呢，进入到构造器中

protected Feign.Builder feign(FeignContext context) {
FeignLoggerFactory loggerFactory = get(context, FeignLoggerFactory.class);
Logger logger = loggerFactory.create(this.type);

// @formatter:off
Feign.Builder builder = get(context, Feign.Builder.class)
// required values
.logger(logger)
.encoder(get(context, Encoder.class))
.decoder(get(context, Decoder.class))
.contract(get(context, Contract.class));
// @formatter:on

configureFeign(context, builder);
return builder;
}

    继续看 getTarget 方法的后面的流程，将 url 拼接成 http://GOODS-APPLICATION 这个地址

if (!StringUtils.hasText(this.url)) {
if (!this.name.startsWith("http")) {
// 进行url拼接
this.url = "http://" + this.name;
}
else {
this.url = this.name;
}
// http://GOODS-APPLICATION
this.url += cleanPath();
return (T) loadBalance(builder, context,
new HardCodedTarget<>(this.type, this.name, this.url));
}
}

    new HardCodedTarget 这个方法里面就是进行了赋值没有什么特殊的东西，直接看 loadBalance 这个方法

loadBalance() 方法

protected <T> T loadBalance(Feign.Builder builder, FeignContext context,
HardCodedTarget<T> target) {
// 根据feignCotext 上下文获取客户端实例，获取的client是 LoadBalancerFeignClient
Client client = getOptional(context, Client.class);
// 如果客户端不为空
if (client != null) {
// 进行客户端创建
builder.client(client);
// 获取 Targeter 操作，这个Targeter 是 HystrixTargerer
Targeter targeter = get(context, Targeter.class);
// 调用 Targeter 的target方法
return targeter.target(this, builder, context, target);
}
}

getOptional 操作

    this.contextId 是 GOODS-APPLICATION，type 是 Client.class

protected <T> T getOptional(FeignContext context, Class<T> type) {
return context.getInstance(this.contextId, type);
}

    返回的 client 信息如下图所示，图中的 CachingSpringLoadBalancerFacory就是要用到的负载均衡那块

HystrixTargeter#target 方法

class HystrixTargeter implements Targeter {

@Override
public <T> T target(FeignClientFactoryBean factory, Feign.Builder feign,
FeignContext context, Target.HardCodedTarget<T> target) {
// 它两不是一种类型所以就是false 之后就是true，进入feign#target方法
if (!(feign instanceof feign.hystrix.HystrixFeign.Builder)) {
return feign.target(target);
}
......
}

Feign.Builder#target 方法

    build 方法里面其实就是创建了一个有关于feign的反射对象，之后又调用了 newInstance 方法

public <T> T target(Target<T> target) {
// 创建了一个 ReflectiveFeign 对象，之后调用 ReflectiveFeign#newInstance 方法
return build().newInstance(target);
}

    先进入build 方法，看看这个方法里面做了什么操作，其实里面主要是做了返回一个 ReflectiveFeign对象，其实一看就是和反射有关系，我们重点看一下ReflectiveFeign#newInstance方法

public Feign build() {
// 同步方法处理工厂，这里面构建了一些信息
SynchronousMethodHandler.Factory synchronousMethodHandlerFactory =
new SynchronousMethodHandler.Factory(client, retryer, requestInterceptors,
logger, logLevel, decode404, closeAfterDecode, propagationPolicy);
// 解析一些信息
ParseHandlersByName handlersByName =
new ParseHandlersByName(contract, options, encoder, decoder, queryMapEncoder,
errorDecoder, synchronousMethodHandlerFactory);
// 重要的方法new了一个 ReflectiveFeign
return new ReflectiveFeign(handlersByName, invocationHandlerFactory, queryMapEncoder);
}

【重点】反射创建代理实例 ReflectiveFeign#newInstance

@Override
public <T> T newInstance(Target<T> target) {
Map<String, MethodHandler> nameToHandler = targetToHandlersByName.apply(target);

    nameToHandler 处理完就是下图的样子，key是咱们定义的接口名字+#+方法名字，value是之前定义好的同步方法处理器

Map<Method, MethodHandler> methodToHandler =
new LinkedHashMap<Method, MethodHandler>();
List<DefaultMethodHandler> defaultMethodHandlers =
new LinkedList<DefaultMethodHandler>();
// 遍历 com.shangde.springcloud.service.GoodsClient 的所有方法，这里面就一个方法 goods
// method public abstract org.springframework.http.ResponseEntity
// com.shangde.springcloud.service.GoodsClient.goods()
for (Method method : target.type().getMethods()) {
if (method.getDeclaringClass() == Object.class) {
continue;
} else if (Util.isDefault(method)) {
DefaultMethodHandler handler = new DefaultMethodHandler(method);
defaultMethodHandlers.add(handler);
methodToHandler.put(method, handler);
} else {
// 因为它的声明不是类也不是默认工具方法所以直接走这里
// Feign.configKey(target.type(), method)) 是 GoodsClient#goods()
// 获取的 MethodHandler 就是 SynchronousMethodHandler
methodToHandler.put(method,
nameToHandler.get(Feign.configKey(target.type(), method)));
}
}
// 创建动态代理，target 是HardCodeTarget,MethodHandler 就是 SynchronousMethodHandler
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;
}

    最后返回的proxy结果就是下图，里面有接口名字，访问的服务名字，以及url地址，其实就是返回了一个feign的代理对象 ReflectiveFeign