Spring源碼解析之BeanFactoryPostProcessor（二）
上一章，我們介紹了在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……。
