Spring原始碼解析之BeanFactoryPostProcessor(二)

北洛發表於2020-12-01

上一章,我們介紹了在AnnotationConfigApplicationContext初始化的時候,會建立AnnotatedBeanDefinitionReader和ClassPathBeanDefinitionScanner兩個物件:

public class AnnotationConfigApplicationContext extends GenericApplicationContext implements AnnotationConfigRegistry {
……
	public AnnotationConfigApplicationContext() {
		this.reader = new AnnotatedBeanDefinitionReader(this);
		this.scanner = new ClassPathBeanDefinitionScanner(this);
	}
……
}

 

我們已經知道AnnotatedBeanDefinitionReader物件建立的大致流程,AnnotatedBeanDefinitionReader是用來註冊配置類的。現在我們要來學習ClassPathBeanDefinitionScanner,首先從ClassPathBeanDefinitionScanner的名字我們大概可以知道,這個類是用來掃描BeanDefinition的類路徑的,那麼,我們要怎麼使用這個類來掃描類路徑呢?來看下面的測試用例:

    @Test
    public void test04() {
        AnnotationConfigApplicationContext ac = new AnnotationConfigApplicationContext();
        ac.scan("org.example.service");
        ac.refresh();
        System.out.println(ac.getBean("orderService"));
    }

    

執行結果:

org.example.service.OrderService@4ba2ca36

  

上面的測試用例,我們不再像之前在配置類上用@ComponentScan標記要掃描的類路徑,並將配置類作為引數傳給AnnotationConfigApplicationContext建立物件。而是在呼叫AnnotationConfigApplicationContext無參構造方法建立物件後,再呼叫ac.scan(String... basePackages)將類路徑傳入,而ac.scan(String... basePackages)方法也是呼叫scanner.scan(String... basePackages)方法來完成類的掃描。

public class AnnotationConfigApplicationContext extends GenericApplicationContext implements AnnotationConfigRegistry {
……
	private final ClassPathBeanDefinitionScanner scanner;
…… @Override public void scan(String... basePackages) { Assert.notEmpty(basePackages, "At least one base package must be specified"); this.scanner.scan(basePackages); } …… }

  

<1>和<2>兩塊程式碼最終效果看起來一樣,都能掃描我們設定的路徑,根據類生成BeanDefinition再生成bean,可能有人會懷疑,掃描用@ComponentScan所標記的類路徑,是否是AnnotationConfigApplicationContext的scanner物件? 這裡筆者可以告訴大家:掃描@ComponentScan標記的類路徑需要用到ClassPathBeanDefinitionScanner類,但並非用AnnotationConfigApplicationContext的scanner物件,而是在程式碼的某處建立了ClassPathBeanDefinitionScanner物件再呼叫scan(String... basePackages)方法掃描@ComponentScan標記的路徑,至於是哪裡建立新的ClassPathBeanDefinitionScanner物件再掃描@ComponentScan標記的路徑後面會講,只是這裡我們要知道AnnotationConfigApplicationContext的scanner物件僅僅用來幫助我們新增掃描路徑,而實際的開發中很少用到。

AnnotationConfigApplicationContext ac = new AnnotationConfigApplicationContext(MyConfig.class);//<1>
————————————————————————————————————————————————————————————————————————————————————————————————
AnnotationConfigApplicationContext ac = new AnnotationConfigApplicationContext();//<2>
ac.scan("org.example.service");
ac.refresh();

  

下面,我們來看看ClassPathBeanDefinitionScanner的scan(String... basePackages)方法都做了些什麼:

public class ClassPathBeanDefinitionScanner extends ClassPathScanningCandidateComponentProvider {

