Spring源码注解启动流程解析（2）

下面解析 register(componentClasses);

@Override
	public void register(Class<?>... componentClasses) {
		Assert.notEmpty(componentClasses, "At least one component class must be specified");
		/**
		 * 这里通过之前无参构造器this()初始化好了AnnotatedBeanDefinitionReader
		 * 执行register
		 */
		this.reader.register(componentClasses);
	}

public void register(Class<?>... componentClasses) {
		/**
		 * 遍历componentClasses注册
		 */
		for (Class<?> componentClass : componentClasses) {
			registerBean(componentClass);
		}
	}

public void registerBean(Class<?> beanClass) {
		doRegisterBean(beanClass, null, null, null);
	}

<T> void doRegisterBean(Class<T> beanClass, @Nullable Supplier<T> instanceSupplier, @Nullable String name,
			@Nullable Class<? extends Annotation>[] qualifiers, BeanDefinitionCustomizer... definitionCustomizers) {
		/**
		 * registerBean方法调用doRegisterBean后面instanceSupplier name qualifiers都为null
		 */
		AnnotatedGenericBeanDefinition abd = new AnnotatedGenericBeanDefinition(beanClass);
		/**
		 *	判断abd是否有Conditional注解
		 *	如果没有就返回false
		 */
		if (this.conditionEvaluator.shouldSkip(abd.getMetadata())) {
			return;
		}
		    /**
		 * 给InstanceSupplier赋值
		 */
		abd.setInstanceSupplier(instanceSupplier);
		/**
		 * 创建ScopeMetadata解析里面@Scope的属性值，value和proxyMode进行赋值
		 */
		ScopeMetadata scopeMetadata = this.scopeMetadataResolver.resolveScopeMetadata(abd);
		/**
		 * scopeName默认为singleton
		 */
		abd.setScope(scopeMetadata.getScopeName());
		/**
		 * 判断是否有org.springframework.stereotype.Component注解
		 * javax.annotation.ManagedBean
		 * javax.inject.Named获取里面的value作为beanName
		 *
		 * 如果没有就调用buildDefaultBeanName把类名小驼峰
		 */
		String beanName = (name != null ? name : this.beanNameGenerator.generateBeanName(abd, this.registry));
		/**
		 * 解析AnnotatedGenericBeanDefinition里面的注解
		 * Lazy Primary DependsOn Role Description
		 * 设置AnnotatedGenericBeanDefinition的属性
		 */
		AnnotationConfigUtils.processCommonDefinitionAnnotations(abd);
		/**
		 * 遍历qualifiers设置AnnotatedGenericBeanDefinition的属性
		 */
		if (qualifiers != null) {
			for (Class<? extends Annotation> qualifier : qualifiers) {
				if (Primary.class == qualifier) {
					abd.setPrimary(true);
				}
				else if (Lazy.class == qualifier) {
					abd.setLazyInit(true);
				}
				else {
					abd.addQualifier(new AutowireCandidateQualifier(qualifier));
				}
			}
		}

		for (BeanDefinitionCustomizer customizer : definitionCustomizers) {
			customizer.customize(abd);
		}
		/**
		 * 通过AnnotatedGenericBeanDefinition和beanName
		 * 创建BeanDefinitionHolder  别名为null
		 */
		BeanDefinitionHolder definitionHolder = new BeanDefinitionHolder(abd, beanName);
		/**
		 * 判断tScopedProxyMode的类型不是NO类型
		 * 创建ScopedProxy
		 */
		definitionHolder = AnnotationConfigUtils.applyScopedProxyMode(scopeMetadata, definitionHolder, this.registry);
		BeanDefinitionReaderUtils.registerBeanDefinition(definitionHolder, this.registry);
	}

1. this.scopeMetadataResolver.resolveScopeMetadata(abd)

 @Override
	public ScopeMetadata resolveScopeMetadata(BeanDefinition definition) {
		ScopeMetadata metadata = new ScopeMetadata();
		if (definition instanceof AnnotatedBeanDefinition) {
			AnnotatedBeanDefinition annDef = (AnnotatedBeanDefinition) definition;
			//获取@scope注解的attributes
			AnnotationAttributes attributes = AnnotationConfigUtils.attributesFor(
					annDef.getMetadata(), this.scopeAnnotationType);
			if (attributes != null) {
				//给metadata的ScopeName赋值value
				metadata.setScopeName(attributes.getString("value"));
				/**
				 * 如果proxyMode为ScopedProxyMode.DEFAULT就赋值defaultProxyMode
				 * 不然就设置为scopedProxyMode
				 */
				ScopedProxyMode proxyMode = attributes.getEnum("proxyMode");
				if (proxyMode == ScopedProxyMode.DEFAULT) {
					proxyMode = this.defaultProxyMode;
				}
				metadata.setScopedProxyMode(proxyMode);
			}
		}
		return metadata;
	}

