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);

   }

}