Spring的IOC容器初始化源碼分析四：載入註解Bean

refresh方法中，調用註解解析bean的loadBeanDefinitions方法如下：

public class AnnotationConfigWebApplicationContext extends AbstractRefreshableWebApplicationContext
		implements AnnotationConfigRegistry 


//載入註解Bean定義資源
	@Override
	protected void loadBeanDefinitions(DefaultListableBeanFactory beanFactory) {
		//爲容器設置註解Bean定義讀取器
		AnnotatedBeanDefinitionReader reader = getAnnotatedBeanDefinitionReader(beanFactory);
		//爲容器設置類路徑Bean定義掃描器
		ClassPathBeanDefinitionScanner scanner = getClassPathBeanDefinitionScanner(beanFactory);

		//獲取容器的Bean名稱生成器
		BeanNameGenerator beanNameGenerator = getBeanNameGenerator();
		//爲註解Bean定義讀取器和類路徑掃描器設置Bean名稱生成器
		if (beanNameGenerator != null) {
			reader.setBeanNameGenerator(beanNameGenerator);
			scanner.setBeanNameGenerator(beanNameGenerator);
			beanFactory.registerSingleton(AnnotationConfigUtils.CONFIGURATION_BEAN_NAME_GENERATOR, beanNameGenerator);
		}

		//獲取容器的作用域元信息解析器
		ScopeMetadataResolver scopeMetadataResolver = getScopeMetadataResolver();
		//爲註解Bean定義讀取器和類路徑掃描器設置作用域元信息解析器
		if (scopeMetadataResolver != null) {
			reader.setScopeMetadataResolver(scopeMetadataResolver);
			scanner.setScopeMetadataResolver(scopeMetadataResolver);
		}

		if (!this.annotatedClasses.isEmpty()) {
			if (logger.isInfoEnabled()) {
				logger.info("Registering annotated classes: [" +
						StringUtils.collectionToCommaDelimitedString(this.annotatedClasses) + "]");
			}
			reader.register(this.annotatedClasses.toArray(new Class<?>[this.annotatedClasses.size()]));
		}

		if (!this.basePackages.isEmpty()) {
			if (logger.isInfoEnabled()) {
				logger.info("Scanning base packages: [" +
						StringUtils.collectionToCommaDelimitedString(this.basePackages) + "]");
			}
			scanner.scan(this.basePackages.toArray(new String[this.basePackages.size()]));
		}

		//獲取容器定義的Bean定義資源路徑
		String[] configLocations = getConfigLocations();
		//如果定位的Bean定義資源路徑不爲空
		if (configLocations != null) {
			for (String configLocation : configLocations) {
				try {
					//使用當前容器的類加載器加載定位路徑的字節碼類文件
					Class<?> clazz = ClassUtils.forName(configLocation, getClassLoader());
					if (logger.isInfoEnabled()) {
						logger.info("Successfully resolved class for [" + configLocation + "]");
					}
					reader.register(clazz);
				}
				catch (ClassNotFoundException ex) {
					if (logger.isDebugEnabled()) {
						logger.debug("Could not load class for config location [" + configLocation +
								"] - trying package scan. " + ex);
					}
					//如果容器類加載器加載定義路徑的Bean定義資源失敗
					//則啓用容器類路徑掃描器掃描給定路徑包及其子包中的類
					int count = scanner.scan(configLocation);
					if (logger.isInfoEnabled()) {
						if (count == 0) {
							logger.info("No annotated classes found for specified class/package [" + configLocation + "]");
						}
						else {
							logger.info("Found " + count + " annotated classes in package [" + configLocation + "]");
						}
					}
				}
			}
		}
	}

