@EnableFeignClients

  1. /**
  2.  * Scans for interfaces that declare they are feign clients (via
  3.  * {@link org.springframework.cloud.openfeign.FeignClient} <code>@FeignClient</code>).
  4.  * Configures component scanning directives for use with
  5.  * {@link org.springframework.context.annotation.Configuration}
  6.  * <code>@Configuration</code> classes.
  7.  * 扫描所有@FeignClient标注的接口
  8.  * 扫描所有@Configuration标注的接口
  9.  *
  10.  * @author Spencer Gibb
  11.  * @author Dave Syer
  12.  * @since 1.0
  13.  */
  14. @Retention(RetentionPolicy.RUNTIME)
  15. @Target(ElementType.TYPE)
  16. @Documented
  17. //引入了FeignClientsRegistrar
  18. @Import(FeignClientsRegistrar.class)
  19. public @interface EnableFeignClients {
  21.     /**
  22.      * Alias for the {@link #basePackages()} attribute. Allows for more concise annotation
  23.      * declarations e.g.: {@code @ComponentScan("org.my.pkg")} instead of
  24.      * {@code @ComponentScan(basePackages="org.my.pkg")}.
  25.      * @return the array of 'basePackages'.
  26.      * 扫描包路径
  27.      */
  28.     String[] value() default {};
  30.     /**
  31.      * Base packages to scan for annotated components.
  32.      * <p>
  33.      * {@link #value()} is an alias for (and mutually exclusive with) this attribute.
  34.      * <p>
  35.      * Use {@link #basePackageClasses()} for a type-safe alternative to String-based
  36.      * package names.
  37.      * @return the array of 'basePackages'. 
  38.      * 扫描包路径
  39.      */
  40.     String[] basePackages() default {};
  42.     /**
  43.      * Type-safe alternative to {@link #basePackages()} for specifying the packages to
  44.      * scan for annotated components. The package of each class specified will be scanned.
  45.      * <p>
  46.      * Consider creating a special no-op marker class or interface in each package that
  47.      * serves no purpose other than being referenced by this attribute.
  48.      * @return the array of 'basePackageClasses'.
  49.      */
  50.     Class<?>[] basePackageClasses() default {};
  52.     /**
  53.      * A custom <code>@Configuration</code> for all feign clients. Can contain override
  54.      * <code>@Bean</code> definition for the pieces that make up the client, for instance
  55.      * {@link feign.codec.Decoder}, {@link feign.codec.Encoder}, {@link feign.Contract}.
  56.      *
  57.      * @see FeignClientsConfiguration for the defaults
  58.      * @return list of default configurations
  59.      * 
  60.      * 所有 FeignClient接口的默认配置
  61.      */
  62.     Class<?>[] defaultConfiguration() default {};
  64.     /**
  65.      * List of classes annotated with @FeignClient. If not empty, disables classpath
  66.      * scanning.
  67.      * @return list of FeignClient classes
  68.      * 
  69.      * 若此项不为空，则不会去扫描所有的FeignClient
  70.      */
  71.     Class<?>[] clients() default {};
  73. }

FeignClientsRegistrar

  1.     @Override
  2.     public void registerBeanDefinitions(AnnotationMetadata metadata,
  3.             BeanDefinitionRegistry registry) {
  4.         registerDefaultConfiguration(metadata, registry);
  5.         registerFeignClients(metadata, registry);
  6.     }

registerDefaultConfiguration方法

这个方法注册注解中指定的默认配置

