相关背景及资源:
曹工说Spring Boot源码(1)-- Bean Definition到底是什么,附spring思维导图分享
曹工说Spring Boot源码(2)-- Bean Definition到底是什么,咱们对着接口,逐个方法讲解
曹工说Spring Boot源码(3)-- 手动注册Bean Definition不比游戏好玩吗,我们来试一下
曹工说Spring Boot源码(4)-- 我是怎么自定义ApplicationContext,从json文件读取bean definition的?
曹工说Spring Boot源码(5)-- 怎么从properties文件读取bean
曹工说Spring Boot源码(6)-- Spring怎么从xml文件里解析bean的
曹工说Spring Boot源码(7)-- Spring解析xml文件,到底从中得到了什么(上)
曹工说Spring Boot源码(8)-- Spring解析xml文件,到底从中得到了什么(util命名空间)
曹工说Spring Boot源码(9)-- Spring解析xml文件,到底从中得到了什么(context命名空间上)
曹工说Spring Boot源码(10)-- Spring解析xml文件,到底从中得到了什么(context:annotation-config 解析)
曹工说Spring Boot源码(11)-- context:component-scan,你真的会用吗(这次来说说它的奇技淫巧)
曹工说Spring Boot源码(12)-- Spring解析xml文件,到底从中得到了什么(context:component-scan完整解析)
曹工说Spring Boot源码(13)-- AspectJ的运行时织入(Load-Time-Weaving),基本内容是讲清楚了(附源码)
曹工说Spring Boot源码(14)-- AspectJ的Load-Time-Weaving的两种实现方式细细讲解,以及怎么和Spring Instrumentation集成
曹工说Spring Boot源码(15)-- Spring从xml文件里到底得到了什么(context:load-time-weaver 完整解析)
曹工说Spring Boot源码(16)-- Spring从xml文件里到底得到了什么(aop:config完整解析【上】)
曹工说Spring Boot源码(17)-- Spring从xml文件里到底得到了什么(aop:config完整解析【中】)
曹工说Spring Boot源码(18)-- Spring AOP源码分析三部曲,终于快讲完了 (aop:config完整解析【下】)
曹工说Spring Boot源码(19)-- Spring 带给我们的工具利器,创建代理不用愁(ProxyFactory)
曹工说Spring Boot源码(20)-- 码网恢恢,疏而不漏,如何记录Spring RedisTemplate每次操作日志
曹工说Spring Boot源码(21)-- 为了让大家理解Spring Aop利器ProxyFactory,我已经拼了
曹工说Spring Boot源码(22)-- 你说我Spring Aop依赖AspectJ,我依赖它什么了
曹工说Spring Boot源码(23)-- ASM又立功了,Spring原来是这么递归获取注解的元注解的
曹工说Spring Boot源码(24)-- Spring注解扫描的瑞士军刀,asm技术实战(上)
曹工说Spring Boot源码(25)-- Spring注解扫描的瑞士军刀,ASM + Java Instrumentation,顺便提提Jar包破解
曹工说Spring Boot源码(26)-- 学习字节码也太难了,实在不能忍受了,写了个小小的字节码执行引擎
曹工说Spring Boot源码(27)-- Spring的component-scan,光是include-filter属性的各种配置方式,就够玩半天了
工程代码地址 思维导图地址
工程结构图:
本讲相对独立,我们也不爱说废话,直接说本讲要做啥。
大家知道,@Component-scan注解,在注解时代,最主要的用法就是指定一个package的名称,然后spring就会去对应的包下面,扫描注解了@Controller、@Service、@Repository等注解的类,然后注册为bean。
spring boot时代,这个注解则站到了幕后,如下:
@Target({ElementType.TYPE}) @Retention(RetentionPolicy.RUNTIME) @Documented @Inherited @SpringBootConfiguration @EnableAutoConfiguration @ComponentScan( excludeFilters = { @Filter(type = FilterType.CUSTOM,classes = {TypeExcludeFilter.class}), @Filter( type = FilterType.CUSTOM,classes = {AutoConfigurationExcludeFilter.class}) } ) public @interface SpringBootApplication { }
总之,这个注解大家再熟悉不过了。我们本讲,最核心的目标是,让大家更懂spring,方法呢,就是让我们自己来实现以下目标:
定义main类
@MyConfiguration @MyComponentScan(value = "org.springframework.test") public class BootStrap { public static void main(String[] args) { ... }
这个上面定义了2个自定义的注解,都加了个前缀"My"。下面简单看看。
@Target(ElementType.TYPE) @Retention(RetentionPolicy.RUNTIME) @Documented public @interface MyConfiguration { }
这个的效果,类似于@configuration,表示我们是一个配置类,配置类上一般会有一堆其他注解,来引入其他bean definition。
然后是MyComponentScan 注解:
@Target(ElementType.TYPE) @Retention(RetentionPolicy.RUNTIME) @Documented public @interface MyComponentScan { /* * 要扫描的包名 */ String value(); }
我们的target包下,有一个需要我们扫描的bean,如下:
package org.springframework.test; @MyComponent @MyComponentScan(value = "org.springframework.test1") public class PersonService { private String personname1; }
这里使用MyComponent注解,这个注解,用来注解我们要扫描为bean的那些类。比如这里,我们希望PersonService这个类,被扫描为bean。
其次,我们还定义了一个 @MyComponentScan(value = "org.springframework.test1")
,这个主要是:我们要能够支持递归处理。
当然,现在可以先忽略,权且当它不存在。
最终的测试效果如下:
import org.springframework.beans.factory.annotation.AnnotatedGenericBeanDefinition; import org.springframework.beans.factory.config.ConfigurableListableBeanFactory; import org.springframework.beans.factory.support.RootBeanDefinition; import org.springframework.context.annotation.AnnotationConfigApplicationContext; import org.springframework.custom.MyConfigurationClassPostProcessor; import org.springframework.custom.annotation.MyComponentScan; import org.springframework.custom.annotation.MyConfiguration; import org.springframework.test1.AnotherPersonService; @MyConfiguration @MyComponentScan(value = "org.springframework.test") public class BootStrap { public static void main(String[] args) { AnnotationConfigApplicationContext context = new AnnotationConfigApplicationContext(); AnnotatedGenericBeanDefinition beanDefinition = new AnnotatedGenericBeanDefinition(BootStrap.class); context.registerBeanDefinition(BootStrap.class.getName(), beanDefinition); /** * 注册一个beanFactoryPostProcessor,用来处理MyComponentScan注解 */ RootBeanDefinition def = new RootBeanDefinition(MyConfigurationClassPostProcessor.class); def.setSource(null); context.registerBeanDefinition(MyConfigurationClassPostProcessor.class.getName(), def); context.refresh(); PersonService bean = context.getBean(PersonService.class); System.out.println(bean); } }
输出如下:
12:39:27.259 [main] DEBUG o.s.b.f.s.DefaultListableBeanFactory - Returning cached instance of singleton bean 'personService' org.springframework.test.PersonService@71ba5790
可以看到,我们的目标就是以上这样。为了实现这个目标,其实我们是仿照spring的实现,自己ctrl c/v了一把,其中进行了大量的简化。
思路基本等同于spring的实现,因为本系列教程的目的就是让大家更懂Spring,所以没必要另辟蹊径。
指定一个用 @MyConfiguration 注解的类,这个类一开始就会被注册为bean definition,类似于spring boot中的启动类,大家知道,spring boot中,启动类也是间接注解了 @SpringBootConfiguration,而 @SpringBootConfiguration呢,大家看看:
@Target(ElementType.TYPE) @Retention(RetentionPolicy.RUNTIME) @Documented @Configuration public @interface SpringBootConfiguration { }
该注解,是注解了@configuration。
其实就是手动指定一个配置类,这个配置类,源码里好像是叫做startUp config,作为一个起点,通过这个起点,我们能发现在这个起点类上的,更多的元注解,比如,在我们公司的真实项目中,启动类就配置了一堆东西:
@SpringBootApplication @EnableTransactionManagement @EnableAspectJAutoProxy(exposeProxy = true) @MapperScan("com.xxx.cad.mapper") @ComponentScan("com.xxx") @EnableFeignClients //@Slf4j @Controller @EnableScheduling public class CadWebService {
这个类,就是我们这里的起点类。这个起点类,然后被注册为一个bean。
注册一个BeanDefinitionRegistryPostProcessor,用来处理配置类上的@MyComponentScan,以发现更多bean
大家知道@configuration配置类,是怎么被处理的呢?就是通过 org.springframework.context.annotation.ConfigurationClassPostProcessor
。
这个类呢,实现了如下接口:
public interface BeanDefinitionRegistryPostProcessor extends BeanFactoryPostProcessor { /** * Modify the application context's internal bean definition registry after its * standard initialization. All regular bean definitions will have been loaded, * but no beans will have been instantiated yet. This allows for adding further * bean definitions before the next post-processing phase kicks in. * @param registry the bean definition registry used by the application context * @throws org.springframework.beans.BeansException in case of errors */ void postProcessBeanDefinitionRegistry(BeanDefinitionRegistry registry) throws BeansException; }
这个接口的这个方法的调用时机,是在:截止目前,通过配置(不论是xml,还是像上面第一步这样,去手动注册bean definition)的方式,能够找到的bean definition都已经找到了;本来,下一步就是找出其中的要eager-init的单例bean,去初始化了。
但是呢,在这之前,我们还有一个步骤,也算是一个扩展点吧,可以让我们去修改目前的bean definition集合。
如果举个通俗的例子,大概是这样的,比如,一个公司,组织大家出去玩,大家自愿报名,一开始假设报了10个人,预定周六出发;在此之前呢,公司再让大家确认一下,大家可以
而要实现这些,只要你实现前面我们提到的那个接口的方法即可,大家可以再观察下这个方法:
void postProcessBeanDefinitionRegistry(BeanDefinitionRegistry registry) throws BeansException;
入参是registry,也就是当前的报名表,报名表都给你了,你还有啥不能干的?
public interface BeanDefinitionRegistry extends AliasRegistry { void registerBeanDefinition(String beanName, BeanDefinition beanDefinition) throws BeanDefinitionStoreException; void removeBeanDefinition(String beanName) throws NoSuchBeanDefinitionException; BeanDefinition getBeanDefinition(String beanName) throws NoSuchBeanDefinitionException; ... }
就拿上面那几个方法举例:
@Configuration注解的处理,就是依赖于一个实现了 BeanDefinitionRegistry
接口的类,在这个类里,它干了很多事:
假如现在的名单里,只有我们的启动类,对吧,上面标了一坨注解,什么各种Enable,什么Component-scan啦,都有。但我们标注这些,比如component-scan,不是摆着玩的,是要去对应的package下,帮我们扫描bean的;这就是相当于说,要往名单上加人。
大致的逻辑可以理解为:
拿到初始名单,这里就是启动类的bean definition,以及一些其他手动弄进去的bean definition
通过实现了 BeanDefinitionRegistry
的 ConfigurationClassPostProcessor
,来看看第一步的初始名单中,有没有注解@Component-scan,如果没注解,直接返回;如果注解了,进入第三步;
拿到@component-scan里配置的要扫描的package名,然后获取这个package下的全部class,然后看看这些class满不满足条件(比如,只认注解了controller、service等注解的)
第三步筛出来的,满足条件的class,它们本身合格了,可以作为bean了;然后看看它们有没有作为配置类的资格,我拿下面的举例:
@Component @ComponentScan(value = "xxxx.xxxx") public class PersonService { private String personname1; }
本身,上面这个例子中,PersonService因为component-scan的功劳,已经被收为bean了,但是,这不是结束,因为它自己上面还注解了@ComponentScan注解,而这,就需要去递归处理。
有些同学会觉得有点极端,maybe,但是,下面的例子极端吗:
@Component @Import({MainClassForTestAnnotationConfig.class}) public class PersonService { private String personname1;
如果觉得@Import极端,那么@ImportResource去导入xml文件里的bean,这个场景,有些时候还是会遇到吧,比如,要兼容老程序的时候。
而我要说的就是,在 ConfigurationClassPostProcessor
处理@configuration注解的过程中,如果发现这个类上有以下行为,都会递归处理:
PropertySource ComponentScan Import ImportResource Bean
总体来说,这个类还是比较难的,而且会递归处理。
我们今天的demo,为了聚焦,也为了实现简单,先只处理了@component-scan本身的递归。
接下来,就来看看具体实现。
@MyConfiguration @MyComponentScan(value = "org.springframework.test") public class BootStrap { public static void main(String[] args) { // 1 AnnotationConfigApplicationContext context = new AnnotationConfigApplicationContext(); AnnotatedGenericBeanDefinition beanDefinition = new AnnotatedGenericBeanDefinition(BootStrap.class); context.registerBeanDefinition(BootStrap.class.getName(), beanDefinition); /** * 2 注册一个beanFactoryPostProcessor */ RootBeanDefinition def = new RootBeanDefinition(MyConfigurationClassPostProcessor.class); def.setSource(null); context.registerBeanDefinition(MyConfigurationClassPostProcessor.class.getName(), def); // 3 context.refresh(); // 4 PersonService bean = context.getBean(PersonService.class); System.out.println(bean); AnotherPersonService anotherPersonService = context.getBean(AnotherPersonService.class); System.out.println(anotherPersonService); } }
@Override public void postProcessBeanDefinitionRegistry(BeanDefinitionRegistry registry) throws BeansException { log.info("postProcessBeanDefinitionRegistry..."); /** * 1: 找到标注了{@link org.springframework.custom.annotation.MyConfiguration}注解的类 * 这些类就是我们的配置类 * 我们通过这些类,可以发现更多的bean definition */ Set<BeanDefinitionHolder> beanDefinitionHolders = new LinkedHashSet<BeanDefinitionHolder>(); for (String beanName : registry.getBeanDefinitionNames()) { BeanDefinition beanDef = registry.getBeanDefinition(beanName); if (MyConfigurationUtils.checkConfigurationClassCandidate(beanDef)) { beanDefinitionHolders.add(new BeanDefinitionHolder(beanDef, beanName)); } } // 2 if (CollectionUtils.isEmpty(beanDefinitionHolders)) { return; } // 3 MyConfigurationClassParser parser = new MyConfigurationClassParser(environment,registry); parser.parse(beanDefinitionHolders); }
具体解析的工作,落在了第三步的身上,具体说,是MyConfigurationClassParser类的身上。
public void parse(Set<BeanDefinitionHolder> configCandidates) { for (BeanDefinitionHolder holder : configCandidates) { BeanDefinition bd = holder.getBeanDefinition(); String className = bd.getBeanClassName(); try { processConfigurationClass(className); } catch (IOException ex) { throw new BeanDefinitionStoreException("Failed to load bean class: " + bd.getBeanClassName(), ex); } } }
这里就是对每个找到的配置类进行处理。比如,我们这里的demo,找到的就是启动类。
然后调用了下面的方法:
protected void processConfigurationClass(String className) throws IOException { MetadataReader metadataReader = MyConfigurationUtils.getMetadataReader(className); AnnotationMetadata annotationMetadata = metadataReader.getAnnotationMetadata(); /** * 1. 判断该类上,是否有标注{@link MyComponentScan} */ Map<String, Object> annotationAttributes = annotationMetadata.getAnnotationAttributes(MyComponentScan.class.getName(), true); AnnotationAttributes componentScan = AnnotationAttributes.fromMap(annotationAttributes); /** * 2. 如果类上有这个{@link MyComponentScan},则需要进行处理 */ if (componentScan != null) { /** * 3. 马上扫描这个base package路径下的bean,在里面,会注册beanDefinition到bean registry */ Set<BeanDefinitionHolder> scannedBeanDefinitions = this.componentScanParser.parse(componentScan, annotationMetadata.getClassName()); /** * 4. 如果扫描回来的bean definition不为空,递归处理 */ if (!CollectionUtils.isEmpty(scannedBeanDefinitions)) { this.parse(scannedBeanDefinitions); } } }
重点是这里的第三步,交给了一个叫componentScanParser的去处理,这个componentScanParser是在本类初始化的时候赋值的:
public MyConfigurationClassParser(Environment environment, BeanDefinitionRegistry registry) { this.environment = environment; this.registry = registry; this.componentScanParser = new MyComponentScanParser(componentScanBeanNameGenerator, environment,registry); }
public Set<BeanDefinitionHolder> parse(AnnotationAttributes componentScan, String className) { // 1 String basePackage = componentScan.getString("value"); // 2 includeFilters.add(new AnnotationTypeFilter(MyComponent.class)); // 3 Set<BeanDefinitionHolder> beanDefinitions = new LinkedHashSet<BeanDefinitionHolder>(); /** * 4 获取包下的全部bean definition */ Set<BeanDefinition> candidates = findCandidateComponents(basePackage); /** * 5 对扫描回来的bean,进行一定的处理,然后注册到bean registry */ for (BeanDefinition candidate : candidates) { String generateBeanName = componentScanBeanNameGenerator.generateBeanName(candidate, registry); if (candidate instanceof AbstractBeanDefinition) { ((AbstractBeanDefinition)candidate).applyDefaults(this.beanDefinitionDefaults); } if (candidate instanceof AnnotatedBeanDefinition) { AnnotationConfigUtils.processCommonDefinitionAnnotations((AnnotatedBeanDefinition) candidate); } boolean b = checkCandidate(generateBeanName, candidate); if (b) { // 6 beanDefinitions.add(new BeanDefinitionHolder(candidate,generateBeanName)); } } /** * 7 注册到bean definition registry */ for (BeanDefinitionHolder beanDefinitionHolder : beanDefinitions) { registry.registerBeanDefinition(beanDefinitionHolder.getBeanName(),beanDefinitionHolder.getBeanDefinition()); } return beanDefinitions; }
以上,只有第4处需要再次说明,其他都比较简单。
public Set<BeanDefinition> findCandidateComponents(String basePackage) { Set<BeanDefinition> candidates = new LinkedHashSet<BeanDefinition>(); try { // 1 String packageSearchPath = ResourcePatternResolver.CLASSPATH_ALL_URL_PREFIX + resolveBasePackage(basePackage) + "/" + this.resourcePattern; Resource[] resources = this.resourcePatternResolver.getResources(packageSearchPath); // 2 for (Resource resource : resources) { log.info("Scanning " + resource); if (!resource.isReadable()) { continue; } // 3 MetadataReader metadataReader = MyConfigurationUtils.getMetadataReader(resource); // 4 if (isCandidateComponent(metadataReader)) { ScannedGenericBeanDefinition sbd = new ScannedGenericBeanDefinition(metadataReader); sbd.setResource(resource); sbd.setSource(resource); // 5 candidates.add(sbd); } else { log.info("Ignored because not matching any filter: " + resource); } } } ... return candidates; }
其中,第4处,实现如下:
protected boolean isCandidateComponent(MetadataReader metadataReader) throws IOException { for (TypeFilter tf : this.includeFilters) { if (tf.match(metadataReader, MyConfigurationUtils.getMetadataReaderFactory())) { return true; } } return false; }
就是用includeFilters去匹配,大家还记得前面,我们设置了吧:
includeFilters.add(new AnnotationTypeFilter(MyComponent.class));
大致的过程,就是这样了。
我发现,好像和我上面说的,差得不太多,我也没用过dubbo,确实没参考dubbo的实现。
比如,它也定义了一个BeanDefinitionRegistryPostProcessor的实现类,叫:
public class ServiceAnnotationBeanPostProcessor implements BeanDefinitionRegistryPostProcessor, EnvironmentAware, ResourceLoaderAware, BeanClassLoaderAware {
其实现如下:
@Override public void postProcessBeanDefinitionRegistry(BeanDefinitionRegistry registry) throws BeansException { registerBeans(registry, DubboBootstrapApplicationListener.class); // 1 Set<String> resolvedPackagesToScan = resolvePackagesToScan(packagesToScan); if (!CollectionUtils.isEmpty(resolvedPackagesToScan)) { // 2 registerServiceBeans(resolvedPackagesToScan, registry); } else { if (logger.isWarnEnabled()) { logger.warn("packagesToScan is empty , ServiceBean registry will be ignored!"); } } }
上面的2处,实现如下:
private void registerServiceBeans(Set<String> packagesToScan, BeanDefinitionRegistry registry) { DubboClassPathBeanDefinitionScanner scanner = new DubboClassPathBeanDefinitionScanner(registry, environment, resourceLoader); BeanNameGenerator beanNameGenerator = resolveBeanNameGenerator(registry); scanner.setBeanNameGenerator(beanNameGenerator); // 1 scanner.addIncludeFilter(new AnnotationTypeFilter(Service.class)); // 2 scanner.addIncludeFilter(new AnnotationTypeFilter(com.alibaba.dubbo.config.annotation.Service.class)); // 3 for (String packageToScan : packagesToScan) { // 4 Registers @Service Bean first scanner.scan(packageToScan); // 5 Set<BeanDefinitionHolder> beanDefinitionHolders = findServiceBeanDefinitionHolders(scanner, packageToScan, registry, beanNameGenerator); // 6 if (!CollectionUtils.isEmpty(beanDefinitionHolders)) { for (BeanDefinitionHolder beanDefinitionHolder : beanDefinitionHolders) { // 7 registerServiceBean(beanDefinitionHolder, registry, scanner); } } } }
org.apache.dubbo.config.annotation.Service
经过前面的讲解,大家应该立即更清楚一些了吧,如果还是有点懵,那最好把demo拉下来试试。
https://gitee.com/ckl111/spring-boot-first-version-learn/tree/master/all-demo-in-spring-learning/spring-annotation-custom-component-scan
如果大家觉得还有点帮助,帮忙点个赞吧。