一、了解SpringBoot
Spring Boot是由Pivotal团队提供的全新框架,其设计目的是用来简化Spring应用的创建、运行、调试、部署等。使用Spring Boot可以做到专注于Spring应用的开发,而无需过多关注XML的配置。Spring Boot使用“习惯优于配置”的理念,简单来说,它提供了一堆依赖打包,并已经按照使用习惯解决了依赖问题。使用Spring Boot可以不用或者只需要很少的Spring配置就可以让企业项目快速运行起来。Spring Boot是开发者和Spring 本身框架的中间层,帮助开发者统筹管理应用的配置,提供基于实际开发中常见配置的默认处理(即习惯优于配置),简化应用的开发,简化应用的运维;总的来说,其目的Spring Boot就是为了对Java web 的开发进行“简化”和加“快”速度,简化开发过程中引入或启动相关Spring 功能的配置。这样带来的好处就是降低开发人员对于框架的关注点,可以把更多的精力放在自己的业务代码上。
1.Spring Boot的主要特点
简化配置:
SpringBoot通过自动配置(auto-configuration)功能,根据应用程序的依赖和环境,自动配置Spring框架所需的各种组件。这样,开发者无需手动编写大量的配置文件,减少了开发时间和维护成本。
内嵌服务器:
SpringBoot集成了常用的Web服务器(如Tomcat、Jetty等),可以将应用程序打包为可执行的JAR文件,并直接运行,无需部署额外的Web服务器。这简化了应用程序的部署和发布过程。
自动化依赖管理:
SpringBoot提供了一套依赖管理机制,称为“Starter”,通过引入不同的Starter,开发者可以方便地添加各种功能模块、数据库驱动、测试框架等依赖,而无需手动处理复杂的依赖关系。
统一的入口:
SpringBoot提供了一个主类(Main Class)作为应用程序的统一入口,简化了应用程序的启动和初始化过程。
健康检查:
SpringBoot内置了健康检查机制,可以通过HTTP端点或管理界面查看应用程序的运行状态和健康度。
外部化配置:
SpringBoot支持将应用程序的配置信息外部化,可以使用属性文件、YAML文件、环境变量等方式进行配置,便于在不同环境中进行部署和配置切换。
强大的开发工具:
SpringBoot提供了丰富的开发工具和插件,如SpringBoot CLI、SpringBoot DevTools等,可以加速开发过程,提高开发效率。
生态系统支持:
SpringBoot与Spring框架紧密集成,可以无缝使用Spring生态系统的各种功能和扩展,如SpringData、SpringSecurity、SpringCloud等。
2.使用SpringBoot的好处
一)为什么要用SpringBoot?
以往的项目整合起来是比较繁琐复杂的,而且存在架包冲突的问题,这时候SpringBoot应运而生了,SpringBoot也就是用来做这个的。
(二)什么是SpringBoot?
SpringBoot是一个快速开发的框架,能过快速整合第三方框架,他是如何快速整合的呢?其实他是的基本原来是Maven依赖关系,Maven的集成,完全采用注解化,简化XML配置,内嵌HTTP服务器(Tomcat,jetty),默认嵌入Tomcat,最终以Java应用程序进行执行。
(三)SpringBoot与SpringCloud 的区别?
1.SpringBoot快速开发框架,快速整合第三方框架(Maven依赖关系###Maven继承),完全采用注解化,简化XML配置,最终以java应用程序进行执行。
2.SpringCloud一套目前完整的微服务解决框架,功能非常强大,注册中心,客户端调用工具,服务治理(负载均衡,断路器,分布式配置中心,网管,消息总线等)。
3.关系:微服务通讯技术Http+json(restfull)轻量级,SpringBoot Web组件默认集成SpringMVC,SpringCloud依赖于SpringBoot实现微服务,使用SpringMVC编写微服务接口。
总结:
SpringCloud 微服务开发——RPC远程通讯技术,服务治理,单纯的只是集成SpringBoot实现快速开发。
3.为什么要学习SpringBoot
①和spring更兼容
因为SpringBoot是伴随着Spring 4.0而生的,boot是引导的意思,也就是它的作用其实就是在于帮助开发者快速的搭建Spring框架,因此SpringBoot继承了Spring优秀的基因,在Spring中开发更为方便快捷。
②简化编码
比如我们要创建一个 web 项目,使用 Spring 的朋友都知道,在使用 Spring 的时候,需要在 pom 文件中添加多个依赖,而 Spring Boot 则会帮助开发着快速启动一个 web 容器,在 Spring Boot 中,我们只需要在 pom 文件中添加如下一个 starter-web 依赖即可。
③简化配置
Spring 虽然使Java EE轻量级框架,但由于其繁琐的配置,一度被人认为是“配置地狱”。各种XML、Annotation配置会让人眼花缭乱,而且配置多的话,如果出错了也很难找出原因。Spring Boot更多的是采用 Java Config 的方式,对 Spring 进行配置。
例:我新建一个类,但是我不用 @Service注解,也就是说,它是个普通的类,那么我们如何使它也成为一个 Bean 让 Spring 去管理呢?只需要@Configuration 和@Bean两个注解即可
@Configuration表示该类是个配置类,@Bean表示该方法返回一个 Bean。这样就把TestService作为 Bean 让 Spring 去管理了,在其他地方,我们如果需要使用该 Bean,和原来一样,直接使用@Resource注解注入进来即可使用,非常方便。@Resource private TestService testService;
另外,部署配置方面,原来 Spring 有多个 xml 和 properties配置,在 Spring Boot 中只需要个 application.yml即可
④简化部署
在使用 Spring 时,项目部署时需要我们在服务器上部署 tomcat,然后把项目打成 war 包扔到 tomcat里,在使用 Spring Boot 后,我们不需要在服务器上去部署 tomcat,因为 Spring Boot 内嵌了 tomcat,我们只需要将项目打成 jar 包,使用 java -jar xxx.jar一键式启动项目。
另外,也降低对运行环境的基本要求,环境变量中有JDK即可。
⑤简化监控
我们可以引入 spring-boot-start-actuator 依赖,直接使用 REST 方式来获取进程的运行期性能参数,从而达到监控的目的,比较方便。但是 Spring Boot 只是个微框架,没有提供相应的服务发现与注册的配套功能,没有外围监控集成方案,没有外围安全管理方案,所以在微服务架构中,还需要 Spring Cloud 来配合一起使用。
二、SpringBoot环境搭建
简单搭建一个 SpringBoot 的开发环境:
1.安装需要的工具
IDEA、jdk 1.8以上、MySQL 5.7以上、Maven、Navicat
2.创建SpringBoot项目
在IDEA工具点击New Project,进入下面界面点击Spring initializr选项,根据以下图中提示填写信息
选择依赖库
上一步填写完信息后点击Next,进入选择依赖库界面,在这里大家就可以选择我们开发当中要使用到的例如数据库驱动,技术,框架等等。
大多项目中会使用到的技术:
最后点击Finish,SpringBoot项目创建成功
3.给IDEA安装插件
插件一共有两个,一个是用来生成封装类的GET/SET方法的插件,另一个是用来生成MyBatis各种配置文件的。
打开settings >>Plugins↓
一个是Lombok
另一个是Free mabatis plugin
安装完后,在 pom.xml 配置文件中添加 Lombok 和 Mybatis 插件的依赖↓
<dependency>
<groupId>org.projectlombok</groupId>
<artifactId>lombok</artifactId>
<optional>true</optional>
</dependency>
<dependency>
<groupId>org.mybatis.spring.boot</groupId>
<artifactId>mybatis-spring-boot-starter</artifactId>
<version>2.1.4</version>
</dependency>
4.配置Maven库
maven下载解压后找到 conf 目录下的 setting.xml 文件,利用编辑器打开,在第55行中将路径改成你们自己的路径
然后在 IDEA 中设置 Maven 库路径↓
Maven home path中选择maven压缩包解压后的路径
User setting File中选择conf目录下的setting.xml
Local repository中选择maven文件夹中的repository文件夹
5.配置MySQL数据库
在Navicat中创建MySQL连接
新建一个数据库
回到IDEA,将IDEA右边侧栏的Database点开,添加MySQL数据库
填写相关信息
数据库连接URL(jdbc:mysql://localhost:3306/你的数据库名?useUnicode=true&characterEncoding=UTF-8&serverTimezone=Asia/Shanghai)
创建成功
6.在Sping配置文件中配置Tomcat、Mysql、Redis、MongoDB
首先,我们先把application.properties文件改成.yml后缀
然后我们打开这个文件,把这个文件原本的内容全部删掉,将我们的服务器和数据库配置信息添加上去,注意:缩进不能随便,一定要严格
server:
tomcat:
uri-encoding: UTF-8
threads:
max: 200
min-spare: 30
connection-timeout: 5000ms
port: 8080
servlet:
context-path: /Csdn-api
spring:
#MySQL数据源
datasource:
type: com.alibaba.druid.pool.DruidDataSource
druid:
driver-class-name: com.mysql.cj.jdbc.Driver
url: jdbc:mysql://localhost:3306/你的数据库名?useUnicode=true&characterEncoding=UTF-8&serverTimezone=Asia/Shanghai
username: root
password: 你的密码
initial-size: 8
max-active: 16
min-idle: 8
max-wait: 60000
test-while-idle: true
test-on-borrow: false
test-on-return: false
#Redis数据源
redis:
database: 0
host: 你的主机IP地址
port: 6379
password: 你的密码
jedis:
pool:
max-active: 1000
max-wait: -1ms
max-idle: 16
min-idle: 8
#MongoDB数据源
data:
mongodb:
host: 你的主机IP地址
port: 27017
database: csdn
authentication-database: admin
username: admin
password: 你的密码
此时你会发现配置信息中type: com.alibaba.druid.pool.DruidDataSource会报错,这是因为因为我们的MySQL用到了阿里巴巴的连接池,而我们还没有添加阿里巴巴的连接池的依赖库,在pom.xml文件中添加
<dependency>
<groupId>com.alibaba</groupId>
<artifactId>druid-spring-boot-starter</artifactId>
<version>1.1.13</version>
</dependency>
添加后让Maven执行一下reload,依赖库就会自动下载相关配置了
三、Spring Boot 自动装配原理与实现
1.什么是 SpringBoot 自动装配?
我们现在提到自动装配的时候,一般会和 Spring Boot 联系在一起。但是,实际上 Spring Framework 早就实现了这个功能。Spring Boot 只是在其基础上,通过 SPI 的方式,做了进一步优化。
SpringBoot 定义了一套接口规范,这套规范规定:SpringBoot 在启动时会扫描外部引用 jar 包中的
META-INF/spring.factories
文件,将文件中配置的类型信息加载到 Spring 容器(此处涉及到 JVM 类加载机制与 Spring 的容器知识),并执行类中定义的各种操作。对于外部 jar 来说,只需要按照 SpringBoot 定义的标准,就能将自己的功能装置进 SpringBoot。
没有 Spring Boot 的情况下,如果我们需要引入第三方依赖,需要手动配置,非常麻烦。但是,Spring Boot 中,我们直接引入一个 starter 即可。比如你想要在项目中使用 redis 的话,直接在项目中引入对应的 starter 即可。
引入 starter 之后,我们通过少量注解和一些简单的配置就能使用第三方组件提供的功能了。
自动装配可以简单理解为:通过注解或者一些简单的配置就能在 Spring Boot 的帮助下实现某块功能。
2.SpringBoot 是如何实现自动装配的?
看一下SpringBoot 的核心注解@ SpringBootApplication
里面都有什么。
我们可以把 @SpringBootApplication
看作是 @Configuration
、@EnableAutoConfiguration
、@ComponentScan
注解的集合。
根据 SpringBoot 官网,这三个注解的作用分别是:
@EnableAutoConfiguration
:启用 SpringBoot 的自动配置机制@Configuration
:允许在上下文中注册额外的 bean 或导入其他配置类@ComponentScan
:扫描被@Component
(@Service
,@Controller
)注解的 bean,注解默认会扫描启动类所在的包下所有的类 ,可以自定义不扫描某些 bean。如下图所示,容器中将排除TypeExcludeFilter
和AutoConfigurationExcludeFilter
。
@EnableAutoConfiguration
是实现自动装配的重要注解,我们以这个注解入手。
@EnableAutoConfiguration:实现自动装配的核心注解
EnableAutoConfiguration
只是一个简单地注解,自动装配核心功能的实现实际是通过 AutoConfigurationImportSelector
类。
AutoConfigurationImportSelector:加载自动装配类
AutoConfigurationImportSelector
类实现了 ImportSelector
接口,也就实现了这个接口中的 selectImports
方法,该方法主要用于获取所有符合条件的类的全限定类名,这些类需要被加载到 IoC 容器中
private static final String[] NO_IMPORTS = new String[0];
public String[] selectImports(AnnotationMetadata annotationMetadata) {
// <1>.判断自动装配开关是否打开
if (!this.isEnabled(annotationMetadata)) {
return NO_IMPORTS;
} else {
//<2>.获取所有需要装配的bean
AutoConfigurationMetadata autoConfigurationMetadata = AutoConfigurationMetadataLoader.loadMetadata(this.beanClassLoader);
AutoConfigurationImportSelector.AutoConfigurationEntry autoConfigurationEntry = this.getAutoConfigurationEntry(autoConfigurationMetadata, annotationMetadata);
return StringUtils.toStringArray(autoConfigurationEntry.getConfigurations());
}
}
这里我们需要重点关注一下getAutoConfigurationEntry()
方法,这个方法主要负责加载自动配置类的。
第 1 步:
判断自动装配开关是否打开。默认spring.boot.enableautoconfiguration=true
,可在 application.properties
或 application.yml
中设置
第 2 步 :
用于获取EnableAutoConfiguration
注解中的 exclude
和 excludeName
第 3 步
获取需要自动装配的所有配置类,读取META-INF/spring.factories
第 4 步 :
到这里可能面试官会问你:“spring.factories
中这么多配置,每次启动都要全部加载么?”。
很明显,这是不现实的,因为,这一步有经历了一遍筛选,@ConditionalOnXXX
中的所有条件都满足,该类才会生效
@Configuration // 检查相关的类:RabbitTemplate 和 Channel是否存在 // 存在才会加载 @ConditionalOnClass({ RabbitTemplate.class, Channel.class }) @EnableConfigurationProperties(RabbitProperties.class) @Import(RabbitAnnotationDrivenConfiguration.class) public class RabbitAutoConfiguration { }
3.Spring Boot 提供的条件注解
@ConditionalOnBean
:当容器里有指定 Bean 的条件下@ConditionalOnMissingBean
:当容器里没有指定 Bean 的情况下@ConditionalOnSingleCandidate
:当指定 Bean 在容器中只有一个,或者虽然有多个但是指定首选 Bean@ConditionalOnClass
:当类路径下有指定类的条件下@ConditionalOnMissingClass
:当类路径下没有指定类的条件下@ConditionalOnProperty
:指定的属性是否有指定的值@ConditionalOnResource
:类路径是否有指定的值@ConditionalOnExpression
:基于 SpEL 表达式作为判断条件@ConditionalOnJava
:基于 Java 版本作为判断条件@ConditionalOnJndi
:在 JNDI 存在的条件下差在指定的位置@ConditionalOnNotWebApplication
:当前项目不是 Web 项目的条件下@ConditionalOnWebApplication
:当前项目是 Web 项 目的条件下
4.如何实现一个 Starter
第一步,创建threadpool-spring-boot-starter
工程
第二步,引入 Spring Boot 相关依赖
第三步,创建ThreadPoolAutoConfiguration
第四步,在threadpool-spring-boot-starter
工程的 resources 包下创建META-INF/spring.factories
文件
最后新建工程引入threadpool-spring-boot-starter
总结
Spring Boot 通过@EnableAutoConfiguration
开启自动装配,通过 SpringFactoriesLoader 最终加载META-INF/spring.factories
中的自动配置类实现自动装配,自动配置类其实就是通过@Conditional
按需加载的配置类,想要其生效必须引入spring-boot-starter-xxx
包实现起步依赖
四、SpringBoot启动流程
SpringApplication的run方法的实现是启动原理探寻的起点,该方法的主要流程大体可以归纳如下:
1) 如果我们使用的是SpringApplication的静态run方法,那么,这个方法里面首先要创建一个 SpringApplication对象实例,然后调用这个创建好的SpringApplication的实例方法。在SpringApplication实例初始化过程中,主要是做一些准备工作,主要通过SpringFactoriesLoader在应用的classpath中查找并加载可用的ApplicationContextInitializer,ApplicationListener,推断并设置main方法所在的定义类
2)待准备工作完成后,就执行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);
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);
}
}
run方法主要流程就是:
1.获取监听器并启动:
2.根据SpringApplication参数来准备环境
3.Banner打印,在启动页面可以看到
3.创建Spring容器,也就是代码中的context
4.对前面生成的Spring容器做一些前置处理、刷新,后置处理等
5.返回Spring context