1.1.先看loadBeanDefinitions中的register方法：

	loadBeanDefinitions：1 register
	
	//註冊多個註解Bean定義類
	public void register(Class<?>... annotatedClasses) {
		for (Class<?> annotatedClass : annotatedClasses) {
			registerBean(annotatedClass);
		}
	}

	
	//註冊一個註解Bean定義類
	public void registerBean(Class<?> annotatedClass) {
		doRegisterBean(annotatedClass, null, null, null);
	}
	
	
	//Bean定義讀取器向容器註冊註解Bean定義類
	<T> void doRegisterBean(Class<T> annotatedClass, @Nullable Supplier<T> instanceSupplier, @Nullable String name,
			@Nullable Class<? extends Annotation>[] qualifiers, BeanDefinitionCustomizer... definitionCustomizers) {

		//根據指定的註解Bean定義類，創建Spring容器中對註解Bean的封裝的數據結構
		AnnotatedGenericBeanDefinition abd = new AnnotatedGenericBeanDefinition(annotatedClass);
		if (this.conditionEvaluator.shouldSkip(abd.getMetadata())) {
			return;
		}

		abd.setInstanceSupplier(instanceSupplier);
		//解析註解Bean定義的作用域，若@Scope("prototype")，則Bean爲原型類型；
		//若@Scope("singleton")，則Bean爲單態類型
		ScopeMetadata scopeMetadata = this.scopeMetadataResolver.resolveScopeMetadata(abd);
		//爲註解Bean定義設置作用域
		abd.setScope(scopeMetadata.getScopeName());
		//爲註解Bean定義生成Bean名稱
		String beanName = (name != null ? name : this.beanNameGenerator.generateBeanName(abd, this.registry));

		//處理註解Bean定義中的通用註解
		AnnotationConfigUtils.processCommonDefinitionAnnotations(abd);
		//如果在向容器註冊註解Bean定義時，使用了額外的限定符註解，則解析限定符註解。
		//主要是配置的關於autowiring自動依賴注入裝配的限定條件，即@Qualifier註解
		//Spring自動依賴注入裝配默認是按類型裝配，如果使用@Qualifier則按名稱
		if (qualifiers != null) {
			for (Class<? extends Annotation> qualifier : qualifiers) {
				//如果配置了@Primary註解，設置該Bean爲autowiring自動依賴注入裝//配時的首選
				if (Primary.class == qualifier) {
					abd.setPrimary(true);
				}
				//如果配置了@Lazy註解，則設置該Bean爲非延遲初始化，如果沒有配置，
				//則該Bean爲預實例化
				else if (Lazy.class == qualifier) {
					abd.setLazyInit(true);
				}
				//如果使用了除@Primary和@Lazy以外的其他註解，則爲該Bean添加一
				//個autowiring自動依賴注入裝配限定符，該Bean在進autowiring
				//自動依賴注入裝配時，根據名稱裝配限定符指定的Bean
				else {
					abd.addQualifier(new AutowireCandidateQualifier(qualifier));
				}
			}
		}
		for (BeanDefinitionCustomizer customizer : definitionCustomizers) {
			customizer.customize(abd);
		}

		//創建一個指定Bean名稱的Bean定義對象，封裝註解Bean定義類數據
		BeanDefinitionHolder definitionHolder = new BeanDefinitionHolder(abd, beanName);
		//根據註解Bean定義類中配置的作用域，創建相應的代理對象
		definitionHolder = AnnotationConfigUtils.applyScopedProxyMode(scopeMetadata, definitionHolder, this.registry);
		//向IOC容器註冊註解Bean類定義對象
		BeanDefinitionReaderUtils.registerBeanDefinition(definitionHolder, this.registry);
	}

	

看一下register中的doRegisterBean方法：

doRegisterBean ：1
	
	public class AnnotationScopeMetadataResolver implements ScopeMetadataResolver 
	
	//解析註解Bean定義類中的作用域元信息
	@Override
	public ScopeMetadata resolveScopeMetadata(BeanDefinition definition) {
		ScopeMetadata metadata = new ScopeMetadata();
		if (definition instanceof AnnotatedBeanDefinition) {
			AnnotatedBeanDefinition annDef = (AnnotatedBeanDefinition) definition;
			//從註解Bean定義類的屬性中查找屬性爲”Scope”的值，即@Scope註解的值
			//annDef.getMetadata().getAnnotationAttributes方法將Bean
			//中所有的註解和註解的值存放在一個map集合中
			AnnotationAttributes attributes = AnnotationConfigUtils.attributesFor(
					annDef.getMetadata(), this.scopeAnnotationType);
			//將獲取到的@Scope註解的值設置到要返回的對象中
			if (attributes != null) {
				metadata.setScopeName(attributes.getString("value"));
				//獲取@Scope註解中的proxyMode屬性值，在創建代理對象時會用到
				ScopedProxyMode proxyMode = attributes.getEnum("proxyMode");
				//如果@Scope的proxyMode屬性爲DEFAULT或者NO
				if (proxyMode == ScopedProxyMode.DEFAULT) {
					//設置proxyMode爲NO
					proxyMode = this.defaultProxyMode;
				}
				//爲返回的元數據設置proxyMode
				metadata.setScopedProxyMode(proxyMode);
			}
		}
		//返回解析的作用域元信息對象
		return metadata;
	}


