springboot源码（一）启动流程+自动配置原理分析

最新推荐文章于 2024-08-18 15:29:42 发布
最新推荐文章于 2024-08-18 15:29:42 发布
阅读量1.5k 收藏 6
点赞数 3
分类专栏： spring boot
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/csdn_20150804/article/details/89418814
版权

文章目录

前言

springboot一直在使用，省去了手动添加很多配置，非常方便；今天总结下对springboot自动配置的一些理解（基于springboot2.1.4，注意2.X和1.X区别较大）。
springboot项目，实际上是一段代码，带有main方法入口的代码，甚至内嵌了tomcat容器的全部代码；
新创建的springboot项目，都会默认生成一个Application.java类（没有生成的，自己去手动创建），如下图：
在这里插入图片描述
打开这个类：

@SpringBootApplication
public class DemoApplication {
    public static void main(String[] args) {
        SpringApplication.run(DemoApplication.class, args);
    }
}

发现只有一个main方法和一个@SpringBootApplication注解，所有的奥秘，都只能在这两个点上了。

但是，在分析这个启动类之前，我们还需要先了解下springboot打包后产生的jar包。但是如果你比较着急想知道spingboot自动配置相关内容，那就直接去看第二节。

一. FAT jar

我们都知道，springboot打包后的jar文案，可以使用 java -jar x.jar来运行该jar文件，那么是如何执行的呢，怎么就执行了我们业务中的启动类中的main方法呢？

spring 打包后产生的jar包，与平时我们maven依赖的jar包有所不同，专业的术语叫做FAT jar，也就是胖jar，顾名思义，它要比普通jar胖一点，也就是内容多一点，我们解压两种jar看看内容：

随便打开一个jar包，比如gson-2.8.6.jar ，如下：
在这里插入图片描述
然后springboot的fat jar （名字是demo.jar）如下：
在这里插入图片描述
区别
很明显，也很简单，Fat jar 多了一个BOOT-INF目录，其他一样（com和org一样，都是包路径以及内部包含一些类文件）。

1.1 BOOT-INF

BOOT-INF里面的内容很明显，是我们的业务类文件以及我们业务依赖的一些jar包，jar在lib中。

1.2 META-INF

META-INF是jar文件规范里面要求的内容，包含MANIFEST.MF文件，我们打开springboot的jar中的MANIFEST.MF文件，如下：

Manifest-Version: 1.0
Implementation-Title: demo
Implementation-Version: 0.0.1-SNAPSHOT
Start-Class: com.example.demo.DemoApplication
Spring-Boot-Classes: BOOT-INF/classes/
Spring-Boot-Lib: BOOT-INF/lib/
Build-Jdk-Spec: 1.8
Spring-Boot-Version: 2.2.0.RELEASE
Created-By: Maven Archiver 3.4.0
Main-Class: org.springframework.boot.loader.JarLauncher

关于此文件的作用以及使用规范，本文不在展开，可以参考相关文章：https://www.cnblogs.com/EasonJim/p/6485677.html

其中，如下两个属性需要注意：
Main-Class: org.springframework.boot.loader.JarLauncher
Start-Class: com.example.demo.DemoApplication

Main-Class才是springboot真正的程序入口，一旦定义了此属性，就可以使用 java -jar x.jar来运行该jar文件。同时也表明，java -jar x.jar的执行方式，并不是springboot专有的，你也可以定义打包插件，让打出的包中包含你自己定义的JarLauncher.class，然后按照你自定义的方式运行程序。

springboot在JarLauncher中，调用了Start-Class，也就是我们工程代码中的启动类。
再往后，才执行工程中的main方法。

注意下，这个JarLauncher.class是打包在jar文件中的，如果想在工程中查看源码，需要增加如下依赖：

<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-loader</artifactId>
    <scope>provided</scope>
</dependency>

二.main方法

这里先简单总结下，然后再分开详细说；
1.main方法里的SpringApplication.run肯定是springboot的程序入口，主要做了处理应用上下文ConfigurableApplicationContext等操作，并且刚才说的@SpringBootApplication注解，也将在这里被触发；
2.@SpringBootApplication注解用来导入外部模块的配置类，这里的模块是指在创建springboot项目时，选择的模块，比如web模块、数据库层的jpa模块等，体现在pom.xml的依赖上：

<dependencies>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-test</artifactId>
            <scope>test</scope>
        </dependency>
    </dependencies>

还是先说@SpringBootApplication注解的机制吧，比如具体怎么导入初始化配置的；至于这个注解什么时候触发执行的，放在后边的SpringApplication.run()方法中说；

2.1.@SpringBootApplication注解原理作用

