spring--AnnotationConfigApplicationContext扫描bean过程源码分析

以你之姓@ 2022-10-25 04:46 127阅读 0赞

# AnnotationConfigApplicationContext #

### 前言 ###

> AnnotationConfigApplicationContext 和 ClassPathXmlApplicationContext 与 FileSystemXmlApplicationContext 类似都是抽象类 AbstractApplicationContext 的子类，最终都调用父类的 refresh 方法开始 bean工厂的初始化等一系列操作，不同的是 AnnotationConfigApplicationContext 是通过注解进行bean扫描的，而另外两个是通过xml进行bean注册的，接下来我们看看 AnnotationConfigApplicationContext 是怎么扫描bean的，附结构图  
> ![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzI1MjE1ODIx_size_16_color_FFFFFF_t_70]

### 使用说明 ###

1.  测试bean
    
        import org.springframework.stereotype.Component;
        
        @Component
        public class TestBean { 
        
            public String test() { 
                return "test";
            }
        }
2.  启动类
    
        import org.springframework.context.annotation.AnnotationConfigApplicationContext;
        
        public class DemoApplication { 
        
            public static void main(String[] args) { 
        
                AnnotationConfigApplicationContext annotationConfigApplicationContext = new AnnotationConfigApplicationContext("com.example.demo");
                TestBean testBean = annotationConfigApplicationContext.getBean(TestBean.class);
                System.out.println(testBean.test());
            }
        }

### 源码解析 ###

> 我们通过创建 AnnotationConfigApplicationContext 类并传入项目包名即可获取到这个包及子包下的bean了，我们看一下 的构造器方法

1.  构造器
    
        public AnnotationConfigApplicationContext(String... basePackages) { 
        		this();
        		scan(basePackages);
        		refresh();
        	}
    
    > 主要分三部分，1、调用无参构造器，2、根据传入的包名进行bean扫描，3、调用父类的refresh方法，这里我们主要关注1、2两步
2.  无参构造器
    
        public AnnotationConfigApplicationContext() { 
        		// 该类用于传入指定bean的类的时候使用，会直接进行beanDefinition注册
        		this.reader = new AnnotatedBeanDefinitionReader(this);
        		// 该类用于通过类路径进行扫描并将符合的bean进行beanDefinition注册
        		this.scanner = new ClassPathBeanDefinitionScanner(this);
        	}
    
    > 通过指定包名创建 AnnotationConfigApplicationContext 类时就是通过 scanner 进行扫描的，注意这里会传入 this 参数，不管是直接指定bean的类进行注册还是扫描注册，实际上是注册到类 **DefaultListableBeanFactory 的 beanDefinitionMap（重要）** 参数上，参数类型为  
    > private final Map<String, BeanDefinition> beanDefinitionMap = new ConcurrentHashMap<>(256);  
    > 而 DefaultListableBeanFactory 是 this 的父类 GenericApplicationContext 进行初始化的，我们知道，子类初始化时会先初始化父类
    
        public GenericApplicationContext() { 
        		this.beanFactory = new DefaultListableBeanFactory();
        	}
