springBoot
Posted 奇迹是执着的人创造的
tags:
篇首语：本文由小常识网(cha138.com)小编为大家整理，主要介绍了springBoot相关的知识，希望对你有一定的参考价值。
文章目录
学习目标
- 基于SpringBoot框架的程序开发步骤
- 熟练使用SpringBoot配置信息修改服务器配置
- 基于SpringBoot的完成SSM整合项目开发
一、SpringBoot简介
1. 入门案例
问题导入
SpringMVC的HelloWord程序大家还记得吗？
-
SpringBoot是由Pivotal团队提供的全新框架，其设计目的是用来简化Spring应用的初始搭建以及开发过程
-
原生开发SpringMVC程序过程
1.1 入门案例开发步骤
①：创建新模块，选择Spring初始化，并配置模块相关基础信息
先新建一个空项目作为容器，存放所有的springBoot案例module
再添加新模块，当然是springBoot模块了
Next
②：选择当前模块需要使用的技术集
版本换一下，改成2.x版本，因为3.0版本开始最低jdk要求是17了(跟创建项目时的jdk版本不一样)
还是想用最常用的jdk8,就改成2.7版本吧
第一次创建项目别着急，要等maven下载一大堆的jar包
多余的东西可以先给他删了，只留下src和pom.xml
要是识别不了这是maven项目，IDEA右边没有maven模块按钮：
双击shift-》搜索maven-》点击Add Maven Project -》 选中pom.xml即可
展开目录发现，所有的东西都给你创建好了，目录也标记好了，该有的包也都有了。这竟然是初始环境，也太棒了吧！
③：开发控制器类
cn.whu包下新建controller包，创建BookController类
@RestController
@RequestMapping("/books")
public class BookController
@GetMapping("/id")
public String getById(@PathVariable Integer id)
System.out.println("book getById & id = " + id);
return "hello , spring boot!";
④：运行自动生成的Springboot01QuickstartApplication类（main包下的，不是test包下的）
如果新建项目时，Package name 没有删掉多余的包，也就是没有改成cn.whu
会导致多一个包，从而Springboot01QuickstartApplication类和BookController类在两个不想干的包下，需要多一行配置
配置: 由于Springboot01QuickstartApplication类和BookController类不在同一个包下面，所以需要加一行扫描注解
@SpringBootApplication(scanBasePackages="cn.whu.controller")
仔细观察，发现tomcat服务器已经启动了 SpringBoot直接内置了tomcat服务器了 (牛)
查看一下插件，果然有springBoot run (点它spring-boot:run 也能启动服务器 也是pom.xml最后一行插件)
简单测试一下刚刚写的controller
IDEA输出
- 最简SpringBoot程序所包含的基础文件 (一个parent继承 + 一个spring-boot-starter-web依赖)
配置文件删得只剩下这么多，依然可以正常访问服务器Controller
<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 https://maven.apache.org/xsd/maven-4.0.0.xsd">
<modelVersion>4.0.0</modelVersion>
<parent>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-parent</artifactId>
<version>2.5.0</version>
</parent>
<groupId>com.itheima</groupId>
<artifactId>springboot-01-quickstart</artifactId>
<version>0.0.1-SNAPSHOT</version>
<dependencies>
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-web</artifactId>
<!-- 之前勾选SpringWeb得到的东西 -->
</dependency>
</dependencies>
</project>
注意<parent> 继承自其他项目，springBoot之所以好用，全靠了继承~
@SpringBootApplication(scanBasePackages="cn.whu.controller")
public class Springboot01QuickstartApplication
public static void main(String[] args)
SpringApplication.run(Springboot01QuickstartApplication.class, args);
- Spring程序与SpringBoot程序对比
注意事项：
基于idea开发SpringBoot程序需要确保联网且能够加载到程序框架结构
1.2 基于SpringBoot官网创建项目
就是可以在官网创建项目，然后下载下来，导入自己的IDE
拉到最下面
和idea里面一样的步骤创建
1.3 SpringBoot项目快速启动
① 对SpringBoot项目打包（执行Maven构建指令package）
② 执行启动指令
java -jar springboot_01_quickstart-0.0.1-SNAPSHOT.jar # 项目的名称根据实际情况修改
先关闭idea的服务器，再用命令启动jar
服务器已然通过jar启动了，可以用浏览器或者postman访问了
给一个jar包，就能启动服务器了，都不需要装tomcat, (访问数据库有数据库就行了)。springBoot太牛了
注意事项：
jar支持命令行启动需要依赖maven插件支持，请确认打包时是否具有SpringBoot对应的maven插件。
<build>
<plugins>
<plugin>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-maven-plugin</artifactId>
</plugin>
</plugins>
</build>
(以前的普通maven工程也能打jar包，但是那种jar包不支持上面这种命令行启动服务 都是上面插件的功劳，把需要用到所有jar包括服务器通信的jar都打包进来了)
2. SpringBoot概述
问题导入
学习了SpringBoot入门案例之后，感觉对比SpringMVC哪一个更加方便简洁？
- SpringBoot是由Pivotal团队提供的全新框架，其设计目的是用来简化Spring应用的初始搭建以及开发过程
- Spring程序缺点
- 配置繁琐
- 依赖设置繁琐
- SpringBoot程序优点
- 自动配置
- 起步依赖（简化依赖配置）
- 辅助功能（内置服务器，……）
2.1 起步依赖
- starter (名称中有starter的就是起步依赖)
- SpringBoot中常见项目名称，定义了当前项目使用的所有项目坐标，以达到减少依赖配置的目的
<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 https://maven.apache.org/xsd/maven-4.0.0.xsd">
<modelVersion>4.0.0</modelVersion>
<parent>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-parent</artifactId>
<version>2.5.0</version>
</parent>
<groupId>com.itheima</groupId>
<artifactId>springboot-01-quickstart</artifactId>
<version>0.0.1-SNAPSHOT</version>
<dependencies>
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-web</artifactId>
<!-- 写依赖即可 不需要写版本 boot帮你管理版本 -->
</dependency>
</dependencies>
</project>
<project xmlns="http://maven.apache.org/POM/4.0.0"
xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance">
<modelVersion>4.0.0</modelVersion>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-dependencies</artifactId>
<version>2.5.0</version>
<packaging>pom</packaging>
<properties>
<servlet-api.version>4.0.1</servlet-api.version>
...
</properties>
</project>
springboot_01_quickstart --继承–> spring-boot-starter-parent --继承–> spring-boot-dependencies
主要就是爷爷pom：spring-boot-dependencies这里，2937行，配置了几乎所有的jar包坐标，所有的版本
(boot项目里写依赖不需要写版本了，boot帮你管理最好的版本)
我甚至直接就找到了lombok
- parent
- 所有SpringBoot项目要继承的项目，定义了若干个坐标版本号（依赖管理，而非依赖），以达到减少依赖冲突的目的
- spring-boot-starter-parent（2.5.0）与 spring-boot-starter-parent（2.4.6）共计57处坐标版本不同
<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"
xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance">
<modelVersion>4.0.0</modelVersion>
<parent>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-dependencies</artifactId>
<version>2.5.0</version>
</parent>
<artifactId>spring-boot-starter-parent</artifactId>
<packaging>pom</packaging>
...
</project>
- 实际开发
- 使用任意坐标时，仅书写GAV中的G和A，V由SpringBoot提供 (再也不用自己管理版本了)
- 如发生坐标错误，再指定version（要小心版本冲突）
<dependency>
<groupId>junit</groupId>
<artifactId>junit</artifactId>
<version>$junit.version</version>
</dependency>
<dependency>
<groupId>javax.servlet</groupId>
<artifactId>javax.servlet-api</artifactId>
<version>$servlet-api.version</version>
</dependency>
<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 https://maven.apache.org/xsd/maven-4.0.0.xsd">
<parent>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-parent</artifactId>
<version>2.5.0</version>
</parent>
<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>
</project>
2.2 辅助功能
- SpringBoot程序启动
@SpringBootApplication
public class Springboot01QuickstartApplication
public static void main(String[] args)
SpringApplication.run(Springboot01QuickstartApplication.class, args);
- SpringBoot在创建项目时，采用jar的打包方式
- SpringBoot的引导类是项目的入口，运行main方法就可以启动项目
- 使用maven依赖管理变更起步依赖项
- Jetty比Tomcat更轻量级，可扩展性更强（相较于Tomcat），谷歌应用引擎（GAE）已经全面切换为Jetty
（tomcat功能全，不管你用不用都在。Jetty功能空，想要时再配上。 现阶段还是主要用Tomcat）
<dependencies>
<dependency>
<!-- 写依赖即可 不需要写版本 boot帮你管理版本 -->
<!-- 之前勾选SpringWeb就会帮你写这个依赖 -->
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-web</artifactId>
<!--web起步依赖环境中，排除Tomcat起步依赖 (不用tomcat用Jetty服务器)-->
<exclusions>
<exclusion>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-tomcat</artifactId>
</exclusion>
</exclusions>
</dependency>
<!--添加Jetty起步依赖，版本由SpringBoot的starter控制-->
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-jetty</artifactId>
</dependency>
</dependencies>
再启动服务器就看到jetty了
. ____ _ __ _ _
/\\\\ / ___'_ __ _ _(_)_ __ __ _ \\ \\ \\ \\
( ( )\\___ | '_ | '_| | '_ \\/ _` | \\ \\ \\ \\
\\\\/ ___)| |_)| | | | | || (_| | ) ) ) )
' |____| .__|_| |_|_| |_\\__, | / / / /
=========|_|==============|___/=/_/_/_/
:: Spring Boot :: (v2.7.10)
2023-03-24 19:37:48.222 INFO 39000 --- [ main] c.w.s.Springboot01QuickstartApplication : Starting Springboot01QuickstartApplication using Java 1.8.0_361 on DESKTOP-FKHNPN0 with PID 39000 (C:\\Users\\hanzhuan\\Documents\\projectData\\IdeaProjects\\springBoot\\springboot_01_quickstart\\target\\classes started by hanzhuan in C:\\Users\\hanzhuan\\Documents\\projectData\\IdeaProjects\\springBoot)
2023-03-24 19:37:48.223 INFO 39000 --- [ main] c.w.s.Springboot01QuickstartApplication : No active profile set, falling back to 1 default profile: "default"
2023-03-24 19:37:48.560 INFO 39000 --- [ main] org.eclipse.jetty.util.log : Logging initialized @855ms to org.eclipse.jetty.util.log.Slf4jLog
2023-03-24 19:37:48.613 INFO 39000 --- [ main] o.s.b.w.e.j.JettyServletWebServerFactory : Server initialized with port: 8080
2023-03-24 19:37:48.615 INFO 39000 --- [ main] org.eclipse.jetty.server.Server : jetty-9.4.51.v20230217; built: 2023-02-17T08:19:37.309Z; git: b45c405e4544384de066f814ed42ae3dceacdd49; jvm 1.8.0_361-b09
2023-03-24 19:37:48.627 INFO 39000 --- [ main] o.e.j.s.h.ContextHandler.application : Initializing Spring embedded WebApplicationContext
2023-03-24 19:37:48.627 INFO 39000 --- [ main] w.s.c.ServletWebServerApplicationContext : Root WebApplicationContext: initialization completed in 384 ms
2023-03-24 19:37:48.660 INFO 39000 --- [ main] org.eclipse.jetty.server.session : DefaultSessionIdManager workerName=node0
2023-03-24 19:37:48.660 INFO 39000 --- [ main] org.eclipse.jetty.server.session : No SessionScavenger set, using defaults
2023-03SpringBoot入门到精通-SpringBoot自动配置原理
SpringBoot源码解析
- SpringBoot入门到精通-Spring的注解编程(一)
- SpringBoot入门到精通-SpringBoot入门(二)
- SpringBoot入门到精通-Spring的基本使用(三)
- SpringBoot入门到精通-SpringBoot集成SSM(四)
- SpringBoot入门到精通-SpringBoot自动配置原理(五)
- SpringBoot入门到精通-SpringBoot自定义starter(六)
1.SpringBoot的自动配置
在之前的学习中，我们深刻的感受到SpringBoot的便捷之处，使用它来开发项目确实是快了很多，SpringBoot为何能做到如此？我们知道SpringBoot是基于Spring进行封装，屏蔽了Spring的配置细节让我们配置Spring显得尤为简单，这需要归功于SpringBoot的“自动配置”能力。
这里我先抛出一个问题：集成SpringMVC后为什么不需要配置DispatcherServlet？带着这个问题我们来一步一步分析SpringBoot自动配置原理。
1.1.@SpringBootApplication注解
使用SpringBoot就需要在启动类贴上：@SpringBootApplication注解，该注解是一个组合注解，结构如下
//配置注解，该注解上又贴了一个 @Configuration
@SpringBootConfiguration
//开启自动配置
@EnableAutoConfiguration
//Spring IOC自动扫描
@ComponentScan(
excludeFilters = @Filter(
type = FilterType.CUSTOM,
classes = TypeExcludeFilter.class
), @Filter(
type = FilterType.CUSTOM,
classes = AutoConfigurationExcludeFilter.class
)
)
public @interface SpringBootApplication ...
【重要】@SpringBootApplication 包含了三个注解
- @SpringBootConfiguration ：该注解的本质其实就是一个 @Configuration 配置注解，标记某个类成为配置类
- @EnableAutoConfiguration ：开启SpringBoot自动配置的注解，比如我们集成SpringMVC并没有配置DispatcherServlet前端控制器，但是这个东西一定是存在的，就是SpringBoot帮我们自动配置好了。
- @ComponentScan ：这个在讲Spring的Java Config就有介绍，它是Spring IOC的自动扫描的注解，默认扫描当前包及其子包中的打了 @Component;@Repository;@Service；@Controller 注解的类。也就是说我们的HelloController其实已经被启动类默认扫描到了。
1.2.@EnableAutoConfiguration自动配置
其中有@EnableAutoConfiguration注解就是开启SpringBoot自动配置的注解，它的结构如下
/**
启用 Spring Application Context 的自动配置，尝试猜测和配置您可能需要的 bean。
自动配置类通常根据您的类路径和您定义的 bean 应用
* Enable auto-configuration of the Spring Application Context, attempting to guess and
* configure beans that you are likely to need. Auto-configuration classes are usually
* applied based on your classpath and what beans you have defined. For example, 8
**/
@Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
@Documented
@Inherited
@AutoConfigurationPackage
@Import(AutoConfigurationImportSelector.class)
public @interface EnableAutoConfiguration
String ENABLED_OVERRIDE_PROPERTY = "spring.boot.enableautoconfiguration";
Class<?>[] exclude() default ;
String[] excludeName() default ;
该注解使用了 @Import(AutoConfigurationImportSelector.class) 导入了一个选择器 该类实现了ImportSelector，在JavaConfig部分有学习过，ImportSelector提供了selectImports方法所返回的类名会自动被注册到Spring容器中，AutoConfigurationImportSelector结构如下
public class AutoConfigurationImportSelector implements DeferredImportSelector, BeanClassLoaderAware,
ResourceLoaderAware, BeanFactoryAware, EnvironmentAware, Ordered
@Override
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);
...省略...
return new AutoConfigurationEntry(configurations, exclusions);
/**
返回自动配置的类的名称
* Return the auto-configuration class names that should be considered. By default
* this method will load candidates using @link SpringFactoriesLoader with
* @link #getSpringFactoriesLoaderFactoryClass().
* @param metadata the source metadata
* @param attributes the @link #getAttributes(AnnotationMetadata) annotation
* attributes
* @return a list of candidate configurations
*/
protected List<String> getCandidateConfigurations(AnnotationMetadata metadata, AnnotationAttributes attributes)
//使用SpringFactoriesLoader（SPI）加载配置类名
List<String> configurations = SpringFactoriesLoader.loadFactoryNames(getSpringFactoriesLoaderFactoryClass(),
getBeanClassLoader());
//从下面日志可以看出来，是在 MET-INF/spring.factories 中加载配置类
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;
AutoConfigurationImportSelector#selectImports最终会调用getCandidateConfigurations方法，该方法的作用是加载需要自动配置的类的名字(权限定名)。也就是说getCandidateConfigurations方法负责加载配置类的类名返回给selectImports方法，而selectImports方法拿到类名再返回，那么这些配置就就会自动注册到Spring容器中了。
从上面代码可以看出，getCandidateConfigurations方法中使用了 SpringFactoriesLoader.loadFactoryNames(SPI)去加载 META-INF/spring.factories 中的配置类。
我们可以使用IDEA搜索一下这个文件 spring.factories
我们看到，在很多的jar包中都有这个文件，就拿 mybatis来说，为了整合SpringBoot在程序启动的时候就需要一些初始配置.那么在 mybatis-spring-boot-autoconfigure 这个包中就提供了 spring.factories 文件其中包含了mybatis的配置类，在SpringBoot启动时就会通过自动配置流程把这些配置类加载到Spring容器，配置类中的配置项也就生效了。
我们这里重点看 spring-boot-autoconfigure 这个包中的spring.factories文件，它是SpringBoot自己的自动配置包
在 External Libraries 中找到这个包，展开就可以看到 spring.factories文件，其中有一个 EnableAutoConfiguration的配置项，后面跟了很多很多的以AutoConfiguration 结尾的自动配置类。其中就有 org.springframework.boot.autoconfigure.web.servlet.DispatcherServletAutoConfiguration
@AutoConfigureOrder(Ordered.HIGHEST_PRECEDENCE)
//配置类
@Configuration(proxyBeanMethods = false)
@ConditionalOnWebApplication(type = Type.SERVLET)
@ConditionalOnClass(DispatcherServlet.class)
@AutoConfigureAfter(ServletWebServerFactoryAutoConfiguration.class)
public class DispatcherServletAutoConfiguration
/*
dispatcherServlet的默认的名字
* The bean name for a DispatcherServlet that will be mapped to the root URL "/"
*/
public static final String DEFAULT_DISPATCHER_SERVLET_BEAN_NAME = "dispatcherServlet";
/*
* The bean name for a ServletRegistrationBean for the DispatcherServlet "/"
*/
public static final String DEFAULT_DISPATCHER_SERVLET_REGISTRATION_BEAN_NAME = "dispatcherServletRegistration";
@Configuration(proxyBeanMethods = false)
@Conditional(DefaultDispatcherServletCondition.class)
@ConditionalOnClass(ServletRegistration.class)
@EnableConfigurationProperties( HttpProperties.class, WebMvcProperties.class )
protected static class DispatcherServletConfiguration
//注册一个DispatcherServlet
@Bean(name = DEFAULT_DISPATCHER_SERVLET_BEAN_NAME)
public DispatcherServlet dispatcherServlet(HttpProperties httpProperties, WebMvcProperties webMvcProperties)
DispatcherServlet dispatcherServlet = new DispatcherServlet();
dispatcherServlet.setDispatchOptionsRequest(webMvcProperties.isDispatchOptionsRequest());
dispatcherServlet.setDispatchTraceRequest(webMvcProperties.isDispatchTraceRequest());
dispatcherServlet.setThrowExceptionIfNoHandlerFound(webMvcProperties.isThrowExceptionIfNoHandlerFound());
dispatcherServlet.setPublishEvents(webMvcProperties.isPublishRequestHandledEvents());
dispatcherServlet.setEnableLoggingRequestDetails(httpProperties.isLogRequestDetails());
return dispatcherServlet;
...省略...
该类标记了@Configuration注解可以被识别为一个配置类，在配置类中通过@Bean+方法的方式注册了一个DispatcherServlet的Bean。最开始提的那个问题似乎可以解答了。
1.3.自动配置总结
-
@SpringBootApplication 注解中包含了@EnableAutoConfiguration 注解，它的作用是开启SpringBoot自动配置.
-
该注解上标记了一个@Import(AutoConfigurationImportSelector.class) 导入选择器，在该导入选择器的selectImports中通过 SpringFactoriesLoader(SPI)去扫描classpath中的jar包中的 META-INF/spring.factories 文件.
-
该文件中有大量的自动配置类的权限定名(标记了@Configuration注解)。 然后会被这些自动配置类注册到Spirng容器中(ImportSelector拥有这样的能力)，达到Spring启动就动态加载配置的目的。
比如：在spring.factories 有一个 DispatcherServletAutoConfiguration ，它就是一个标记了@Configuration 的配置类，它通过@Bean+方法 的方式定义了 DispatcherServlet的Bean。
2.DataSource的自动配置
2.1.DataSource的配置
对于DataSource而言，我们在导入了相关依赖之后，就只需要值yml中配置如下信息
spring:
datasource:
username: root
password: admin
url: jdbc:mysql:///test?useUnicode=true&characterEncoding=UTF-8&serverTimezone=UTC
driver-class-name: com.mysql.jdbc.Driver
type: com.alibaba.druid.pool.DruidDataSource #指定使用druid的连接池
2.2.DataSource自动配置
然后SpringBoot就可以自动为我们创建DataSource的Bean,那么SpringBoot是如何做到的呢？在 spring-boot-autoconfigure这个jar的 MATE-INF/spring.factories 文件中有一个配置类 DataSourceAutoConfiguration ，它的作用就是自动配置DataSource，结构如下
//是一个配置类
@Configuration(proxyBeanMethods = false)
//满足条件，存在DataSource.class,配置生效
@ConditionalOnClass( DataSource.class, EmbeddedDatabaseType.class )
//开启Properties ,DataSourceProperties
@EnableConfigurationProperties(DataSourceProperties.class)
@Import( DataSourcePoolMetadataProvidersConfiguration.class, DataSourceInitializationConfiguration.class )
public class DataSourceAutoConfiguration
...省略...
@Configuration(proxyBeanMethods = false)
@Conditional(PooledDataSourceCondition.class)
@ConditionalOnMissingBean( DataSource.class, XADataSource.class )
//连接池配置，默认使用 Hikari 。当我们配置了 Type,会使用 DataSourceConfiguration.Generic
@Import( DataSourceConfiguration.Hikari.class, DataSourceConfiguration.Tomcat.class,
DataSourceConfiguration.Dbcp2.class, DataSourceConfiguration.Generic.class,
DataSourceJmxConfiguration.class )
protected static class PooledDataSourceConfiguration
该类也标记了 @Configuration 注解，可被识别为Spring的配置类，类上通过 @EnableConfigurationProperties(DataSourceProperties.class) 引入了DataSourceProperties。 DataSourceProperties是用来绑定yml中DataSource配置的，源码如下
@ConfigurationProperties(prefix = "spring.datasource")
public class DataSourceProperties implements BeanClassLoaderAware, InitializingBean
private ClassLoader classLoader;
private Class<? extends DataSource> type;
private String driverClassName;
private String url;
private String username;
private String password;
@ConfigurationProperties(prefix = “spring.datasource”)这种用法我们在Spring注解编程的时候已经有学习过，就是把yml中以spring.datasource为前缀的配置绑定到当前对象中。DataSourceAutoConfiguration通过DataSourceProperties得到yml中的配置内容。
我们来看一下 DataSourceConfiguration.Hikari.class ，它是SpringBoot默认的连接池，源码如下org.springframework.boot.autoconfigure.jdbc.DataSourceConfiguration.Hikari
abstract class DataSourceConfiguration
//创建DataSource
@SuppressWarnings("unchecked")
protected static <T> T createDataSource(DataSourceProperties properties, Class<? extends DataSource> type)
return (T) properties.initializeDataSourceBuilder().type(type).build();
@Configuration(proxyBeanMethods = false)
@ConditionalOnClass(HikariDataSource.class)
@ConditionalOnMissingBean(DataSource.class)
@ConditionalOnProperty(name = "spring.datasource.type", havingValue = "com.zaxxer.hikari.HikariDataSource",
matchIfMissing = true)
static class Hikari
//读取以
@Bean
@ConfigurationProperties(prefix = "spring.datasource.hikari")
//绑定以spring.datasource.hikari开头的配置
HikariDataSource dataSource(DataSourceProperties properties)
//创建DataSource
HikariDataSource dataSource = createDataSource(properties, HikariDataSource.class);
if (StringUtils.hasText(properties.getName()))
dataSource.setPoolName(properties.getName());
return dataSource;
如果我们yml中没有配置spring.datasource.type属性，就会使用 HikariDataSource作为DataSource。也是通过DataSourceProperties来绑定配置到DataSource对象中。
当我们在yml中配置了spring.datasource.type属性，就会走DataSourceConfiguration.Generic
/**
* Generic DataSource configuration.
*/
@Configuration(proxyBeanMethods = false)
//当不存在DataSource，就创建DataSource
@ConditionalOnMissingBean(DataSource.class)
//当有spring.datasource.type就创建DataSource
@ConditionalOnProperty(name = "spring.datasource.type")
static class Generic
//向Spring容器注册DataSource
@Bean
DataSource dataSource(DataSourceProperties properties)
//使用properties创建DataSource
return properties.initializeDataSourceBuilder().build();
Generic是个内部类，上面有两个条件，需要满足这两个条件，配置类才会起作用
-
@ConditionalOnMissingBean(DataSource.class) ： 当不存在DataSource，就创建DataSource
-
@ConditionalOnProperty(name = “spring.datasource.type”) ： 当有spring.datasource.type就创建DataSource
Generic中通过 DataSourceProperties 创建DataSource,其中会拿到spring.datasource.type指向的DataSource的名字，然后使用反射创建实例，然后把参数设置到DataSource中，如下
public T build()
//拿到 spring.datasource.type指向的class
Class<? extends DataSource> type = getType();
//创建DataSource实例
DataSource result = BeanUtils.instantiateClass(type);
maybeGetDriverClassName();
//绑定四大属性
bind(result);
return (T) result;
自动配置就分析到这里，SpringBoot对其他组件都是以这样的方式和流程进行自动配置的。
文章结束啦，如果文章对你有所帮助，请一定给个好评哦，请一定给个好评哦，请一定给个好评哦
以上是关于springBoot的主要内容，如果未能解决你的问题，请参考以下文章
Springbootspring-boot-starter-redis包报错 :unknown
SpringBootSpring Boot Configuration Annotation Processor not found in classpath
Spring boot spring.batch.job.enabled=false 无法识别
Spring boot spring.batch.job.enabled=false 无法识别
1.3.7.RELEASE -> 1.4.1.RELEASE | java.lang.NoSuchMethodError：org.springframework.boot.builder.Spr