feign client初始化

程序启动的时候，会检查是否有@EnableFeignClients注解，如果有该注解，则开启包扫描，扫描被@FeignClient注解接口，源码如下，

/**
 * 扫描注解@FeignClient标注的接口
 */
@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.class)导入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,为其生成动态代理
		**/
		registerFeignClients(metadata, registry);
	}
	private void registerDefaultConfiguration(AnnotationMetadata metadata,
			BeanDefinitionRegistry registry) {
		//获取@EnableFeignClients注解属性
		Map 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 basePackages;
        //@EnableFeignClients注解属性
		Map 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 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)));
		}
        /**
            扫描package逻辑
        **
		for (String basePackage : basePackages) {
		    //从类路径下的所有.class文件中扫描@FeignClient注解的接口
			Set 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 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 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);
	}
}

以上就是@FeignClient 扫描初始化逻辑。