3.  扫描bean
    
        @Override
        	public void scan(String... basePackages) { 
        		Assert.notEmpty(basePackages, "At least one base package must be specified");
        		// 委托给 scanner 进行扫描
        		this.scanner.scan(basePackages);
        	}
    
        public int scan(String... basePackages) { 
        		// 1.先获取已注册的beanDefinition数量
        		int beanCountAtScanStart = this.registry.getBeanDefinitionCount();
        		// 2.进行扫描
        		doScan(basePackages);
        
        		// 3.这里会注册一些后置处理器
        		if (this.includeAnnotationConfig) { 
        			AnnotationConfigUtils.registerAnnotationConfigProcessors(this.registry);
        		}
        		// 4.返回本次执行扫描后新增的beanDefinition数量
        		return (this.registry.getBeanDefinitionCount() - beanCountAtScanStart);
        	}
    
    > 1 和 4 是直接调用 **DefaultListableBeanFactory 的 beanDefinitionMap**.size() 获取数量  
    > 3 是直接通过 registry (即传入的this) 进行 beanDefinition 注册，由于本章重点是第二步，所以我直接列一下都注册了哪些后置处理器，然后我们继续深入第二步的解析
    
    <table> 
     <thead> 
      <tr> 
       <th>类名</th> 
       <th>beanName</th> 
       <th>功能描述</th> 
      </tr> 
     </thead> 
     <tbody> 
      <tr> 
       <td>ConfigurationClassPostProcessor</td> 
       <td>org.springframework.context.annotation.internalConfigurationAnnotationProcessor</td> 
       <td>处理@Configuration注解</td> 
      </tr> 
      <tr> 
       <td>AutowiredAnnotationBeanPostProcessor</td> 
       <td>org.springframework.context.annotation.internalAutowiredAnnotationProcessor</td> 
       <td>主要处理@Autowired和@Value注解，还支持@Inject注解以及@Lookup注解功能</td> 
      </tr> 
      <tr> 
       <td>CommonAnnotationBeanPostProcessor</td> 
       <td>org.springframework.context.annotation.internalCommonAnnotationProcessor</td> 
       <td>处理@PostConstruct、@PreDestroy和@Resource等注解</td> 
      </tr> 
      <tr> 
       <td>PersistenceAnnotationBeanPostProcessor</td> 
       <td>org.springframework.context.annotation.internalPersistenceAnnotationProcessor</td> 
       <td>处理@PersistenceUnit和@PersistenceContext注解</td> 
      </tr> 
      <tr> 
       <td>EventListenerMethodProcessor</td> 
       <td>org.springframework.context.event.internalEventListenerProcessor</td> 
       <td>处理@EventListener注解</td> 
      </tr> 
      <tr> 
       <td>DefaultEventListenerFactory</td> 
       <td>org.springframework.context.event.internalEventListenerFactory</td> 
       <td>事件监听工厂，用于创建被@EventListener注解标注的监听器</td> 
      </tr> 
     </tbody> 
    </table>
    
        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) { 
        			// 找到这个包下的所有符合条件的 beanDefinition
        			Set<BeanDefinition> candidates = findCandidateComponents(basePackage);
        			for (BeanDefinition candidate : candidates) { 
        				// 对使用了 @Scope 注解的类做额外处理，否则直接返回 new ScopeMetadata();
        				ScopeMetadata scopeMetadata = this.scopeMetadataResolver.resolveScopeMetadata(candidate);
        				// 如果没有使用 @Scope 注解，则 scopeMetadata.getScopeName() 为空，否则为 @Scope 注解的 value 属性值
        				candidate.setScope(scopeMetadata.getScopeName());
        				// 生成bean名称
        				String beanName = this.beanNameGenerator.generateBeanName(candidate, this.registry);
        				if (candidate instanceof AbstractBeanDefinition) { 
        					// 使用全局配置(beanDefinitionDefaults)设置是否懒加载(lazyInit)、自动装配模式(autowireMode)、bean依赖检查(dependencyCheck)、
        					// bean初始化方法名(initMethodName)、bean销毁方法名(destroyMethodName)、以及是否执行初始化方法(enforceInitMethod)和是否执行销毁方法(enforceDestroyMethod)
        					// 通过参数(autowireCandidatePatterns) 对beanName进行匹配以设置autowireCandidate(表示该bean是否可被依赖查找)，默认为true
        					postProcessBeanDefinition((AbstractBeanDefinition) candidate, beanName);
        				}
        				if (candidate instanceof AnnotatedBeanDefinition) { 
        					// 处理 @Lazy、@Primary、@DependsOn、@Role、@Description 注解
        					AnnotationConfigUtils.processCommonDefinitionAnnotations((AnnotatedBeanDefinition) candidate);
        				}
        				// 检查 beanDefinitionMap 中是否已经存在这个beanName，如果不存在则返回直接返回true，如果存在并且和参数 candidate 不相等则报错，否则返回false
        				if (checkCandidate(beanName, candidate)) { 
        					BeanDefinitionHolder definitionHolder = new BeanDefinitionHolder(candidate, beanName);
        					// 处理使用了 @Scope 注解并且 proxyMode 参数不为 ScopedProxyMode.NO 的情况
        					definitionHolder = AnnotationConfigUtils.applyScopedProxyMode(scopeMetadata, definitionHolder, this.registry);
        					beanDefinitions.add(definitionHolder);
        					// 向 registry 注册 beanDefinition
        					registerBeanDefinition(definitionHolder, this.registry);
        				}
        			}
        		}
        		return beanDefinitions;
        	}
    
    > 1.这里处理了 @Scope 注解设置bean的类型(单例，原型等)，默认为单例  
    > 2.autowireMode 表示了自动装配模式，默认是0(AUTOWIRE\_NO),需要通过@Autowire等注解手动装配bean，如果设置为1或者2则可以不需要@Autowire注解即可通过set方法自动注入，还有3是构造器注入  
    > 3.autowireCandidate 属性表示该bean是否可被依赖查找，当存在依赖时会进行bean查找，如果找到两个bean符合依赖，正常情况下会抛出异常，而如果只有一个bean的 autowireCandidate 为true时则可正常注入  
    > 我们继续跟进beanDefinition扫描过程 findCandidateComponents(basePackage)
    
        public Set<BeanDefinition> findCandidateComponents(String basePackage) { 
        		// componentsIndex 默认为空，可以配置spring.index.ignore 参数为true并且META-INF路径下存在spring.components文件才会启用，该扫描基于 @Indexed 注解spring实现快速启动
        		if (this.componentsIndex != null && indexSupportsIncludeFilters()) { 
        			return addCandidateComponentsFromIndex(this.componentsIndex, basePackage);
        			
        		} else { 
        			return scanCandidateComponents(basePackage);
        		}
        	}
    
    > 基于 @Indexed 注解快速启动是spring5.0开始支持的，默认情况不启用，有兴趣的朋友可自行了解，我们继续深入 scanCandidateComponents(basePackage) 方法
    
        private Set<BeanDefinition> scanCandidateComponents(String basePackage) { 
        		Set<BeanDefinition> candidates = new LinkedHashSet<>();
        		try { 
        			// 1.解析替换包内的占位符（${}），默认情况下可取系统变量和环境变量
        			basePackage = resolveBasePackage(basePackage);
        			// 2.设置匹配所有class文件规则
        			String packageSearchPath = String.format("classpath*:%s/**/*.class", basePackage);
        			// 3.使用 PathMatchingResourcePatternResolver 根据匹配规则获取所有类转化为 Resource 类型
        			Resource[] resources = getResourcePatternResolver().getResources(packageSearchPath);
        			for (Resource resource : resources) { 
        				// 4.如果资源不可读则跳过
        				if (!resource.isReadable()) { 
        					continue;
        				}
        				// 5.解析class文件为元数据
        				MetadataReader metadataReader = getMetadataReaderFactory().getMetadataReader(resource);
        				// 6.根据排除过滤器(excludeFilters)和包括过滤器(includeFilters)匹配，前者匹配到了则返回false，后者匹配到则返回true
        				if (!isCandidateComponent(metadataReader)) { 
        					continue;
        				}
        				// 7.包装beanDefinition
        				ScannedGenericBeanDefinition sbd = new ScannedGenericBeanDefinition(metadataReader);
        				// 8.设置数据源
        				sbd.setResource(resource);
        				sbd.setSource(resource);
        				// 9.判断class类型是否符合
        				if (isCandidateComponent(sbd)) { 
        					candidates.add(sbd);
        				}
        			}
        		} catch (IOException ex) { 
        			throw new BeanDefinitionStoreException("I/O failure during classpath scanning", ex);
        		}
        		return candidates;
        	}
    
    > 至此扫描 beanDefinition 已经结束了,我们再简单讲一下第六步和第九步的两个影响扫描结果的判断