registerFeignClients方法

  1. 若在@EnableFeignClients中指定了clients属性,只会注册指定的
  2. @FeignCient注解只允许标注在接口上

  3. 每个@FeignCient接口都会在这个方法里做如下动作：

    1. 注册client的配置类为Bean

    2. 将接口注册成为FeignClient

      registerFeignClient

      1. private void registerFeignClient(BeanDefinitionRegistry registry,
      2.                                AnnotationMetadata annotationMetadata, Map<String, Object> attributes) {
      3.   String className = annotationMetadata.getClassName();
      4.   BeanDefinitionBuilder definition = BeanDefinitionBuilder
      5.       .genericBeanDefinition(FeignClientFactoryBean.class);
      6.   validate(attributes);
      7.   definition.addPropertyValue("url", getUrl(attributes));
      8.   definition.addPropertyValue("path", getPath(attributes));
      9.   String name = getName(attributes);
      10.   definition.addPropertyValue("name", name);
      11.   String contextId = getContextId(attributes);
      12.   definition.addPropertyValue("contextId", contextId);
      13.   definition.addPropertyValue("type", className);
      14.   definition.addPropertyValue("decode404", attributes.get("decode404"));
      15.   definition.addPropertyValue("fallback", attributes.get("fallback"));
      16.   definition.addPropertyValue("fallbackFactory", attributes.get("fallbackFactory"));
      17.   definition.setAutowireMode(AbstractBeanDefinition.AUTOWIRE_BY_TYPE);
      19.   String alias = contextId + "FeignClient";
      20.   AbstractBeanDefinition beanDefinition = definition.getBeanDefinition();
      22.   boolean primary = (Boolean) attributes.get("primary"); // has a default, won't be
      23.   // null
      25.   beanDefinition.setPrimary(primary);
      27.   String qualifier = getQualifier(attributes);
      28.   if (StringUtils.hasText(qualifier)) {
      29.       alias = qualifier;
      30.   }
      32.   BeanDefinitionHolder holder = new BeanDefinitionHolder(beanDefinition, className,
      33.       new String[] { alias });
      34.   BeanDefinitionReaderUtils.registerBeanDefinition(holder, registry);
      35. }

      为每个FeignClient接口注册一个FeignClientFactoryBean的BeanDefinition

  4. beanName默认为className

  5. alias为contextId属性+FeginClient

    注册FeignClientBean

    在分析@EnableFeginClients方法后，发现其为每个Feign接口提供了一个FeignClientFactoryBean,让我们来看看这个FactoryBean ```java class FeignClientFactoryBean

    1.  implements FactoryBean<Object>, InitializingBean, ApplicationContextAware {

    /*

    • WARNING! Nothing in this class should be @Autowired. It causes NPEs because of some

    • lifecycle race condition. */

      private Class<?> type;

      private String name;

      private String url;

      private String contextId;

      private String path;

      private boolean decode404;

      private ApplicationContext applicationContext;

      private Class<?> fallback = void.class;

      private Class<?> fallbackFactory = void.class;

      @Override public void afterPropertiesSet() throws Exception { Assert.hasText(this.contextId, “Context id must be set”); Assert.hasText(this.name, “Name must be set”); }

  1. //通过context 构建FeignBuilder
  2. protected Feign.Builder feign(FeignContext context) {
  3.     FeignLoggerFactory loggerFactory = get(context, FeignLoggerFactory.class);
  4.     Logger logger = loggerFactory.create(this.type);
  6.     // @formatter:off
  7.     Feign.Builder builder = 
  8.             //获取Feign.Builder的bean    
  9.             get(context, Feign.Builder.class)
  10.             // required values
  11.             .logger(logger)
  12.             // 获取Encoder
  13.             .encoder(get(context, Encoder.class))
  14.             .decoder(get(context, Decoder.class))
  15.             .contract(get(context, Contract.class));
  16.     // @formatter:on
  18.     configureFeign(context, builder);
  20.     return builder;
  21. }
  24. protected void configureFeign(FeignContext context, Feign.Builder builder) {
  25.     FeignClientProperties properties = this.applicationContext
  26.             .getBean(FeignClientProperties.class);
  27.     if (properties != null) {
  28.         is_default_to_properties，则先Configuration、后propeties
  29.         if (properties.isDefaultToProperties()) {
  30.             //自定义的Configuration
  31.             configureUsingConfiguration(context, builder);
  32.             //默认
  33.             configureUsingProperties(
  34.                     properties.getConfig().get(properties.getDefaultConfig()),
  35.                     builder);
  36.             //自己的
  37.             configureUsingProperties(properties.getConfig().get(this.contextId),
  38.                     builder);
  39.         }
  40.         else {
  41.             //默认的
  42.             configureUsingProperties(
  43.                     properties.getConfig().get(properties.getDefaultConfig()),
  44.                     builder);
  45.             //自己的
  46.             configureUsingProperties(properties.getConfig().get(this.contextId),
  47.                     builder);
  48.             //configuration
  49.             configureUsingConfiguration(context, builder);
  50.         }
  51.     }
  52.     else {
  53.         //Configuration
  54.         configureUsingConfiguration(context, builder);
  55.     }
  56. }
  72. private <T> T getOrInstantiate(Class<T> tClass) {
  73.     try {
  74.         return this.applicationContext.getBean(tClass);
  75.     }
  76.     catch (NoSuchBeanDefinitionException e) {
  77.         return BeanUtils.instantiateClass(tClass);
  78.     }
  79. }
  81. protected <T> T get(FeignContext context, Class<T> type) {
  82.     T instance = context.getInstance(this.contextId, type);
  83.     if (instance == null) {
  84.         throw new IllegalStateException(
  85.                 "No bean found of type " + type + " for " + this.contextId);
  86.     }
  87.     return instance;
  88. }
  90. protected <T> T getOptional(FeignContext context, Class<T> type) {
  91.     return context.getInstance(this.contextId, type);
  92. }
  94. protected <T> T loadBalance(Feign.Builder builder, FeignContext context,
  95.         HardCodedTarget<T> target) {
  96.     Client client = getOptional(context, Client.class);
  97.     if (client != null) {
  98.         builder.client(client);
  99.         Targeter targeter = get(context, Targeter.class);
  100.         return targeter.target(this, builder, context, target);
  101.     }
  103.     throw new IllegalStateException(
  104.             "No Feign Client for loadBalancing defined. Did you forget to include spring-cloud-starter-netflix-ribbon?");
  105. }
  109. @Override
  110. public Object getObject() throws Exception {
  111.     //调用getTarget方法
  112.     return getTarget();
  113. }
  115. /**
  116.  * @param <T> the target type of the Feign client
  117.  * T是Feign接口的类
  118.  * @return a {@link Feign} client created with the specified data and the context
  119.  * information
  120.  */
  121. <T> T getTarget() {
  122.     //获取FeignContext 
  123.     FeignContext context = this.applicationContext.getBean(FeignContext.class);
  124.     //通过context构建 Feign
  125.     Feign.Builder builder = feign(context);
  127.     //若不包含 url属性,则自动生成
  128.     if (!StringUtils.hasText(this.url)) {
  129.         if (!this.name.startsWith("http")) {
  130.             this.url = "http://" + this.name;
  131.         }
  132.         else {
  133.             this.url = this.name;
  134.         }
  135.         this.url += cleanPath();
  136.         //loadBalance(); 可能是个普通DefaultTargeter、或hystrix
  137.         return (T) loadBalance(builder, context,
  138.                 new HardCodedTarget<>(this.type, this.name, this.url));
  139.     }
  142.     //若有url但是 不是 http开头则加入
  143.     if (StringUtils.hasText(this.url) && !this.url.startsWith("http")) {
  144.         this.url = "http://" + this.url;
  145.     }
  147.     String url = this.url + cleanPath();
  148.     Client client = getOptional(context, Client.class);
  149.     if (client != null) {
  150.         if (client instanceof LoadBalancerFeignClient) {
  151.             // not load balancing because we have a url,
  152.             // but ribbon is on the classpath, so unwrap
  153.             //当ribbon
  154.             client = ((LoadBalancerFeignClient) client).getDelegate();
  155.         }
  156.         if (client instanceof FeignBlockingLoadBalancerClient) {
  157.             // not load balancing because we have a url,
  158.             // but Spring Cloud LoadBalancer is on the classpath, so unwrap
  159.             // 当 Spring Cloud LoadBalancer 在的
  160.             client = ((FeignBlockingLoadBalancerClient) client).getDelegate();
  161.         }
  162.         builder.client(client);
  163.     }
  164.     Targeter targeter = get(context, Targeter.class);
  165.     return (T) targeter.target(this, builder, context,
  166.             new HardCodedTarget<>(this.type, this.name, url));
  167. }
  169. private String cleanPath() {
  170.     String path = this.path.trim();
  171.     if (StringUtils.hasLength(path)) {
  172.         if (!path.startsWith("/")) {
  173.             path = "/" + path;
  174.         }
  175.         if (path.endsWith("/")) {
  176.             path = path.substring(0, path.length() - 1);
  177.         }
  178.     }
  179.     return path;
  180. }

}

  1. ```java
  2. @ConfigurationProperties("feign.client")
  3. public class FeignClientProperties {
  5.     private boolean defaultToProperties = true;
  7.     private String defaultConfig = "default";
  9.     /** 
  10.     * client1 --> 配置
  11.     * client2 --> 配置
  12.     */
  13.     private Map<String, FeignClientConfiguration> config = new HashMap<>();
  15.     public static class FeignClientConfiguration {
  16.         private Logger.Level loggerLevel;
  17.         private Integer connectTimeout;
  18.         private Integer readTimeout;
  19.         private Class<Retryer> retryer;
  20.         private Class<ErrorDecoder> errorDecoder;
  21.         private List<Class<RequestInterceptor>> requestInterceptors;
  22.         private Boolean decode404;
  23.         private Class<Decoder> decoder;
  24.         private Class<Encoder> encoder;
  25.         private Class<Contract> contract;
  26.         private ExceptionPropagationPolicy exceptionPropagationPolicy;
  27.     }
  28. }
  2. protected void configureUsingProperties(
  3.             FeignClientProperties.FeignClientConfiguration config,
  4.             Feign.Builder builder) {
  5.         if (config == null) {
  6.             return;
  7.         }
  9.         if (config.getLoggerLevel() != null) {
  10.             builder.logLevel(config.getLoggerLevel());
  11.         }
  13.         if (config.getConnectTimeout() != null && config.getReadTimeout() != null) {
  14.             builder.options(new Request.Options(config.getConnectTimeout(),
  15.                     config.getReadTimeout()));
  16.         }
  18.         if (config.getRetryer() != null) {
  19.             Retryer retryer = getOrInstantiate(config.getRetryer());
  20.             builder.retryer(retryer);
  21.         }
  23.         if (config.getErrorDecoder() != null) {
  24.             ErrorDecoder errorDecoder = getOrInstantiate(config.getErrorDecoder());
  25.             builder.errorDecoder(errorDecoder);
  26.         }
  28.         if (config.getRequestInterceptors() != null
  29.                 && !config.getRequestInterceptors().isEmpty()) {
  30.             // this will add request interceptor to builder, not replace existing
  31.             for (Class<RequestInterceptor> bean : config.getRequestInterceptors()) {
  32.                 RequestInterceptor interceptor = getOrInstantiate(bean);
  33.                 builder.requestInterceptor(interceptor);
  34.             }
  35.         }
  37.         if (config.getDecode404() != null) {
  38.             if (config.getDecode404()) {
  39.                 builder.decode404();
  40.             }
  41.         }
  43.         if (Objects.nonNull(config.getEncoder())) {
  44.             builder.encoder(getOrInstantiate(config.getEncoder()));
  45.         }
  47.         if (Objects.nonNull(config.getDecoder())) {
  48.             builder.decoder(getOrInstantiate(config.getDecoder()));
  49.         }
  51.         if (Objects.nonNull(config.getContract())) {
  52.             builder.contract(getOrInstantiate(config.getContract()));
  53.         }
  55.         if (Objects.nonNull(config.getExceptionPropagationPolicy())) {
  56.             builder.exceptionPropagationPolicy(config.getExceptionPropagationPolicy());
  57.         }
  58.     }
  2.     protected void configureUsingConfiguration(FeignContext context,
  3.             Feign.Builder builder) {
  4.         Logger.Level level = getOptional(context, Logger.Level.class);
  5.         if (level != null) {
  6.             builder.logLevel(level);
  7.         }
  8.         Retryer retryer = getOptional(context, Retryer.class);
  9.         if (retryer != null) {
  10.             builder.retryer(retryer);
  11.         }
  12.         ErrorDecoder errorDecoder = getOptional(context, ErrorDecoder.class);
  13.         if (errorDecoder != null) {
  14.             builder.errorDecoder(errorDecoder);
  15.         }
  16.         Request.Options options = getOptional(context, Request.Options.class);
  17.         if (options != null) {
  18.             builder.options(options);
  19.         }
  20.         Map<String, RequestInterceptor> requestInterceptors = context
  21.                 .getInstances(this.contextId, RequestInterceptor.class);
  22.         if (requestInterceptors != null) {
  23.             builder.requestInterceptors(requestInterceptors.values());
  24.         }
  25.         QueryMapEncoder queryMapEncoder = getOptional(context, QueryMapEncoder.class);
  26.         if (queryMapEncoder != null) {
  27.             builder.queryMapEncoder(queryMapEncoder);
  28.         }
  29.         if (this.decode404) {
  30.             builder.decode404();
  31.         }
  32.         ExceptionPropagationPolicy exceptionPropagationPolicy = getOptional(context,
  33.                 ExceptionPropagationPolicy.class);
  34.         if (exceptionPropagationPolicy != null) {
  35.             builder.exceptionPropagationPolicy(exceptionPropagationPolicy);
  36.         }
  37.     }