	private final BeanDefinitionRegistry registry;
	……
	public int scan(String... basePackages) {
		int beanCountAtScanStart = this.registry.getBeanDefinitionCount();

		doScan(basePackages);//<1>

		// Register annotation config processors, if necessary.
		if (this.includeAnnotationConfig) {
			AnnotationConfigUtils.registerAnnotationConfigProcessors(this.registry);//<2>
		}

		return (this.registry.getBeanDefinitionCount() - beanCountAtScanStart);
	}
	protected Set<BeanDefinitionHolder> doScan(String... basePackages) {
		Assert.notEmpty(basePackages, "At least one base package must be specified");
		Set<BeanDefinitionHolder> beanDefinitions = new LinkedHashSet<>();
		for (String basePackage : basePackages) {
			Set<BeanDefinition> candidates = findCandidateComponents(basePackage);//<3>
			for (BeanDefinition candidate : candidates) {
				ScopeMetadata scopeMetadata = this.scopeMetadataResolver.resolveScopeMetadata(candidate);
				candidate.setScope(scopeMetadata.getScopeName());
				String beanName = this.beanNameGenerator.generateBeanName(candidate, this.registry);//<4>
				if (candidate instanceof AbstractBeanDefinition) {
					postProcessBeanDefinition((AbstractBeanDefinition) candidate, beanName);
				}
				if (candidate instanceof AnnotatedBeanDefinition) {
					AnnotationConfigUtils.processCommonDefinitionAnnotations((AnnotatedBeanDefinition) candidate);//<5>
				}
				if (checkCandidate(beanName, candidate)) {
					BeanDefinitionHolder definitionHolder = new BeanDefinitionHolder(candidate, beanName);//<6>
					definitionHolder =
							AnnotationConfigUtils.applyScopedProxyMode(scopeMetadata, definitionHolder, this.registry);
					beanDefinitions.add(definitionHolder);
					registerBeanDefinition(definitionHolder, this.registry);//<7>
				}
			}
		}
		return beanDefinitions;
	}
	……
}

  

  • 進入到scan(String... basePackages)方法後,會在<1>處將要掃描的類路徑傳遞給doScan(String... basePackages),由doScan(String... basePackages)代替其完成掃描。
  • includeAnnotationConfig欄位預設為true,會進入到AnnotationConfigUtils.registerAnnotationConfigProcessors(BeanDefinitionRegistry registry)方法,這個方法在上一章有講過,會預先註冊一些BeanDefinition到BeanDefinitionRegistry。
  • 進入到doScan(String... basePackages)後,在<3>處會呼叫父類ClassPathScanningCandidateComponentProvider的findCandidateComponents(String basePackage)方法,這個方法可以針對我們傳入的一個類路徑,掃描路徑下所有元件並返回其BeanDefinition,這裡返回的是BeanDefinition的集合。
  • 在<3>處拿到BeanDefinition集合後會迴圈每一個BeanDefinition,在<4>處用beanName生成器根據BeanDefinition生成beanName。
  • 在程式碼<5>處會判斷BeanDefinition能否轉型成AnnotatedBeanDefinition(註解BeanDefinition),如果可以則會將BeanDefinition傳入到AnnotationConfigUtils.processCommonDefinitionAnnotations(AnnotatedBeanDefinition abd),在這個方法中會獲取AnnotatedBeanDefinition的元資訊並設定其屬性,比如這個類是否標記了@Lazy、@Primary、@DependsOn、@Description……等。
  • 最後,在<6>處會根據BeanDefinition和beanName生成一個BeanDefinitionHolder物件,在<7>處將BeanDefinitionHolder和registry物件傳入registerBeanDefinition(BeanDefinitionHolder definitionHolder, BeanDefinitionRegistry registry)方法,將BeanDefinition和beanName註冊到registry。