### 类型过滤器 ###

1.  源码
    
        protected boolean isCandidateComponent(MetadataReader metadataReader) throws IOException { 
        		// 1.排除过滤器
        		for (TypeFilter tf : this.excludeFilters) { 
        			if (tf.match(metadataReader, getMetadataReaderFactory())) { 
        				return false;
        			}
        		}
        		// 2.包括过滤器
        		for (TypeFilter tf : this.includeFilters) { 
        			if (tf.match(metadataReader, getMetadataReaderFactory())) { 
        				// 3. 条件过滤
        				return isConditionMatch(metadataReader);
        			}
        		}
        		return false;
        	}
2.  排除过滤器
    
    > 即如果该类存在于排除过滤器中，则跳过加载，默认为空
3.  包括过滤器
    
    > 即该类必须符合包括过滤器条件才会返回true，而根据源码可以看出，如果包括过滤器也为空的话，会直接返回false，这样的话就直接跳过加载了，显然不符合我们的初衷，所以包括过滤器肯定不会为空，那么是在哪一步进行配置的呢，还记得最开始的无参构造吗,答案就在new ClassPathBeanDefinitionScanner(this);里
    
        public AnnotationConfigApplicationContext() { 
        		this.reader = new AnnotatedBeanDefinitionReader(this);
        		this.scanner = new ClassPathBeanDefinitionScanner(this);
        	}
        
        	public ClassPathBeanDefinitionScanner(BeanDefinitionRegistry registry) { 
        		this(registry, true);
        	}
        
        	public ClassPathBeanDefinitionScanner(BeanDefinitionRegistry registry, boolean useDefaultFilters) { 
        		this(registry, useDefaultFilters, getOrCreateEnvironment(registry));
        	}
        
        	public ClassPathBeanDefinitionScanner(BeanDefinitionRegistry registry, boolean useDefaultFilters, Environment environment) { 
        		this(registry, useDefaultFilters, environment, (registry instanceof ResourceLoader ? (ResourceLoader) registry : null));
        	}
        
        	public ClassPathBeanDefinitionScanner(BeanDefinitionRegistry registry, boolean useDefaultFilters, Environment environment, @Nullable ResourceLoader resourceLoader) { 
        		Assert.notNull(registry, "BeanDefinitionRegistry must not be null");
        		this.registry = registry;
        
        		if (useDefaultFilters) { 
        			registerDefaultFilters();
        		}
        		setEnvironment(environment);
        		setResourceLoader(resourceLoader);
        	}
    
    > 通过层层的构造器跳转，终于到了注册过滤器方法了 **registerDefaultFilters()**;
    
        protected void registerDefaultFilters() { 
        		// 添加 @Component 过滤器
        		this.includeFilters.add(new AnnotationTypeFilter(Component.class));
        		ClassLoader cl = ClassPathScanningCandidateComponentProvider.class.getClassLoader();
        		// 添加 @ManagedBean 过滤器，需要支持 JSR-250
        		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.
        		}
        		// 添加 @Named 过滤器，需要支持 JSR-330
        		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.
        		}
        	}
    
    > 看到了我们熟悉的注解 @Component 所以只要标注的该注解的类都可以正常注册
