springboot默认扫描的路径方式

更新时间：2023年07月06日 14:44:21 作者：鶸者为何战斗

这篇文章主要介绍了springboot默认扫描的路径方式，具有很好的参考价值，希望对大家有所帮助。如有错误或未考虑完全的地方，望不吝赐教

springboot默认扫描的路径

一般来说spring boot默认的扫描路径是启动类当前的包和子包

@SpringBootApplication
@EnableTransactionManagement(proxyTargetClass = true)
@MapperScan(basePackages = {"com.frame.springboot.dao", "com.frame.springboot.base"})
public class SpringbootApplication {
    public static void main(String[] args) {
        SpringApplication app = new SpringApplication(SpringbootApplication.class);
        app.addListeners(new MyApplicationStartedEventListener());
        app.run(args);
    }
    static class MyApplicationStartedEventListener implements ApplicationListener<ApplicationStartedEvent> {
        private Logger logger = LoggerFactory.getLogger(MyApplicationStartedEventListener.class);
        @Override
        public void onApplicationEvent(ApplicationStartedEvent event) {
            SpringApplication app = event.getSpringApplication();
            app.setBannerMode(Banner.Mode.OFF);// 不显示banner信息
            logger.info("==MyApplicationStartedEventListener==");
        }
    }
}

例如这个类的包和子类

接下来就从源码角度来分析这是为什么

首先这个加载过程肯定是从refreshcontext中的操作，因此进入。

  public void refresh() throws BeansException, IllegalStateException {
        synchronized(this.startupShutdownMonitor) {
            this.prepareRefresh();
            ConfigurableListableBeanFactory beanFactory = this.obtainFreshBeanFactory();
            this.prepareBeanFactory(beanFactory);
            try {
                this.postProcessBeanFactory(beanFactory);
                this.invokeBeanFactoryPostProcessors(beanFactory);
                this.registerBeanPostProcessors(beanFactory);
                this.initMessageSource();
                this.initApplicationEventMulticaster();
                this.onRefresh();
                this.registerListeners();
                this.finishBeanFactoryInitialization(beanFactory);
                this.finishRefresh();
            } catch (BeansException var9) {
                if (this.logger.isWarnEnabled()) {
                    this.logger.warn("Exception encountered during context initialization - cancelling refresh attempt: " + var9);
                }
                this.destroyBeans();
                this.cancelRefresh(var9);
                throw var9;
            } finally {
                this.resetCommonCaches();
            }
        }
    }

这个操作实在初始化factorypostprocessors中进行的。

接下来进入方法

  protected void invokeBeanFactoryPostProcessors(ConfigurableListableBeanFactory beanFactory) {
        PostProcessorRegistrationDelegate.invokeBeanFactoryPostProcessors(beanFactory, this.getBeanFactoryPostProcessors());
        if (beanFactory.getTempClassLoader() == null && beanFactory.containsBean("loadTimeWeaver")) {
            beanFactory.addBeanPostProcessor(new LoadTimeWeaverAwareProcessor(beanFactory));
            beanFactory.setTempClassLoader(new ContextTypeMatchClassLoader(beanFactory.getBeanClassLoader()));
        }
    }

在这里很明显是把任务委托给了PostProcessorRegistrationDelegate。

接下来我们继续点击进入

invokeBeanFactoryPostProcessors的方法很长我只截取我们关心的代码

