[SpringCloud] Feign Client 的创建 (一) (四)

文章目录

- - 1.FeignClientsRegistrar
  - 2.完成配置注册
  - - 2.1 registerDefaultConfiguration方法
    - 2.2 迭代稳定性
    - 2.3 registerFeignClients方法

1.FeignClientsRegistrar

在这里插入图片描述

FeignClientsRegistrar实现ImportBeanDefinitionRegistrar接口。

在这里插入图片描述

2.完成配置注册

    public void registerBeanDefinitions(AnnotationMetadata metadata, BeanDefinitionRegistry registry) {
    	// 注册默认的Configuration（其实就是在解析@EnableFeignClients注解）
        this.registerDefaultConfiguration(metadata, registry);
        // 1)扫描所有的@FeignClient接口, 即扫描到Feign接口
        // 2)将每个@FeignClient注解的configuration属性注册进一个缓存map
        // 3)根据@FeignClient注解元数据生成的FeignClientBeanFactory的BeanDefinition, 
        // 并将这个BeanDefinition注册进一个map
        this.registerFeignClients(metadata, registry);
    }

registerDefaultConfiguration方法
registerFeignClients方法

导入的类元数据就是启动类, 通过这个类的元数据可以获取到它上面所有的注解信息。

在这里插入图片描述

2.1 registerDefaultConfiguration方法

registerDefaultConfiguration():

//FeignClientsRegistrar.java
private void registerDefaultConfiguration(AnnotationMetadata metadata,
		BeanDefinitionRegistry registry) {
	//从类元数据中获取@EnableFeignClients注解
	//getAnnotationAttributes：获取类上指定注解的属性
	//该方法第二个参数true，表示将注解中class类型的属性转换为字符串类名暴露到返回到map中
	Map<String, Object> defaultAttrs = metadata
			.getAnnotationAttributes(EnableFeignClients.class.getName(), true);
			
	//处理defaultConfiguration属性
	if (defaultAttrs != null && defaultAttrs.containsKey("defaultConfiguration")) {
		String name;
		//返回当前类是否在封闭类中声明(例如，当前类是一个内部/嵌套类，还是一个方法中的本地类)。
		//false代表当前类就是顶级类，此时是启动类，肯定是顶级类
		if (metadata.hasEnclosingClass()) {
			//如果当前是内部、嵌套、方法中的类，获取我的封闭类的类名
			name = "default." + metadata.getEnclosingClassName();
		}
		else {
			//返回false代表当前是就顶级类，直接获取类名
			name = "default." + metadata.getClassName();
		}
		registerClientConfiguration(registry, name,
				defaultAttrs.get("defaultConfiguration"));
	}
}

在这里插入图片描述

registerClientConfiguration():

//FeignClientsRegistrar.java
private void registerClientConfiguration(BeanDefinitionRegistry registry, Object name,
		Object configuration) {
	//获取一个BeanDefinition的构建者 专门构建FeignClientSpecification的BeanDefinition
	BeanDefinitionBuilder builder = BeanDefinitionBuilder
			.genericBeanDefinition(FeignClientSpecification.class);
	//为FeignClientSpecification的构造器设置参数
	builder.addConstructorArgValue(name);
	builder.addConstructorArgValue(configuration);
	//builder.getBeanDefinition()会构建对应的BeanDefinition实例
	//然后将其注册到Spring的注册表中
	registry.registerBeanDefinition(
			name + "." + FeignClientSpecification.class.getSimpleName(),
			builder.getBeanDefinition());
}

//BeanDefinitionBuilder.java
/**
 * Add an indexed constructor arg value. The current index is tracked internally
 * and all additions are at the present point.
 * 添加一个索引构造函数arg值。 内部跟踪当前索引，所有添加都在当前位置。
 */
public BeanDefinitionBuilder addConstructorArgValue(@Nullable Object value) {
	this.beanDefinition.getConstructorArgumentValues().addIndexedArgumentValue(
			this.constructorArgIndex++, value);
	return this;
}

在这里插入图片描述