從上面的程式碼我們得知,spring掃描類路徑是呼叫ClassPathScanningCandidateComponentProvider.findCandidateComponents(String basePackage)方法,所以我們繼續追蹤到這個方法:

	public Set<BeanDefinition> findCandidateComponents(String basePackage) {
		if (this.componentsIndex != null && indexSupportsIncludeFilters()) {
			return addCandidateComponentsFromIndex(this.componentsIndex, basePackage);
		}
		else {
			return scanCandidateComponents(basePackage);//<1>
		}
	}
	
	private Set<BeanDefinition> scanCandidateComponents(String basePackage) {
		Set<BeanDefinition> candidates = new LinkedHashSet<>();
		try {
			String packageSearchPath = ResourcePatternResolver.CLASSPATH_ALL_URL_PREFIX +
					resolveBasePackage(basePackage) + '/' + this.resourcePattern;//<2>
			Resource[] resources = getResourcePatternResolver().getResources(packageSearchPath);//<3>
			……
			for (Resource resource : resources) {
				if (resource.isReadable()) {
					try {
						MetadataReader metadataReader = getMetadataReaderFactory().getMetadataReader(resource);//<4>
						if (isCandidateComponent(metadataReader)) {//<5>
							ScannedGenericBeanDefinition sbd = new ScannedGenericBeanDefinition(metadataReader);//<6>
							sbd.setSource(resource);//<7>
							if (isCandidateComponent(sbd)) {//<8>
								candidates.add(sbd);
							}
						}
						……
					}
					catch (Throwable ex) {
						throw new BeanDefinitionStoreException(
								"Failed to read candidate component class: " + resource, ex);
					}
				}
			}
		}
		catch (IOException ex) {
			throw new BeanDefinitionStoreException("I/O failure during classpath scanning", ex);
		}
		return candidates;
	}

  

  • 在findCandidateComponents(String basePackage)方法中,一般是呼叫<1>處的程式碼進行類掃描,即else分支,if分支一般是使用spring註解@Index進行掃描效能的提升,否則不會進入。
  • 在scanCandidateComponents(String basePackage)方法的<2>處會根據類路徑生成一個spring自定義的表示式packageSearchPath,在<3>處spring可以解析這個表示式並返回一個Resource陣列,每個Resource元素都代表類路徑下的一個class檔案的路徑。
  • 之後會迴圈每個Resource元素,在<4>處獲取其後設資料,並在<5>處判斷通過父類ClassPathScanningCandidateComponentProvider的isCandidateComponent(MetadataReader metadataReader)方法判斷Resource元素所對應的class是否是一個元件,比如標記了@Component、@Service、@Controller……等。
  • 通過<5>處的判斷如果一個類是一個元件,在<6>處會根據後設資料生成一個ScannedGenericBeanDefinition物件,這裡我們又看到一個BeanDefinition的實現,然後在<7>處設定BeanDefinition的元資訊,即:sbd.setSource(resource),之前說過,一個物件的元資訊是類,一個類的元資訊是類檔案路徑,而BeanDefinition是用於描述類的,所以它的元資訊也是類檔案路徑。
  • 最後,會在<7>處呼叫父類ClassPathScanningCandidateComponentProvider的過載方法isCandidateComponent(AnnotatedBeanDefinition beanDefinition),在這個方法決定描述類的BeanDefinition是否有資格加入到<8>處candidates集合,什麼樣的類才可以加入到candidates集合呢?比如:這個類是一個頂級類或者靜態巢狀內部類,這個類不需要藉助其他類來構造例項;或者這個類並不是一個介面類,或者這個類是個抽象類,但內部方法有用@Lookup註解來標記。這裡不理解的不要心急,下面還會講到ClassPathScanningCandidateComponentProvider的isCandidateComponent(MetadataReader metadataReader)和isCandidateComponent(AnnotatedBeanDefinition beanDefinition)這兩個過載方法。

現在,我們來除錯一下上面的程式碼,看看packageSearchPath和resources的內容,首先我們來看我們類路徑下的檔案:

 D:\F\java_space\spring-source\spring-beanFactoryPostProcessor\target\classes\org\example\service 的目錄

2020/11/19  08:22    <DIR>          .
2020/11/19  08:22    <DIR>          ..
2020/11/19  08:22               490 HelloService$BarService.class
2020/11/19  08:22               609 HelloService$FooService.class
2020/11/19  08:22               318 HelloService$Hello.class
2020/11/19  08:22               524 HelloService.class
2020/11/19  08:22               559 OrderService.class
2020/11/19  08:22             1,783 Test1BeanFactoryPostProcessor.class
2020/11/19  08:22               555 UserService.class
               7 個檔案          4,838 位元組
               2 個目錄 102,708,711,424 可用位元組

 

然後除錯進入上面的程式碼,可以看到packageSearchPath的內容為:classpath*:org/example/service/**/*.class,之前說過,這裡spring會自定義表示式,通過表示式可以掃描這個路徑下的類檔案。

 

現在我們來看下ClassPathScanningCandidateComponentProvider的isCandidateComponent(MetadataReader metadataReader)和isCandidateComponent(AnnotatedBeanDefinition beanDefinition)兩個過載方法的實現:

public class ClassPathScanningCandidateComponentProvider implements EnvironmentCapable, ResourceLoaderAware {
	……
	private final List<TypeFilter> includeFilters = new LinkedList<>();

	private final List<TypeFilter> excludeFilters = new LinkedList<>();
	……
	protected void registerDefaultFilters() {
		this.includeFilters.add(new AnnotationTypeFilter(Component.class));//<1>
		ClassLoader cl = ClassPathScanningCandidateComponentProvider.class.getClassLoader();
		try {
			this.includeFilters.add(new AnnotationTypeFilter(
					((Class<? extends Annotation>) ClassUtils.forName("javax.annotation.ManagedBean", cl)), false));
			logger.trace("JSR-250 'javax.annotation.ManagedBean' found and supported for component scanning");
		}
		catch (ClassNotFoundException ex) {
			// JSR-250 1.1 API (as included in Java EE 6) not available - simply skip.
		}
		try {
			this.includeFilters.add(new AnnotationTypeFilter(
					((Class<? extends Annotation>) ClassUtils.forName("javax.inject.Named", cl)), false));
			logger.trace("JSR-330 'javax.inject.Named' annotation found and supported for component scanning");
		}
		catch (ClassNotFoundException ex) {
			// JSR-330 API not available - simply skip.
		}
	}
	……
	protected boolean isCandidateComponent(MetadataReader metadataReader) throws IOException {
		for (TypeFilter tf : this.excludeFilters) {//<2>
			if (tf.match(metadataReader, getMetadataReaderFactory())) {
				return false;
			}
		}
		for (TypeFilter tf : this.includeFilters) {//<3>
			if (tf.match(metadataReader, getMetadataReaderFactory())) {
				return isConditionMatch(metadataReader);
			}
		}
		return false;
	}
	
	protected boolean isCandidateComponent(AnnotatedBeanDefinition beanDefinition) {
		AnnotationMetadata metadata = beanDefinition.getMetadata();
		return (metadata.isIndependent() && (metadata.isConcrete() ||
				(metadata.isAbstract() && metadata.hasAnnotatedMethods(Lookup.class.getName()))));//<4>
	}
	……
}

  

  • 在建立ClassPathScanningCandidateComponentProvider物件時,一般會呼叫到registerDefaultFilters()方法,在這個方法中會往includeFilters欄位加入需要掃描的註解,如:在<1>處加入對標記了@Component類的過濾。
  • isCandidateComponent(MetadataReader metadataReader)在<2>和<3>會按照我們在@CommponScan設定的excludeFilters和includeFilters來過濾要掃描的類。
  • <4>處的isCandidateComponent(AnnotatedBeanDefinition beanDefinition)會獲取beanDefinition的後設資料,根據後設資料判斷這個beanDefinition是否是一個候選元件,比如:metadata.isIndependent()要求一個類必須是頂級類或者是靜態內部巢狀類,即這個類不需要依賴其他類來生成,而內部巢狀類必須依賴外部類來生成物件;metadata.isConcrete()判斷一個類是否是抽象類或者介面;metadata.isAbstract()判斷是否是一個抽象類,metadata.hasAnnotatedMethods(Lookup.class.getName())則判斷這個類中是否有標記了Lookup的方法。如果一個抽象類中沒有標記Lookup的方法,則不能成為候選元件。

現在,我們來分析下下面的類哪些可以成為候選元件。

package org.example.service;

import org.springframework.stereotype.Component;


public class HelloService {
    @Component
    public class FooService {
    }

    @Component
    public static class BarService {
    }

    @Component
    public interface Hello {
        void sayHello();
    }
}

  

  • FooService是巢狀內部類,需要依賴HelloService來生成物件,所以它無法成為一個候選元件。
  • BarService是靜態巢狀內部類,可以獨立生成物件,所以它可以成為一個候選元件。
  • Hello是介面,無法獨立生成物件,所以它無法成為一個候選元件。

現在,我們回到AnnotationConfigApplicationContext(Class<?>... componentClasses)的構造方法:

public class AnnotationConfigApplicationContext extends GenericApplicationContext implements AnnotationConfigRegistry {

	private final AnnotatedBeanDefinitionReader reader;