这个方法主要是通过bd生成一个ScopeMetadata，如过类上面有注解@Scope注解就解析scopeNameh和proxyMode的值赋值给ScopeMetadata,如果没有注解就使用默认的

private String scopeName = BeanDefinition.SCOPE_SINGLETON(“singleton”);

private ScopedProxyMode scopedProxyMode = ScopedProxyMode.NO;

2.AnnotationConfigUtils.processCommonDefinitionAnnotations(abd);

public static void processCommonDefinitionAnnotations(AnnotatedBeanDefinition abd) {
		processCommonDefinitionAnnotations(abd, abd.getMetadata());
	}

static void processCommonDefinitionAnnotations(AnnotatedBeanDefinition abd, AnnotatedTypeMetadata metadata) {
		//获取Lazy注解
		AnnotationAttributes lazy = attributesFor(metadata, Lazy.class);
		if (lazy != null) {
			//设置AnnotatedBeanDefinition的LazyInit为注解Lazy的value
			abd.setLazyInit(lazy.getBoolean("value"));
		}
		/**
		 * 如果AnnotatedBeanDefinition里面的metadata不等于参数metadata
		 * 就从AnnotatedBeanDefinition里面获取metadata
		 * 赋值LazyInit
		 */
		else if (abd.getMetadata() != metadata) {
			lazy = attributesFor(abd.getMetadata(), Lazy.class);
			if (lazy != null) {
				abd.setLazyInit(lazy.getBoolean("value"));
			}
		}
		/**
		 * 判断metadata里面有没有Primary注解
		 * 有就设置AnnotatedBeanDefinition的Primary为true
		 */
		/**
		 * 科普一下@Primary
		 *
		 * 自动装配时当出现多个Bean候选者时，被注解为@Primary的Bean将作为首选者，否则将抛出异常
		 */
		if (metadata.isAnnotated(Primary.class.getName())) {
			abd.setPrimary(true);
		}
		/**
		 * DependsOn注解可以定义在类和方法上，
		 * 意思是我这个组件要依赖于另一个组件，也就是说被依赖的组件会比该组件先注册到IOC容器中。
		 */
		AnnotationAttributes dependsOn = attributesFor(metadata, DependsOn.class);
		if (dependsOn != null) {
			abd.setDependsOn(dependsOn.getStringArray("value"));
		}
		/**
		 * Role注解标识Bean的分类
		 */
		AnnotationAttributes role = attributesFor(metadata, Role.class);
		if (role != null) {
			abd.setRole(role.getNumber("value").intValue());
		}
		/**
		 * Description注解 bean定义关联的文本描述
		 */
		AnnotationAttributes description = attributesFor(metadata, Description.class);
		if (description != null) {
			abd.setDescription(description.getString("value"));
		}
	}

3.BeanDefinitionReaderUtils.registerBeanDefinition(definitionHolder, this.registry)

public static void registerBeanDefinition(
			BeanDefinitionHolder definitionHolder, BeanDefinitionRegistry registry)
			throws BeanDefinitionStoreException {

		// Register bean definition under primary name.、
		//在主名称下注册bean定义。
		String beanName = definitionHolder.getBeanName();
		/**
		 * 注册在beanFactory里面的beanDefinitionMap
		 */
		registry.registerBeanDefinition(beanName, definitionHolder.getBeanDefinition());

		// Register aliases for bean name, if any.
		// 注册bean名称的别名（如果有）。
		// 注册在beanFactory里面的aliasMap
		String[] aliases = definitionHolder.getAliases();
		if (aliases != null) {
			for (String alias : aliases) {
				registry.registerAlias(beanName, alias);
			}
		}
	}

4. registry.registerBeanDefinition(beanName, definitionHolder.getBeanDefinition())

@Override
	public void registerBeanDefinition(String beanName, BeanDefinition beanDefinition)
			throws BeanDefinitionStoreException {

		this.beanFactory.registerBeanDefinition(beanName, beanDefinition);
	}