doRegisterBean：2
	
	//處理註解Bean定義中的通用註解
	AnnotationConfigUtils.processCommonDefinitionAnnotations(abd);
	
	public static void processCommonDefinitionAnnotations(AnnotatedBeanDefinition abd) {
		processCommonDefinitionAnnotations(abd, abd.getMetadata());
	}

	
	static void processCommonDefinitionAnnotations(AnnotatedBeanDefinition abd, AnnotatedTypeMetadata metadata) {
		AnnotationAttributes lazy = attributesFor(metadata, Lazy.class);
		//如果Bean定義中有@Lazy註解，則將該Bean預實例化屬性設置爲@lazy註解的值
		if (lazy != null) {
			abd.setLazyInit(lazy.getBoolean("value"));
		}

		else if (abd.getMetadata() != metadata) {
			lazy = attributesFor(abd.getMetadata(), Lazy.class);
			if (lazy != null) {
				abd.setLazyInit(lazy.getBoolean("value"));
			}
		}
		//如果Bean定義中有@Primary註解，則爲該Bean設置爲autowiring自動依賴注入裝配的首選對象
		if (metadata.isAnnotated(Primary.class.getName())) {
			abd.setPrimary(true);
		}
		//如果Bean定義中有@ DependsOn註解，則爲該Bean設置所依賴的Bean名稱，
		//容器將確保在實例化該Bean之前首先實例化所依賴的Bean
		AnnotationAttributes dependsOn = attributesFor(metadata, DependsOn.class);
		if (dependsOn != null) {
			abd.setDependsOn(dependsOn.getStringArray("value"));
		}

		if (abd instanceof AbstractBeanDefinition) {
			AbstractBeanDefinition absBd = (AbstractBeanDefinition) abd;
			AnnotationAttributes role = attributesFor(metadata, Role.class);
			if (role != null) {
				absBd.setRole(role.getNumber("value").intValue());
			}
			AnnotationAttributes description = attributesFor(metadata, Description.class);
			if (description != null) {
				absBd.setDescription(description.getString("value"));
			}
		}
	}
	
	
	
	-----------------------------------------
	doRegisterBean：3
	
	//根據註解Bean定義類中配置的作用域，創建相應的代理對象
		definitionHolder = AnnotationConfigUtils.applyScopedProxyMode(scopeMetadata, definitionHolder, this.registry);
		
	static BeanDefinitionHolder applyScopedProxyMode(
			ScopeMetadata metadata, BeanDefinitionHolder definition, BeanDefinitionRegistry registry) {

		//獲取註解Bean定義類中@Scope註解的proxyMode屬性值
		ScopedProxyMode scopedProxyMode = metadata.getScopedProxyMode();
		//如果配置的@Scope註解的proxyMode屬性值爲NO，則不應用代理模式
		if (scopedProxyMode.equals(ScopedProxyMode.NO)) {
			return definition;
		}
		//獲取配置的@Scope註解的proxyMode屬性值，如果爲TARGET_CLASS
		//則返回true，如果爲INTERFACES，則返回false
		boolean proxyTargetClass = scopedProxyMode.equals(ScopedProxyMode.TARGET_CLASS);
		//爲註冊的Bean創建相應模式的代理對象
		return ScopedProxyCreator.createScopedProxy(definition, registry, proxyTargetClass);
	}

	
	-----------------------------------------
	doRegisterBean：4
	
	//向IOC容器註冊註解Bean類定義對象
	BeanDefinitionReaderUtils.registerBeanDefinition(definitionHolder, this.registry);
	//將解析的BeanDefinitionHold註冊到容器中
	public static void registerBeanDefinition(
			BeanDefinitionHolder definitionHolder, BeanDefinitionRegistry registry)
			throws BeanDefinitionStoreException {

		// Register bean definition under primary name.
		//獲取解析的BeanDefinition的名稱
		String beanName = definitionHolder.getBeanName();
		//向IOC容器註冊BeanDefinition
		registry.registerBeanDefinition(beanName, definitionHolder.getBeanDefinition());

		// Register aliases for bean name, if any.
		//如果解析的BeanDefinition有別名，向容器爲其註冊別名
		String[] aliases = definitionHolder.getAliases();
		if (aliases != null) {
			for (String alias : aliases) {
				registry.registerAlias(beanName, alias);
			}
		}
	}

  ----------------------------------------------------------------

 

