一、概念
约定优于配置：springboot基于约定优于配置，是一种软件设计规范。简单来说就是假如你所期待的配置与约定的配置一致，那么就可以不做任何配置，约定不符合期待时才需要对约定进行替换配置。
好处：大大减少了配置项
springboot基于spring4.0开发的，可以快速构建一个spring项目而不需要配置大量的配置文件，主要依靠其核心的一个功能，起步依赖。另外springboot集成大量的框架使得依赖包的版本冲突得到解决
- 主要特性：
1、 SpringBoot Starter：他将常用的依赖分组进行了整合，将其合并到一个依赖中，这样就可以一次性添加到项目的Maven或Gradle构建中；
2、 使编码变得简单，SpringBoot采用 JavaConfig的方式对Spring进行配置，并且提供了大量的注解，极大的提高了工作效率。
3、 自动配置：SpringBoot的自动配置特性利用了Spring对条件化配置的支持，合理地推测应用所需的bean并自动化配置他们；
4、 使部署变得简单，SpringBoot内置了三种Servlet容器，Tomcat，Jetty,undertow.我们只需要一个Java的运行环境就可以跑SpringBoot的项目了，SpringBoot的项目可以打成一个jar包。
二、热部署
1.引入jar
<!-- 引入热部署依赖 -->
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-devtools</artifactId>
</dependency>
2.设置idea
选择IDEA工具界面的【File】->【Settings】选项，打开Compiler面板设置页面.
在项目任意页面中使用组合快捷键“Ctrl+Shift+Alt+/”打开Maintenance选项框，选中并打开Registry页面
3.热部署原理
我们在编辑器上启动项目，然后改动相关的代码，然后编辑器自动触发编译替换掉历史的.class文件后，项目检测到有文件变更后会重启srpring-boot项目。
对于第三方jar包采用baseclassloader来加载，对于开发人员自己开发的代码则使用restartClassLoader来进行加载
三、全局配置文件
作用：修改默认值，自定义配置
支持哪些配置文件：.properties文件和.yaml文件
位置：/config（即resource下的config文件夹下）、/(即resource下)
加载顺序、优先级：①/config ②/。但是两个目录下同时存在application.properties文件，其中设置的属性是互补的，非重叠属性都会加载，重叠属性以优先级高的为准
如果同一个目录下，有application.yml也有application.properties，默认先读取 application.properties。（2.4.0之后优先级为yml）
四、属性注入
@ConfigurationProperties
@ConfigurationProperties(prefix = "person")注解的作用是将配置文件中以person开头的属性值通过setXX()方法注入到实体类对应属性中
@Component
@ConfigurationProperties(prefix = "person") //将配置文件中以person开头的属性注入到该类中
@Date
public class Person {
private int id; //id
private String name; //名称
}
//yaml
person.id=1
person.name=duan
会自动将配置文件中的person.id和name会自动注入到Person类的属性中
还有一个书写提示的依赖
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-configuration-processor</artifactId>
<optional>true</optional>
</dependency>
@Value
@Value：属性注入
//java
jdbc.driverClassName=com.mysql.jdbc.Driver
jdbc.url=jdbc:mysql://127.0.0.1:3306/springboot_h
jdbc.username=root
jdbc.password=123
//yml
@Configuration //设置为配置类
public class JdbcConfiguration {
@Value("${jdbc.url}")
String url;
@Value("${jdbc.driverClassName}")
String driverClassName;
@Value("${jdbc.username}")
String username;
@Value("${jdbc.password}")
String password;
@Bean
public DataSource dataSource() {
DruidDataSource dataSource = new DruidDataSource();
dataSource.setUrl(url);
dataSource.setDriverClassName(driverClassName);
dataSource.setUsername(username);
dataSource.setPassword(password);
return dataSource;
} }
六、源码
让我们带着问题来看源码
1.为什么导入dependency时不需要指定版本？
<!-- Spring Boot父项目依赖管理 -->
<parent>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-parent</artifactId>
<version>2.2.9.RELEASE</version>
<relativePath/> <!-- lookup parent from repository -->
</parent>
这个依赖启动器中还包含一个父依赖
<parent>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-dependencies</artifactId>
<version>2.5.2</version>
</parent>
里面包含了大部分日常开发所需版本
2.Spring Boot到底是如何进行自动配置的，都把哪些组件进行了自动配置？
自动配置：根据我们添加的jar包依赖，会自动将一些配置类的bean注册进ioc容器，我们可以需要的地方使用@autowired或者@resource等注解来使用它。
@SpringBootApplication：
@Target({ElementType.TYPE}) //注解适用范围,Type表示注解可描述在类、接口、注解或枚举中
@Retention(RetentionPolicy.RUNTIME) //表示注解的生命周期，Runtime运行时
@Documented //表示注解可以记录在javadoc中
@Inherited //表示可以被子类继承该注解
@SpringBootConfiguration // 标明该类为配置类
@EnableAutoConfiguration // 启动自动配置功能
@ComponentScan(excludeFilters = { @Filter(type = FilterType.CUSTOM, classes = TypeExcludeFilter.class), @Filter(type = FilterType.CUSTOM, classes = AutoConfigurationExcludeFilter.class) })
public @interface SpringBootApplication {
SpringBootConfiguration:里面是一个@Configuration，就表示是一个配置类
@EnableAutoConfiguration：Spring 中有很多以 Enable 开头的注解，其作用就是借助 @Import 来收集并注册特定场景相关的Bean ，并加载到 IOC 容器。@EnableAutoConfiguration就是借助@Import来收集所有符合自动配置条件的bean定义，并加载到IoC容器。
@Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
@Documented
@Inherited
@AutoConfigurationPackage // 导入Registrar中注册的组件,主要是借助@Import注册了一个BasePackages的bean整合如jpa等其他第三方的时候提供启动类所在包路径，用来扫描
@Import(AutoConfigurationImportSelector.class)
//AutoConfigurationImportSelector 可以帮助 Springboot 应用将所有符合条件的 @Configuration配置都加载到当前 SpringBoot 创建并使用的 IOC 容器( ApplicationContext )中
public @interface EnableAutoConfiguration {
@AutoConfigurationPackage 导入Registrar中注册的组件,主要是借助@Import注册了一个BasePackages的bean整合如jpa等其他第三方的时候提供启动类所在包路径，用来扫描
@Import(AutoConfigurationImportSelector.class)：可以帮助 springboot 应用将所有符合条件的 @Configuration配置都加载到当前 SpringBoot 创建并使用的 IOC 容器( ApplicationContext )中.
重点是实现了 DeferredImportSelector 接口，然后 DeferredImportSelector 接口又继承了 ImportSelector 接口。
ImportSelector是@Import的一种用法，@Import可以用于导入第三方包。
最终是加载META-INF/spring.factories文件，包括第三方jar包下的这个目录下的spring.factories文件，文件中配置了所有常用的属性的默认配置，如下图为springboot的spring.factories文件，其中的EnableAutoConfiguration属性对应的值是springboot所对接支持的其他第三方的配置类，最后导入ioc容器中（前提是maven中引入的对应的依赖）。这也是java的spi机制的一种体现。
实战应用：搭建springcloud微服务项目，其中多个模块拆分之后，每个模块又分为servic业务模块，和service-api远程调用模块，在service-api中的feign配置类的路径是和引用api接口模块的路径不同的，那么久无法初始化feign配置类，就需要spi去指定初始化的时候加载的配置类路径。如下：
@Configuration
@EnableFeignClients(basePackages = "com.mall.goods")
public class FeignConfig {
}
EnableFeignClients配置的路径是goods-api的包路径，在order的模块中引入就无法初始化feign接口。
解决办法：
3.SpringApplication.run
两件事：1.初始化SpringApplication 2.执行run方法
点进run方法
public static ConfigurableApplicationContext run(Class<?> primarySource, String... args) {
// 调用重载方法
return run(new Class<?>[] { primarySource }, args);
}
public static ConfigurableApplicationContext run(Class<?>[] primarySources, String[] args) {
// 两件事：1.初始化SpringApplication 2.执行run方法
return new SpringApplication(primarySources).run(args);
}
4.SpringApplication.run中的new SpringApplication()
//【1.1 推断应用类型，后面会根据类型初始化对应的环境。常用的一般都是servlet环境 】
this.webApplicationType = WebApplicationType.deduceFromClasspath();
//【1.2 初始化classpath下 META-INF/spring.factories中已配置的 ApplicationContextInitializer 】
setInitializers((Collection) getSpringFactoriesInstances(ApplicationContextInitializer.class));
//【1.3 初始化classpath下所有已配置的 ApplicationListener 】
setListeners((Collection) getSpringFactoriesInstances(ApplicationListener.class));
//【1.4 根据调用栈，推断出 main 方法的类名 】
this.mainApplicationClass = deduceMainApplicationClass();
即最后给两个属性赋值：
private List<ApplicationContextInitializer<?>> initializers;
private List<ApplicationListener<?>> listeners;
5.SpringApplication.run中的run方法
1、获取并启动监听器： getRunListeners()
- 可以监听Spring容器中正在发生的一些事件， Spring的事件为Bean和Bean之间的消息传递提供支持。当一个对象处理完某种任务后，通知另外的对象进行某些处理，常用的场景有进行某些操作后发送通知，消息、邮件等情况。
2、构造应用上下文环境：prepareEnvironment（）
包括计算机的环境，Java环境，Spring的运行环境，Spring项目的配置（在SpringBoot中就是那个熟悉的application.properties/yml）等等
3、初始化应用上下文-ConfigurableApplicationContext，创建ioc容器并存放在beanFactory中
对应方法：createApplicationContext()
- 重点：上下文就是一堆属性的集合，在这里将spring.factories中符合条件的配置类转为beanDefinition并加载至beanFactory中的beanDefinitionMa，
4、刷新应用上下文前的准备阶段（为上面初始化的上下文即一堆属性赋值，并创建一些bean）
对应方法：prepareContext(context, environment, listeners, applicationArguments, printedBanner);
- 设置容器环境 context.setEnvironment
- 设置容器后置处理 context.getBeanFactory().setConversionService
- 执行容器中的 ApplicationContextInitializer
- 向各个监听器发送容器已经准备好的事件
- 将main函数中的args参数封装成单例Bean，注册进容器
- 加载我们的启动类，将启动类注入容器
- 发布容器已加载事件
5、刷新应用上下文：refreshContext(context)
spring的refresh()方法
其中invokeBeanFactoryPostProcessors是真正的使第3步的配置类生效，并将其内部的bean生成实例对象存入容器中。第三部只是配置类放入map容器，配置类内部包含许多@Bean注解的方法，这个方法是真正的解析生成其他bean并放入map
1.//获取beanFactory
obtainFreshBeanFactory();
2.//准备BeanFactory
prepareBeanFactory(beanFactory);
//具体做了哪些准备：
// 配置类加载器：默认使用当前上下文的类加载器
beanFactory.setBeanClassLoader(getClassLoader());
// 配置EL表达式：在Bean初始化完成，填充属性的时候会用到
beanFactory.setBeanExpressionResolver(new StandardBeanExpressionResolver(beanFactory.getBeanClassLoader()));
// 添加属性编辑器
PropertyEditor beanFactory.addPropertyEditorRegistrar(new ResourceEditorRegistrar(this, getEnvironment()));
// 添加Bean的后置处理器
beanFactory.addBeanPostProcessor(new ApplicationContextAwareProcessor(this));
3.//向上下文中添加了一系列的Bean的后置处理器。
//后置处理器工作的时机是在所有的beanDenifition加载完成之后，bean实例化之前执行。
//简单来说Bean的后置处理器可以修改BeanDefinition的属性信息。
postProcessBeanFactory(beanFactory);
4.//1.Resource定位 2.第二步：启动类同级和子目录下BeanDefinition的载入 3.第三个过程：注册所有的BeanDefinition
invokeBeanFactoryPostProcessors(beanFactory)
//实例化所有的（non-lazy-init）单例bean
finishBeanFactoryInitialization
6、刷新应用上下文后的扩展接口
- afterRefresh：扩展接口，设计模式中的模板方法，默认为空实现。如果有自定义需求，可以重写该方法。比如打印一些启动结束log，或者一些其它后置处理。
拓展
@Import注解执行的时机，spring容器启动的时候，解析配置类的时候，由ConfigurationClassParser当中的processImports来处理。
/**
*处理@Import类
*/
private void processImports(ConfigurationClass configClass, SourceClass currentSourceClass,
Collection<SourceClass> importCandidates, Predicate<String> exclusionFilter,
boolean checkForCircularImports) {
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) {//遍历注入的候选集合
/**
* 如果是实现了ImportSelector接口的类
*/
if (candidate.isAssignable(ImportSelector.class)) {
// Candidate class is an ImportSelector -> delegate to it to determine imports
Class<?> candidateClass = candidate.loadClass();
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) {//todo 延迟注入 这里还没有研究 有空了看看
this.deferredImportSelectorHandler.handle(configClass, (DeferredImportSelector) selector);
}
else {//调用selector当中的selectImports方法，得到要注入的类的全限定名
String[] importClassNames = selector.selectImports(currentSourceClass.getMetadata());
// 获得元类信息
Collection<SourceClass> importSourceClasses = asSourceClasses(importClassNames, exclusionFilter);
// 递归的处理注入的类
processImports(configClass, currentSourceClass, importSourceClasses, exclusionFilter, false);
}
}
/**
* 如果是ImportBeanDefinitionRegistrar 则configClass.addImportBeanDefinitionRegistrar 提前放到一个map当中
*/
else if (candidate.isAssignable(ImportBeanDefinitionRegistrar.class)) {
// Candidate class is an ImportBeanDefinitionRegistrar ->
// delegate to it to register additional bean definitions
Class<?> candidateClass = candidate.loadClass();
ImportBeanDefinitionRegistrar registrar =
ParserStrategyUtils.instantiateClass(candidateClass, ImportBeanDefinitionRegistrar.class,
this.environment, this.resourceLoader, this.registry);//实例化
configClass.addImportBeanDefinitionRegistrar(registrar, currentSourceClass.getMetadata());//放到一个map中
}
/**
* 如果是普通类
*/
else {
// Candidate class not an ImportSelector or ImportBeanDefinitionRegistrar ->
// process it as an @Configuration class
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();
}
}
}