先打开这个注解：

@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 {

几个传统注解不单独说了，下面重点说下其余2个：
1.@SpringBootConfiguration，打开


@Target({ElementType.TYPE})
@Retention(RetentionPolicy.RUNTIME)
@Documented
@Configuration
public @interface SpringBootConfiguration {
}

没啥东西，等同于@Configuration；
2.@EnableAutoConfiguration，所有奥秘都在这个注解里了，打开：

@Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
@Documented
@Inherited
@AutoConfigurationPackage
@Import(AutoConfigurationImportSelector.class)//这里是重点
public @interface EnableAutoConfiguration {

先说明下，不懂@import注解的作用的话，很难继续往下理解了，import注解就是用来导入配置文件的，怎么用，具体看另外一个帖子：《spring @Import注解的作用和几种使用方式》
继续说：AutoConfigurationImportSelector这个类，打开，

    @Override
	public void process(AnnotationMetadata annotationMetadata,
			DeferredImportSelector deferredImportSelector) {
		Assert.state(
				deferredImportSelector instanceof AutoConfigurationImportSelector,
				() -> String.format("Only %s implementations are supported, got %s",
						AutoConfigurationImportSelector.class.getSimpleName(),
						deferredImportSelector.getClass().getName()));
		AutoConfigurationEntry autoConfigurationEntry = ((AutoConfigurationImportSelector) deferredImportSelector)
				.getAutoConfigurationEntry(getAutoConfigurationMetadata(),
						annotationMetadata);
		this.autoConfigurationEntries.add(autoConfigurationEntry);
		for (String importClassName : autoConfigurationEntry.getConfigurations()) {
			this.entries.putIfAbsent(importClassName, annotationMetadata);
		}
	}

找到上面重写的process方法，继续按照这个调用链路:getAutoConfigurationEntry（）->getCandidateConfigurations（）->
SpringFactoriesLoader.loadFactoryNames()->SpringFactoriesLoader.loadSpringFactories,地方到了

private static Map<String, List<String>> loadSpringFactories(@Nullable ClassLoader classLoader) {
		MultiValueMap<String, String> result = cache.get(classLoader);
		if (result != null) {
			return result;
		}
		try {
			Enumeration<URL> urls = (classLoader != null ?
					classLoader.getResources(FACTORIES_RESOURCE_LOCATION) :
					ClassLoader.getSystemResources(FACTORIES_RESOURCE_LOCATION));//看这里!!！
			result = new LinkedMultiValueMap<>();
			while (urls.hasMoreElements()) {
				URL url = urls.nextElement();
				UrlResource resource = new UrlResource(url);
				Properties properties = PropertiesLoaderUtils.loadProperties(resource);
				for (Map.Entry<?, ?> entry : properties.entrySet()) {
					String factoryClassName = ((String) entry.getKey()).trim();
					for (String factoryName : StringUtils.commaDelimitedListToStringArray((String) entry.getValue())) {
						result.add(factoryClassName, factoryName.trim());
					}
				}
			}
			cache.put(classLoader, result);
			return result;
		}

public static final String FACTORIES_RESOURCE_LOCATION = "META-INF/spring.factories";

就是从META-INF/spring.factories这个路径下，读取配置文件； 我们在demo工程里搜一下这个文件，发现好多jar包里面都有：
在这里插入图片描述
回过头，在看下SpringFactoriesLoader.loadFactoryNames的入参，第一个参数值是getSpringFactoriesLoaderFactoryClass()，
打开看下，

protected Class<?> getSpringFactoriesLoaderFactoryClass() {
		return EnableAutoConfiguration.class;
	}

发现是EnableAutoConfiguration这个类；也就是说，加载的就是spring.factories中key为EnableAutoConfiguration这个类的配置项；
springboot这种约定机制，给我们扩展功能带来方便；比如我们项目中自己开发公共的代码部分，可以打包成一个jar包，里面也可以加上这个文件，里面写一些我们想初始化的类；这样其他项目引用了自定义的jar包，一些需要的配置就会被sprinboot读取到；
打开springboot的默认配置文件：
在这里插入图片描述
在这里插入图片描述
里面的存储结构是key=value的形式，value可以写多个，用逗号隔开；
可以看到，springboot默认加载了es、jpa、redis等非常多的功能模块；
打开其中的org.springframework.boot.autoconfigure.data.redis.RedisAutoConfiguration，我们看下springboot是怎么配置redis参数的；
在这里插入图片描述
这个类上有个@EnableConfigurationProperties(RedisProperties.class)，打开RedisProperties，
在这里插入图片描述
可以发现，springboot读取了配置文件中前缀是spring.redis的配置参数；
@SpringBootApplication就先粗浅的写这些吧；

2.2.Run方法执行流程

public static ConfigurableApplicationContext run(Class<?>[] primarySources, String[] args) {
        return (new SpringApplication(primarySources)).run(args);
    }

new了一个SpringApplication对象，然后执行run方法；
先看下构造函数：

public SpringApplication(ResourceLoader resourceLoader, Class<?>... primarySources) {
		this.resourceLoader = resourceLoader;
		Assert.notNull(primarySources, "PrimarySources must not be null");
		this.primarySources = new LinkedHashSet<>(Arrays.asList(primarySources));
		this.webApplicationType = WebApplicationType.deduceFromClasspath();
		setInitializers((Collection) getSpringFactoriesInstances(
				ApplicationContextInitializer.class));
		setListeners((Collection) getSpringFactoriesInstances(ApplicationListener.class));
		this.mainApplicationClass = deduceMainApplicationClass();
	}

1.这里入参primarySources就是启动类本身，那么后边代码就能通过反射获取到这个类中的所有内容，主要是注解信息；
2.setInitializers，设置初始化类，用的依然是SpringFactoriesLoader，加载spring.factories文件中，key是ApplicationContextInitializer类的配置项目；
3.setListeners，同样的，加载spring.factories文件中，key是ApplicationListener的配置项目；
继续看run方法：

public ConfigurableApplicationContext run(String... args) {
        StopWatch stopWatch = new StopWatch();
        stopWatch.start();
        ConfigurableApplicationContext context = null;
        Collection<SpringBootExceptionReporter> exceptionReporters = new ArrayList();
        this.configureHeadlessProperty();
        SpringApplicationRunListeners listeners = this.getRunListeners(args);
        listeners.starting();

        Collection exceptionReporters;
        try {
            ApplicationArguments applicationArguments = new DefaultApplicationArguments(args);
            ConfigurableEnvironment environment = this.prepareEnvironment(listeners, applicationArguments);
            this.configureIgnoreBeanInfo(environment);
            Banner printedBanner = this.printBanner(environment);
            context = this.createApplicationContext();
            exceptionReporters = this.getSpringFactoriesInstances(SpringBootExceptionReporter.class, new Class[]{ConfigurableApplicationContext.class}, context);
            //Initializer类在这里被执行！！！！
            this.prepareContext(context, environment, listeners, applicationArguments, printedBanner);
            //看这里！！！
            this.refreshContext(context);
            this.afterRefresh(context, applicationArguments);
            stopWatch.stop();
            if (this.logStartupInfo) {
                (new StartupInfoLogger(this.mainApplicationClass)).logStarted(this.getApplicationLog(), stopWatch);
            }
            listeners.started(context);
            this.callRunners(context, applicationArguments);
        } catch (Throwable var10) {
            this.handleRunFailure(context, var10, exceptionReporters, listeners);
            throw new IllegalStateException(var10);
        }
        try {
            listeners.running(context);
            return context;
        } catch (Throwable var9) {
            this.handleRunFailure(context, var9, exceptionReporters, (SpringApplicationRunListeners)null);
            throw new IllegalStateException(var9);
        }
    }

挑重点说，因为主要想和上边的@SpringBootApplication注解串起来，其他的后边在慢慢说，贪多嚼不烂；
我们refreshContext（）这个方法，打开，

private void refreshContext(ConfigurableApplicationContext context) {
        this.refresh(context);
        if (this.registerShutdownHook) {
            try {
                context.registerShutdownHook();
            } catch (AccessControlException var3) {
                ;
            }
        }
    }

继续打开refresh方法，

protected void refresh(ApplicationContext applicationContext) {
        Assert.isInstanceOf(AbstractApplicationContext.class, applicationContext);
        ((AbstractApplicationContext)applicationContext).refresh();
    }

继续打开refresh，因为这个applicationContext是ServletWebServerApplicationContext类型的，因此进入ServletWebServerApplicationContext.refresh()方法：

@Override
public final void refresh() throws BeansException, IllegalStateException {
	try {
		super.refresh();
	}
	catch (RuntimeException ex) {
		stopAndReleaseWebServer();
		throw ex;
	}
}

super.refresh()，父类是AbstractApplicationContext，也就是执行AbstractApplicationContext.refresh()方法，
到这里，已经不再是springboot的代码了，已经进入了spring的代码中，

public void refresh() throws BeansException, IllegalStateException {
        Object var1 = this.startupShutdownMonitor;
        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();
            }

        }
    }

invokeBeanFactoryPostProcessors执行后，就会走到@EnableAutoConfiguration注解中@import的AutoConfigurationImportSelector类的process方法中；至此，run方法和启动类上的注解就关联起来了；
其他@EnableXX的注解发挥作用的流程，也是一样的道理，关键就是那个@import注解。

refresh()方法中的具体内容，参考spring最新版本代码分析《spring5源码阅读（二）refresh()方法》

内嵌tomcat

主线内容还差一点，继续：
this.finishRefresh();在执行的时候，由于ServletWebServerApplicationContext作为子类，重写了此方法：

@Override
protected void finishRefresh() {
	super.finishRefresh();
	WebServer webServer = startWebServer();
	if (webServer != null) {
		publishEvent(new ServletWebServerInitializedEvent(webServer, this));
	}
}

子类在执行完父类的super.finishRefresh();后，还额外执行了
WebServer webServer = startWebServer();
跟进去，你就会发现，springboot内嵌的tomcat，就是在这里触发启动的。

先记录到这里吧，springboot内容还是比较多的，先挑主线，后期再慢慢丰富内容。

雨剑yyy
关注
专栏目录
Spring Boot面试杀手锏————自动配置原理
Morty的技术乐园
11-07 19万+
引言 不论在工作中，亦或是求职面试，Spring Boot已经成为我们必知必会的技能项。除了某些老旧的政府项目或金融项目持有观望态度外，如今的各行各业都在飞速的拥抱这个已经不是很新的Spring启动框架。 当然，作为Spring Boot的精髓，自动配置原理的工作过程往往只有在“面试”的时候才能用得上，但是如果在工作中你能够深入的理解Spring Boot的自动配置原理，将无往不利。 Spr...
【SpringBoot源码】SpringBoot自动配置原理
最新发布
xajh_czbk的博客
08-22 809
EnableAutoConfiguration注解通过@Import(AutoConfigurationImportSelector.class)向容器中导入了AutoConfigurationImportSelector组件，它实现了DeferredImportSelector，并间接实现了ImportSelector接口，重写了selectImports()方法，帮助我们返回所有需要被注册为bean的类全限定类名的数组集合。//...
Spring Boot深入原理 - SpringApplication启动原理
阿雨的博客
12-29 4018
我们知道，如果不需要特殊的配置，只需要在main方法里调用SpringApplicatio.run（）方法即可启动Spring Boot应用： public static void main(String[] args) throws Exception { SpringApplication.run(Application.class, args);} 作为深入原理的第一篇，我
Spring Boot自动配置原理
m0_68041576的博客
08-18 3991
自动装配是指在应用程序启动时，SpringBoot根据classpath类路径下的依赖自动装配应用程序所需的一系列bean和配置类，从而减少开发者的配置工作，提高开发效率。需求： 自定义redis-starter，要求当导入redis坐标时，SpringBoot自动创建Jedis的Bean参考： 可以参考mybatis启动类的应用创建redis-spring-boot-autoconfigure模块。
springBoot自动配置的一些理解
盛世繁华
03-20 299
Spring是一个很厉害的框架，它帮助程序员做了很多繁琐且重复的工作，帮助程序员从繁杂的配置文件中解脱出来，那么它到底是怎么实现一系列神奇的功能呢？ 首先springBoot的入口类上需要加一个注解@SpringBootApplication 这个@springBootApplication是一个组合注解 @Target({ElementType.TYPE}) @Retention(Retenti...
深入Springboot启动流程+自动配置原理
热门推荐
易柏州的博客
05-07 1万+
深入Springboot启动流程+自动配置原理🍅写在前面🍅相关常见面试题Springboot启动入口@SpringBootConfiguration解读@ComponentScan解读@EnableAutoConfiguration解读（重点）@AutoConfigurationPackage解读@Import({AutoConfigurationImportSelector.class})解读（重点） 🍅写在前面🍅 自从SpringBoot问世以来，开发界可以说是乱了套。 我还记得我朋友几年前去参加
SpringBoot自动配置原理深入理解
qq_45050714的博客
09-08 420
较为深入的介绍SpringBoot自动配置原理
SpringBoot+Mybatis+MySQL+thymeleaf框架源码
03-11
【SpringBoot+Mybatis+MySQL+...此外，还可以了解Maven的依赖管理、SpringBoot的自动配置原理以及如何进行单元测试。对于初学者，这是一个很好的实践项目，能深入理解这些技术的工作机制，并提升实际开发能力。
SpringBoot自动配置原理.docx
11-14
总结，Spring Boot的自动配置原理基于对类路径、配置文件和条件注解的智能分析，实现了高度自动化和灵活的配置管理。理解这些核心概念有助于我们更好地利用Spring Boot，提高开发效率，并且便于维护和扩展我们的应用...
SpringBoot 源码学习——SpringBoot 自动装配源码解析 +Spring 如何处理配置类的
m0_71563599的博客
09-20 413
SpringBoot 通过 SPI 的机制，在我们程序员引入一些 starter 之后，扫描外部引用 jar 包中的文件，将文件中配置的类型信息加载到 Spring 容器，实现引入 starter 即可开启相关功能的操作，大大简化了程序员手动配置 bean，即开即用。SpringBoot 并不是 Spring 的替代品，而是利用 Spring 加上约定大于配置的思想，方便程序员开发的框架。所以其底层还是 Spring 那一套。
深入理解springboot自动配置原理
zsy979的博客
07-24 362
前言 用过springmvc的同学都知道，如果我想要在项目中使用mybatis的时候，按照maven项目来说得先引入依赖，再去xml配置bean，还需要在application.properties配置username，password等连接信息，第一次配置好后再写个demo结果一运行控制台都是error就尴尬了。这一折腾大半天过去了，而springboot可以自动配置xml和properties...
说说springboot启动机制
快乐人生的博客
05-16 161
说说springboot启动机制 ----- maven对依赖的管理，场景器，SpringBootApplication，EnableAutoConfiguration几个注解，加载了Tomcat，Mvc ... 说说springboot启动机制 https://ke.qq.com/webcourse/index.html#cid=333216&term_id=100395479&taid=2568313133929888&vid=5285890788262993749 .
Spring Boot 自动配置理解与实践
旧路
11-04 492
一 自动配置理解         Spring Boot提倡通过注解(annotation)来进行Bean的配置。最终达到零配置，开箱即用的效果。我们可以简单的认为Spring Boot里面有两种创建Bean的方式：configure(即@Configuration注解的使用)和auto-configure(即@EnableAutoConfiguration...
springboot的自动配置再理解
qq_40792591的博客
03-28 84
我们可以点击 查看到spring工厂里面有什么我们可以配置的属性， 点击spring.factories进去，就可以看到了 加入我们需要配置HTTP属性，找到httpAutoconfigure,点击进入， 然后再点击： HttpProperties.class进入到HTTP里面的属性，就可以看到我们可以配置那些东西了 绑定了spring.http里面的一些东西 找的时候我...
spring boot自动配置与启动流程分析
nobody
02-03 1528
spring boot自动配置与启动流程分析  我们先了解一下spring的注解@Controller、@Repository、@Service与@Component的关系： @Target({ElementType.TYPE}) @Retention(RetentionPolicy.RUNTIME) @Documented @Component public @interfa
SpringBoot的自动配置原理和启动原理
m0_52305392的博客
09-26 888
springBoot固然好用，可是很多人还不知道，你爽爽的CRUD时，springBoot在背后为了做了多少事情
Springboot自动配置原理理解一
weixin_40571937的博客
08-04 204
大致过程 根据@SpringBootApplication注解找到spring.factories文件 SpringBoot启动会加载大量的自动配置类（spring.factories里面） 我们看我们需要的功能有没有在SpringBoot默认写好的自动配置类当中； 我们在来看这个自动配置类中到底配置了哪些组件；（只要我们要用的组件存在在其中，我们就不需要在手动配置了） 给容器中自动配置类添加组件的时候，会从XXXproperties类中获取某些属性。我们只需要在配置文件中指定这些属性的值即可； 核心
springboot的自动配置
2401_83287540的博客
07-24 915
1.通过Condition注解----固定文件的自动配置实现过程:首先定义一个类其次:定义一个类,实现Condition接口,在重写其中的matches方法,判断相关的文件是否存在最后:通过创建配置类,通过Condition注解 @Conditional(value= 实现类类名.class)//@Conditional中的 实现类类名.class的matches方法，返回true则将该类通过@bean注解注入到spring容器中，返回false则不注入到spring容器中，
谈谈你对SpringBoot的理解
学亮编程手记
06-04 650
内嵌服务器：Spring Boot集成了常见的Servlet容器（如Tomcat、Jetty等），可以将应用程序打包成一个可执行的JAR文件，并通过内置的服务器运行，无需外部容器的部署。快速开发：Spring Boot提供了一组开箱即用的功能模块和组件，如Web开发、数据访问、安全性等，以及与主流开发工具的集成，使得开发人员能够快速搭建一个可运行的应用程序。它的设计目标是尽可能地减少开发人员的工作量，同时提供了一套强大的功能和工具，使得开发和部署Java应用程序变得更加容易和高效。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值