FeignContext

这里存放的是各个feignclient的配置项，是通过自动配置类注册成bean的

  1. @Configuration(proxyBeanMethods = false)
  2. @ConditionalOnClass(Feign.class)
  3. @EnableConfigurationProperties({ FeignClientProperties.class,
  4.         FeignHttpClientProperties.class })
  5. @Import(DefaultGzipDecoderConfiguration.class)
  6. public class FeignAutoConfiguration {
  8.     @Autowired(required = false)
  9.     private List<FeignClientSpecification> configurations = new ArrayList<>();
  11.     @Bean
  12.     public HasFeatures feignFeature() {
  13.         return HasFeatures.namedFeature("Feign", Feign.class);
  14.     }
  16.     @Bean
  17.     public FeignContext feignContext() {
  18.         FeignContext context = new FeignContext();
  19.         //所有的配置
  20.         context.setConfigurations(this.configurations);
  21.         return context;
  22.     }
  24.     ....
  25. }

代理对象创建

  1.     @Override
  2.     public <T> T target(FeignClientFactoryBean factory, Feign.Builder feign,
  3.             FeignContext context, Target.HardCodedTarget<T> target) {
  4.         return feign.target(target);
  5.     }
  7.  public <T> T target(Target<T> target) {
  8.       return build().newInstance(target);
  9.     }
  1. public Feign build() {
  2.       SynchronousMethodHandler.Factory synchronousMethodHandlerFactory =
  3.           new SynchronousMethodHandler.Factory(client, retryer, requestInterceptors, logger,
  4.               logLevel, decode404, closeAfterDecode, propagationPolicy);
  5.       ParseHandlersByName handlersByName =
  6.           new ParseHandlersByName(contract, options, encoder, decoder, queryMapEncoder,
  7.               errorDecoder, synchronousMethodHandlerFactory);
  8.       return new ReflectiveFeign(handlersByName, invocationHandlerFactory, queryMapEncoder);
  9.     }
  1.  @Override
  2.   public <T> T newInstance(Target<T> target) {
  3.     Map<String, MethodHandler> nameToHandler = targetToHandlersByName.apply(target);
  4.     Map<Method, MethodHandler> methodToHandler = new LinkedHashMap<Method, MethodHandler>();
  5.     List<DefaultMethodHandler> defaultMethodHandlers = new LinkedList<DefaultMethodHandler>();
  7.     for (Method method : target.type().getMethods()) {
  8.       if (method.getDeclaringClass() == Object.class) {
  9.         continue;
  10.       } else if (Util.isDefault(method)) {
  11.         DefaultMethodHandler handler = new DefaultMethodHandler(method);
  12.         defaultMethodHandlers.add(handler);
  13.         methodToHandler.put(method, handler);
  14.       } else {
  15.         methodToHandler.put(method, nameToHandler.get(Feign.configKey(target.type(), method)));
  16.       }
  17.     }
  18.     InvocationHandler handler = factory.create(target, methodToHandler);
  19.     T proxy = (T) Proxy.newProxyInstance(target.type().getClassLoader(),
  20.         new Class<?>[] {target.type()}, handler);
  22.     for (DefaultMethodHandler defaultMethodHandler : defaultMethodHandlers) {
  23.       defaultMethodHandler.bindTo(proxy);
  24.     }
  25.     return proxy;
  26.   }