解讀 Spring Boot 核心知識點全覽
在當今的軟件開發領域，Spring Boot 猶如一顆璀璨的明星，散發著耀眼的光芒。它以其強大的功能和便捷的特性，成為了眾多開發者的首選框架。當我們深入探究 Spring Boot 的世界，會發現其中蘊含著豐富而關鍵的核心知識點，這些知識點猶如構建大廈的基石，支撐著整個應用的高效運行。
為什么需要Spring boot
Spring框架是輕量級Java框架，他完全可以基于配置+一些POJO(簡單的Java對象，不是JavaBean, EntityBean 或者 SessionBean，無需擔任任何的角色)即可完成一套web服務器開發。 盡管是輕量級，但是還是需要配置大量的xml，而Spring boot則將繁瑣的配置全部封裝起來，使得我們可以開箱即用。
相較于原生的Spring他有著如下優點：
- 可以非常方便的開發出Spring應用容器。
- 基于Spring boot開發應用的時間比Spring要少很多，生產力明顯提高了。
- 可以非常方便集成其他Spring組件，例如Spring JDBC、Spring ORM等。
- Spring boot內嵌了web容器，例如tomcat服務器，也可以改為jetty。
- Spring boot內部提供的CLI命令行工具，例如java或者Groovy。
- 無需編寫大量的xml配置文件。
- Spring Boot 遵循“固執己見的默認配置”，以減少開發工作（默認配置可以修改）。
- Spring boot內部也提供了許多的插件，例如Maven 或Gradle，使得我們的可以快速的開發或者測試Spring應用。
什么是Spring Boot Starters
原本我們開發web應用需要手動引入mvc、jackson等各種依賴，有了Starters之后，我們只需引入一個Starters依賴即可完成所有Spring web應用的配置，非常方便。
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-web</artifactId>
</dependency>SpringBoot應用Starters基本的一共有44種，具體如下：
1）spring-boot-starter 這是Spring Boot的核心啟動器，包含了自動配置、日志和YAML。
2）spring-boot-starter-actuator 幫助監控和管理應用。
3）spring-boot-starter-amqp 通過spring-rabbit來支持AMQP協議（Advanced Message Queuing Protocol）。
4）spring-boot-starter-aop 支持面向方面的編程即AOP，包括spring-aop和AspectJ。
5）spring-boot-starter-artemis 通過Apache Artemis支持JMS的API（Java?Message Service API）。
6）spring-boot-starter-batch 支持Spring Batch，包括HSQLDB數據庫。
7）spring-boot-starter-cache 支持Spring的Cache抽象。
8）spring-boot-starter-cloud-connectors 支持Spring Cloud Connectors，簡化了在像Cloud Foundry或Heroku這樣的云平臺上連接服務。
9）spring-boot-starter-data-elasticsearch 支持ElasticSearch搜索和分析引擎，包括spring-data-elasticsearch。
10）spring-boot-starter-data-gemfire 支持GemFire分布式數據存儲，包括spring-data-gemfire。
11）spring-boot-starter-data-jpa 支持JPA（Java Persistence API），包括spring-data-jpa、spring-orm、hibernate。
12）spring-boot-starter-data-MongoDB 支持MongoDB數據，包括spring-data-mongodb。
13）spring-boot-starter-data-rest 通過spring-data-rest-webmvc，支持通過REST暴露Spring Data數據倉庫。
14）spring-boot-starter-data-solr 支持Apache Solr搜索平臺，包括spring-data-solr。
15）spring-boot-starter-freemarker 支持FreeMarker模板引擎。
16）spring-boot-starter-groovy-templates 支持Groovy模板引擎。
17）spring-boot-starter-hateoas 通過spring-hateoas支持基于HATEOAS的RESTful Web服務。
18）spring-boot-starter-hornetq 通過HornetQ支持JMS。
19）spring-boot-starter-integration 支持通用的spring-integration模塊。
20）spring-boot-starter-jdbc 支持JDBC數據庫。
21）spring-boot-starter-jersey 支持Jersey RESTful Web服務框架。
22）spring-boot-starter-jta-atomikos 通過Atomikos支持JTA分布式事務處理。
23）spring-boot-starter-jta-bitronix 通過Bitronix支持JTA分布式事務處理。
24）spring-boot-starter-mail 支持javax.mail模塊。
25）spring-boot-starter-mobile 支持spring-mobile。
26）spring-boot-starter-mustache 支持Mustache模板引擎。
27）spring-boot-starter-Redis 支持Redis鍵值存儲數據庫，包括spring-redis。
28）spring-boot-starter-security 支持spring-security。
29）spring-boot-starter-social-facebook 支持spring-social-facebook
30）spring-boot-starter-social-linkedin 支持pring-social-linkedin
31）spring-boot-starter-social-twitter 支持pring-social-twitter
32）spring-boot-starter-test 支持常規的測試依賴，包括JUnit、Hamcrest、Mockito以及spring-test模塊。
33）spring-boot-starter-thymeleaf 支持Thymeleaf模板引擎，包括與Spring的集成。
34）spring-boot-starter-velocity 支持Velocity模板引擎。
35）spring-boot-starter-web S支持全棧式Web開發，包括Tomcat和spring-webmvc。
36）spring-boot-starter-websocket 支持WebSocket開發。
37）spring-boot-starter-ws 支持Spring Web Services。
Spring Boot應用啟動器面向生產環境的還有2種，具體如下：
38）spring-boot-starter-actuator 增加了面向產品上線相關的功能，比如測量和監控。
39）spring-boot-starter-remote-shell 增加了遠程ssh shell的支持。
最后，Spring Boot應用啟動器還有一些替換技術的啟動器，具體如下：
40）spring-boot-starter-jetty 引入了Jetty HTTP引擎（用于替換Tomcat）。
41）spring-boot-starter-log4j 支持Log4J日志框架。
42）spring-boot-starter-logging 引入了Spring Boot默認的日志框架Logback。
43）spring-boot-starter-tomcat 引入了Spring Boot默認的HTTP引擎Tomcat。
44）spring-boot-starter-undertow 引入了Undertow HTTP引擎（用于替換Tomcat）。
Spring Boot 支持哪些內嵌 Servlet
Spring支持的內嵌Servlet有3種：
- Tomcat (這個是默認的容器)
- Jetty
- Undertow
正是因為Spring boot內嵌了web容器，使得我們啟動web程序就像啟動普通Java程序的一樣方便，由于Spring boot默認使用的web容器是Tomcat ，如果我們想修改可以使用下面這種方式排除tomcat容器，再引入其他容器
<!--從Web啟動器依賴中排除Tomcat-->
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-web</artifactId>
<exclusions>
<exclusion>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-tomcat</artifactId>
</exclusion>
</exclusions>
</dependency>
<!--添加Jetty依賴-->
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-jetty</artifactId>
</dependency>詳解@SpringBootApplication 這個注解
這個注解我們完全可以通過源碼就知道它大概做的實際，如下所示，可以看到SpringBootApplication 主要是由SpringBootConfiguration、EnableAutoConfiguration、ComponentScan構成。這三個注解分別是意思是：
- SpringBootConfiguration內部有一個Configuration注解，所以它的意思是允許在上下文開啟額外bean或者其他配置類。
- EnableAutoConfiguration啟用Spring boot自動配置機制。
- ComponentScan自動掃描當前類的包下的所有被@Component (@Service,@Controller)注解的類。
@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 {
.....
}Spring是如何啟動的(重點)
總結一下大概有9個步驟:
- 創建監聽，并準備監聽。
- 容器環境預配置。
- 打印banner。
- 創建應用上下文即applicationContextFactory。
- 容器刷新前置處理:進行應用上下文各種配置初始化，拿到我們的啟動類元信息生成BeanDefinition存入beanDefinitionMap中。
- 容器刷新，即走到Spring的IOC邏輯，手機配置、注解中的bean信息存入beanDefinitionMap，然后進行bean的創建和注入。
- 容器刷新后置處理，默認為空。
- 發出容器刷新結束事件ApplicationReadyEvent通知。
- 調用callRunners獲取所有容器中的ApplicationRunner和CommandLineRunner的run方法并執行。
對應的我們給出源碼即SpringApplication下的run方法，讀者可參考上述流程閱讀一下下面這段源碼：
public ConfigurableApplicationContext run(String... args) {
//......
// 1. 獲取并啟動監聽
SpringApplicationRunListeners listeners = getRunListeners(args);
listeners.starting(bootstrapContext, this.mainApplicationClass);
try {
ApplicationArguments applicationArguments = new DefaultApplicationArguments(args);
//2. 項目環境environment 預配置
ConfigurableEnvironment environment = prepareEnvironment(listeners, bootstrapContext, applicationArguments);
configureIgnoreBeanInfo(environment);
//打印banner，此時控制臺會輸出一個banner
Banner printedBanner = printBanner(environment);
//3. 創建Sring容器
context = createApplicationContext();
context.setApplicationStartup(this.applicationStartup);
//4. 容器刷新前置處理，進行應用上下文各種配置信息初始化，并將當前啟動類存入beanDefinitionMap中
prepareContext(bootstrapContext, context, environment, listeners, applicationArguments, printedBanner);
//5.刷新容器，這里會進行IOC相關操作
refreshContext(context);
//6. 容器刷新后置操作，默認空實現
afterRefresh(context, applicationArguments);
Duration timeTakenToStartup = Duration.ofNanos(System.nanoTime() - startTime);
if (this.logStartupInfo) {
new StartupInfoLogger(this.mainApplicationClass).logStarted(getApplicationLog(), timeTakenToStartup);
}
// 7. 發出執行結束的ApplicationReadyEvent事件通知
listeners.started(context, timeTakenToStartup);
//8. 調用runner，完成啟動后的特定命令
callRunners(context, applicationArguments);
}
catch (Throwable ex) {
//......
}
//9. 返回上下文
return context;
}Spring Boot 的自動裝配是如何實現的
關于spring自動裝配的原理和使用，建議閱讀筆者這篇文章，里面有詳盡的分析和實踐：
為什么會有yml格式的文件，和properties區別是什么
相比于properties，yml格式的文件結構更加清晰，更易于閱讀和理解，但是缺點也很明顯，因為格式的嚴格要求，很可能因為格式原因導致配置無法讀取，以筆者為例，線上配置seata配置時明明注冊地址，但是服務始終讀取不到配置，導致啟動失敗，這種問題是肉眼無法觀察的：
而且yml還有一個缺點即@PropertySource 這個注解無法讀取yml格式的配置數據。
Spring Boot 常用的讀取配置文件的方法
通過 @value 讀取簡單直觀的配置：為了演示這種讀取方式，我們可以在resource目錄下建立一個 application.yml文件
配置文件內容為：
myConfig: 這個是helloworld配置的具體內容哦后續如果我們希望獲取到myConfig這個值的話，只需按照下面這種方式引入即可，注意value注解獲取配置值的方式，Spring并不推薦使用。
@Value("${myConfig}")
private String value;(1) 通過@ConfigurationProperties讀取并與 bean 綁定：
這種方式相較于上面那種更加強大，可以與bean綁定，例如我們yml的配置文件內容如下(注意配置名稱必須全小寫，否則會報一些奇怪的錯誤)
myobj:
name: out-side-config
email: out-side-config@qq.com那么我們就可以編寫一個類，代碼如下所示，使用ConfigurationProperties引入前綴為myobj的配置內容即可，該配置就會將myobj前綴下的所有配置和我們的類綁定
/**
* 注意 yml配置文件不能有大寫字母
*/
@ConfigurationProperties(prefix = "myobj")
public class MyObj {
private String name;
private String email;
//......get、set
}(2) @PropertySource讀取指定的 properties 文件
有時候我們希望指定配置文件和類進行綁定，那么我們就可以使用PropertySource注解，例如我們在resource目錄下有個student.properties文件，內容為：
name:xiaoming
no:18 我們只需使用PropertySource執行路徑以及配置文件名，再配合value即可完成屬性綁定。
@Component
@PropertySource("classpath:student.properties")
public class Student {
@Value("${name}")
private String name;
@Value("${no}")
private String no;
//......get、set
}
Spring Boot 加載配置文件的優先級
大體來說優先考慮外部、properties或者yml指明profile的文件：
- 命令行參數。所有的配置都可以在命令行上進行指定。
- 操作系統環境變量 。
- jar包外部的application-{profile}.properties或帶spring.profile的application.yml配置文件
- jar包內部的application-{profile}.properties或帶spring.profile的application.yml配置文件，再來加載不帶profile。
- jar包外部的application.properties或不帶spring.profile的application.yml配置文件
- jar包內部的application.properties或不帶spring.profile的application.yml配置文件
常用的 Bean 映射工具有哪些
常見的是:MapStruct、ModelMapper、Dozer、Orika、JMapper 這幾種吧。
最常用的還是MapStruct，它的工作原理也很簡單，我們聲明一個轉換接口后，它會在編譯期為了我們生成轉換實現類的字節碼文件。
對此我們不妨距離一下它的使用方式，首先引入版本號、依賴、插件。
- 版本號：
<properties>
<java.version>1.8</java.version>
<org.mapstruct.version>1.5.3.Final</org.mapstruct.version>
</properties>- 依賴：
<!--mapstruct依賴-->
<dependency>
<groupId>org.mapstruct</groupId>
<artifactId>mapstruct</artifactId>
<version>${org.mapstruct.version}</version>
</dependency>
<dependency>
<groupId>org.projectlombok</groupId>
<artifactId>lombok</artifactId>
<version>1.18.12</version>
</dependency>- 插件：
<plugin>
<groupId>org.apache.maven.plugins</groupId>
<artifactId>maven-compiler-plugin</artifactId>
<version>3.8.1</version>
<configuration>
<source>1.8</source>
<target>1.8</target>
<annotationProcessorPaths>
<path>
<groupId>org.mapstruct</groupId>
<artifactId>mapstruct-processor</artifactId>
<version>${org.mapstruct.version}</version>
</path>
</annotationProcessorPaths>
</configuration>
</plugin>例如我們現在有個Doctor 希望轉為DoctorDTO類，代碼如下所示：
public class Doctor {
private Integer id;
private String name;
private String srcAddr;
//......get、set
}
}DoctorDTO 類，可以看出地址的字段名為dstAddr，和上面的srcAddr有區別：
public class DoctorDTO {
private Integer id;
private String name;
private String dstAddr;
//......get、set
}所以我們編寫一個接口，如下所示，對于字段名不一樣的，我們使用Mapping手動配置映射關系：
import org.mapstruct.Mapper;
import org.mapstruct.Mapping;
import org.mapstruct.factory.Mappers;
@Mapper
public interface DoctorMapper {
DoctorMapper INSTANCE = Mappers.getMapper(DoctorMapper.class);
/**
* 會在編譯期生成
* @param doctor
* @return
*/
@Mapping(source = "srcAddr", target = "dstAddr")
DoctorDTO toDTO(Doctor doctor);
}測試代碼，可以看到bean轉換完成：
@Test
public void testToDTO() {
Integer doctorId = 15;
String doctorName = "xiaoming";
Doctor doctor = new Doctor();
doctor.setId(doctorId);
doctor.setName(doctorName);
doctor.setSrcAddr("中國北京");
DoctorDTO doctorDTO = DoctorMapper.INSTANCE.toDTO(doctor);
// 輸出結果 DoctorDTO{id=15, name='xiaoming', dstAddr='中國北京'}
System.out.println(doctorDTO);
assertEquals(doctorId, doctorDTO.getId());
assertEquals(doctorName, doctorDTO.getName());
}通過源碼我們可以看到這個接口的實現類會在編譯器生成：
Spring Boot 如何監控系統實際運行狀況
引入spring-boot-starter-actuator的依賴：
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-actuator</artifactId>
</dependency>然后鍵入下面的地址即可查看對應端點的信息：http://localhost:8080/actuator
Spring Boot 如何做請求參數校驗
有兩種校驗框架，一個是Hibernate Validator，還有一個是JSR(Java Specification Requests）校驗，后者比較常用，無需引入特殊的依賴。就例如我們現在有個Person類，希望名字不為空，性別是是數字最大值為2，而email必須為郵箱格式，那么我們就可以基于JSR的注解進行說明。
public class Person {
@NotNull(message = "姓名不可為空")
@Size(max = 10, message = "姓名長度不可超過10位")
private String name;
@Max(value = 2, message = "性別最大值只能為2")
private int sex;
@Email(message = "郵箱格式不正確")
private String email;
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getSex() {
return sex;
}
public void setSex(int sex) {
this.sex = sex;
}
public String getEmail() {
return email;
}
public void setEmail(String email) {
this.email = email;
}
@Override
public String toString() {
return "Person{" +
"name='" + name + '\'' +
", sex='" + sex + '\'' +
", email='" + email + '\'' +
'}';
}
}當他作為controller的requestBody的參數時，用法如下所示：
@PostMapping("/test/hello")
public void hello(@Valid Person person) {
logger.info("hello {}", person.getName());
}假如我們想校驗路徑參數時，我們只需在Controller上方加一個注解@Validated,然后對于路徑參數加入校驗注解Valid +校驗規則注解即可即可。
@GetMapping("/test/hello2/{id}")
public void hello2(@Valid @PathVariable("id") @Max(value = 5,message = "最大值為5") Integer id) {
logger.info("hello {}", id);
}補充一下常見的一些校驗注解:
1. @NotEmpty 被注釋的字符串的不能為 null 也不能為空
2. @NotBlank 被注釋的字符串非 null，并且必須包含一個非空白字符
3. @Null 被注釋的元素必須為 null
4. @NotNull 被注釋的元素必須不為 null
5. @AssertTrue 被注釋的元素必須為 true
6. @AssertFalse 被注釋的元素必須為 false
7. @Pattern(regex=,flag=)被注釋的元素必須符合指定的正則表達式
8. @Email 被注釋的元素必須是 Email 格式。
9. @Min(value)被注釋的元素必須是一個數字，其值必須大于等于指定的最小值
10. @Max(value)被注釋的元素必須是一個數字，其值必須小于等于指定的最大值
11. @DecimalMin(value)被注釋的元素必須是一個數字，其值必須大于等于指定的最小值
12. @DecimalMax(value) 被注釋的元素必須是一個數字，其值必須小于等于指定的最大值
13. @Size(max=, min=)被注釋的元素的大小必須在指定的范圍內
14. @Digits(integer, fraction)被注釋的元素必須是一個數字，其值必須在可接受的范圍內
15. @Past被注釋的元素必須是一個過去的日期
16. @Future 被注釋的元素必須是一個將來的日期如何使用 Spring Boot 進行全局異常處理
通過@ControllerAdvice將控制器聲明為增強器，然后通過ExceptionHandler 對自己自己的異常進行處理。 例如我們想處理所有控制器的BindException，代碼如下所示：
/**
* 統一異常處理、數據預處理等
*/
@ControllerAdvice
public class ControllerExceptionHandler {
private static final Logger LOG = LoggerFactory.getLogger(ControllerExceptionHandler.class);
/**
* 校驗異常統一處理
* @param e
* @return
*/
@ExceptionHandler(value = BindException.class)
@ResponseBody
public CommonResp validExceptionHandler(BindException e) {
CommonResp commonResp = new CommonResp();
LOG.warn("參數校驗失敗：{}", e.getBindingResult().getAllErrors().get(0).getDefaultMessage());
commonResp.setSuccess(false);
commonResp.setMessage(e.getBindingResult().getAllErrors().get(0).getDefaultMessage());
return commonResp;
}
}Spring Boot 中如何實現定時任務
首先在啟動類中添加@EnableScheduling注解，然后編寫一個定時任務bean，然后在定時任務的方法上添加@Scheduled注解：
@Component
@EnableAsync
//@EnableAsync 和 @Async 使定時任務并行執行
public class AsyncScheduledTasks {
private static final Logger log = LoggerFactory.getLogger(AsyncScheduledTasks.class);
private static final SimpleDateFormat dateFormat = new SimpleDateFormat("HH:mm:ss");
private List<Integer> index = Arrays.asList(6, 6, 2, 3);
int i = 0;
@Scheduled(fixedRate = 5000)
@Async
public void reportCurrentTimeWithFixedRate() {
log.info("Current Thread : {}", Thread.currentThread().getName());
if (i == 0) {
log.info("Start time is {}", dateFormat.format(new Date()));
}
if (i < 4) {
try {
TimeUnit.SECONDS.sleep(index.get(i));
log.info("Fixed Rate Task : The time is now {}", dateFormat.format(new Date()));
} catch (InterruptedException e) {
e.printStackTrace();
}
i++;
}
}
}
