亲宝软件园·资讯

展开

曹工说Spring Boot源码(28)-- Spring的component-scan机制,让你自己来进行简单实现,怎么办

三国梦回 人气:0
# 写在前面的话 相关背景及资源: [曹工说Spring Boot源码(1)-- Bean Definition到底是什么,附spring思维导图分享](https://www.cnblogs.com/grey-wolf/p/12044199.html) [曹工说Spring Boot源码(2)-- Bean Definition到底是什么,咱们对着接口,逐个方法讲解](https://www.cnblogs.com/grey-wolf/p/12051957.html ) [曹工说Spring Boot源码(3)-- 手动注册Bean Definition不比游戏好玩吗,我们来试一下](https://www.cnblogs.com/grey-wolf/p/12070377.html) [曹工说Spring Boot源码(4)-- 我是怎么自定义ApplicationContext,从json文件读取bean definition的?](https://www.cnblogs.com/grey-wolf/p/12078673.html) [曹工说Spring Boot源码(5)-- 怎么从properties文件读取bean](https://www.cnblogs.com/grey-wolf/p/12093929.html) [曹工说Spring Boot源码(6)-- Spring怎么从xml文件里解析bean的](https://www.cnblogs.com/grey-wolf/p/12114604.html ) [曹工说Spring Boot源码(7)-- Spring解析xml文件,到底从中得到了什么(上)](https://www.cnblogs.com/grey-wolf/p/12151809.html) [曹工说Spring Boot源码(8)-- Spring解析xml文件,到底从中得到了什么(util命名空间)](https://www.cnblogs.com/grey-wolf/p/12158935.html) [曹工说Spring Boot源码(9)-- Spring解析xml文件,到底从中得到了什么(context命名空间上)](https://www.cnblogs.com/grey-wolf/p/12189842.html) [曹工说Spring Boot源码(10)-- Spring解析xml文件,到底从中得到了什么(context:annotation-config 解析)](https://www.cnblogs.com/grey-wolf/p/12199334.html) [曹工说Spring Boot源码(11)-- context:component-scan,你真的会用吗(这次来说说它的奇技淫巧)](https://www.cnblogs.com/grey-wolf/p/12203743.html) [曹工说Spring Boot源码(12)-- Spring解析xml文件,到底从中得到了什么(context:component-scan完整解析)](https://www.cnblogs.com/grey-wolf/p/12214408.html) [曹工说Spring Boot源码(13)-- AspectJ的运行时织入(Load-Time-Weaving),基本内容是讲清楚了(附源码)](https://www.cnblogs.com/grey-wolf/p/12228958.html) [曹工说Spring Boot源码(14)-- AspectJ的Load-Time-Weaving的两种实现方式细细讲解,以及怎么和Spring Instrumentation集成](https://www.cnblogs.com/grey-wolf/p/12283544.html) [曹工说Spring Boot源码(15)-- Spring从xml文件里到底得到了什么(context:load-time-weaver 完整解析)](https://www.cnblogs.com/grey-wolf/p/12288391.html) [曹工说Spring Boot源码(16)-- Spring从xml文件里到底得到了什么(aop:config完整解析【上】)](https://www.cnblogs.com/grey-wolf/p/12314954.html) [曹工说Spring Boot源码(17)-- Spring从xml文件里到底得到了什么(aop:config完整解析【中】)](https://www.cnblogs.com/grey-wolf/p/12317612.html) [曹工说Spring Boot源码(18)-- Spring AOP源码分析三部曲,终于快讲完了 (aop:config完整解析【下】)](https://www.cnblogs.com/grey-wolf/p/12322587.html) [曹工说Spring Boot源码(19)-- Spring 带给我们的工具利器,创建代理不用愁(ProxyFactory)](https://www.cnblogs.com/grey-wolf/p/12359963.html) [曹工说Spring Boot源码(20)-- 码网恢恢,疏而不漏,如何记录Spring RedisTemplate每次操作日志](https://www.cnblogs.com/grey-wolf/p/12375656.html) [曹工说Spring Boot源码(21)-- 为了让大家理解Spring Aop利器ProxyFactory,我已经拼了](https://www.cnblogs.com/grey-wolf/p/12384356.html) [曹工说Spring Boot源码(22)-- 你说我Spring Aop依赖AspectJ,我依赖它什么了](https://www.cnblogs.com/grey-wolf/p/12418425.html) [曹工说Spring Boot源码(23)-- ASM又立功了,Spring原来是这么递归获取注解的元注解的](https://www.cnblogs.com/grey-wolf/p/12535152.html) [曹工说Spring Boot源码(24)-- Spring注解扫描的瑞士军刀,asm技术实战(上)](https://www.cnblogs.com/grey-wolf/p/12571217.html) [曹工说Spring Boot源码(25)-- Spring注解扫描的瑞士军刀,ASM + Java Instrumentation,顺便提提Jar包破解](https://www.cnblogs.com/grey-wolf/p/12584861.html) [曹工说Spring Boot源码(26)-- 学习字节码也太难了,实在不能忍受了,写了个小小的字节码执行引擎](https://www.cnblogs.com/grey-wolf/p/12600097.html) [曹工说Spring Boot源码(27)-- Spring的component-scan,光是include-filter属性的各种配置方式,就够玩半天了](https://www.cnblogs.com/grey-wolf/p/12601823.html) [工程代码地址](https://gitee.com/ckl111/spring-boot-first-version-learn ) [思维导图地址](https://www.processon.com/view/link/5deeefdee4b0e2c298aa5596) 工程结构图: ![](https://img2018.cnblogs.com/blog/519126/201912/519126-20191215144930717-1919774390.png) # 概要 本讲相对独立,我们也不爱说废话,直接说本讲要做啥。 大家知道,@Component-scan注解,在注解时代,最主要的用法就是指定一个package的名称,然后spring就会去对应的包下面,扫描注解了@Controller、@Service、@Repository等注解的类,然后注册为bean。 spring boot时代,这个注解则站到了幕后,如下: ```java @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,方法呢,就是让我们自己来实现以下目标: 1. 定义main类 ```java @MyConfiguration @MyComponentScan(value = "org.springframework.test") public class BootStrap { public static void main(String[] args) { ... } ``` 这个上面定义了2个自定义的注解,都加了个前缀"My"。下面简单看看。 ```java @Target(ElementType.TYPE) @Retention(RetentionPolicy.RUNTIME) @Documented public @interface MyConfiguration { } ``` 这个的效果,类似于@configuration,表示我们是一个配置类,配置类上一般会有一堆其他注解,来引入其他bean definition。 然后是MyComponentScan 注解: ```java @Target(ElementType.TYPE) @Retention(RetentionPolicy.RUNTIME) @Documented public @interface MyComponentScan { /* * 要扫描的包名 */ String value(); } ``` 2. 我们的target包下,有一个需要我们扫描的bean,如下: ```java 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")`,这个主要是:我们要能够支持递归处理。 当然,现在可以先忽略,权且当它不存在。 3. 最终的测试效果如下: ```java 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注解一个起点配置类 指定一个用 @MyConfiguration 注解的类,这个类一开始就会被注册为bean definition,类似于spring boot中的启动类,大家知道,spring boot中,启动类也是间接注解了 @SpringBootConfiguration,而 @SpringBootConfiguration呢,大家看看: ```java @Target(ElementType.TYPE) @Retention(RetentionPolicy.RUNTIME) @Documented @Configuration public @interface SpringBootConfiguration { } ``` 该注解,是注解了@configuration。 其实就是手动指定一个配置类,这个配置类,源码里好像是叫做startUp config,作为一个起点,通过这个起点,我们能发现在这个起点类上的,更多的元注解,比如,在我们公司的真实项目中,启动类就配置了一堆东西: ```java @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`。 这个类呢,实现了如下接口: ```java 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个人,预定周六出发;在此之前呢,公司再让大家确认一下,大家可以 1. 增,带家属,带男女朋友; 2. 删,自己不去了 3. 改,我周六好像还要写bug,但我另一个同事没啥事,他可以去 而要实现这些,只要你实现前面我们提到的那个接口的方法即可,大家可以再观察下这个方法: ```java void postProcessBeanDefinitionRegistry(BeanDefinitionRegistry registry) throws BeansException; ``` 入参是registry,也就是当前的报名表,报名表都给你了,你还有啥不能干的? ```java 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; ... } ``` 就拿上面那几个方法举例: 1. registerBeanDefinition,这个就是往名单上加人 2. removeBeanDefinition,这个就是自己不去了 3. BeanDefinition getBeanDefinition(String beanName),这个可以用自己名字查到报名信息,改个名字,没问题吧? @Configuration注解的处理,就是依赖于一个实现了`BeanDefinitionRegistry`接口的类,在这个类里,它干了很多事: 假如现在的名单里,只有我们的启动类,对吧,上面标了一坨注解,什么各种Enable,什么Component-scan啦,都有。但我们标注这些,比如component-scan,不是摆着玩的,是要去对应的package下,帮我们扫描bean的;这就是相当于说,要往名单上加人。 大致的逻辑可以理解为: 1. 拿到初始名单,这里就是启动类的bean definition,以及一些其他手动弄进去的bean definition 2. 通过实现了`BeanDefinitionRegistry`的`ConfigurationClassPostProcessor`,来看看第一步的初始名单中,有没有注解@Component-scan,如果没注解,直接返回;如果注解了,进入第三步; 3. 拿到@component-scan里配置的要扫描的package名,然后获取这个package下的全部class,然后看看这些class满不满足条件(比如,只认注解了controller、service等注解的) 4. 第三步筛出来的,满足条件的class,它们本身合格了,可以作为bean了;然后看看它们有没有作为配置类的资格,我拿下面的举例: ```java @Component @ComponentScan(value = "xxxx.xxxx") public class PersonService { private String personname1; } ``` 本身,上面这个例子中,PersonService因为component-scan的功劳,已经被收为bean了,但是,这不是结束,因为它自己上面还注解了@ComponentScan注解,而这,就需要去递归处理。 有些同学会觉得有点极端,maybe,但是,下面的例子极端吗: ```java @Component @Import({MainClassForTestAnnotationConfig.class}) public class PersonService { private String personname1; ``` 如果觉得@Import极端,那么@ImportResource去导入xml文件里的bean,这个场景,有些时候还是会遇到吧,比如,要兼容老程序的时候。 而我要说的就是,在`ConfigurationClassPostProcessor`处理@configuration注解的过程中,如果发现这个类上有以下行为,都会递归处理: 1. 内部类先解析 2. `PropertySource` 注解 3. `ComponentScan`注解 4. `Import` 注解 5. `ImportResource`注解 6. 有`Bean` 注解的方法 7. 处理superClass 总体来说,这个类还是比较难的,而且会递归处理。 我们今天的demo,为了聚焦,也为了实现简单,先只处理了@component-scan本身的递归。 接下来,就来看看具体实现。 # 具体实现 ## 测试类,主逻辑,驱动整体流程 ```java @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); } } ``` * 1处,使用spring默认的注解驱动上下文,设置:config的起点类为当前类,注册到spring容器 * 2处,注册一个 MyConfigurationClassPostProcessor 到spring 容器,这个和前面讲的ConfigurationClassPostProcessor 效果类似,用于解析我们自己的@MyComponentScan * 3处,加载上下文 * 4处,获取bean,检测效果。 ##MyConfigurationClassPostProcessor,解析@MyComponentScan ```java @Override public void postProcessBeanDefinitionRegistry(BeanDefinitionRegistry registry) throws BeansException { log.info("postProcessBeanDefinitionRegistry..."); /** * 1: 找到标注了{@link org.springframework.custom.annotation.MyConfiguration}注解的类 * 这些类就是我们的配置类 * 我们通过这些类,可以发现更多的bean definition */ Set beanDefinitionHolders = new LinkedHashSet(); 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); } ``` * 1处,找到目前的,标注了 MyConfiguration注解的全部bean definition * 2处,如果不存在,返回 * 3处,对第一步找到的集合,进行下一步处理 具体解析的工作,落在了第三步的身上,具体说,是MyConfigurationClassParser类的身上。 ##MyConfigurationClassParser具体执行者 ```java public void parse(Set 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,找到的就是启动类。 然后调用了下面的方法: ```java protected void processConfigurationClass(String className) throws IOException { MetadataReader metadataReader = MyConfigurationUtils.getMetadataReader(className); AnnotationMetadata annotationMetadata = metadataReader.getAnnotationMetadata(); /** * 1. 判断该类上,是否有标注{@link MyComponentScan} */ Map 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 scannedBeanDefinitions = this.componentScanParser.parse(componentScan, annotationMetadata.getClassName()); /** * 4. 如果扫描回来的bean definition不为空,递归处理 */ if (!CollectionUtils.isEmpty(scannedBeanDefinitions)) { this.parse(scannedBeanDefinitions); } } } ``` * 1处,判断该类上,是否有标注 @MyComponentScan * 2处,如果类上有这个 @MyComponentScan ,则需要进行处理 * 3处,马上扫描这个base package路径下的bean,在里面,会注册beanDefinition到bean registry * 4处,对第三步扫描,得到bean,递归处理,查找更多bean 重点是这里的第三步,交给了一个叫componentScanParser的去处理,这个componentScanParser是在本类初始化的时候赋值的: ```java public MyConfigurationClassParser(Environment environment, BeanDefinitionRegistry registry) { this.environment = environment; this.registry = registry; this.componentScanParser = new MyComponentScanParser(componentScanBeanNameGenerator, environment,registry); } ``` ## MyComponentScanParser的处理过程 ```java public Set parse(AnnotationAttributes componentScan, String className) { // 1 String basePackage = componentScan.getString("value"); // 2 includeFilters.add(new AnnotationTypeFilter(MyComponent.class)); // 3 Set beanDefinitions = new LinkedHashSet(); /** * 4 获取包下的全部bean definition */ Set 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; } ``` * 1处,获取MyComponentScan注解中value信息,表示要扫描的package * 2处,设置识别bean的规则,这里是把注解了@MyComponent的,认为是自己人 * 3处,定义变量,用于存放返回的结果 * 4处,扫描包下的全部满足条件的,bean definition * 5处,处理第4步拿到的bean definition集合 * 6处,加到待返回的结果集 * 7处,注册到spring容器 以上,只有第4处需要再次说明,其他都比较简单。 ## 获取满足条件的bean definition的过程 ```java public Set findCandidateComponents(String basePackage) { Set candidates = new LinkedHashSet(); 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; } ``` * 1处,扫描包下的全部class * 2处,遍历class * 3处,获取该class的注解信息 * 4处,利用注解信息,判断是否是自己人(注解了@MyComponent) * 5处,自己人,准备带走 其中,第4处,实现如下: ```java protected boolean isCandidateComponent(MetadataReader metadataReader) throws IOException { for (TypeFilter tf : this.includeFilters) { if (tf.match(metadataReader, MyConfigurationUtils.getMetadataReaderFactory())) { return true; } } return false; } ``` 就是用includeFilters去匹配,大家还记得前面,我们设置了吧: ```java includeFilters.add(new AnnotationTypeFilter(MyComponent.class)); ``` 大致的过程,就是这样了。 # dubbo中的实现,粗浅分析 我发现,好像和我上面说的,差得不太多,我也没用过dubbo,确实没参考dubbo的实现。 比如,它也定义了一个BeanDefinitionRegistryPostProcessor的实现类,叫: ```java public class ServiceAnnotationBeanPostProcessor implements BeanDefinitionRegistryPostProcessor, EnvironmentAware, ResourceLoaderAware, BeanClassLoaderAware { ``` 其实现如下: ```java @Override public void postProcessBeanDefinitionRegistry(BeanDefinitionRegistry registry) throws BeansException { registerBeans(registry, DubboBootstrapApplicationListener.class); // 1 Set 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!"); } } } ``` * 1处,找到要扫描的package * 2处,扫描指定包 上面的2处,实现如下: ```java private void registerServiceBeans(Set 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 beanDefinitionHolders = findServiceBeanDefinitionHolders(scanner, packageToScan, registry, beanNameGenerator); // 6 if (!CollectionUtils.isEmpty(beanDefinitionHolders)) { for (BeanDefinitionHolder beanDefinitionHolder : beanDefinitionHolders) { // 7 registerServiceBean(beanDefinitionHolder, registry, scanner); } } } } ``` * 1,设置includeFilters,注解类型,注解了`org.apache.dubbo.config.annotation.Service`类型就算 * 2,还是设置includeFilters,只是为了兼容以前的 * 3,遍历要扫描的package * 4,扫描指定的包 * 5,扫描包,获取到满足条件的集合 * 6,第五步返回不为空,则开始在下面的第7步去注册到spring * 7,注册到spring # 总结 经过前面的讲解,大家应该立即更清楚一些了吧,如果还是有点懵,那最好把demo拉下来试试。 如果大家觉得还有点帮助,帮忙点个赞吧。

加载全部内容

相关教程
猜你喜欢
用户评论