loadBeanDefinitions：2 
	int count = scanner.scan(configLocation);
	
	//調用類路徑Bean定義掃描器入口方法
	public int scan(String... basePackages) {
		//獲取容器中已經註冊的Bean個數
		int beanCountAtScanStart = this.registry.getBeanDefinitionCount();

		//啓動掃描器掃描給定包
		doScan(basePackages);

		// Register annotation config processors, if necessary.
		//註冊註解配置(Annotation config)處理器
		if (this.includeAnnotationConfig) {
			AnnotationConfigUtils.registerAnnotationConfigProcessors(this.registry);
		}

		//返回註冊的Bean個數
		return (this.registry.getBeanDefinitionCount() - beanCountAtScanStart);
	}

 

scan：1
	//啓動掃描器掃描給定包
	doScan(basePackages);
		
		
	//類路徑Bean定義掃描器掃描給定包及其子包
	protected Set<BeanDefinitionHolder> doScan(String... basePackages) {
		Assert.notEmpty(basePackages, "At least one base package must be specified");
		//創建一個集合，存放掃描到Bean定義的封裝類
		Set<BeanDefinitionHolder> beanDefinitions = new LinkedHashSet<>();
		//遍歷掃描所有給定的包
		for (String basePackage : basePackages) {
			//調用父類ClassPathScanningCandidateComponentProvider的方法
			//掃描給定類路徑，獲取符合條件的Bean定義
			Set<BeanDefinition> candidates = findCandidateComponents(basePackage);
			//遍歷掃描到的Bean
			for (BeanDefinition candidate : candidates) {
				//獲取Bean定義類中@Scope註解的值，即獲取Bean的作用域
				ScopeMetadata scopeMetadata = this.scopeMetadataResolver.resolveScopeMetadata(candidate);
				//爲Bean設置註解配置的作用域
				candidate.setScope(scopeMetadata.getScopeName());
				//爲Bean生成名稱
				String beanName = this.beanNameGenerator.generateBeanName(candidate, this.registry);
				//如果掃描到的Bean不是Spring的註解Bean，則爲Bean設置默認值，
				//設置Bean的自動依賴注入裝配屬性等
				if (candidate instanceof AbstractBeanDefinition) {
					postProcessBeanDefinition((AbstractBeanDefinition) candidate, beanName);
				}
				//如果掃描到的Bean是Spring的註解Bean，則處理其通用的Spring註解
				if (candidate instanceof AnnotatedBeanDefinition) {
					//處理註解Bean中通用的註解，在分析註解Bean定義類讀取器時已經分析過
					AnnotationConfigUtils.processCommonDefinitionAnnotations((AnnotatedBeanDefinition) candidate);
				}
				//根據Bean名稱檢查指定的Bean是否需要在容器中註冊，或者在容器中衝突
				if (checkCandidate(beanName, candidate)) {
					BeanDefinitionHolder definitionHolder = new BeanDefinitionHolder(candidate, beanName);
					//根據註解中配置的作用域，爲Bean應用相應的代理模式
					definitionHolder =
							AnnotationConfigUtils.applyScopedProxyMode(scopeMetadata, definitionHolder, this.registry);
					beanDefinitions.add(definitionHolder);
					//向容器註冊掃描到的Bean
					registerBeanDefinition(definitionHolder, this.registry);
				}
			}
		}
		return beanDefinitions;
	}

//掃描給定類路徑的包
	public Set<BeanDefinition> findCandidateComponents(String basePackage) {
		if (this.componentsIndex != null && indexSupportsIncludeFilters()) {
			return addCandidateComponentsFromIndex(this.componentsIndex, basePackage);
		}
		else {
			return scanCandidateComponents(basePackage);
		}
	}

 