4.  包括过滤器后的条件过滤
    
    > 由于篇幅问题，这里只记录一下，包括过滤器匹配成功后会进入到条件过滤器，如果类使用了 @Conditional 注解则进行条件匹配并返回匹配结果，否则直接返回true，即成功匹配可以加载

### bean类型判断 ###

1.  源码
    
        protected boolean isCandidateComponent(AnnotatedBeanDefinition beanDefinition) { 
        		AnnotationMetadata metadata = beanDefinition.getMetadata();
        				// 必须是顶级类或静态内部类
        		return metadata.isIndependent() &&
        				// 不是接口并且不是抽象类
        			(	metadata.isConcrete() ||
        				// 如果是抽象的并且方法上使用了 @Lookup
        				(metadata.isAbstract() && metadata.hasAnnotatedMethods(Lookup.class.getName()))
        			);
        	}
    
    > 1.  必须是顶级类或静态内部类
    > 2.  不能是接口或抽象类 或者 是抽象类且方法上存在 @Lookup 注解
2.  @Lookup 注解
    
    > spring 会对抽象类使用了 @Lookup 注解的方法生成代理类，要求该方法为无参方法且返回值为类，我们可以注入该抽象类调用标注了 @Lookup 注解的方法得到对应的bean，该bean是原型模式，即每次调用都会重新创建

### 总结 ###

1.  注册大量后置处理器，ConfigurationClassPostProcessor、AutowiredAnnotationBeanPostProcessor、CommonAnnotationBeanPostProcessor、PersistenceAnnotationBeanPostProcessor、EventListenerMethodProcessor
2.  处理 @Scope 注解
3.  autowireMode 表示了自动装配模式
4.  autowireCandidate 属性表示该bean是否可被依赖查找
5.  配置spring.index.ignore 参数为true并且META-INF路径下存在spring.components文件，即可使用 @Indexed 注解进行快速启动
6.  扫描包路径可以使用$\{\}占位符
7.  使用excludeFilters和includeFilters进行条件过滤，includeFilters默认添加 @Component、@ManagedBean、@Named 注解过滤
8.  @Conditional 条件过滤在 includeFilters 匹配成功之后调用
9.  在抽象类上使用 @Lookup 注解也生成 beanDefinition, 方法返回的是个 bean，是原型模式

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzI1MjE1ODIx_size_16_color_FFFFFF_t_70]: /images/20221024/91011533a9d64e00a5c42f973cb79934.png