转载

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

写在前面的话

相关背景及资源:

曹工说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属性的各种配置方式,就够玩半天了

工程代码地址 思维导图地址

工程结构图:

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

概要

本讲相对独立,我们也不爱说废话,直接说本讲要做啥。

大家知道,@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,方法呢,就是让我们自己来实现以下目标:

  1. 定义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();
    
    }
  2. 我们的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") ,这个主要是:我们要能够支持递归处理。

    当然,现在可以先忽略,权且当它不存在。

  3. 最终的测试效果如下:

    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呢,大家看看:

@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个人,预定周六出发;在此之前呢,公司再让大家确认一下,大家可以

  1. 增,带家属,带男女朋友;
  2. 删,自己不去了
  3. 改,我周六好像还要写bug,但我另一个同事没啥事,他可以去

而要实现这些,只要你实现前面我们提到的那个接口的方法即可,大家可以再观察下这个方法:

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;

	...
}

就拿上面那几个方法举例:

  1. registerBeanDefinition,这个就是往名单上加人
  2. removeBeanDefinition,这个就是自己不去了
  3. BeanDefinition getBeanDefinition(String beanName),这个可以用自己名字查到报名信息,改个名字,没问题吧?

@Configuration注解的处理,就是依赖于一个实现了 BeanDefinitionRegistry 接口的类,在这个类里,它干了很多事:

假如现在的名单里,只有我们的启动类,对吧,上面标了一坨注解,什么各种Enable,什么Component-scan啦,都有。但我们标注这些,比如component-scan,不是摆着玩的,是要去对应的package下,帮我们扫描bean的;这就是相当于说,要往名单上加人。

大致的逻辑可以理解为:

  1. 拿到初始名单,这里就是启动类的bean definition,以及一些其他手动弄进去的bean definition

  2. 通过实现了 BeanDefinitionRegistryConfigurationClassPostProcessor ,来看看第一步的初始名单中,有没有注解@Component-scan,如果没注解,直接返回;如果注解了,进入第三步;

  3. 拿到@component-scan里配置的要扫描的package名,然后获取这个package下的全部class,然后看看这些class满不满足条件(比如,只认注解了controller、service等注解的)

  4. 第三步筛出来的,满足条件的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);
    }
}
  • 1处,使用spring默认的注解驱动上下文,设置:config的起点类为当前类,注册到spring容器
  • 2处,注册一个 MyConfigurationClassPostProcessor 到spring 容器,这个和前面讲的ConfigurationClassPostProcessor 效果类似,用于解析我们自己的@MyComponentScan
  • 3处,加载上下文
  • 4处,获取bean,检测效果。

MyConfigurationClassPostProcessor,解析@MyComponentScan

@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);
    }
  • 1处,找到目前的,标注了 MyConfiguration注解的全部bean definition
  • 2处,如果不存在,返回
  • 3处,对第一步找到的集合,进行下一步处理

具体解析的工作,落在了第三步的身上,具体说,是MyConfigurationClassParser类的身上。

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);
            }
        }

    }
  • 1处,判断该类上,是否有标注 @MyComponentScan
  • 2处,如果类上有这个 @MyComponentScan ,则需要进行处理
  • 3处,马上扫描这个base package路径下的bean,在里面,会注册beanDefinition到bean registry
  • 4处,对第三步扫描,得到bean,递归处理,查找更多bean

重点是这里的第三步,交给了一个叫componentScanParser的去处理,这个componentScanParser是在本类初始化的时候赋值的:

public MyConfigurationClassParser(Environment environment, BeanDefinitionRegistry registry) 	{
        this.environment = environment;
        this.registry = registry;
        this.componentScanParser = new MyComponentScanParser(componentScanBeanNameGenerator,
                environment,registry);
    }

MyComponentScanParser的处理过程

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;
    }
  • 1处,获取MyComponentScan注解中value信息,表示要扫描的package
  • 2处,设置识别bean的规则,这里是把注解了@MyComponent的,认为是自己人
  • 3处,定义变量,用于存放返回的结果
  • 4处,扫描包下的全部满足条件的,bean definition
  • 5处,处理第4步拿到的bean definition集合
  • 6处,加到待返回的结果集
  • 7处,注册到spring容器

以上,只有第4处需要再次说明,其他都比较简单。

获取满足条件的bean definition的过程

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;
}
  • 1处,扫描包下的全部class
  • 2处,遍历class
  • 3处,获取该class的注解信息
  • 4处,利用注解信息,判断是否是自己人(注解了@MyComponent)
  • 5处,自己人,准备带走

其中,第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,确实没参考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!");
            }
        }

    }
  • 1处,找到要扫描的package
  • 2处,扫描指定包

上面的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

如果大家觉得还有点帮助,帮忙点个赞吧。

原文  http://www.cnblogs.com/grey-wolf/p/12632419.html
正文到此结束
Loading...