findCandidateComponents  1
	
	private Set<BeanDefinition> addCandidateComponentsFromIndex(CandidateComponentsIndex index, String basePackage) {
		//創建存儲掃描到的類的集合
		Set<BeanDefinition> candidates = new LinkedHashSet<>();
		try {
			Set<String> types = new HashSet<>();
			for (TypeFilter filter : this.includeFilters) {
				String stereotype = extractStereotype(filter);
				if (stereotype == null) {
					throw new IllegalArgumentException("Failed to extract stereotype from "+ filter);
				}
				types.addAll(index.getCandidateTypes(basePackage, stereotype));
			}
			boolean traceEnabled = logger.isTraceEnabled();
			boolean debugEnabled = logger.isDebugEnabled();
			for (String type : types) {
				//爲指定資源獲取元數據讀取器，元信息讀取器通過彙編(ASM)讀//取資源元信息
				MetadataReader metadataReader = getMetadataReaderFactory().getMetadataReader(type);
				//如果掃描到的類符合容器配置的過濾規則
				if (isCandidateComponent(metadataReader)) {
					//通過彙編(ASM)讀取資源字節碼中的Bean定義元信息
					AnnotatedGenericBeanDefinition sbd = new AnnotatedGenericBeanDefinition(
							metadataReader.getAnnotationMetadata());
					if (isCandidateComponent(sbd)) {
						if (debugEnabled) {
							logger.debug("Using candidate component class from index: " + type);
						}
						candidates.add(sbd);
					}
					else {
						if (debugEnabled) {
							logger.debug("Ignored because not a concrete top-level class: " + type);
						}
					}
				}
				else {
					if (traceEnabled) {
						logger.trace("Ignored because matching an exclude filter: " + type);
					}
				}
			}
		}
		catch (IOException ex) {
			throw new BeanDefinitionStoreException("I/O failure during classpath scanning", ex);
		}
		return candidates;
	}

	
	if (isCandidateComponent(sbd)) {
	//判斷元信息讀取器讀取的類是否符合容器定義的註解過濾規則
	protected boolean isCandidateComponent(MetadataReader metadataReader) throws IOException {
		//如果讀取的類的註解在排除註解過濾規則中，返回false
		for (TypeFilter tf : this.excludeFilters) {
			if (tf.match(metadataReader, getMetadataReaderFactory())) {
				return false;
			}
		}
		//如果讀取的類的註解在包含的註解的過濾規則中，則返回ture
		for (TypeFilter tf : this.includeFilters) {
			if (tf.match(metadataReader, getMetadataReaderFactory())) {
				return isConditionMatch(metadataReader);
			}
		}
		//如果讀取的類的註解既不在排除規則，也不在包含規則中，則返回false
		return false;
	}
	
	
	
	findCandidateComponents：  2
	
	private Set<BeanDefinition> scanCandidateComponents(String basePackage) {
		Set<BeanDefinition> candidates = new LinkedHashSet<>();
		try {
			String packageSearchPath = ResourcePatternResolver.CLASSPATH_ALL_URL_PREFIX +
					resolveBasePackage(basePackage) + '/' + this.resourcePattern;
			Resource[] resources = getResourcePatternResolver().getResources(packageSearchPath);
			boolean traceEnabled = logger.isTraceEnabled();
			boolean debugEnabled = logger.isDebugEnabled();
			for (Resource resource : resources) {
				if (traceEnabled) {
					logger.trace("Scanning " + resource);
				}
				if (resource.isReadable()) {
					try {
						MetadataReader metadataReader = getMetadataReaderFactory().getMetadataReader(resource);
						if (isCandidateComponent(metadataReader)) {
							ScannedGenericBeanDefinition sbd = new ScannedGenericBeanDefinition(metadataReader);
							sbd.setResource(resource);
							sbd.setSource(resource);
							if (isCandidateComponent(sbd)) {
								if (debugEnabled) {
									logger.debug("Identified candidate component class: " + resource);
								}
								candidates.add(sbd);
							}
							else {
								if (debugEnabled) {
									logger.debug("Ignored because not a concrete top-level class: " + resource);
								}
							}
						}
						else {
							if (traceEnabled) {
								logger.trace("Ignored because not matching any filter: " + resource);
							}
						}
					}
					catch (Throwable ex) {
						throw new BeanDefinitionStoreException(
								"Failed to read candidate component class: " + resource, ex);
					}
				}
				else {
					if (traceEnabled) {
						logger.trace("Ignored because not readable: " + resource);
					}
				}
			}
		}
		catch (IOException ex) {
			throw new BeanDefinitionStoreException("I/O failure during classpath scanning", ex);
		}
		return candidates;
	}