将BeanDefinition注册到Spring注册表:

在这里插入图片描述

DefaultListableBeanFactory.registerBeanDefinition():

//DefaultListableBeanFactory.java
public void registerBeanDefinition(String beanName, BeanDefinition beanDefinition)
		throws BeanDefinitionStoreException {
	//此时beanName为  default.启动类类名.FeignClientSpecification
	Assert.hasText(beanName, "Bean name must not be empty");
	Assert.notNull(beanDefinition, "BeanDefinition must not be null");

	if (beanDefinition instanceof AbstractBeanDefinition) {
		try {
			//验证这个bean定义。
			((AbstractBeanDefinition) beanDefinition).validate();
		}
		catch (BeanDefinitionValidationException ex) {
			throw new BeanDefinitionStoreException(beanDefinition.getResourceDescription(), beanName,
					"Validation of bean definition failed", ex);
		}
	}
	//先尝试从注册表中获取
	BeanDefinition existingDefinition = this.beanDefinitionMap.get(beanName);
	if (existingDefinition != null) {
		//如果已经存在，判断是否允许覆盖，不允许就抛异常
		if (!isAllowBeanDefinitionOverriding()) {
			throw new BeanDefinitionOverrideException(beanName, beanDefinition, existingDefinition);
		}
		else if (existingDefinition.getRole() < beanDefinition.getRole()) {
			// e.g. was ROLE_APPLICATION, now overriding with ROLE_SUPPORT or ROLE_INFRASTRUCTURE
			if (logger.isInfoEnabled()) {
				logger.info("Overriding user-defined bean definition for bean '" + beanName +
						"' with a framework-generated bean definition: replacing [" +
						existingDefinition + "] with [" + beanDefinition + "]");
			}
		}
		else if (!beanDefinition.equals(existingDefinition)) {
			if (logger.isDebugEnabled()) {
				logger.debug("Overriding bean definition for bean '" + beanName +
						"' with a different definition: replacing [" + existingDefinition +
						"] with [" + beanDefinition + "]");
			}
		}
		else {
			if (logger.isTraceEnabled()) {
				logger.trace("Overriding bean definition for bean '" + beanName +
						"' with an equivalent definition: replacing [" + existingDefinition +
						"] with [" + beanDefinition + "]");
			}
		}
		//覆盖，放入beanDefinitionMap
		this.beanDefinitionMap.put(beanName, beanDefinition);
	}
	else {
		//第一次注册
		//检查该工厂bean创建阶段是否已经开始，通过在此期间是否有任何bean被标记为已创建来判断
		if (hasBeanCreationStarted()) {
			// Cannot modify startup-time collection elements anymore (for stable iteration)
			// 不能修改启动中的集合元素（用于稳定的迭代）
			synchronized (this.beanDefinitionMap) {
				//先放入注册表
				this.beanDefinitionMap.put(beanName, beanDefinition);
				//beanDefinitionNames是一个可供遍历的beanName集合，bean创建阶段就是
				//先遍历该集合通过beanName再从beanDefinitionMap中获取BeanDefinition的
				
				//所以在创建阶段为了保证集合迭代稳定性，需要创建新的集合在新的集合上进行修改
				//创建一个新list，将beanDefinitionNames内容添加进去
				List<String> updatedDefinitions = new ArrayList<>(this.beanDefinitionNames.size() + 1);
				updatedDefinitions.addAll(this.beanDefinitionNames);
				//把新的beanName放到新的list中
				updatedDefinitions.add(beanName);
				//将新的集合替代旧的集合
				this.beanDefinitionNames = updatedDefinitions;
				//从工厂内部的手动单例名称集中删除指定名称，避免重复注册
				removeManualSingletonName(beanName);
			}
		}
		else {
			// Still in startup registration phase
			//仍处于启动注册阶段,不用考虑集合迭代稳定性问题
			//直接放入注册表、添加到可遍历集合中
			this.beanDefinitionMap.put(beanName, beanDefinition);
			this.beanDefinitionNames.add(beanName);
			//从工厂内部的手动单例名称集中删除指定名称，避免重复注册
			removeManualSingletonName(beanName);
		}
		this.frozenBeanDefinitionNames = null;
	}

	if (existingDefinition != null || containsSingleton(beanName)) {
		resetBeanDefinition(beanName);
	}
}

