SpringBoot——启动与自动配置类查找
今天学习一下SpringBoot的启动及自动配置，由于没有参与过springBoot项目开发，
所以初次学习的主要目标：将SpringBoot中的自动配置与启动与之前学习的Spring与SpringMVC实现联系起来。弄清楚SpringBoot中的：
- SpringIOC容器初始化(怎样实现自动配置的)
- SpringAOP支持
- Spring事务支持
- SpringMVC组件初始化
- Tomcat启动
一、SpringBoot启动流程
@SpringBootApplication public class App { public static void main( String[] args ) { //springboot应用启动 SpringApplication.run(App.class,args); } } /*
* org.springframework.boot.SpringApplication#run()
*/ public static ConfigurableApplicationContext run(Class<?>[] primarySources, String[] args) { return new SpringApplication(primarySources).run(args); }
1、SpringApplication的初始化
初始化了6个属性：
- resourceLoader：资源加载器，初始化时一般为null
- primarySources：启动时配置文件Configuration
- webApplicationType：容器类型；
- initalizers：实例化多个与容器初始化有关的组件；
- listeners：实例化多个应用监听器；
- mainApplicationClass：main方法所在的类的Class实例。
public SpringApplication(ResourceLoader resourceLoader, Class<?>... primarySources) { //null this.resourceLoader = resourceLoader; Assert.notNull(primarySources, "PrimarySources must not be null"); //启动时配置Configuration this.primarySources = new LinkedHashSet<>(Arrays.asList(primarySources)); //容器类型,三个枚举类型，判断顺序 // ① 反应式web容器：WebApplicationType.REACTIVE：项目工程中包含DispatcherHandler.class，不包含DispatcherServlet.class、ServletContainer.class // ② 不是web应用：WebApplicationType.NONE：项目工程中不包含ConfigurableWebApplicationContext.class、Servlet.class // ③ 响应式web容器：WebApplicationType.SERVLET：不是上面两种情况，则响应式web容器启动 this.webApplicationType = WebApplicationType.deduceFromClasspath(); //实例化多个与IOC容器初始化有关的组件 // 具体实例化所有jar包下的/META-INF/spring.factories文件中，ApplicationContextInitializer.class全限定名指定的class数组中所以Class setInitializers((Collection) getSpringFactoriesInstances(ApplicationContextInitializer.class)); //实例化多个应用监听器 // 具体实例化所有jar包下的/META-INF/spring.factories文件中，ApplicationListener.class全限定名指定的class数组中所以Class setListeners((Collection) getSpringFactoriesInstances(ApplicationListener.class)); //main方法所在的类的Class实例 this.mainApplicationClass = deduceMainApplicationClass(); }
先介绍下getSpringFactorieInstances()方法：springboot中SPI（服务发现接口）机制的实现，主要是根据/META-INF/spring.factories中寻找并创建对应的服务实例。
private <T> Collection<T> getSpringFactoriesInstances(Class<T> type, Class<?>[] parameterTypes, Object... args) { //获取类加载器，(SPI打破类加载的双亲委派模型) ClassLoader classLoader = getClassLoader(); // 从所用/META-INF/spring.factories中找到type对应的class集合，后面SpringFactoriesLoader是Spring-core.java中的类。 Set<String> names = new LinkedHashSet<>(SpringFactoriesLoader.loadFactoryNames(type, classLoader)); // 实例化class类型集合（parameterTypers：class的有参构造器中参数类型；args：构造器传参） List<T> instances = createSpringFactoriesInstances(type, parameterTypes, classLoader, args, names); //优先级排序（BeanFactoryPostProcessor时提到过的顺序：先PriorityOrdered，后Ordered,其他） AnnotationAwareOrderComparator.sort(instances); return instances; }
例如上面的：getSpringFactoriesInstances(ApplicationListener.class)
//spring-boot-autoconfigure.jar/META-INF/spring.factories //Application Listeners org.springframework.context.ApplicationListener=\ org.springframework.boot.autoconfigure.BackgroundPreinitializer
2、SpringApplication.run()运行的流程
public ConfigurableApplicationContext run(String... args) { // ① 简单的秒表，记录服务启动到关闭的时间 StopWatch stopWatch = new StopWatch(); stopWatch.start(); ConfigurableApplicationContext context = null; // ② 异常记录器 spring.factories中SpringBootExceptionReporter.class对应的类型实例 // org.springframework.boot.diagnostics.FailureAnalyzers的实例 Collection<SpringBootExceptionReporter> exceptionReporters = new ArrayList<>(); // ③ 启动抽象窗口工具包支持：java.awt.headless = true // 无显示设备，鼠标，键盘时，awt+Swing可进行窗口编程（window+frame等） configureHeadlessProperty(); // ③ 应用监听器 spring.factories中SpringApplicationRunListener.class对应的类型实例 // org.springframework.boot.context.event.EventPublishingRunListener实例 SpringApplicationRunListeners listeners = getRunListeners(args); listeners.starting(); try { ApplicationArguments applicationArguments = new DefaultApplicationArguments(args); // ④ 初始化环境变量 // 根据上面容器类型创建对应的创建变量实例 // 设置defaultProperties(springApplication.set)、args(命令行参数)、profiles(spring.profiles.active)属性 // 绑定环境变量到监听器+spring.main(默认当前SpringApplication实例) ConfigurableEnvironment environment = prepareEnvironment(listeners, applicationArguments); // 设置spring.beaninfo.ignore（默认true）到环境变量中 configureIgnoreBeanInfo(environment); // 打印/不打印环境到控制台、日志 Banner printedBanner = printBanner(environment); // ⑤ 根据对应容器类型创建容器 // 响应式web容器：AnnotationConfigServletWebServerApplicationContext // ① 父类的构造方法中创建DefaultListableBeanFactory // ② reader 注册注解注入的Bean后置处理器到IOC容器中AutowiredAnnotationBeanPostProcessor
// BeanFactory后置处理器ConfigurationClassPostProcessor,后面发现这个就是自动配置实现的类 // ③ scanner 设置环境变量、resourceLoader、includeFilters（Spring的@Component+JDK的@Named） context = createApplicationContext(); exceptionReporters = getSpringFactoriesInstances(SpringBootExceptionReporter.class, new Class[] { ConfigurableApplicationContext.class }, context); //⑥ 初始化容器context的一部分属性 // ① 环境变量覆盖 // ② 将容器绑定到初始化组件(initializers)、监听器(listeners)中// ③ 注册单例 命令行参数的包装实例applicationArguments、printedBanner // ④ 设置懒加载则注册懒加载BeanFactory后置处理器 LazyInitializationBeanFactoryPostProcessor // ⑤ 不允许BeanDefinition覆盖 // ⑥ 将配置resource（包括MainClass）加载到容器中，MainClass(App.class)解析成一个AnnotatedGenericBeanDefinition // ⑦ 将listeners中ApplicationContextListener类型的监听器注册到容器中 prepareContext(context, environment, listeners, applicationArguments, printedBanner); //⑦ 容器初始化 主要是AnnotationConfigServletWebServerApplicationContext的父类 // ServletWebServerApplicationContext,这个第三节研究 refreshContext(context); //⑧ 空方法 afterRefresh(context, applicationArguments); stopWatch.stop(); if (this.logStartupInfo) { // 打印日志 new StartupInfoLogger(this.mainApplicationClass).logStarted(getApplicationLog(), stopWatch); } //监听器启动 listeners.started(context); //唤醒runners callRunners(context, applicationArguments); } catch (Throwable ex) { handleRunFailure(context, ex, exceptionReporters, listeners); throw new IllegalStateException(ex); } try { //监听器运行 listeners.running(context); } catch (Throwable ex) { //监听器关闭 handleRunFailure(context, ex, exceptionReporters, null); throw new IllegalStateException(ex); } return context; }
小结：熟悉了大致流程：发现核心的实现还是在⑦ 容器初始化中：refreshContext()。
- 容器的初始化
- tomcat的嵌入
- 两个组件initalizers、listeners的作用
3、Springboot容器初始化——refreshContext()
refreshContext() : 容器初始化+优雅停机
/* org.springframework.boot.SpringApplication#refreshContext */ private void refreshContext(ConfigurableApplicationContext context) { //容器初始化 refresh((ApplicationContext) context); if (this.registerShutdownHook) { try { // JDK的shutdownHook关闭钩子, // 作用：优雅停机。调用系统退出方法（关机注销）时，线程还在跑,但不提供服务，设定一个超时时间，到时间后停机。 // kill pid（注意：不能kill -9 pid） context.registerShutdownHook(); } catch (AccessControlException ex) { // Not allowed in some environments. } } } protected void refresh(ApplicationContext applicationContext) { Assert.isInstanceOf(ConfigurableApplicationContext.class, applicationContext); //容器初始化 refresh((ConfigurableApplicationContext) applicationContext); } protected void refresh(ConfigurableApplicationContext applicationContext) { //容器初始化 //AnnotationConfigServletWebServerApplicationContext.refresh() applicationContext.refresh(); }
AnnotationConfigServletWebServerApplicationContext.refresh()，
查看AnnotationConfigServletWebServerApplicationContext的类图，发现springboot相比于spring实现了一个ServletWebServerApplicationContext
如果观看AnnotationConfigservletWebServerApplicationContext源码，发现具体逻辑实现都在ServletWebServerApplicationContext中，所以主要学习ServletWebServerApplicationContext的源码:ServletWebServerApplicationContext.refresh();
/* org.springframework.boot.web.servlet.context.ServletWebServerApplicationContext#refresh */ public final void refresh() throws BeansException, IllegalStateException { try { //AbstractApplicationContext.refresh() super.refresh(); } catch (RuntimeException ex) { //关闭释放web服务（tomcat、jetty等） stopAndReleaseWebServer(); throw ex; } }
结合之前的SpringIOC——refresh()分析，装饰者模式(继承实现)有对哪些模块有增强。先给出AbstractApplicationContext.refresh()。仅说明增强功能。
public void refresh() throws BeansException, IllegalStateException { synchronized (this.startupShutdownMonitor) { // ② IOC初始化前的装备(配置环境参数、创建监听器、事件容器) // 增强：scanner缓存清理 prepareRefresh(); ConfigurableListableBeanFactory beanFactory = obtainFreshBeanFactory(); prepareBeanFactory(beanFactory); try { // 彻底重写 postProcessBeanFactory(beanFactory); invokeBeanFactoryPostProcessors(beanFactory); registerBeanPostProcessors(beanFactory); initMessageSource(); initApplicationEventMulticaster(); //增强：初始化了一个web服务:createWebServer（tomcat、jetty等），并启动 onRefresh(); registerListeners(); finishBeanFactoryInitialization(beanFactory); //增强：webServer未启动时，重新启动 finishRefresh(); } catch (BeansException ex) { if (logger.isWarnEnabled()) { logger.warn("Exception encountered during context initialization - " + "cancelling refresh attempt: " + ex); } destroyBeans(); cancelRefresh(ex); throw ex; } finally { resetCommonCaches(); } } }
综上：找到了tomcat启动的位置，但是没有找到自动配置的位置，可能是postProcessBeanFactory(beanFactory)
/* org/springframework/boot/web/servlet/context/ServletWebServerApplicationContext */ protected void postProcessBeanFactory(ConfigurableListableBeanFactory beanFactory) { //注册了一个Bean后置处理器WebApplicationContextServletContextAwareProcessor //这个Bean后置处理器逻辑很简单：仅有一个前置方法 // servletContextAware类型的bean，bean.set(servletContext) // servletConfigAware类型的bean,bean.set(servletConfig) beanFactory.addBeanPostProcessor(new WebApplicationContextServletContextAwareProcessor(this)); //忽略实现接口ServletContextAware的Bean //跟上面的Bean后置处理器冲突，应该是版本升级加的吧 beanFactory.ignoreDependencyInterface(ServletContextAware.class); registerWebApplicationScopes(); } private void registerWebApplicationScopes() { // 允许用户自定义scope（不能与自带的singleton，prototype冲突） // 注册web的作用域scope（session、request） // 将scope注册进IOC容器中 ExistingWebApplicationScopes existingScopes = new ExistingWebApplicationScopes(getBeanFactory()); WebApplicationContextUtils.registerWebApplicationScopes(getBeanFactory()); existingScopes.restore(); }
综上：还是没有找到自动配置实现的地方，只能IDEA debug一行一行的找了，最终发现
invokeBeanFactoryPostProcessors(beanFactory)：这一行执行完，容器中多了100多个BeanDefinition，也就是说是BeanFactory的后置处理器实现自动配置的。
最终找到了ConfigurationClassPostProcessor，这个BeanFactoryPostProcessor是在AnnotationConfigservletWebServerApplicationContext初始化时注册入到容器中的
/* org.springframework.boot.web.servlet.context.AnnotationConfigServletWebServerApplicationContext#AnnotationConfigServletWebServerApplicationContext() */ public AnnotationConfigServletWebServerApplicationContext() { this.reader = new AnnotatedBeanDefinitionReader(this); this.scanner = new ClassPathBeanDefinitionScanner(this); } /* * 下面是spring-context.jar中的源码，也就是自动加载还是依托于spring源码实现的 */ /* org.springframework.context.annotation.AnnotatedBeanDefinitionReader#AnnotatedBeanDefinitionReader(org.springframework.beans.factory.support.BeanDefinitionRegistry, org.springframework.core.env.Environment) */ public AnnotatedBeanDefinitionReader(BeanDefinitionRegistry registry, Environment environment) { Assert.notNull(registry, "BeanDefinitionRegistry must not be null"); Assert.notNull(environment, "Environment must not be null"); this.registry = registry; this.conditionEvaluator = new ConditionEvaluator(registry, environment, null); AnnotationConfigUtils.registerAnnotationConfigProcessors(this.registry); } /*org.springframework.context.annotation.AnnotationConfigUtils#registerAnnotationConfigProcessors(org.springframework.beans.factory.support.BeanDefinitionRegistry, java.lang.Object) */ public static Set<BeanDefinitionHolder> registerAnnotationConfigProcessors( BeanDefinitionRegistry registry, @Nullable Object source) { DefaultListableBeanFactory beanFactory = unwrapDefaultListableBeanFactory(registry); if (beanFactory != null) { if (!(beanFactory.getDependencyComparator() instanceof AnnotationAwareOrderComparator)) { beanFactory.setDependencyComparator(AnnotationAwareOrderComparator.INSTANCE); } if (!(beanFactory.getAutowireCandidateResolver() instanceof ContextAnnotationAutowireCandidateResolver)) { beanFactory.setAutowireCandidateResolver(new ContextAnnotationAutowireCandidateResolver()); } } Set<BeanDefinitionHolder> beanDefs = new LinkedHashSet<>(8); if (!registry.containsBeanDefinition(CONFIGURATION_ANNOTATION_PROCESSOR_BEAN_NAME)) { //BeanFactory后置处理器：会对class上的@Configuration、@ComponentScan、@Component、@Import、@ImportResource注解解析 RootBeanDefinition def = new RootBeanDefinition(ConfigurationClassPostProcessor.class); def.setSource(source); beanDefs.add(registerPostProcessor(registry, def, CONFIGURATION_ANNOTATION_PROCESSOR_BEAN_NAME)); } if (!registry.containsBeanDefinition(AUTOWIRED_ANNOTATION_PROCESSOR_BEAN_NAME)) { //Bean后置处理器：在bean实例化后实现依赖注入的（@Autowired注解） RootBeanDefinition def = new RootBeanDefinition(AutowiredAnnotationBeanPostProcessor.class); def.setSource(source); beanDefs.add(registerPostProcessor(registry, def, AUTOWIRED_ANNOTATION_PROCESSOR_BEAN_NAME)); } // Check for JSR-250 support, and if present add the CommonAnnotationBeanPostProcessor. if (jsr250Present && !registry.containsBeanDefinition(COMMON_ANNOTATION_PROCESSOR_BEAN_NAME)) { RootBeanDefinition def = new RootBeanDefinition(CommonAnnotationBeanPostProcessor.class); def.setSource(source); beanDefs.add(registerPostProcessor(registry, def, COMMON_ANNOTATION_PROCESSOR_BEAN_NAME)); } // Check for JPA support, and if present add the PersistenceAnnotationBeanPostProcessor. if (jpaPresent && !registry.containsBeanDefinition(PERSISTENCE_ANNOTATION_PROCESSOR_BEAN_NAME)) { RootBeanDefinition def = new RootBeanDefinition(); try { def.setBeanClass(ClassUtils.forName(PERSISTENCE_ANNOTATION_PROCESSOR_CLASS_NAME, AnnotationConfigUtils.class.getClassLoader())); } catch (ClassNotFoundException ex) { throw new IllegalStateException( "Cannot load optional framework class: " + PERSISTENCE_ANNOTATION_PROCESSOR_CLASS_NAME, ex); } def.setSource(source); beanDefs.add(registerPostProcessor(registry, def, PERSISTENCE_ANNOTATION_PROCESSOR_BEAN_NAME)); } if (!registry.containsBeanDefinition(EVENT_LISTENER_PROCESSOR_BEAN_NAME)) { RootBeanDefinition def = new RootBeanDefinition(EventListenerMethodProcessor.class); def.setSource(source); beanDefs.add(registerPostProcessor(registry, def, EVENT_LISTENER_PROCESSOR_BEAN_NAME)); } if (!registry.containsBeanDefinition(EVENT_LISTENER_FACTORY_BEAN_NAME)) { RootBeanDefinition def = new RootBeanDefinition(DefaultEventListenerFactory.class); def.setSource(source); beanDefs.add(registerPostProcessor(registry, def, EVENT_LISTENER_FACTORY_BEAN_NAME)); } return beanDefs; }
ConfigurationClassPostProcessor.processConfigBeanDefinitions():解析@Configuration注解类中的@Bean到容器BeanDefinition容器中（属于Spring的源码）
二、自动配置
自动配置配置代码有点复杂，主要看看@SpringBootApplication的实现
1、@SpringBootApplication注解
@SpringBootApplication是一个组合注解，主要是@SpringBootConfiguration+@EnableAutoConfiguration+@ComponentScan
@SpringBootConfiguration == @Configuration
@EnableAutoConfiguration = @AutoConfigurationPackage +@Import(AutoConfigurationImportSelector.class)
@AutoConfigurationPackage = @Import(AutoConfigurationPackages.Registrar.class)
综上：@SpringBootApplication = @Configuration + @Import(AutoConfigurationPackages.Registrar.class)+@Import(AutoConfigurationImportSelector.class)+@ComponentScan
顺序ConfigurationClassPostProcessor找到@ComponentScan、@Import的解析
ConfigurationClassPostProcessor.processConfigBeanDefinitions()-->parser.parse(candidates)
ConfigurationClassParser.parse-->ConfigurationClassParser.processConfigurationClass->ConfigurationClassParser.doProcessConfigurationClass()
protected final SourceClass doProcessConfigurationClass( ConfigurationClass configClass, SourceClass sourceClass, Predicate<String> filter) throws IOException { if (configClass.getMetadata().isAnnotated(Component.class.getName())) { // Recursively process any member (nested) classes first processMemberClasses(configClass, sourceClass, filter); } // 处理@PropertySource注解 for (AnnotationAttributes propertySource : AnnotationConfigUtils.attributesForRepeatable( sourceClass.getMetadata(), PropertySources.class, org.springframework.context.annotation.PropertySource.class)) { if (this.environment instanceof ConfigurableEnvironment) { processPropertySource(propertySource); } else { logger.info("Ignoring @PropertySource annotation on [" + sourceClass.getMetadata().getClassName() + "]. Reason: Environment must implement ConfigurableEnvironment"); } } // 处理componentScans注解 Set<AnnotationAttributes> componentScans = AnnotationConfigUtils.attributesForRepeatable( sourceClass.getMetadata(), ComponentScans.class, ComponentScan.class); if (!componentScans.isEmpty() && !this.conditionEvaluator.shouldSkip(sourceClass.getMetadata(), ConfigurationPhase.REGISTER_BEAN)) { for (AnnotationAttributes componentScan : componentScans) { // The config class is annotated with @ComponentScan -> perform the scan immediately Set<BeanDefinitionHolder> scannedBeanDefinitions = this.componentScanParser.parse(componentScan, sourceClass.getMetadata().getClassName()); // Check the set of scanned definitions for any further config classes and parse recursively if needed for (BeanDefinitionHolder holder : scannedBeanDefinitions) { BeanDefinition bdCand = holder.getBeanDefinition().getOriginatingBeanDefinition(); if (bdCand == null) { bdCand = holder.getBeanDefinition(); } if (ConfigurationClassUtils.checkConfigurationClassCandidate(bdCand, this.metadataReaderFactory)) { //如果bdCand也被@Configuration注解，解析
parse(bdCand.getBeanClassName(), holder.getBeanName()); } } } } // 处理Import注解 processImports(configClass, sourceClass, getImports(sourceClass), filter, true); // 处理@ImportResource注解 AnnotationAttributes importResource = AnnotationConfigUtils.attributesFor(sourceClass.getMetadata(), ImportResource.class); if (importResource != null) { String[] resources = importResource.getStringArray("locations"); Class<? extends BeanDefinitionReader> readerClass = importResource.getClass("reader"); for (String resource : resources) { String resolvedResource = this.environment.resolveRequiredPlaceholders(resource); configClass.addImportedResource(resolvedResource, readerClass); } } // 处理@Configuration中的@Bean注解 Set<MethodMetadata> beanMethods = retrieveBeanMethodMetadata(sourceClass); for (MethodMetadata methodMetadata : beanMethods) { configClass.addBeanMethod(new BeanMethod(methodMetadata, configClass)); } // 处理接口默认的方法 @Import(AutoConfigurationPackages.Registrar.class)
// AutoConfigurationPackages.Registrar 的接口有默认方法,
// 将MainClass的basePackage封装成一个BeanDefinition放入到IOC容器中，并不是扫描basePackage，仅仅是一个记录的作用 processInterfaces(configClass, sourceClass); // 处理超类 if (sourceClass.getMetadata().hasSuperClass()) { String superclass = sourceClass.getMetadata().getSuperClassName(); if (superclass != null && !superclass.startsWith("java") && !this.knownSuperclasses.containsKey(superclass)) { this.knownSuperclasses.put(superclass, configClass); // Superclass found, return its annotation metadata and recurse return sourceClass.getSuperClass(); } } return null; }
@ComponentScan注解解析：
basePackage/basePackageClasses未设置时，扫描@ComponentScan所注解的类所在的包下的所有class文件，
@Component注解的class文件，生成BeanDefinition放入IOC容器中
SpringBoot未配置basePackage、basePackageClasses，所以会扫描MainClass所在包下的所有class文件。
public Set<BeanDefinitionHolder> parse(AnnotationAttributes componentScan, final String declaringClass) { //@ComponentScan注解对应一个ClassPathBeanDefinitionScanner实例 //setUserDefaultFilters：是否使用默认过滤器Filters，默认使用 ClassPathBeanDefinitionScanner scanner = new ClassPathBeanDefinitionScanner(this.registry, componentScan.getBoolean("useDefaultFilters"), this.environment, this.resourceLoader); //setBeanNameGenerator：设置默认的beanName生成器，默认使用BeanNameGenerator.class Class<? extends BeanNameGenerator> generatorClass = componentScan.getClass("nameGenerator"); boolean useInheritedGenerator = (BeanNameGenerator.class == generatorClass); scanner.setBeanNameGenerator(useInheritedGenerator ? this.beanNameGenerator : BeanUtils.instantiateClass(generatorClass)); //setScopedProxyMode：设置是否为检测组件生成代理 ScopedProxyMode scopedProxyMode = componentScan.getEnum("scopedProxy"); if (scopedProxyMode != ScopedProxyMode.DEFAULT) { scanner.setScopedProxyMode(scopedProxyMode); } else { Class<? extends ScopeMetadataResolver> resolverClass = componentScan.getClass("scopeResolver"); scanner.setScopeMetadataResolver(BeanUtils.instantiateClass(resolverClass)); } //setResourcePattern：扫描包下源文件格式 默认"**/*.class" scanner.setResourcePattern(componentScan.getString("resourcePattern")); //includeFilter：扫描组件过滤器，符合includeFilter条件的类，生成BeanDefinition for (AnnotationAttributes filter : componentScan.getAnnotationArray("includeFilters")) { for (TypeFilter typeFilter : typeFiltersFor(filter)) { scanner.addIncludeFilter(typeFilter); } } //excludeFilter：扫描组件反向过滤器，符合excludeFilter条件的类，不生成BeanDefinition for (AnnotationAttributes filter : componentScan.getAnnotationArray("excludeFilters")) { for (TypeFilter typeFilter : typeFiltersFor(filter)) { scanner.addExcludeFilter(typeFilter); } } //lazyInit：懒加载 默认关闭 boolean lazyInit = componentScan.getBoolean("lazyInit"); if (lazyInit) { scanner.getBeanDefinitionDefaults().setLazyInit(true); } //扫描的包basePackages下class文件 Set<String> basePackages = new LinkedHashSet<>(); String[] basePackagesArray = componentScan.getStringArray("basePackages"); for (String pkg : basePackagesArray) { String[] tokenized = StringUtils.tokenizeToStringArray(this.environment.resolvePlaceholders(pkg), ConfigurableApplicationContext.CONFIG_LOCATION_DELIMITERS); Collections.addAll(basePackages, tokenized); } //扫描的basePackageClasses所在包下class文件 for (Class<?> clazz : componentScan.getClassArray("basePackageClasses")) { basePackages.add(ClassUtils.getPackageName(clazz)); } //如果basePackages，basePackageClasses未设置， // 扫描@ComponentScan所注解的类所在包下的class文件： // 这里就是Springboot扫描MainClass同包下的Bean的原因 if (basePackages.isEmpty()) { basePackages.add(ClassUtils.getPackageName(declaringClass)); } scanner.addExcludeFilter(new AbstractTypeHierarchyTraversingFilter(false, false) { @Override protected boolean matchClassName(String className) { return declaringClass.equals(className); } }); //scanner.do(basePackages):熟悉的spring源码，扫描basePackages下的class文件(includeFilters = @Component)生成组件 return scanner.doScan(StringUtils.toStringArray(basePackages)); }
@Import解析：
- DeferredImportSelector放入容器ConfigurationClassParser中的deferredImportSelectors中
- ImportBeanDefinitionRegistrar放入ConfigurationClass的importBeanDefinitionRegistrars容器中
- 其他类型@Import==@Configuration处理
/* org.springframework.context.annotation.ConfigurationClassParser#processImports */ private void processImports(ConfigurationClass configClass, SourceClass currentSourceClass, Collection<SourceClass> importCandidates, Predicate<String> exclusionFilter, boolean checkForCircularImports) { //校验@Import()如果括号中值为空直接返回 if (importCandidates.isEmpty()) { return; } if (checkForCircularImports && isChainedImportOnStack(configClass)) { this.problemReporter.error(new CircularImportProblem(configClass, this.importStack)); } else { this.importStack.push(configClass); try { for (SourceClass candidate : importCandidates) { if (candidate.isAssignable(ImportSelector.class)) { //@Import()指定类型是ImportSelector类型 Class<?> candidateClass = candidate.loadClass(); //初始化ImportSelector实例 ImportSelector selector = ParserStrategyUtils.instantiateClass(candidateClass, ImportSelector.class, this.environment, this.resourceLoader, this.registry); Predicate<String> selectorFilter = selector.getExclusionFilter(); if (selectorFilter != null) { exclusionFilter = exclusionFilter.or(selectorFilter); } if (selector instanceof DeferredImportSelector) { // 指定类型再细分为DeferredImportSelector类型 // springboot的注解@Import(AutoConfigurationImportSelector.class) // 将AutoConfigurationImportSelector实例放入到 // ConfigurationClassParser中的deferredImportSelectors容器中 this.deferredImportSelectorHandler.handle(configClass, (DeferredImportSelector) selector); } else { String[] importClassNames = selector.selectImports(currentSourceClass.getMetadata()); Collection<SourceClass> importSourceClasses = asSourceClasses(importClassNames, exclusionFilter); processImports(configClass, currentSourceClass, importSourceClasses, exclusionFilter, false); } } else if (candidate.isAssignable(ImportBeanDefinitionRegistrar.class)) { //@Import()指定类型是ImportBeanDefinitionRegistrar类型时 //springboot的注解@Import(AutoConfigurationPackages.Registrar.class) Class<?> candidateClass = candidate.loadClass(); //创建一个ImportBeanDefinitionRegistrar实例， // 放入到ConfigurationClass的importBeanDefinitionRegistrars容器中 // ConfigurationClass是@Configuration注解的类的元数据+beanName的封装类型 ImportBeanDefinitionRegistrar registrar = ParserStrategyUtils.instantiateClass(candidateClass, ImportBeanDefinitionRegistrar.class, this.environment, this.resourceLoader, this.registry); configClass.addImportBeanDefinitionRegistrar(registrar, currentSourceClass.getMetadata()); } else { // 指定类不是上两种类型，将@Import视为@Configuration处理 this.importStack.registerImport( currentSourceClass.getMetadata(), candidate.getMetadata().getClassName()); processConfigurationClass(candidate.asConfigClass(configClass), exclusionFilter); } } } catch (BeanDefinitionStoreException ex) { throw ex; } catch (Throwable ex) { throw new BeanDefinitionStoreException( "Failed to process import candidates for configuration class [" + configClass.getMetadata().getClassName() + "]", ex); } finally { this.importStack.pop(); } } }
@Import+@ComponentScan解析完，后退到ConfigurationClassParser.parse方法
public void parse(Set<BeanDefinitionHolder> configCandidates) { for (BeanDefinitionHolder holder : configCandidates) { BeanDefinition bd = holder.getBeanDefinition(); try { if (bd instanceof AnnotatedBeanDefinition) { //@注解解析（@PropertySource、@ComponentScan、@Import、@ImportResource） parse(((AnnotatedBeanDefinition) bd).getMetadata(), holder.getBeanName()); } else if (bd instanceof AbstractBeanDefinition && ((AbstractBeanDefinition) bd).hasBeanClass()) { parse(((AbstractBeanDefinition) bd).getBeanClass(), holder.getBeanName()); } else { parse(bd.getBeanClassName(), holder.getBeanName()); } } catch (BeanDefinitionStoreException ex) { throw ex; } catch (Throwable ex) { throw new BeanDefinitionStoreException( "Failed to parse configuration class [" + bd.getBeanClassName() + "]", ex); } } //springboot自动配置 this.deferredImportSelectorHandler.process(); }
this.deferredImportSelectorHandler.process();
调用AutoConfigurationImportSelector.selectImports()方法返回/META-INF/spring.factories中EnableAutoConfiguration对应的class数组
将每个文件视作为一个@Configuration注解的class文件进行解析，解析生成BeanDefinition
/* org.springframework.context.annotation.ConfigurationClassParser.DeferredImportSelectorHandler#process */ public void process() { List<DeferredImportSelectorHolder> deferredImports = this.deferredImportSelectors; this.deferredImportSelectors = null; try { if (deferredImports != null) { DeferredImportSelectorGroupingHandler handler = new DeferredImportSelectorGroupingHandler(); deferredImports.sort(DEFERRED_IMPORT_COMPARATOR); deferredImports.forEach(handler::register); handler.processGroupImports(); } } finally { this.deferredImportSelectors = new ArrayList<>(); } } /* org.springframework.context.annotation.ConfigurationClassParser.DeferredImportSelectorGroupingHandler#register*/ public void register(DeferredImportSelectorHolder deferredImport) { //调用ImportSelector.getImportGroup返回group类型 //springboot: AutoConfigurationImportSelector.getImportGroup==AutoConfigurationGroup.class Class<? extends Group> group = deferredImport.getImportSelector().getImportGroup(); //将group转换成一个DeferredImportSelectorGrouping类型grouping DeferredImportSelectorGrouping grouping = this.groupings.computeIfAbsent( (group != null ? group : deferredImport), key -> new DeferredImportSelectorGrouping(createGroup(group))); //将deferredImport放入到grouping.deferredImports容器中 //这里还是回忆一下springboot的deferredImport是AutoConfigurationImportSelector、ConfigurationClass的封装器 grouping.add(deferredImport); //将ConfigurationClass放入到ConfigurationClasses容器中， //springboot：MainClass放入到ConfigurationClasses容器中 this.configurationClasses.put(deferredImport.getConfigurationClass().getMetadata(), deferredImport.getConfigurationClass()); } /* org.springframework.context.annotation.ConfigurationClassParser.DeferredImportSelectorGroupingHandler#processGroupImports */ public void processGroupImports() { for (DeferredImportSelectorGrouping grouping : this.groupings.values()) { Predicate<String> exclusionFilter = grouping.getCandidateFilter(); //grouping.getImports() == <configurationClass,importSelect.selectImports(configurationClass)> //selectImports(configurationClass) ==SpringFactoriesLoader.loadFactoryNames(EnableAutoConfiguration.class, getBeanClassLoader()) //即这里遍历的是/MATE-INF/spring.factories中EnableAutoConfiguration对应的class数组 //将每个class视作为一个@Import注解解析 // ① class是ImportSelector类型，加入到ConfigurationClassParser中的deferredImportSelectors容器中 // ② ImportBeanDefinitionRegistrar，放入到ConfigurationClass的importBeanDefinitionRegistrars容器中 // ③ 不是上面两种类型，就视为一个@Configuration注解的配置文件类解析 grouping.getImports().forEach(entry -> { ConfigurationClass configurationClass = this.configurationClasses.get(entry.getMetadata()); try { processImports(configurationClass, asSourceClass(configurationClass, exclusionFilter), Collections.singleton(asSourceClass(entry.getImportClassName(), exclusionFilter)), exclusionFilter, false); } catch (BeanDefinitionStoreException ex) { throw ex; } catch (Throwable ex) { throw new BeanDefinitionStoreException( "Failed to process import candidates for configuration class [" + configurationClass.getMetadata().getClassName() + "]", ex); } }); } }
最后看下AutoConfigurationImportSelector.selectImports()实现
/* org.springframework.boot.autoconfigure.AutoConfigurationImportSelector#selectImports */ public String[] selectImports(AnnotationMetadata annotationMetadata) { if (!isEnabled(annotationMetadata)) { return NO_IMPORTS; } AutoConfigurationMetadata autoConfigurationMetadata = AutoConfigurationMetadataLoader.loadMetadata(this.beanClassLoader); AutoConfigurationEntry autoConfigurationEntry = getAutoConfigurationEntry(autoConfigurationMetadata, annotationMetadata); return StringUtils.toStringArray(autoConfigurationEntry.getConfigurations()); } protected AutoConfigurationEntry getAutoConfigurationEntry( AutoConfigurationMetadata autoConfigurationMetadata, AnnotationMetadata annotationMetadata) { if (!isEnabled(annotationMetadata)) { return EMPTY_ENTRY; } AnnotationAttributes attributes = getAttributes(annotationMetadata); List<String> configurations = getCandidateConfigurations(annotationMetadata, attributes); configurations = removeDuplicates(configurations); Set<String> exclusions = getExclusions(annotationMetadata, attributes); checkExcludedClasses(configurations, exclusions); configurations.removeAll(exclusions); //@Condition注解筛选 configurations = filter(configurations, autoConfigurationMetadata); fireAutoConfigurationImportEvents(configurations, exclusions); return new AutoConfigurationEntry(configurations, exclusions); } protected List<String> getCandidateConfigurations(AnnotationMetadata metadata, AnnotationAttributes attributes) { List<String> configurations = SpringFactoriesLoader.loadFactoryNames( getSpringFactoriesLoaderFactoryClass(), getBeanClassLoader()); Assert.notEmpty(configurations, "No auto configuration classes found in META-INF/spring.factories. If you " + "are using a custom packaging, make sure that file is correct."); return configurations; } protected Class<?> getSpringFactoriesLoaderFactoryClass() { return EnableAutoConfiguration.class; }
spring-boot-autoconfigure-2.1.3.RELEASE.jar!/META-INF/spring.factories中自动配置class数组
总共有118个class,列举spring相关的自动配置
org.springframework.boot.autoconfigure.EnableAutoConfiguration=\
org.springframework.boot.autoconfigure.admin.SpringApplicationAdminJmxAutoConfiguration,\
org.springframework.boot.autoconfigure.aop.AopAutoConfiguration,\
org.springframework.boot.autoconfigure.context.ConfigurationPropertiesAutoConfiguration,\
org.springframework.boot.autoconfigure.context.MessageSourceAutoConfiguration,\
org.springframework.boot.autoconfigure.context.PropertyPlaceholderAutoConfiguration,\
org.springframework.boot.autoconfigure.data.jdbc.JdbcRepositoriesAutoConfiguration,\
org.springframework.boot.autoconfigure.jdbc.DataSourceAutoConfiguration,\
org.springframework.boot.autoconfigure.jdbc.JdbcTemplateAutoConfiguration,\
org.springframework.boot.autoconfigure.jdbc.JndiDataSourceAutoConfiguration,\
org.springframework.boot.autoconfigure.jdbc.XADataSourceAutoConfiguration,\
org.springframework.boot.autoconfigure.jdbc.DataSourceTransactionManagerAutoConfiguration,\
org.springframework.boot.autoconfigure.web.servlet.DispatcherServletAutoConfiguration,\
org.springframework.boot.autoconfigure.web.servlet.ServletWebServerFactoryAutoConfiguration,\
org.springframework.boot.autoconfigure.web.servlet.error.ErrorMvcAutoConfiguration,\
org.springframework.boot.autoconfigure.web.servlet.HttpEncodingAutoConfiguration,\
org.springframework.boot.autoconfigure.web.servlet.MultipartAutoConfiguration,\
org.springframework.boot.autoconfigure.web.servlet.WebMvcAutoConfiguration,\
118个class并不是都有效，还需要经过@Condition中条件筛选
/* org.springframework.boot.autoconfigure.AutoConfigurationImportSelector#filter */ private List<String> filter(List<String> configurations, AutoConfigurationMetadata autoConfigurationMetadata) { long startTime = System.nanoTime(); String[] candidates = StringUtils.toStringArray(configurations); boolean[] skip = new boolean[candidates.length]; boolean skipped = false; //注意filters也是在spring.factories中指定的 //默认三个OnBeanCondition，OnClassCondition，OnWebApplicationCondition即只有三个注解有效@ConditionOnBean @ConditionOnClass @ConditionOnWebApplication for (AutoConfigurationImportFilter filter : getAutoConfigurationImportFilters()) { invokeAwareMethods(filter); //Condition条件判断 boolean[] match = filter.match(candidates, autoConfigurationMetadata); for (int i = 0; i < match.length; i++) { if (!match[i]) { skip[i] = true;//没通过的打标true candidates[i] = null; skipped = true; } } } if (!skipped) { //所有class都满足各自的Condition return configurations; } List<String> result = new ArrayList<>(candidates.length); for (int i = 0; i < candidates.length; i++) { if (!skip[i]) { //满足条件的Bean才会被视为配置文件（@Configuration）解析 result.add(candidates[i]); } } if (logger.isTraceEnabled()) { int numberFiltered = configurations.size() - result.size(); logger.trace("Filtered " + numberFiltered + " auto configuration class in " + TimeUnit.NANOSECONDS.toMillis(System.nanoTime() - startTime) + " ms"); } return new ArrayList<>(result); }
条件过滤是有顺序：（追究这个好像没什么意义，最终Condition都生效了......）
1、先select过滤：在调用AutoConfigurationImportSelector.filters时仅仅只检测@ConditionOnClass @ConditionOnBean @ConditionOnWebApplication三个条件
2、后class上的@Condition过滤：这个时候类上的@ConditionalOnProperty才会生效
以AopAutoConfiguration为例
@Configuration @ConditionalOnClass({ EnableAspectJAutoProxy.class, Aspect.class, Advice.class,AnnotatedElement.class }) @ConditionalOnProperty(prefix = "spring.aop", name = "auto", havingValue = "true", matchIfMissing = true) public class AopAutoConfiguration { ... }
将spring.aop.auto = false，依然扫描进了configurations中，后续类加载时，@ConditionOnProperty才生效
三、总结
1、springboot主动注解配置，是依赖spring源码中BeanFactory的后置处理器ConfigurationClassPostProcessor实现的，这个后置处理器是在ApplicationContext的构造方法中注入到IOC容器中的，ConfigurationClassPostProcessor会处理解析5个注解@Configuration、@Import、@ImportResource、@Component、@ComponentScan。
2、@SpringBootApplication = @Configuration+@ComponentScan+@Import（AutoConfigurationImportSelector.class） +@Import（AutoConfigurationPackages.Registrar.class）
- @Configuration：主要是一个属性proxyBeanMethods：默认开启（true），允许其他类调用@Bean注解的方法，为false的话，不允许则想要一个@Bean注解的类型只能自己初始化一个。
- @ComponentScan：springboot扫描MainClass所在包下的class文件。这个标签basePackages、basePackageClasses未指定时，扫描注解类（MainClass）所在package下的所有class文件到IOC容器中。
- @Import（AutoConfigurationImportSelector.class）：自动配置的核心。会调用selector.selectImports(medata)方法，获取/META-INF/spring.factories文件中的EnableAutoConfiguration映射的class数组，class数组就是配置类的集合。（可视为每个类被@Configuration注解）。
- @Import（AutoConfigurationPackages.Registrar.class）：注册basePackage为一个BeanDefinition到容器中。注意仅仅是记录basePackage，不会进行包扫描，包扫描由上面的@ComponentScan实现
3、springboot的SPI机制：对应文件/META-INF/spring.factories，所有的自动发现并加载的类都配置在这里面。这也是springboot热拔插的原因，直接依赖jar包，就可以使用redis，kafka等中间件，通过spring.factories+@ConditionOnClass(判断Class是否存在 == 是否引入jar包)来发现中间件的Bean，例如RedisTemplate等
4、spring的启动顺序：
① initalizers+listeners+webType
② 异常记录器exceptionReporters +headless模式
③ 初始化环境变量environment（命令行参数+spring.profiles.active+系统环境变量path）
④ printbanner日志横幅
⑤ 根据webType创建对应的容器ApplicationContext，
⑥ initalizers+listeners+environment与容器ApplicationContext的互相绑定
⑦ 容器启动（允许自定义scope，重写AbstarctApplicationContext的onRefresh，开启tomcat服务）
四、遗留问题
1、知道了怎么找到配置类，但是属性自动注入还没有弄清楚
2、知道tomcat启动的地方，但嵌入细节不知道，开启一个后台线程吗？
五、补充
1、SpringBoot自定义的注解@ConditionOnClass等