	private final ClassPathBeanDefinitionScanner scanner;
	……
	public AnnotationConfigApplicationContext(Class<?>... componentClasses) {
		this();//<1>
		register(componentClasses);//<2>
		refresh();
	}	
	……
	@Override
	public void register(Class<?>... componentClasses) {
		Assert.notEmpty(componentClasses, "At least one component class must be specified");
		this.reader.register(componentClasses);//<3>
	}
	……
}

  

在<1>處,會初始化reader和scanner,我們可以呼叫AnnotationConfigApplicationContext.scan(String... basePackages)傳入類路徑,這個方法會進而根據傳入的類路徑用scanner來掃描元件。當然,我們一般不用這種方式,而是在建立AnnotationConfigApplicationContext物件時將配置類傳入,讓spring自行讀取配置類裡的類路徑。之前筆者已經大致講解完<1>處this()方法,現在我們要來學習<2>處的配置類註冊方法,如我們所見,<2>處會進而將配置類傳給<3>處的reader物件。reader物件會根據配置類生成對應的BeanDefinition註冊進spring容器。

AnnotatedBeanDefinitionReader.register(Class<?>... componentClasses)經過一系列的呼叫,會來到下面的AnnotatedBeanDefinitionReader.doRegisterBean(...)方法,這裡我們又看到一個BeanDefinition的實現——AnnotatedGenericBeanDefinition,這段程式碼在<1>處將配置類生成一個對應的AnnotatedGenericBeanDefinition,在<2>處生成beanName,在<3>處將beanName和BeanDefinition包裝成一個BeanDefinitionHolder物件,最後在<4>處將beanName和BeanDefinition註冊進原先的AnnotationConfigApplicationContext物件。

public class AnnotatedBeanDefinitionReader {
	……
	private <T> void doRegisterBean(Class<T> beanClass, @Nullable String name,
			@Nullable Class<? extends Annotation>[] qualifiers, @Nullable Supplier<T> supplier,
			@Nullable BeanDefinitionCustomizer[] customizers) {

		AnnotatedGenericBeanDefinition abd = new AnnotatedGenericBeanDefinition(beanClass);//<1>
		……
		abd.setScope(scopeMetadata.getScopeName());
		String beanName = (name != null ? name : this.beanNameGenerator.generateBeanName(abd, this.registry));//<2>
		……
		BeanDefinitionHolder definitionHolder = new BeanDefinitionHolder(abd, beanName);//<3>
		definitionHolder = AnnotationConfigUtils.applyScopedProxyMode(scopeMetadata, definitionHolder, this.registry);
		BeanDefinitionReaderUtils.registerBeanDefinition(definitionHolder, this.registry);//<4>
	}
	……
}

  

在生成配置類對應的BeanDefinition並註冊進spring容器後,AnnotationConfigApplicationContext就會呼叫父類的refresh()方法,我們先大致看一下refresh()方法:、

public abstract class AbstractApplicationContext extends DefaultResourceLoader
		implements ConfigurableApplicationContext {
	……
	@Override
	public void refresh() throws BeansException, IllegalStateException {
		synchronized (this.startupShutdownMonitor) {
			……
			// Tell the subclass to refresh the internal bean factory.
			ConfigurableListableBeanFactory beanFactory = obtainFreshBeanFactory();//<1>
			……
			try {
				……
				// Invoke factory processors registered as beans in the context.
				invokeBeanFactoryPostProcessors(beanFactory);//<2>
				……
				// Instantiate all remaining (non-lazy-init) singletons.
				finishBeanFactoryInitialization(beanFactory);//<3>
				……
			}

			catch (BeansException ex) {
				……
				// Destroy already created singletons to avoid dangling resources.
				destroyBeans();
				……
			}
			……
		}
	}
}

  

程式碼<1>處會返回AnnotationConfigApplicationContext父類GenericApplicationContext的beanFactory屬性,其型別為DefaultListableBeanFactory。之後將beanFactory傳給<2>處和<3>處的方法,從方法註釋可以看到,<2>處會呼叫bean工廠後置處理器,<3>處會用beanFactory來初始化剩餘的非懶載入單例物件,即我們編寫的dao、service、controller……。

相關文章