2.2 迭代稳定性

在这里插入图片描述

多线程的情况, 需要复制一个新的集合, 在新的集合中添加元素后, 替换原来旧集合。

保证多线程情况下共享变量的可见性, 添加了volatile修饰。
保证有序性、原子性, 添加了synchronized关键字。
迭代稳定性：
一个线程正在修改集合中的数据，另一个线程正在迭代读取集合中的数据，由于加了volatile，导致读线程迭代的过程中，写线程对集合中的修改读线程是立即可见的，读线程读取的数据正好是写线程修改的数据，或者读线程一开始获取的个数是10个，遍历过程中，数量变多了变少了，发生这些变化都代表不稳定，并有可能引发错误。
解决方案：修改的线程在原来集合基础上复制一个新的集合进行修改，等所有修改完成后，将整个新的集合替换掉原来旧的集合，而在修改过程中，其他线程访问的集合的地址还是指向旧的（类似写时复制的感觉）
如果使用JUC并发包的集合，严重影响性能。

手动单例名称集中删除指定名称, 避免重复注册。

//DefaultListableBeanFactory.java
private void removeManualSingletonName(String beanName) {
	//Consumer：对给定的参数执行此操作。
	//set -> set.remove(beanName)：对给定的set集合删除key为beanName的元素
	
	//Predicate：对给定参数计算此谓词。
	//set -> set.contains(beanName)：对给定的set集合进行判断，包含key为beanName的元素就返回true
	updateManualSingletonNames(set -> set.remove(beanName), set -> set.contains(beanName));
}

//DefaultListableBeanFactory.java
//更新工厂内部的手动单例名称集。
private void updateManualSingletonNames(Consumer<Set<String>> action, Predicate<Set<String>> condition) {
	//检查这个工厂的bean创建阶段是否已经开始
	if (hasBeanCreationStarted()) {//一样存在迭代稳定性问题
		// Cannot modify startup-time collection elements anymore (for stable iteration)
		// 不能修改启动中的集合元素（用于稳定的迭代）
		synchronized (this.beanDefinitionMap) {
			if (condition.test(this.manualSingletonNames)) {
				//复制了一个集合，对复制的集合进行操作
				Set<String> updatedSingletons = new LinkedHashSet<>(this.manualSingletonNames);
				action.accept(updatedSingletons);
				this.manualSingletonNames = updatedSingletons;
			}
		}
	}
	else {
		// Still in startup registration phase
		// 判断this.manualSingletonNames这个集合是否包含key为beanName的元素
		if (condition.test(this.manualSingletonNames)) {
			//包含了就从manualSingletonNames集合删除这个key为beanName的元素
			action.accept(this.manualSingletonNames);
		}
	}
}

updateManualSingletonNames方法:

此方法不仅有迭代稳定性, 而且有双锁DCL

在这里插入图片描述

2.3 registerFeignClients方法

