[Java] Spring-cloud Feign 的深入理解

@override
public void registerbeandefinitions(annotationmetadata metadata,
  beandefinitionregistry registry) {
  //注册feign配置信息
  registerdefaultconfiguration(metadata, registry);
  //注册feign client
  registerfeignclients(metadata, registry);
}
 
private void registerfeignclient(beandefinitionregistry registry,
  annotationmetadata annotationmetadata, map<string, object> attributes) {
  string classname = annotationmetadata.getclassname();
  //准备注入feignclientfactorybean
  beandefinitionbuilder definition = beandefinitionbuilder
    .genericbeandefinition(feignclientfactorybean.class);
  ...
}

@override
public object getobject() throws exception {
  feigncontext context = applicationcontext.getbean(feigncontext.class);
  //构建feign.builder
  feign.builder builder = feign(context);
  //如果注解没有指定url
  if (!stringutils.hastext(this.url)) {
  string url;
  if (!this.name.startswith("http")) {
    url = "http://" + this.name;
  }
  else {
    url = this.name;
  }
  url += cleanpath();
  return loadbalance(builder, context, new hardcodedtarget<>(this.type,
    this.name, url));
  }
  //如果指定了url
  if (stringutils.hastext(this.url) && !this.url.startswith("http")) {
  this.url = "http://" + this.url;
  }
  string url = this.url + cleanpath();
  client client = getoptional(context, client.class);
  if (client != null) {
  if (client instanceof loadbalancerfeignclient) {
    // 因为指定了url且classpath下有ribbon，获取client的delegate（unwrap）
    // not load balancing because we have a url,
    // but ribbon is on the classpath, so unwrap
    client = ((loadbalancerfeignclient)client).getdelegate();
  }
  builder.client(client);
  }
  targeter targeter = get(context, targeter.class);
  return targeter.target(this, builder, context, new hardcodedtarget<>(
    this.type, this.name, url));
}
 
protected <t> t loadbalance(feign.builder builder, feigncontext context,
  hardcodedtarget<t> target) {
  //获取feign client实例
  client client = getoptional(context, client.class);
  if (client != null) {
  builder.client(client);
  //defaulttargeter或者hystrixtargeter
  targeter targeter = get(context, targeter.class);
  //调用builder的target，其中就调用了feign的newinstance
  return targeter.target(this, builder, context, target);
  }
 
  throw new illegalstateexception(
    "no feign client for loadbalancing defined. did you forget to include spring-cloud-starter-netflix-ribbon?");
}

@bean
@scope("prototype")
@conditionalonmissingbean
public feign.builder feignbuilder(retryer retryer) {
  return feign.builder().retryer(retryer);
}

public feign build() {
 synchronousmethodhandler.factory synchronousmethodhandlerfactory =
   new synchronousmethodhandler.factory(client, retryer, requestinterceptors, logger,
            loglevel, decode404);
 parsehandlersbyname handlersbyname =
   new parsehandlersbyname(contract, options, encoder, decoder,
         errordecoder, synchronousmethodhandlerfactory);
 //reflectivefeign构造参数
 //parsehandlersbyname作用是通过传入的target返回代理接口下的方法的各种信息（methodhandler）
 //contract：解析接口的方法注解规则，生成methodmetadata
 //options：request超时配置
 //encoder：请求编码器
 //decoder：返回解码器
 //errordecoder：错误解码器
 //synchronousmethodhandler.factory是构建synchronousmethodhandler的工厂
 //client：代表真正执行http的组件
 //retryer：该组决定了在http请求失败时是否需要重试
 //requestinterceptor：请求前的拦截器
 //logger：记录日志组件，包含各个阶段记录日志的方法和留给用户自己实现的log方法
 //logger.level：日志级别
 //decode404：处理404的策略，返回空还是报错
 //synchronousmethodhandlerfactory通过所有的信息去包装一个synchronousmethodhandler，在调用invoke方法的时候执行http
 return new reflectivefeign(handlersbyname, invocationhandlerfactory);
}

/**
 * creates an api binding to the {@code target}. as this invokes reflection, care should be taken
 * to cache the result.
 */
@suppresswarnings("unchecked")
@override
//接收target参数（包含feign代理接口的类型class，名称，http url）
public <t> t newinstance(target<t> target) {
 //首先通过**parsehandlersbyname**解析出接口中包含的方法，包装requesttemplate，组装成<name, methodhandler>
 map<string, methodhandler> nametohandler = targettohandlersbyname.apply(target);
 map<method, methodhandler> methodtohandler = new linkedhashmap<method, methodhandler>();
 //接口default方法list
 list<defaultmethodhandler> defaultmethodhandlers = new linkedlist<defaultmethodhandler>();
 
 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 {
   methodtohandler.put(method, nametohandler.get(feign.configkey(target.type(), method)));
  }
 }
 //invocationhandlerfactory.default()返回了一个reflectivefeign.feigninvocationhandler对象，通过传入的methodhandler map 调用目标对象的对应方法
 invocationhandler handler = factory.create(target, methodtohandler);
 //生成jdk代理对象
 t proxy = (t) proxy.newproxyinstance(target.type().getclassloader(), new class<?>[]{target.type()}, handler);
 //绑定接口的默认方法到代理对象
 for(defaultmethodhandler defaultmethodhandler : defaultmethodhandlers) {
  defaultmethodhandler.bindto(proxy);
 }
 return proxy;
}

@override
public object invoke(object[] argv) throws throwable {
 //工厂创建请求模版
 requesttemplate template = buildtemplatefromargs.create(argv);
 //每次克隆一个新的retryer
 retryer retryer = this.retryer.clone();
 while (true) {
  try {
   //这里调用实际的feign client execute
   return executeanddecode(template);
  } catch (retryableexception e) {
   //失败重试
   retryer.continueorpropagate(e);
   if (loglevel != logger.level.none) {
  logger.logretry(metadata.configkey(), loglevel);
   }
   continue;
  }
 }
}

@override
public response execute(request request, request.options options) throws ioexception {
  try {
  uri asuri = uri.create(request.url());
  string clientname = asuri.gethost();
  uri uriwithouthost = cleanurl(request.url(), clientname);
  //delegate这里是client.default实例，底层调用的是java.net原生网络访问
  feignloadbalancer.ribbonrequest ribbonrequest = new feignloadbalancer.ribbonrequest(
    this.delegate, request, uriwithouthost);
 
  iclientconfig requestconfig = getclientconfig(options, clientname);
  //executewithloadbalancer会根据ribbon的负载均衡算法构建url，这里不展开
  return lbclient(clientname).executewithloadbalancer(ribbonrequest,
    requestconfig).toresponse();
  }
  catch (clientexception e) {
  ioexception io = findioexception(e);
  if (io != null) {
    throw io;
  }
  throw new runtimeexception(e);
  }
}