＜番外篇＞spring-cloud Hoxton.SR2 openfeign自动装配部分源码解析，以及@EnableFeignClients注解详解

Myth丶恋晨 2021-09-23 10:20 413阅读 0赞

# <番外篇>spring-cloud Hoxton.SR2 openfeign自动装配部分源码解析，以及@EnableFeignClients注解详解 #

### 文章目录 ###

*  <番外篇>spring-cloud Hoxton.SR2 openfeign自动装配部分源码解析，以及@EnableFeignClients注解详解
 *   *  1、找到自动装配的主入口；
     *   *  1.1、自动装配的配置类是\`org.springframework.cloud.openfeign.FeignAutoConfiguration.class\`；
         *  1.2、自动装配\`org.springframework.cloud.openfeign.ribbon.FeignRibbonClientAutoConfiguration.class\`
         *   *  1.2.1、类的上面的注解部分：
             *  1.2.2、主要注入的组件\`CachingSpringLoadBalancerFactory\`，负载均衡器的缓存工厂
     *  2、主类的注解\`@EnableFeignClients\`

## 1、找到自动装配的主入口； ##

openfeign的构建，是基于eureka上的，使用底层使用ribbon，只需要引入`spring-cloud-starter-openfeign`的包就可以了；

<dependency>
                <groupId>org.springframework.cloud</groupId>
                <artifactId>spring-cloud-starter-openfeign</artifactId>
            </dependency>

![6871a69f779033ed556c5fef21cabe77.png][]

可以看到，主要依赖`spring-cloud-openfeign-core`，又间接依赖`spring-cloud-starter-netflix-ribbon`，所以说，ribbon的自动装配也会生效。

找到`spring-cloud-openfeign-core`包的`spring.factories`文件；

![19db1e2de9284c1f82f3f93c3538517d.png][]

查看文件内容

org.springframework.boot.autoconfigure.EnableAutoConfiguration=\
    org.springframework.cloud.openfeign.ribbon.FeignRibbonClientAutoConfiguration,\
    org.springframework.cloud.openfeign.FeignAutoConfiguration,\
    org.springframework.cloud.openfeign.encoding.FeignAcceptGzipEncodingAutoConfiguration,\
    org.springframework.cloud.openfeign.encoding.FeignContentGzipEncodingAutoConfiguration

### 1.1、自动装配的配置类是`org.springframework.cloud.openfeign.FeignAutoConfiguration.class`； ###

在对应包下，找到这个类文件；

第一部分代码主要内容如下所示：

@Bean
    	public HasFeatures feignFeature() { 
    		return HasFeatures.namedFeature("Feign", Feign.class);
    	}
    
    	@Bean
    	public FeignContext feignContext() { 
    		FeignContext context = new FeignContext();
    		context.setConfigurations(this.configurations);
    		return context;
    	}
    
    	@Configuration
    	@ConditionalOnClass(name = "feign.hystrix.HystrixFeign")
    	protected static class HystrixFeignTargeterConfiguration { 
    
    		@Bean
    		@ConditionalOnMissingBean
    		public Targeter feignTargeter() { 
    			return new HystrixTargeter();
    		}
    
    	}
    
    	@Configuration
    	@ConditionalOnMissingClass("feign.hystrix.HystrixFeign")
    	protected static class DefaultFeignTargeterConfiguration { 
    
    		@Bean
    		@ConditionalOnMissingBean
    		public Targeter feignTargeter() { 
    			return new DefaultTargeter();
    		}
    
    	}

主要是注入了FeignContext这个配置类，代码如下：

public class FeignContext extends NamedContextFactory<FeignClientSpecification> { 
    
    	public FeignContext() { 
    		super(FeignClientsConfiguration.class, "feign", "feign.client.name");
    	}
    
    }

继承了NamedContextFactory类，跟ribbon一样，就不在继续看了，可以参考

[《<番外篇>spring-cloud Hoxton.SR2 负载均衡ribbon自动装配，负载均衡部分源码解析》][spring-cloud Hoxton.SR2 _ribbon]；

下面的部分，实例化了Targeter这个类，断路器（fegin默认集成了断路器，实现熔断机制，下一遍会讲熔断）；

有feign.hystrix.HystrixFeign这个类的时候，实例化HystrixTargeter，没有的是 ，就有个默认实现DefaultTargeter。

代码还有一份如下：

@Configuration
    	@ConditionalOnClass(ApacheHttpClient.class)
    	@ConditionalOnMissingClass("com.netflix.loadbalancer.ILoadBalancer")
    	@ConditionalOnMissingBean(CloseableHttpClient.class)
    	@ConditionalOnProperty(value = "feign.httpclient.enabled", matchIfMissing = true)
    	protected static class HttpClientFeignConfiguration { }
    
    
    
    	@Configuration
    	@ConditionalOnClass(OkHttpClient.class)
    	@ConditionalOnMissingClass("com.netflix.loadbalancer.ILoadBalancer")
    	@ConditionalOnMissingBean(okhttp3.OkHttpClient.class)
    	@ConditionalOnProperty("feign.okhttp.enabled")
    	protected static class OkHttpFeignConfiguration { }

分为两个部分，根据不同条件，创建远程调用的实例，有ApacheHttpClient和OkHttpClient；想要使用哪个，导入对应的包就可以了；包如下

<dependency>
                <groupId>com.squareup.okhttp3</groupId>
                <artifactId>okhttp</artifactId>
            </dependency>
            
            <dependency>
                <groupId>io.github.openfeign</groupId>
                <artifactId>feign-httpclient</artifactId>
            </dependency>

### 1.2、自动装配`org.springframework.cloud.openfeign.ribbon.FeignRibbonClientAutoConfiguration.class` ###

代码如下：

@ConditionalOnClass({  ILoadBalancer.class, Feign.class })
    @Configuration
    @AutoConfigureBefore(FeignAutoConfiguration.class)
    @EnableConfigurationProperties({  FeignHttpClientProperties.class })
    // Order is important here, last should be the default, first should be optional
    // see
    // https://github.com/spring-cloud/spring-cloud-netflix/issues/2086#issuecomment-316281653
    @Import({  HttpClientFeignLoadBalancedConfiguration.class,
    		OkHttpFeignLoadBalancedConfiguration.class,
    		DefaultFeignLoadBalancedConfiguration.class })
    public class FeignRibbonClientAutoConfiguration { 
    
    	@Bean
    	@Primary
    	@ConditionalOnMissingBean
    	@ConditionalOnMissingClass("org.springframework.retry.support.RetryTemplate")
    	public CachingSpringLoadBalancerFactory cachingLBClientFactory(
    			SpringClientFactory factory) { 
    		return new CachingSpringLoadBalancerFactory(factory);
    	}
    
    	@Bean
    	@Primary
    	@ConditionalOnMissingBean
    	@ConditionalOnClass(name = "org.springframework.retry.support.RetryTemplate")
    	public CachingSpringLoadBalancerFactory retryabeCachingLBClientFactory(
    			SpringClientFactory factory, LoadBalancedRetryFactory retryFactory) { 
    		return new CachingSpringLoadBalancerFactory(factory, retryFactory);
    	}
    
    	@Bean
    	@ConditionalOnMissingBean
    	public Request.Options feignRequestOptions() { 
    		return LoadBalancerFeignClient.DEFAULT_OPTIONS;
    	}
    
    }

#### 1.2.1、类的上面的注解部分： ####

@Import({  HttpClientFeignLoadBalancedConfiguration.class,
    		OkHttpFeignLoadBalancedConfiguration.class,
    		DefaultFeignLoadBalancedConfiguration.class })

只说这个吧，其他的不说了，导入了三个组件，其他的组件大同小异，只看第一个的一部分

@Configuration
    @ConditionalOnClass(ApacheHttpClient.class)
    @ConditionalOnProperty(value = "feign.httpclient.enabled", matchIfMissing = true)
    class HttpClientFeignLoadBalancedConfiguration { }

就是第一个自动装配类里的，要使用ApacheHttpClient，需要在配置文件里

feign.httpclient.enabled=true

#### 1.2.2、主要注入的组件`CachingSpringLoadBalancerFactory`，负载均衡器的缓存工厂 ####

感兴趣的大家自己看源代码吧。

## 2、主类的注解`@EnableFeignClients` ##

看注解的内容，主要说的是，扫描被`@FeignClient`注解标注的接口的包，多种形式的配置（包名，或者接口类的集合）注解代码如下：

@Retention(RetentionPolicy.RUNTIME)
    @Target(ElementType.TYPE)
    @Documented
    @Import(FeignClientsRegistrar.class)
    public @interface EnableFeignClients { 
    
    	/** * Alias for the {@link #basePackages()} attribute. Allows for more concise annotation * declarations e.g.: {@code @ComponentScan("org.my.pkg")} instead of * {@code @ComponentScan(basePackages="org.my.pkg")}. * @return the array of 'basePackages'. */
    	String[] value() default { };
    
    	/** * Base packages to scan for annotated components. * <p> * {@link #value()} is an alias for (and mutually exclusive with) this attribute. * <p> * Use {@link #basePackageClasses()} for a type-safe alternative to String-based * package names. * @return the array of 'basePackages'. */
    	String[] basePackages() default { };
    
    	/** * Type-safe alternative to {@link #basePackages()} for specifying the packages to * scan for annotated components. The package of each class specified will be scanned. * <p> * Consider creating a special no-op marker class or interface in each package that * serves no purpose other than being referenced by this attribute. * @return the array of 'basePackageClasses'. */
    	Class<?>[] basePackageClasses() default { };
    
    	/** * A custom <code>@Configuration</code> for all feign clients. Can contain override * <code>@Bean</code> definition for the pieces that make up the client, for instance * {@link feign.codec.Decoder}, {@link feign.codec.Encoder}, {@link feign.Contract}. * * @see FeignClientsConfiguration for the defaults * @return list of default configurations */
    	Class<?>[] defaultConfiguration() default { };
    
    	/** * List of classes annotated with @FeignClient. If not empty, disables classpath * scanning. * @return list of FeignClient classes */
    	Class<?>[] clients() default { };
    
    }

主要是通过`@Import(FeignClientsRegistrar.class)`导入了FeignClientsRegistrar.class组件；

关于`@Import`注解，详细参考[《spring注解 @Import的使用，ImportSelector接口，ImportBeanDefinitionRegistrar接口》][spring_ _Import_ImportSelector_ImportBeanDefinitionRegistrar]；

通过上面的博文知道，FeignClientsRegistrar.class实现了ImportBeanDefinitionRegistrar、ResourceLoaderAware、EnvironmentAware接口；

主要看重写的ImportBeanDefinitionRegistrar接口里的registerBeanDefinitions方法

/** * AnnotationMetadata：当前类的注解信息 * BeanDefinitionRegistry:BeanDefinition注册类； 把所有需要添加到容器中的bean；调用 * BeanDefinitionRegistry.registerBeanDefinition手工注册进来 */
    	@Override
    	public void registerBeanDefinitions(AnnotationMetadata metadata,
    			BeanDefinitionRegistry registry) { 
    		registerDefaultConfiguration(metadata, registry);
    		registerFeignClients(metadata, registry);
    	}

registerDefaultConfiguration：注入了一些配置属性

private void registerDefaultConfiguration(AnnotationMetadata metadata,
    			BeanDefinitionRegistry registry) { 
    		Map<String, Object> defaultAttrs = metadata
    				.getAnnotationAttributes(EnableFeignClients.class.getName(), true);
    
    		if (defaultAttrs != null && defaultAttrs.containsKey("defaultConfiguration")) { 
    			String name;
    			if (metadata.hasEnclosingClass()) { 
    				name = "default." + metadata.getEnclosingClassName();
    			}
    			else { 
    				name = "default." + metadata.getClassName();
    			}
    			registerClientConfiguration(registry, name,
    					defaultAttrs.get("defaultConfiguration"));
    		}
    	}

registerFeignClients：在spring容器中，注入了被`@FeignClient`标注的接口，详细代码如下

public void registerFeignClients(AnnotationMetadata metadata,
    			BeanDefinitionRegistry registry) { 
    		ClassPathScanningCandidateComponentProvider scanner = getScanner();
    		scanner.setResourceLoader(this.resourceLoader);
    
    		Set<String> basePackages;
    
    		Map<String, Object> attrs = metadata
    				.getAnnotationAttributes(EnableFeignClients.class.getName());
    		AnnotationTypeFilter annotationTypeFilter = new AnnotationTypeFilter(
    				FeignClient.class);
    		final Class<?>[] clients = attrs == null ? null
    				: (Class<?>[]) attrs.get("clients");
    		if (clients == null || clients.length == 0) { 
    			scanner.addIncludeFilter(annotationTypeFilter);
    			basePackages = getBasePackages(metadata);
    		}
    		else { 
    			final Set<String> clientClasses = new HashSet<>();
    			basePackages = new HashSet<>();
    			for (Class<?> clazz : clients) { 
    				basePackages.add(ClassUtils.getPackageName(clazz));
    				clientClasses.add(clazz.getCanonicalName());
    			}
    			AbstractClassTestingTypeFilter filter = new AbstractClassTestingTypeFilter() { 
    				@Override
    				protected boolean match(ClassMetadata metadata) { 
    					String cleaned = metadata.getClassName().replaceAll("\\$", ".");
    					return clientClasses.contains(cleaned);
    				}
    			};
    			scanner.addIncludeFilter(
    					new AllTypeFilter(Arrays.asList(filter, annotationTypeFilter)));
    		}
    
    		for (String basePackage : basePackages) { 
    			Set<BeanDefinition> candidateComponents = scanner
    					.findCandidateComponents(basePackage);
    			for (BeanDefinition candidateComponent : candidateComponents) { 
    				if (candidateComponent instanceof AnnotatedBeanDefinition) { 
    					// verify annotated class is an interface
    					AnnotatedBeanDefinition beanDefinition = (AnnotatedBeanDefinition) candidateComponent;
    					AnnotationMetadata annotationMetadata = beanDefinition.getMetadata();
    					Assert.isTrue(annotationMetadata.isInterface(),
    							"@FeignClient can only be specified on an interface");
    
    					Map<String, Object> attributes = annotationMetadata
    							.getAnnotationAttributes(
    									FeignClient.class.getCanonicalName());
    
    					String name = getClientName(attributes);
    					registerClientConfiguration(registry, name,
    							attributes.get("configuration"));
    
    					registerFeignClient(registry, annotationMetadata, attributes);
    				}
    			}
    		}
    	}
    
    	private void registerFeignClient(BeanDefinitionRegistry registry,
    			AnnotationMetadata annotationMetadata, Map<String, Object> attributes) { 
    		String className = annotationMetadata.getClassName();
    		BeanDefinitionBuilder definition = BeanDefinitionBuilder
    				.genericBeanDefinition(FeignClientFactoryBean.class);
    		validate(attributes);
    		definition.addPropertyValue("url", getUrl(attributes));
    		definition.addPropertyValue("path", getPath(attributes));
    		String name = getName(attributes);
    		definition.addPropertyValue("name", name);
    		String contextId = getContextId(attributes);
    		definition.addPropertyValue("contextId", contextId);
    		definition.addPropertyValue("type", className);
    		definition.addPropertyValue("decode404", attributes.get("decode404"));
    		definition.addPropertyValue("fallback", attributes.get("fallback"));
    		definition.addPropertyValue("fallbackFactory", attributes.get("fallbackFactory"));
    		definition.setAutowireMode(AbstractBeanDefinition.AUTOWIRE_BY_TYPE);
    		String alias = contextId + "FeignClient";
    		AbstractBeanDefinition beanDefinition = definition.getBeanDefinition();
    		boolean primary = (Boolean) attributes.get("primary"); // has a default, won't be
    																// null
    		beanDefinition.setPrimary(primary);
    		String qualifier = getQualifier(attributes);
    		if (StringUtils.hasText(qualifier)) { 
    			alias = qualifier;
    		}
    		BeanDefinitionHolder holder = new BeanDefinitionHolder(beanDefinition, className,
    				new String[] {  alias });
    		BeanDefinitionReaderUtils.registerBeanDefinition(holder, registry);
    	}

大家自己看吧，不复杂，就是把`@FeignClient`注解里的属性取出来，标注的接口代理出来，并注入（实例化）到spring的容器里。

具体代码信息，可以查看《[码云》][Link 1]

[6871a69f779033ed556c5fef21cabe77.png]: /images/20210923/0183d56cde8844a588cead74487bb4d0.png
[19db1e2de9284c1f82f3f93c3538517d.png]: /images/20210923/ad9341389c4d42229842be34993e6e46.png
[spring-cloud Hoxton.SR2 _ribbon]: https://blog.csdn.net/qq_28410283/article/details/102689483
[spring_ _Import_ImportSelector_ImportBeanDefinitionRegistrar]: https://blog.csdn.net/qq_28410283/article/details/90136845
[Link 1]: https://gitee.com/liqi01/badger-spring-cloud