//FeignClientsRegistrar.java
public void registerFeignClients(AnnotationMetadata metadata,
		BeanDefinitionRegistry registry) {
	//获取扫描器
	ClassPathScanningCandidateComponentProvider scanner = getScanner();
	//设置资源加载器
	scanner.setResourceLoader(this.resourceLoader);

	Set<String> basePackages;
	//获取@EnableFeignClients注解的属性
	Map<String, Object> attrs = metadata
			.getAnnotationAttributes(EnableFeignClients.class.getName());
	//定义扫描过滤器，专门指定扫描被@FeignClient注解的类
	AnnotationTypeFilter annotationTypeFilter = new AnnotationTypeFilter(
			FeignClient.class);
	//获取@EnableFeignClients注解的clients属性
	//该属性直接指定要加载哪些@FeignClient类，配置了这个属性就只会加载指定的
	final Class<?>[] clients = attrs == null ? null
			: (Class<?>[]) attrs.get("clients");
	if (clients == null || clients.length == 0) {
		//clients属性为空，则为扫描器指定条件，只扫描被@FeignClient注解的类
		scanner.addIncludeFilter(annotationTypeFilter);
		//获取扫描路径
		basePackages = getBasePackages(metadata);
	}
	else {
		//clients不空的情况
		final Set<String> clientClasses = new HashSet<>();
		basePackages = new HashSet<>();
		for (Class<?> clazz : clients) {//直接遍历指定的@FeignClient类
			//获取类所在的包路径
			basePackages.add(ClassUtils.getPackageName(clazz));
			//获取类的规范类名
			clientClasses.add(clazz.getCanonicalName());
		}
		//定义扫描过滤器，只扫描clientClasses中包含的类
		AbstractClassTestingTypeFilter filter = new AbstractClassTestingTypeFilter() {
			@Override
			protected boolean match(ClassMetadata metadata) {
			    //对扫描到的类进行匹配：
			    //获取当前扫描到的类的类名，转换成规范类名（处理内部类的情况）
				String cleaned = metadata.getClassName().replaceAll("\\$", ".");
				//判断clientClasses中是否包含这个类
				return clientClasses.contains(cleaned);
			}
		};
		//即要同时满足被@FeignClient注解，同时该类在@FeignClientd的clients属性中被指定
		scanner.addIncludeFilter(
				new AllTypeFilter(Arrays.asList(filter, annotationTypeFilter)));
	}

	for (String basePackage : basePackages) {
		//扫描包，获取候选组件的BeanDefinition
		Set<BeanDefinition> candidateComponents = scanner
				.findCandidateComponents(basePackage);
		for (BeanDefinition candidateComponent : candidateComponents) {
			//判断是否是具有注解元数据的BeanDefinition
			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");
				//获取@FeignClient注解的属性
				Map<String, Object> attributes = annotationMetadata
						.getAnnotationAttributes(
								FeignClient.class.getCanonicalName());
				//获取FeignClient的名称（即@FeignClient注解的四个属性）
				//优先级contextId > value > name > serviceId
				//就是服务id、服务名称
				String name = getClientName(attributes);
				//注册ClientConfiguration，之前跟过
				//就是注册FeignClientSpecification，FeignClient规范
				registerClientConfiguration(registry, name,
						attributes.get("configuration"));
				//注册FeignClient的FactoryBean的BeanDefinition
				registerFeignClient(registry, annotationMetadata, attributes);
			}
		}
	}
}

getBasePackages: clients属性为空, 扫描其路径。
getCanonicalName: 获取规范类名。
getClientName: 获取FeignClient的服务名称。
registerFeignClient: 注册FeignClient的FactoryBean。

getBasePackages

//FeignClientsRegistrar.java
protected Set<String> getBasePackages(AnnotationMetadata importingClassMetadata) {
	//获取@EnableFeignClients注解的属性
	Map<String, Object> attributes = importingClassMetadata
			.getAnnotationAttributes(EnableFeignClients.class.getCanonicalName());

	Set<String> basePackages = new HashSet<>();
	for (String pkg : (String[]) attributes.get("value")) {//获取value属性
		if (StringUtils.hasText(pkg)) {
			basePackages.add(pkg);
		}
	}
	for (String pkg : (String[]) attributes.get("basePackages")) {//获取basePackages属性
		if (StringUtils.hasText(pkg)) {
			basePackages.add(pkg);
		}
	}
	for (Class<?> clazz : (Class[]) attributes.get("basePackageClasses")) {//获取basePackageClasses属性
		//获取类所在的包路径
		basePackages.add(ClassUtils.getPackageName(clazz));
	}

	if (basePackages.isEmpty()) {
		//如果还为空，获取之前@Import注解所标记的那个类所在的包路径
		basePackages.add(
				ClassUtils.getPackageName(importingClassMetadata.getClassName()));
	}
	return basePackages;
}

这些属性指定的扫描包路径, 是一个并集的关系。