public static void invokeBeanFactoryPostProcessors(ConfigurableListableBeanFactory beanFactory, List<BeanFactoryPostProcessor> beanFactoryPostProcessors) {
        Set<String> processedBeans = new HashSet();
        int var9;
        ArrayList currentRegistryProcessors;
        String[] postProcessorNames;
        if (beanFactory instanceof BeanDefinitionRegistry) {
            BeanDefinitionRegistry registry = (BeanDefinitionRegistry)beanFactory;
            List<BeanFactoryPostProcessor> regularPostProcessors = new LinkedList();
            List<BeanDefinitionRegistryPostProcessor> registryProcessors = new LinkedList();
            Iterator var6 = beanFactoryPostProcessors.iterator();
            while(var6.hasNext()) {
                BeanFactoryPostProcessor postProcessor = (BeanFactoryPostProcessor)var6.next();
                if (postProcessor instanceof BeanDefinitionRegistryPostProcessor) {
                    BeanDefinitionRegistryPostProcessor registryProcessor = (BeanDefinitionRegistryPostProcessor)postProcessor;
                    registryProcessor.postProcessBeanDefinitionRegistry(registry);
                    registryProcessors.add(registryProcessor);
                } else {
                    regularPostProcessors.add(postProcessor);
                }
            }
}

这里先来简单的说一下，首先会调用传入的beanFactoryPostProcessors的postProcessBeanDefinitionRegistry。

处理一般会调用

ConfigurationClassPostProcessor类，接下来进去看一下postProcessBeanDefinitionRegistry方法

    public void postProcessBeanDefinitionRegistry(BeanDefinitionRegistry registry) {
        int registryId = System.identityHashCode(registry);
        if (this.registriesPostProcessed.contains(registryId)) {
            throw new IllegalStateException("postProcessBeanDefinitionRegistry already called on this post-processor against " + registry);
        } else if (this.factoriesPostProcessed.contains(registryId)) {
            throw new IllegalStateException("postProcessBeanFactory already called on this post-processor against " + registry);
        } else {
            this.registriesPostProcessed.add(registryId);
            this.processConfigBeanDefinitions(registry);
        }
    }

在这里最重要的还是processConfigBeanDefinitions方法，但是这个方法实在是太长了截取重要的步骤

    public void processConfigBeanDefinitions(BeanDefinitionRegistry registry) {
          //省略
          parser.parse(candidates);
}

这个方法主要是用来解析beandefinitions。

进入看一下

   public void parse(Set<BeanDefinitionHolder> configCandidates) {
        this.deferredImportSelectors = new LinkedList();
        Iterator var2 = configCandidates.iterator();
        while(var2.hasNext()) {
            BeanDefinitionHolder holder = (BeanDefinitionHolder)var2.next();
            BeanDefinition bd = holder.getBeanDefinition();
            try {
                if (bd instanceof AnnotatedBeanDefinition) {
                    this.parse(((AnnotatedBeanDefinition)bd).getMetadata(), holder.getBeanName());
                } else if (bd instanceof AbstractBeanDefinition && ((AbstractBeanDefinition)bd).hasBeanClass()) {
                    this.parse(((AbstractBeanDefinition)bd).getBeanClass(), holder.getBeanName());
                } else {
                    this.parse(bd.getBeanClassName(), holder.getBeanName());
                }
            } catch (BeanDefinitionStoreException var6) {
                throw var6;
            } catch (Throwable var7) {
                throw new BeanDefinitionStoreException("Failed to parse configuration class [" + bd.getBeanClassName() + "]", var7);
            }
        }
        this.processDeferredImportSelectors();
    }

这由于我们使用的是注解来进行那么进入第一个parse，主要调用了processConfigurationClass 的方法

protected void processConfigurationClass(ConfigurationClass configClass) throws IOException {
        if (!this.conditionEvaluator.shouldSkip(configClass.getMetadata(), ConfigurationPhase.PARSE_CONFIGURATION)) {
            ConfigurationClass existingClass = (ConfigurationClass)this.configurationClasses.get(configClass);
            if (existingClass != null) {
                if (configClass.isImported()) {
                    if (existingClass.isImported()) {
                        existingClass.mergeImportedBy(configClass);
                    }
                    return;
                }
                this.configurationClasses.remove(configClass);
                Iterator it = this.knownSuperclasses.values().iterator();
                while(it.hasNext()) {
                    if (configClass.equals(it.next())) {
                        it.remove();
                    }
                }
            }
            ConfigurationClassParser.SourceClass sourceClass = this.asSourceClass(configClass);
            do {
                sourceClass = this.doProcessConfigurationClass(configClass, sourceClass);
            } while(sourceClass != null);
            this.configurationClasses.put(configClass, configClass);
        }
    }

这个方法获取config的class和解析，其中主要方法是doProcessConfigurationClass

    protected final ConfigurationClassParser.SourceClass doProcessConfigurationClass(ConfigurationClass configClass, ConfigurationClassParser.SourceClass sourceClass) throws IOException {
     Set<AnnotationAttributes> componentScans = AnnotationConfigUtils.attributesForRepeatable(sourceClass.getMetadata(), ComponentScans.class, ComponentScan.class);
        if (!componentScans.isEmpty() && !this.conditionEvaluator.shouldSkip(sourceClass.getMetadata(), ConfigurationPhase.REGISTER_BEAN)) {
            Iterator var13 = componentScans.iterator();
            while(var13.hasNext()) {
                AnnotationAttributes componentScan = (AnnotationAttributes)var13.next();
                Set<BeanDefinitionHolder> scannedBeanDefinitions = this.componentScanParser.parse(componentScan, sourceClass.getMetadata().getClassName());
                Iterator var7 = scannedBeanDefinitions.iterator();
                while(var7.hasNext()) {
                    BeanDefinitionHolder holder = (BeanDefinitionHolder)var7.next();
                    if (ConfigurationClassUtils.checkConfigurationClassCandidate(holder.getBeanDefinition(), this.metadataReaderFactory)) {
                        this.parse(holder.getBeanDefinition().getBeanClassName(), holder.getBeanName());
                    }
                }
            }
        }
}

只截取了其中的重要部分，看到componentScanParser.parse了，那么基本就想到是要去获取Component组件了，为什么config会和component关系呢，请看一下注解内部里面有一个@component。

接下来进去看一下

    public Set<BeanDefinitionHolder> parse(AnnotationAttributes componentScan, final String declaringClass) {
  Set<String> basePackages = new LinkedHashSet();
        String[] basePackagesArray = componentScan.getStringArray("basePackages");
        String[] var19 = basePackagesArray;
        int var21 = basePackagesArray.length;
        int var22;
        for(var22 = 0; var22 < var21; ++var22) {
            String pkg = var19[var22];
            String[] tokenized = StringUtils.tokenizeToStringArray(this.environment.resolvePlaceholders(pkg), ",; \t\n");
            basePackages.addAll(Arrays.asList(tokenized));
        }
        Class[] var20 = componentScan.getClassArray("basePackageClasses");
        var21 = var20.length;
        for(var22 = 0; var22 < var21; ++var22) {
            Class<?> clazz = var20[var22];
            basePackages.add(ClassUtils.getPackageName(clazz));
        }
        if (basePackages.isEmpty()) {
            basePackages.add(ClassUtils.getPackageName(declaringClass));
        }
}

这个代码是为了寻找可以扫描的基础包，但是在创建启动类的时候我们并没有设置也就是basePackages.isEmpty()==true。

接下来的操作是添加declaringClass路径，那么这个类是什么呢。

这个类就是你的启动类。

所以真正设置扫描路径的代码在这。

总结

以上为个人经验，希望能给大家一个参考，也希望大家多多支持脚本之家。

您可能感兴趣的文章:

Java线程同步机制_动力节点Java学院整理
在之前，已经学习到了线程的创建和状态控制，但是每个线程之间几乎都没有什么太大的联系。可是有的时候，可能存在多个线程多同一个数据进行操作，这样，可能就会引用各种奇怪的问题。现在就来学习多线程对数据访问的控制吧
2017-05-05
java设计模式--桥接模式详解
这篇文章主要为大家详细介绍了java设计模式之桥接模式，具有一定的参考价值，感兴趣的小伙伴们可以参考一下，希望能给你带来帮助
2021-07-07
浅析Java中JNI静态注册和动态注册
这篇文章主要为大家详细介绍了Java中JNI静态注册和动态注册的相关知识,文中的示例代码简洁易懂,感兴趣的小伙伴可以跟随小编一起学习一下
2024-12-12
多模块maven的deploy集成gitlab ci自动发版配置
这篇文章主要为大家介绍了多模块maven项目deploy集成gitlab ci自动发版的配置流程步骤，有需要的朋友可以借鉴参考下，希望能够有所帮助
2022-02-02
微信小程序微信登录的实现方法详解(JAVA后台)
通常我们在登录微信小程序的时候都是通过授权登录,下面这篇文章主要给大家介绍了关于微信小程序微信登录的实现方法,文中通过实例代码介绍的介绍的非常详细,需要的朋友可以参考下
2022-07-07
浅谈Java中对类的主动引用和被动引用
这篇文章主要介绍了浅谈Java中对类的主动引用和被动引用，分享了相关代码示例，小编觉得还是挺不错的，具有一定借鉴价值，需要的朋友可以参考下
2018-02-02
Java使用PDFBox渲染生成pdf文档的代码详解
使用PDFBox可以渲染生成pdf文档,并且自定义程度高,只是比较麻烦,这篇文章将为大家详细介绍一下具体的实现方法,感兴趣的小伙伴可以参考一下
2025-04-04
Java基础学习之关键字和变量数据类型的那些事
变量就是系统为程序分配的一块内存单元,用来存储各种类型的数据,下面这篇文章主要给大家介绍了关于Java基础学习之关键字和变量数据类型的那些事,文中通过实例代码介绍的非常详细,需要的朋友可以参考下
2022-07-07
SpringBoot中的Javaconfig代码示例
JavaConfig是一种使用Java类替代XML配置文件的方式来定义Spring Bean的机制,通过使用`@Configuration`和`@Bean`注解,可以将第三方JAR包中的对象纳入Spring IOC容器管理,本文介绍SpringBoot中的Javaconfig,感兴趣的朋友一起看看吧
2025-02-02
Redis Spring配置集群过程
这篇文章主要介绍了Redis Spring配置集群过程,具有很好的参考价值,希望对大家有所帮助,如有错误或未考虑完全的地方,望不吝赐教
2025-04-04