@Override
	public void registerBeanDefinition(String beanName, BeanDefinition beanDefinition)
			throws BeanDefinitionStoreException {

		Assert.hasText(beanName, "Bean name must not be empty");
		Assert.notNull(beanDefinition, "BeanDefinition must not be null");

		if (beanDefinition instanceof AbstractBeanDefinition) {
			try {
				//做一些校验
				((AbstractBeanDefinition) beanDefinition).validate();
			}
			catch (BeanDefinitionValidationException ex) {
				throw new BeanDefinitionStoreException(beanDefinition.getResourceDescription(), beanName,
						"Validation of bean definition failed", ex);
			}
		}
		//先从beanDefinitionMap里面获取
		BeanDefinition existingDefinition = this.beanDefinitionMap.get(beanName);
		//这里是beanDefinitionMap不为null的情况，我们启动很少会出现这种情况
		if (existingDefinition != null) {
			/**
			 * 判断下是否应允许它覆盖bean，不能就抛异常
			 */
			if (!isAllowBeanDefinitionOverriding()) {
				throw new BeanDefinitionOverrideException(beanName, beanDefinition, existingDefinition);
			}
			/**
			 * 下面是允许它覆盖bean
			 */
			/**
			 * 判断下beanDefinitionMap里面拿出来的bdRole是否小于现在的bdRole
			 * 小于就打印日志
			 */
			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 + "]");
				}
			}
			/**
			 * 判断下beanDefinitionMap里面拿出来的bd和现在的是否一样
			 * 不一样就打印日志
			 */
			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 + "]");
				}
			}
			//这里执行覆盖逻辑
			this.beanDefinitionMap.put(beanName, beanDefinition);
		}
		else {
			//检查该工厂的Bean创建阶段是否已经开始
			if (hasBeanCreationStarted()) {
				// 不能再修改启动时间的集合元素了 为了稳定的迭代
				// Cannot modify startup-time collection elements anymore (for stable iteration)
				/**
				 * 通过加锁 去更新beanDefinitionMap和beanDefinitionNames
				 */
				synchronized (this.beanDefinitionMap) {
					this.beanDefinitionMap.put(beanName, beanDefinition);
					List<String> updatedDefinitions = new ArrayList<>(this.beanDefinitionNames.size() + 1);
					updatedDefinitions.addAll(this.beanDefinitionNames);
					updatedDefinitions.add(beanName);
					this.beanDefinitionNames = updatedDefinitions;
					removeManualSingletonName(beanName);
				}
			}
			else {
				// Still in startup registration phase
				// 仍处于启动注册阶段
				//把beanDefinition注册到beanDefinitionMap
				this.beanDefinitionMap.put(beanName, beanDefinition);
				//在beanDefinitionNames添加beanName
				this.beanDefinitionNames.add(beanName);
				//判断beanName 再manualSingletonNames里面有没有  没有就添加进去
				removeManualSingletonName(beanName);
			}
			//设置 冻结配置的情况下，bean定义名称的缓存数组为null
			this.frozenBeanDefinitionNames = null;
		}
		/**
		 *
		 * 从beanDefinitionMap里面获取 existingDefinition不为null
		 * singletonObjects有这个beanName
		 * 就执行resetBeanDefinition
		 */
		if (existingDefinition != null || containsSingleton(beanName)) {
			resetBeanDefinition(beanName);
		}
		/**
		 * 是否可以为所有bean缓存bean定义元数据
		 */
		else if (isConfigurationFrozen()) {
			clearByTypeCache();
		}
	}

5.removeManualSingletonName（）

private void removeManualSingletonName(String beanName) {
		updateManualSingletonNames(set -> set.remove(beanName), set -> set.contains(beanName));
	}

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) {
				/**
				 * updateManualSingletonNames(set -> set.add(beanName), set -> !this.beanDefinitionMap.containsKey(beanName));
				 *
				 * 做了下面的操作：
				 * 			首先调用了containsKey判断里面没有这个beanName然后	再新建一个set addAll(manualSingletonNames) 最后在add beanName
				 */
				if (condition.test(this.manualSingletonNames)) {
					Set<String> updatedSingletons = new LinkedHashSet<>(this.manualSingletonNames);
					action.accept(updatedSingletons);
					this.manualSingletonNames = updatedSingletons;
				}
			}
		}
		else {
			//首先调用了containsKey判断里面没有这个beanName然后 这个是直接在manualSingletonNames新增
			// Still in startup registration phase
			if (condition.test(this.manualSingletonNames)) {
				action.accept(this.manualSingletonNames);
			}
		}
	}