getCanonicalName

在这里插入图片描述

//Class.java
/**
 * Returns the canonical name of the underlying class as
 * defined by the Java Language Specification.  Returns null if
 * the underlying class does not have a canonical name (i.e., if
 * it is a local or anonymous class or an array whose component
 * type does not have a canonical name).
 * 返回Java语言规范定义的基础类的规范名称。如果基础类没有规范名称则返回null。
 * (例如，如果它是一个本地或匿名类，或者是一个元素类型没有规范名称的数组)
 * 
 * @since 1.5
 */
public String getCanonicalName() {
    if (isArray()) {
        //数组情况：
        //获取数组元素的规范名称
        String canonicalName = getComponentType().getCanonicalName();
        if (canonicalName != null)
            return canonicalName + "[]";
        else
            return null;
    }
    if (isLocalOrAnonymousClass())
        //本地或匿名类
        return null;
    Class<?> enclosingClass = getEnclosingClass();
    if (enclosingClass == null) { // top level class
        //当前类就是最顶层类
        return getName();
    } else {
        //内部类情况：
        String enclosingName = enclosingClass.getCanonicalName();
        if (enclosingName == null)
            return null;
        return enclosingName + "." + getSimpleName();
    }
}

getClientName

//FeignClientsRegistrar.java
private String getClientName(Map<String, Object> client) {
	//注意,client是@FeignClient注解的属性
	if (client == null) {
		return null;
	}
	String value = (String) client.get("contextId");
	if (!StringUtils.hasText(value)) {
		value = (String) client.get("value");
	}
	if (!StringUtils.hasText(value)) {
		value = (String) client.get("name");
	}
	if (!StringUtils.hasText(value)) {
		value = (String) client.get("serviceId");
	}
	if (StringUtils.hasText(value)) {
		return value;
	}
    //看到优先级contextId > value > name > serviceId
	throw new IllegalStateException("Either 'name' or 'value' must be provided in @"
			+ FeignClient.class.getSimpleName());
}

registerFeignClient

//FeignClientsRegistrar.java
private void registerFeignClient(BeanDefinitionRegistry registry,
		AnnotationMetadata annotationMetadata, Map<String, Object> attributes) {
	//registry：Spring注册表
	//annotationMetadata：扫描到的被@FeignClient注解的类的注解数据
	//attributes：当前@FeignClient注解上相关的属性
	
	
	String className = annotationMetadata.getClassName();
	//FeignClientFactoryBean.class：FeignClient的工厂Bean，用来创建FeignClient实例的。
	
	//获取构建者构建FeignClientFactoryBean的BeanDefinition
	BeanDefinitionBuilder definition = BeanDefinitionBuilder
			.genericBeanDefinition(FeignClientFactoryBean.class);
	//@FeignClient注解的属性校验
	validate(attributes);
	//用@FeignClient注解的属性值为将来创建的FeignClientFactoryBean实例赋值
	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";
	//构建出beanDefinition实例
	AbstractBeanDefinition beanDefinition = definition.getBeanDefinition();
	
	//继续初始化，处理primary和qualifier属性配置
	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
	BeanDefinitionHolder holder = new BeanDefinitionHolder(beanDefinition, className,
			new String[] { alias });
	//注册
	BeanDefinitionReaderUtils.registerBeanDefinition(holder, registry);
}

//BeanDefinitionReaderUtils.java
public static void registerBeanDefinition(
		BeanDefinitionHolder definitionHolder, BeanDefinitionRegistry registry)
		throws BeanDefinitionStoreException {

	// Register bean definition under primary name.
	// 获取beanName
	String beanName = definitionHolder.getBeanName();
	// 注册到注册表
	registry.registerBeanDefinition(beanName, definitionHolder.getBeanDefinition());

	// Register aliases for bean name, if any.
	// 为beanName注册别名
	String[] aliases = definitionHolder.getAliases();
	if (aliases != null) {
		for (String alias : aliases) {
			registry.registerAlias(beanName, alias);
		}
	}
}