@FeignClient注入找不到異常如何解決

更新時間：2021年06月24日 10:29:03 作者：愛琴孩

這篇文章主要介紹了@FeignClient注入找不到異常的解決方案，具有很好的參考價值，希望對大家有所幫助。如有錯誤或未考慮完全的地方，望不吝賜教

前言

Springcloud中的服務間調用是通過Feign進行調用的，在調用方服務中，我們需要定義一些帶有@FeignClient注解的接口類。并且在啟動類上加上@EnableFeignClients注解。

程序啟動的時候，會檢查是否有@EnableFeignClients注解，如果有該注解，則開啟包掃描，掃描帶有@FeignClient注解的接口。

這里結合之前遇到的一個問題來和大家一起學習下@EnableFeignClients啟動過程。

問題描述

之前搭建一個簡單demo的時候，啟動之后總是報錯

Field client1Feign in com.aiqinhai.client2.controller.Testrequired a bean of type
'com.aiqinhai.client2.feignclient.Client1Feign' that could not be found.
Action:
Consider defining a bean of type 'com.aiqinhai.client2.feignclient.Client1Feign' in your configuration.
Process finished with exit code 1

排查了一頓之后，發(fā)現啟動上的@EnableFeignClients注解，沒有指定basePackages包掃描路徑。

而且Client1Feign接口不是和啟動類在同一目錄下，所以啟動的時候就會報上述錯誤。

后來在@EnableFeignClients指定了掃描包路徑就解決了。

@SpringBootApplication
@EnableDiscoveryClient
@EnableFeignClients(basePackages = {"com.aiqinhai.client2.feignclient"})
public class Client2Application {
    public static void main(String[] args) {
        SpringApplication.run(Client2Application.class, args);
    }
}

問題確實解決了，但是我們還是需要了解服務啟動的時候，@EnableFeignClients注解干了哪些事。

刨根@EnableFeignClients

想了解清楚這個注解的作用，最好的方式就是看看注解的源碼。點進去之后，可以看到

/**
 * 掃描注解@FeignClient標注的接口
 */
@Retention(RetentionPolicy.RUNTIME)
@Target({ElementType.TYPE})
@Documented
@Import(FeignClientsRegistrar.class)
public @interface EnableFeignClients {
 //同basePackages
 String[] value() default {};
        //掃描的package.
 String[] basePackages() default {};
 //feigin client全局配置，默認配置在FeignClientsConfiguration類中
 Class<?>[] defaultConfiguration() default {};
 //@FeignClient注解的接口，如果指定了該屬性，則關閉掃描。
 Class<?>[] clients() default {};
}

可以看到，注解中import了FeignClientsRegistrar類，我們進去看看，可以看到包掃描的邏輯就是在FeignClientsRegistrar中實現的，會掃描所有的.class文件，過濾出@FeignClient標注的接口，然后通過BeanDefinitionBuilder生成FeignClientFactoryBean對象，注入到IOC容器中。

具體代碼如下

class FeignClientsRegistrar implements ImportBeanDefinitionRegistrar,
		ResourceLoaderAware, EnvironmentAware {
	//包掃描方法入口
	@Override
	public void registerBeanDefinitions(AnnotationMetadata metadata,
			BeanDefinitionRegistry registry) {
		//注冊默認配置bean到ioc
		registerDefaultConfiguration(metadata, registry);
		//注冊@FeignClients標注的接口bean,為其生成動態(tài)代理
		registerFeignClients(metadata, registry);
	}
	private void registerDefaultConfiguration(AnnotationMetadata metadata,
			BeanDefinitionRegistry registry) {
		//獲取@EnableFeignClients注解屬性
		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();
			}
			//注冊@EnableFeignClients defaultConfiguration 類中定義的bean到ioc
			registerClientConfiguration(registry, name,
					defaultAttrs.get("defaultConfiguration"));		}
	}
	public void registerFeignClients(AnnotationMetadata metadata,
			BeanDefinitionRegistry registry) {
		//spring 掃描工具類
		ClassPathScanningCandidateComponentProvider scanner = getScanner();
		scanner.setResourceLoader(this.resourceLoader);
        //待掃描的包
		Set<String> basePackages;
        //@EnableFeignClients注解屬性
		Map<String, Object> attrs = metadata
				.getAnnotationAttributes(EnableFeignClients.class.getName());
		//@FeignClient注解過濾器，只掃描@FeignClient注解標注的接口
		AnnotationTypeFilter annotationTypeFilter = new AnnotationTypeFilter(
				FeignClient.class);
		//解析@EnableFeignClient 屬性clients
		final Class<?>[] clients = attrs == null ? null
				: (Class<?>[]) attrs.get("clients");
		//如果@EnableFeignClient沒有指定clients,則開啟包掃描，否則關閉掃描，使用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) {
		    //從類路徑下的所有.class文件中掃描@FeignClient注解的接口
			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();
					//@FeignClient注解必須應用在接口上，否則拋出異常。
					Assert.isTrue(annotationMetadata.isInterface(),
							"@FeignClient can only be specified on an interface");
                        //獲取FeignClient注解屬性
					Map<String, Object> attributes = annotationMetadata
							.getAnnotationAttributes(
									FeignClient.class.getCanonicalName());
                        //服務名稱
					String name = getClientName(attributes);
					//注冊configuration中指定的bean
					registerClientConfiguration(registry, name,
							attributes.get("configuration"));
					//生成FeignClient bean,并注冊到ioc
					registerFeignClient(registry, annotationMetadata, attributes);
				}
			}
		}
	}
 
    //生成bean,注入到IOC容器
	private void registerFeignClient(BeanDefinitionRegistry registry,
			AnnotationMetadata annotationMetadata, Map<String, Object> attributes) {
		// feignclient類名稱
		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);
		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 = name + "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 });
		//注冊到ioc
		BeanDefinitionReaderUtils.registerBeanDefinition(holder, registry);
	}
}