1，SpringBoot簡介

SpringBoot 是由 Pivotal 團隊提供的全新框架，其設計目的是用來簡化Spring 應用的初始搭建以及開發(fā)過程。

使用了 Spring 框架后已經簡化了我們的開發(fā)。而 SpringBoot 又是對 Spring 開發(fā)進行簡化的，可想而知 SpringBoot 使用的簡單及廣泛性。既然 SpringBoot 是用來簡化 Spring 開發(fā)的，那我們就先回顧一下，以 SpringMVC 開發(fā)為例：

1. 創(chuàng)建工程，并在 pom.xml 配置文件中配置所依賴的坐標

2. 編寫 web3.0 的配置類

   作為 web 程序，web3.0 的配置類不能缺少，而這個配置類還是比較麻煩的，代碼如下

3. 編寫 SpringMVC 的配置類

? 做到這只是將工程的架子搭起來。要想被外界訪問，最起碼還需要提供一個 Controller 類，在該類中提供一個方法。

4. 編寫 Controller 類

1.1 SpringBoot快速入門

1.1.1 開發(fā)步驟

SpringBoot 開發(fā)起來特別簡單，分為如下幾步：

• 創(chuàng)建新模塊，選擇Spring初始化，并配置模塊相關基礎信息。
• 選擇當前模塊需要使用的技術集。
• 開發(fā)控制器類。
• 運行自動生成的Application類。

知道了 SpringBoot 的開發(fā)步驟后，接下來我們進行具體的操作。

1.1.1.1 創(chuàng)建新模塊

• 點擊 + 選擇 New Module 創(chuàng)建新模塊

• 選擇 Spring Initializr ，用來創(chuàng)建 SpringBoot 工程。

  以前我們選擇的是 Maven ，今天選擇 Spring Initializr 來快速構建 SpringBoot 工程。而在 Module SDK 這一項選擇我們安裝的 JDK 版本。
  

• 對 SpringBoot 工程進行相關的設置

  我們使用這種方式構建的 SpringBoot 工程其實也是 Maven 工程，而該方式只是一種快速構建的方式而已。

注意：打包方式這里需要設置為 Jar

• 選中 Web，然后勾選 Spring Web

  由于我們需要開發(fā)一個 web 程序，使用到了 SpringMVC 技術，所以按照下圖紅框進行勾選

• 下圖界面不需要任何修改，直接點擊 Finish 完成 SpringBoot 工程的構建。

經過以上步驟后就創(chuàng)建了如下結構的模塊，它會幫我們自動生成一個 Application 類，而該類一會再啟動服務器時會用到

注意：

1. 在創(chuàng)建好的工程中不需要創(chuàng)建配置類

2. 創(chuàng)建好的項目會自動生成其他的一些文件，而這些文件目前對我們來說沒有任何作用，所以可以將這些文件刪除。

   可以刪除的目錄和文件如下：

   • .mvn
   • .gitignore
   • HELP.md
   • mvnw
   • mvnw.cmd

1.1.1.2 創(chuàng)建 Controller

在 com.test.controller 包下創(chuàng)建 BookController ，代碼如下：

@RestController
@RequestMapping("/books")
public class BookController {

    @GetMapping("/{id}")
    public String getById(@PathVariable Integer id){
        System.out.println("id ==> "+id);
        return "hello , spring boot!";
    }
}

1.1.1.3 啟動服務器

運行 SpringBoot 工程不需要使用本地的 Tomcat 和 插件，只運行項目 com.test 包下的 Application 類，我們就可以在控制臺看出如下信息。

1.1.1.4 進行測試

使用 Postman 工具來測試我們的程序。

通過上面的入門案例我們可以看到使用 SpringBoot 進行開發(fā)，使整個開發(fā)變得很簡單，那它是如何做到的呢？

要研究這個問題，我們需要看看 Application 類和 pom.xml 都書寫了什么。先看看 Applicaion 類，該類內容如下：

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

這個類中的東西很簡單，就在類上添加了一個 @SpringBootApplication 注解，而在主方法中就一行代碼。我們在啟動服務器時就是執(zhí)行的該類中的主方法。

再看看 pom.xml 配置文件中的內容

<?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.test</groupId>
    <artifactId>springboot_01_quickstart</artifactId>
    <version>0.0.1-SNAPSHOT</version>

    <!--JDK 的版本-->
    <properties>
        <java.version>8</java.version>
    </properties>
    
    <dependencies>
        <!--該依賴就是我們在創(chuàng)建 SpringBoot 工程勾選的那個 Spring Web 產生的-->
        <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>

    <build>
        <plugins>
            <!--這個插件是在打包時需要的，而這里暫時還沒有用到-->
            <plugin>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-maven-plugin</artifactId>
            </plugin>
        </plugins>
    </build>
</project>

我們代碼之所以能簡化，就是因為指定的父工程和 Spring Web 依賴實現的。

1.1.2 對比

做完 SpringBoot 的入門案例后，接下來對比一下 Spring 程序和 SpringBoot 程序。如下圖

• 坐標

  Spring 程序中的坐標需要自己編寫，而且坐標非常多。

  SpringBoot 程序中的坐標是我們在創(chuàng)建工程時進行勾選自動生成的。

• web3.0配置類

  Spring 程序需要自己編寫這個配置類。這個配置類大家之前編寫過，肯定感覺很復雜。

  SpringBoot 程序不需要我們自己書寫。

• 配置類

  Spring/SpringMVC 程序的配置類需要自己書寫。而 SpringBoot 程序則不需要書寫。

注意：基于Idea的 Spring Initializr 快速構建 SpringBoot 工程時需要聯網。

1.1.3 官網構建工程

在入門案例中之所以能快速構建 SpringBoot 工程，是因為 Idea 使用了官網提供了快速構建 SpringBoot 工程的組件實現的。那如何在官網進行工程構建呢？通過如下步驟構建

1.1.3.1 進入SpringBoot官網

官網地址如下：

https://spring.io/projects/spring-boot

進入到 SpringBoot 官網后拖到最下方就可以看到如下內容

然后點擊 Spring Initializr 超鏈接就會跳轉到如下頁面

這個頁面內容是不是感覺很眼熟的，這和我們使用 Idea 快速構建 SpringBoot 工程的界面基本相同。在上面頁面輸入對應的信息。

1.1.3.2 選擇依賴

選擇 Spring Web 可以點擊上圖右上角的 ADD DEPENDENCIES... CTRL + B 按鈕，就會出現如下界面。

1.1.3.3 生成工程

以上步驟完成后就可以生成 SpringBoot 工程了。在頁面的最下方點擊 GENERATE CTRL + 回車 按鈕生成工程并下載到本地，如下圖所示

打開下載好的壓縮包可以看到工程結構和使用 Idea 生成的一模一樣，如下圖

而打開 pom.xml 文件，里面也包含了父工程和 Spring Web 的依賴。

通過上面官網的操作，我們知道 Idea 中快速構建 SpringBoot 工程其實就是使用的官網的快速構建組件，那以后即使沒有 Idea 也可以使用官網的方式構建 SpringBoot 工程。

1.1.4 SpringBoot工程快速啟動

1.1.4.1 問題導入

以后我們和前端開發(fā)人員協同開發(fā)，而前端開發(fā)人員需要測試前端程序就需要后端開啟服務器，這就受制于后端開發(fā)人員。為了擺脫這個受制，前端開發(fā)人員嘗試著在自己電腦上安裝 Tomcat 和 Idea ，在自己電腦上啟動后端程序，這顯然不現實。

我們后端可以將 SpringBoot 工程打成 jar 包，該 jar 包運行不依賴于 Tomcat 和 Idea 這些工具也可以正常運行，只是這個 jar 包在運行過程中連接和我們自己程序相同的 Mysql 數據庫即可。這樣就可以解決這個問題，如下圖

那現在問題是如何打包呢？

1.1.4.2 打包

由于我們在構建 SpringBoot 工程時已經在 pom.xml 中配置了如下插件

<plugin>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-maven-plugin</artifactId>
</plugin>

所以我們只需要使用 Maven 的 package 指令打包就會在 target 目錄下生成對應的 Jar 包。

注意：該插件必須配置，不然打好的 jar 包也是有問題的。

1.1.4.3 啟動

進入 jar 包所在位置，在 命令提示符 中輸入如下命令

java -jar springboot_01_quickstart-0.0.1-SNAPSHOT.jar

執(zhí)行上述命令就可以看到 SpringBoot 運行的日志信息

1.2 SpringBoot概述

SpringBoot 是由Pivotal團隊提供的全新框架，其設計目的是用來簡化Spring應用的初始搭建以及開發(fā)過程。

大家已經感受了 SpringBoot 程序，回過頭看看 SpringBoot 主要作用是什么，就是簡化 Spring 的搭建過程和開發(fā)過程。

原始 Spring 環(huán)境搭建和開發(fā)存在以下問題：

• 配置繁瑣
• 依賴設置繁瑣

SpringBoot 程序優(yōu)點恰巧就是針對 Spring 的缺點

• 自動配置。這個是用來解決 Spring 程序配置繁瑣的問題
• 起步依賴。這個是用來解決 Spring 程序依賴設置繁瑣的問題
• 輔助功能（內置服務器,…）。我們在啟動 SpringBoot 程序時既沒有使用本地的 tomcat 也沒有使用 tomcat 插件，而是使用 SpringBoot 內置的服務器。

接下來我們來說一下 SpringBoot 的起步依賴

1.2.1 起步依賴

我們使用 Spring Initializr 方式創(chuàng)建的 Maven 工程的的 pom.xml 配置文件中自動生成了很多包含 starter 的依賴，如下圖

這些依賴就是啟動依賴，接下來我們探究一下他是如何實現的。

1.2.1.1 探索父工程

從上面的文件中可以看到指定了一個父工程，我們進入到父工程，發(fā)現父工程中又指定了一個父工程，如下圖所示

再進入到該父工程中，在該工程中我們可以看到配置內容結構如下圖所示

上圖中的 properties 標簽中定義了各個技術軟件依賴的版本，避免了我們在使用不同軟件技術時考慮版本的兼容問題。在 properties 中我們找 servlet 和 mysql 的版本如下圖

dependencyManagement 標簽是進行依賴版本鎖定，但是并沒有導入對應的依賴；如果我們工程需要那個依賴只需要引入依賴的 groupid 和 artifactId 不需要定義 version。

而 build 標簽中也對插件的版本進行了鎖定，如下圖

看完了父工程中 pom.xml 的配置后不難理解我們工程的的依賴為什么都沒有配置 version。

1.2.1.2 探索依賴

在我們創(chuàng)建的工程中的 pom.xml 中配置了如下依賴

進入到該依賴，查看 pom.xml 的依賴會發(fā)現它引入了如下的依賴

里面的引入了 spring-web 和 spring-webmvc 的依賴，這就是為什么我們的工程中沒有依賴這兩個包還能正常使用 springMVC 中的注解的原因。

而依賴 spring-boot-starter-tomcat ，從名字基本能確認內部依賴了 tomcat，所以我們的工程才能正常啟動。

結論：以后需要使用技術，只需要引入該技術對應的起步依賴即可

1.2.1.3 小結

starter

• SpringBoot 中常見項目名稱，定義了當前項目使用的所有項目坐標，以達到減少依賴配置的目的。

parent

• 所有 SpringBoot 項目要繼承的項目，定義了若干個坐標版本號（依賴管理，而非依賴），以達到減少依賴沖突的目的。

• spring-boot-starter-parent（2.5.0）與 spring-boot-starter-parent（2.4.6）共計57處坐標版本不同。

實際開發(fā)

• 使用任意坐標時，僅書寫GAV中的G和A，V由SpringBoot提供

  G：groupid

  A：artifactId

  V：version

• 如發(fā)生坐標錯誤，再指定version（要小心版本沖突）

1.2.2 程序啟動

創(chuàng)建的每一個 SpringBoot 程序時都包含一個類似于下面的類，我們將這個類稱作引導類

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

注意：

• SpringBoot 在創(chuàng)建項目時，采用jar的打包方式

• SpringBoot 的引導類是項目的入口，運行 main 方法就可以啟動項目

  因為我們在 pom.xml 中配置了 spring-boot-starter-web 依賴，而該依賴通過前面的學習知道它依賴 tomcat ，所以運行 main 方法就可以使用 tomcat 啟動咱們的工程。

1.2.3 切換web服務器

現在我們啟動工程使用的是 tomcat 服務器，那能不能不使用 tomcat 而使用 jetty 服務器，jetty 在我們 maven 高級時講 maven 私服使用的服務器。而要切換 web 服務器就需要將默認的 tomcat 服務器給排除掉，怎么排除呢？使用 exclusion 標簽

<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-web</artifactId>
    <exclusions>
        <exclusion>
            <artifactId>spring-boot-starter-tomcat</artifactId>
            <groupId>org.springframework.boot</groupId>
        </exclusion>
    </exclusions>
</dependency>

現在我們運行引導類可以嗎？運行一下試試，打印的日志信息如下

程序直接停止了，為什么呢？那是因為排除了 tomcat 服務器，程序中就沒有服務器了。所以此時不光要排除 tomcat 服務器，還要引入 jetty 服務器。在 pom.xml 中因為 jetty 的起步依賴

<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-jetty</artifactId>
</dependency>

接下來再次運行引導類，在日志信息中就可以看到使用的是 jetty 服務器

小結：

通過切換服務器，我們不難發(fā)現在使用 SpringBoot 換技術時只需要導入該技術的起步依賴即可。

2，配置文件

2.1 配置文件格式

我們現在啟動服務器默認的端口號是 8080，訪問路徑可以書寫為

http://localhost:8080/books/1

在線上環(huán)境我們還是希望將端口號改為 80，這樣在訪問的時候就可以不寫端口號了，如下

http://localhost/books/1

而 SpringBoot 程序如何修改呢？SpringBoot 提供了多種屬性配置方式

• application.properties

  server.port=80
  

• application.yml

  server:
  	port: 81
  

• application.yaml

  server:
  	port: 82
  

注意：SpringBoot 程序的配置文件名必須是 application ，只是后綴名不同而已。

2.1.1 環(huán)境準備

在該工程中的 com.test.controller 包下創(chuàng)建一個名為 BookController 的控制器。內容如下：

@RestController
@RequestMapping("/books")
public class BookController {

    @GetMapping("/{id}")
    public String getById(@PathVariable Integer id){
        System.out.println("id ==> "+id);
        return "hello , spring boot!";
    }
}

2.1.2 不同配置文件演示

• application.properties配置文件

現在需要進行配置，配合文件必須放在 resources 目錄下，而該目錄下有一個名為 application.properties 的配置文件，我們就可以在該配置文件中修改端口號，在該配置文件中書寫 port ，Idea 就會提示，如下

application.properties 配置文件內容如下：

server.port=80

啟動服務，會在控制臺打印出日志信息，從日志信息中可以看到綁定的端口號已經修改了。

• application.yml配置文件

刪除 application.properties 配置文件中的內容。在 resources 下創(chuàng)建一個名為 application.yml 的配置文件，在該文件中書寫端口號的配置項，格式如下：

server:
	port: 81

注意： 在:后，數據前一定要加空格。

而在 yml 配置文件中也是有提示功能的，我們也可以在該文件中書寫 port ，然后 idea 就會提示并書寫成上面的格式。

啟動服務，可以在控制臺看到綁定的端口號是 81

• application.yaml配置文件

刪除 application.yml 配置文件和 application.properties 配置文件內容，然后在 resources 下創(chuàng)建名為 application.yaml 的配置文件，配置內容和后綴名為 yml 的配置文件中的內容相同，只是使用了不同的后綴名而已。

application.yaml 配置文件內容如下：

server:
	port: 83

啟動服務，在控制臺可以看到綁定的端口號。

注意：在配合文件中如果沒有提示，可以使用一下方式解決。

• 點擊 File 選中 Project Structure

• 彈出如下窗口，按圖中標記紅框進行選擇
  

• 通過上述操作，會彈出如下窗口

• 點擊上圖的 + 號，彈出選擇該模塊的配置文件

• 通過上述幾步后，就可以看到如下界面。properties 類型的配合文件有一個，ymal 類型的配置文件有兩個。

2.1.3 三種配合文件的優(yōu)先級

在三種配合文件中分別配置不同的端口號，啟動服務查看綁定的端口號。用這種方式就可以看到哪個配置文件的優(yōu)先級更高一些。

application.properties 文件內容如下：

server.port=80

application.yml 文件內容如下：

server:
	port: 81

application.yaml 文件內容如下：

server:
	port: 82

啟動服務，在控制臺可以看到使用的端口號是 80。說明 application.properties 的優(yōu)先級最高

注釋掉 application.properties 配置文件內容。再次啟動服務，在控制臺可以看到使用的端口號是 81，說明 application.yml 配置文件為第二優(yōu)先級。

從上述的驗證結果可以確定三種配置文件的優(yōu)先級是：

application.properties > application.yml > application.yaml

注意：

• SpringBoot 核心配置文件名為 application

• SpringBoot 內置屬性過多，且所有屬性集中在一起修改，在使用時，通過提示鍵+關鍵字修改屬性

  例如要設置日志的級別時，可以在配置文件中書寫 logging，就會提示出來。配置內容如下

  logging:
    level:
      root: info
  

2.2 yaml格式

上面講了三種不同類型的配置文件，而 properties 類型的配合文件之前我們學習過，接下來我們重點學習 yaml 類型的配置文件。

YAML（YAML Ain’t Markup Language），一種數據序列化格式。這種格式的配置文件在近些年已經占有主導地位，那么這種配置文件和前期使用的配置文件是有一些優(yōu)勢的，我們先看之前使用的配置文件。

最開始我們使用的是 xml ，格式如下：

<enterprise>
    <name>itcast</name>
    <age>16</age>
    <tel>4006184000</tel>
</enterprise>

而 properties 類型的配置文件如下

enterprise.name=itcast
enterprise.age=16
enterprise.tel=4006184000

yaml 類型的配置文件內容如下

enterprise:
	name: itcast
	age: 16
	tel: 4006184000

優(yōu)點：

• 容易閱讀

  yaml 類型的配置文件比 xml 類型的配置文件更容易閱讀，結構更加清晰。

• 容易與腳本語言交互。

• 以數據為核心，重數據輕格式。

  yaml 更注重數據，而 xml 更注重格式。

YAML 文件擴展名：

• .yml (主流)
• .yaml

上面兩種后綴名都可以，以后使用更多的還是 yml 的。

2.2.1 語法規(guī)則

• 大小寫敏感。

• 屬性層級關系使用多行描述，每行結尾使用冒號結束。

• 使用縮進表示層級關系，同層級左側對齊，只允許使用空格（不允許使用Tab鍵）。

  空格的個數并不重要，只要保證同層級的左側對齊即可。

• 屬性值前面添加空格（屬性名與屬性值之間使用冒號+空格作為分隔）。

• # 表示注釋。

核心規(guī)則：數據前面要加空格與冒號隔開。

數組數據在數據書寫位置的下方使用減號作為數據開始符號，每行書寫一個數據，減號與數據間空格分隔，例如

enterprise:
  name: itcast
  age: 16
  tel: 4006184000
  subject:
    - Java
    - 前端
    - 大數據

2.3 yaml配置文件數據讀取

2.3.1 環(huán)境準備

新創(chuàng)建一個名為 springboot_03_read_data 的 SpringBoot 工程，目錄結構如下

在 com.test.controller 包寫創(chuàng)建名為 BookController 的控制器，內容如下

@RestController
@RequestMapping("/books")
public class BookController {

    @GetMapping("/{id}")
    public String getById(@PathVariable Integer id){
        System.out.println("id ==> "+id);
        return "hello , spring boot!";
    }
}

在 com.test.domain 包下創(chuàng)建一個名為 Enterprise 的實體類等會用來封裝數據，內容如下

public class Enterprise {
    private String name;
    private int age;
    private String tel;
    private String[] subject;
    
    //setter and getter
    
    //toString
}

在 resources 下創(chuàng)建一個名為 application.yml 的配置文件，里面配置了不同的數據，內容如下

lesson: SpringBoot

server:
  port: 80

enterprise:
  name: itcast
  age: 16
  tel: 4006184000
  subject:
    - Java
    - 前端
    - 大數據

2.3.2 讀取配置數據

2.3.2.1 使用 @Value注解

使用 @Value("表達式") 注解可以從配合文件中讀取數據，注解中用于讀取屬性名引用方式是：${一級屬性名.二級屬性名……}

我們可以在 BookController 中使用 @Value 注解讀取配合文件數據，如下

@RestController
@RequestMapping("/books")
public class BookController {
    
    @Value("${lesson}")
    private String lesson;
    @Value("${server.port}")
    private Integer port;
    @Value("${enterprise.subject[0]}")
    private String subject_00;

    @GetMapping("/{id}")
    public String getById(@PathVariable Integer id){
        System.out.println(lesson);
        System.out.println(port);
        System.out.println(subject_00);
        return "hello , spring boot!";
    }
}

2.3.2.2 Environment對象

上面方式讀取到的數據特別零散，SpringBoot 還可以使用 @Autowired 注解注入 Environment 對象的方式讀取數據。這種方式 SpringBoot 會將配置文件中所有的數據封裝到 Environment 對象中，如果需要使用哪個數據只需要通過調用 Environment 對象的 getProperty(String name) 方法獲取。具體代碼如下：

@RestController
@RequestMapping("/books")
public class BookController {
    
    @Autowired
    private Environment env;
    
    @GetMapping("/{id}")
    public String getById(@PathVariable Integer id){
        System.out.println(env.getProperty("lesson"));
        System.out.println(env.getProperty("enterprise.name"));
        System.out.println(env.getProperty("enterprise.subject[0]"));
        return "hello , spring boot!";
    }
}

注意：這種方式，框架內容大量數據，而在開發(fā)中我們很少使用。

2.3.2.3 自定義對象

SpringBoot 還提供了將配置文件中的數據封裝到我們自定義的實體類對象中的方式。具體操作如下：

• 將實體類 bean 的創(chuàng)建交給 Spring 管理。

  在類上添加 @Component 注解。

• 使用 @ConfigurationProperties 注解表示加載配置文件。

  在該注解中也可以使用 prefix 屬性指定只加載指定前綴的數據。

• 在 BookController 中進行注入。

具體代碼如下：

Enterprise 實體類內容如下：

@Component
@ConfigurationProperties(prefix = "enterprise")
public class Enterprise {
    private String name;
    private int age;
    private String tel;
    private String[] subject;

   //get set toString 方法
}

BookController 內容如下：

@RestController
@RequestMapping("/books")
public class BookController {
    
    @Autowired
    private Enterprise enterprise;

    @GetMapping("/{id}")
    public String getById(@PathVariable Integer id){
        System.out.println(enterprise.getName());
        System.out.println(enterprise.getAge());
        System.out.println(enterprise.getSubject());
        System.out.println(enterprise.getTel());
        System.out.println(enterprise.getSubject()[0]);
        return "hello , spring boot!";
    }
}

注意：

使用第三種方式，在實體類上有如下警告提示。

這個警告提示解決是在 pom.xml 中添加如下依賴即可

<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-configuration-processor</artifactId>
    <optional>true</optional>
</dependency>

2.4 多環(huán)境配置

以后在工作中，對于開發(fā)環(huán)境、測試環(huán)境、生產環(huán)境的配置肯定都不相同，比如我們開發(fā)階段會在自己的電腦上安裝 mysql ，連接自己電腦上的 mysql 即可，但是項目開發(fā)完畢后要上線就需要該配置，將環(huán)境的配置改為線上環(huán)境的。

來回的修改配置會很麻煩，而 SpringBoot 給開發(fā)者提供了多環(huán)境的快捷配置，需要切換環(huán)境時只需要改一個配置即可。不同類型的配置文件多環(huán)境開發(fā)的配置都不相同，接下來對不同類型的配置文件進行說明。

2.4.1 yaml文件

在 application.yml 中使用 --- 來分割不同的配置，內容如下

#開發(fā)
spring:
  profiles: dev #給開發(fā)環(huán)境起的名字
server:
  port: 80
---
#生產
spring:
  profiles: pro #給生產環(huán)境起的名字
server:
  port: 81
---
#測試
spring:
  profiles: test #給測試環(huán)境起的名字
server:
  port: 82
---

上面配置中 spring.profiles 是用來給不同的配置起名字的。而如何告知 SpringBoot 使用哪段配置呢？可以使用如下配置來啟用都一段配置。

#設置啟用的環(huán)境
spring:
  profiles:
    active: dev  #表示使用的是開發(fā)環(huán)境的配置

綜上所述，application.yml 配置文件內容如下。

#設置啟用的環(huán)境
spring:
  profiles:
    active: dev

---
#開發(fā)
spring:
  profiles: dev
server:
  port: 80
---
#生產
spring:
  profiles: pro
server:
  port: 81
---
#測試
spring:
  profiles: test
server:
  port: 82
---

注意：

在上面配置中給不同配置起名字的 spring.profiles 配置項已經過時。最新用來起名字的配置項是 。

#開發(fā)
spring:
  config:
    activate:
      on-profile: dev

2.4.2 properties文件

properties 類型的配置文件配置多環(huán)境需要定義不同的配置文件。

• application-dev.properties 是開發(fā)環(huán)境的配置文件。我們在該文件中配置端口號為 80

  server.port=80
  

• application-test.properties 是測試環(huán)境的配置文件。我們在該文件中配置端口號為 81

  server.port=81
  

• application-pro.properties 是生產環(huán)境的配置文件。我們在該文件中配置端口號為 82

  server.port=82
  

SpringBoot 只會默認加載名為 application.properties 的配置文件，所以需要在 application.properties 配置文件中設置啟用哪個配置文件，配置如下:

spring.profiles.active=pro

2.4.3 命令行啟動參數設置

使用 SpringBoot 開發(fā)的程序以后都是打成 jar 包，通過 java -jar xxx.jar 的方式啟動服務的。那么就存在一個問題，如何切換環(huán)境呢？因為配置文件打到的jar包中了。

我們知道 jar 包其實就是一個壓縮包，可以解壓縮，然后修改配置，最后再打成jar包就可以了。這種方式顯然有點麻煩，而 SpringBoot 提供了在運行 jar 時設置開啟指定的環(huán)境的方式，如下

java –jar xxx.jar –-spring.profiles.active=test

那么這種方式能不能臨時修改端口號呢？也是可以的，可以通過如下方式

java –jar xxx.jar –-server.port=88

當然也可以同時設置多個配置，比如即指定啟用哪個環(huán)境配置，又臨時指定端口，如下

java –jar springboot.jar –-server.port=88 –-spring.profiles.active=test

大家進行測試后就會發(fā)現命令行設置的端口號優(yōu)先級高（也就是使用的是命令行設置的端口號），配置的優(yōu)先級其實 SpringBoot 官網已經進行了說明，參見 :

https://docs.spring.io/spring-boot/docs/current/reference/html/spring-boot-features.html#boot-features-external-config

進入上面網站后會看到如下頁面

如果使用了多種方式配合同一個配置項，優(yōu)先級高的生效。

2.5 配置文件分類

有這樣的場景，我們開發(fā)完畢后需要測試人員進行測試，由于測試環(huán)境和開發(fā)環(huán)境的很多配置都不相同，所以測試人員在運行我們的工程時需要臨時修改很多配置，如下

java –jar springboot.jar –-spring.profiles.active=test --server.port=85 --server.servlet.context-path=/heima --server.tomcat.connection-timeout=-1 …… …… …… …… ……

針對這種情況，SpringBoot 定義了配置文件不同的放置的位置；而放在不同位置的優(yōu)先級時不同的。

SpringBoot 中4級配置文件放置位置：

• 1級：classpath：application.yml
• 2級：classpath：config/application.yml
• 3級：file ：application.yml
• 4級：file ：config/application.yml

==說明：==級別越高優(yōu)先級越高

2.5.1 代碼演示

在這里我們只演示不同級別配置文件放置位置的優(yōu)先級。

2.5.1.1 環(huán)境準備

創(chuàng)建一個名為 springboot_06_config_file 的 SpringBoot 工程，目錄結構如下

在 resources 下創(chuàng)建一個名為 config 的目錄，在該目錄中創(chuàng)建 application.yml 配置文件，而在該配置文件中將端口號設置為 81，內容如下

server:
  port: 81

而在 resources 下創(chuàng)建的 application.yml 配置文件中并將端口號設置為 80，內容如下

server:
  port: 80

2.5.1.2 驗證1級和2級的優(yōu)先級

運行啟動引導類，可以在控制臺看到如下日志信息

通過這個結果可以得出類路徑下的 config 下的配置文件優(yōu)先于類路徑下的配置文件。

2.5.1.3 驗證2級和4級的優(yōu)先級

要驗證4級，按照以下步驟完成

• 將工程打成 jar 包

  點擊工程的 package 來打 jar 包

• 在硬盤上找到 jar 包所在位置

• 在 jar 包所在位置創(chuàng)建 config 文件夾，在該文件夾下創(chuàng)建 application.yml 配置文件，而在該配合文件中將端口號設置為 82

• 在命令行使用以下命令運行程序

  java -jar springboot_06_config_file-0.0.1-SNAPSHOT.jar
  

  運行后日志信息如下

  

  通過這個結果可以得出file： config 下的配置文件優(yōu)先于類路徑下的配置文件。

注意：

SpringBoot 2.5.0版本存在一個bug，我們在使用這個版本時，需要在 jar 所在位置的 config 目錄下創(chuàng)建一個任意名稱的文件夾

3，SpringBoot整合junit

回顧 Spring 整合 junit

@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration(classes = SpringConfig.class)
public class UserServiceTest {
    
    @Autowired
    private BookService bookService;
    
    @Test
    public void testSave(){
        bookService.save();
    }
}

使用 @RunWith 注解指定運行器，使用 @ContextConfiguration 注解來指定配置類或者配置文件。而 SpringBoot 整合 junit 特別簡單，分為以下三步完成

• 在測試類上添加 SpringBootTest 注解
• 使用 @Autowired 注入要測試的資源
• 定義測試方法進行測試

3.1 環(huán)境準備

創(chuàng)建一個名為 springboot_07_test 的 SpringBoot 工程，工程目錄結構如下

在 com.test.service 下創(chuàng)建 BookService 接口，內容如下

public interface BookService {
    public void save();
}

在 com.test.service.impl 包寫創(chuàng)建一個 BookServiceImpl 類，使其實現 BookService 接口，內容如下

@Service
public class BookServiceImpl implements BookService {
    @Override
    public void save() {
        System.out.println("book service is running ...");
    }
}

3.2 編寫測試類

在 test/java 下創(chuàng)建 com.test 包，在該包下創(chuàng)建測試類，將 BookService 注入到該測試類中

@SpringBootTest
class Springboot07TestApplicationTests {

    @Autowired
    private BookService bookService;

    @Test
    public void save() {
        bookService.save();
    }
}

==注意：==這里的引導類所在包必須是測試類所在包及其子包。

例如：

• 引導類所在包是 com.test
• 測試類所在包是 com.test

如果不滿足這個要求的話，就需要在使用 @SpringBootTest 注解時，使用 classes 屬性指定引導類的字節(jié)碼對象。如 @SpringBootTest(classes = Springboot07TestApplication.class)

4，SpringBoot整合mybatis

4.1 回顧Spring整合Mybatis

Spring 整合 Mybatis 需要定義很多配置類

• SpringConfig 配置類

  • 導入 JdbcConfig 配置類

  • 導入 MybatisConfig 配置類

    @Configuration
    @ComponentScan("com.test")
    @PropertySource("classpath:jdbc.properties")
    @Import({JdbcConfig.class,MyBatisConfig.class})
    public class SpringConfig {
    }
    
    

• JdbcConfig 配置類

  • 定義數據源（加載properties配置項：driver、url、username、password）

    public class JdbcConfig {
        @Value("${jdbc.driver}")
        private String driver;
        @Value("${jdbc.url}")
        private String url;
        @Value("${jdbc.username}")
        private String userName;
        @Value("${jdbc.password}")
        private String password;
    
        @Bean
        public DataSource getDataSource(){
            DruidDataSource ds = new DruidDataSource();
            ds.setDriverClassName(driver);
            ds.setUrl(url);
            ds.setUsername(userName);
            ds.setPassword(password);
            return ds;
        }
    }
    

• MybatisConfig 配置類

  • 定義 SqlSessionFactoryBean

  • 定義映射配置

    @Bean
    public MapperScannerConfigurer getMapperScannerConfigurer(){
        MapperScannerConfigurer msc = new MapperScannerConfigurer();
        msc.setBasePackage("com.test.dao");
        return msc;
    }
    
    @Bean
    public SqlSessionFactoryBean getSqlSessionFactoryBean(DataSource dataSource){
        SqlSessionFactoryBean ssfb = new SqlSessionFactoryBean();
        ssfb.setTypeAliasesPackage("com.test.domain");
        ssfb.setDataSource(dataSource);
        return ssfb;
    }
    
    

4.2 SpringBoot整合mybatis

4.2.1 創(chuàng)建模塊

• 創(chuàng)建新模塊，選擇 Spring Initializr，并配置模塊相關基礎信息
  

• 選擇當前模塊需要使用的技術集（MyBatis、MySQL）
  

4.2.2 定義實體類

在 com.test.domain 包下定義實體類 Book，內容如下

public class Book {
    private Integer id;
    private String name;
    private String type;
    private String description;
    
    //setter and  getter
    
    //toString
}

4.2.3 定義dao接口

在 com.test.dao 包下定義 BookDao 接口，內容如下

public interface BookDao {
    @Select("select * from tbl_book where id = #{id}")
    public Book getById(Integer id);
}

4.2.4 定義測試類

在 test/java 下定義包 com.test ，在該包下測試類，內容如下

@SpringBootTest
class Springboot08MybatisApplicationTests {

	@Autowired
	private BookDao bookDao;

	@Test
	void testGetById() {
		Book book = bookDao.getById(1);
		System.out.println(book);
	}
}

4.2.5 編寫配置

我們代碼中并沒有指定連接哪兒個數據庫，用戶名是什么，密碼是什么。所以這部分需要在 SpringBoot 的配置文件中進行配合。

在 application.yml 配置文件中配置如下內容

spring:
  datasource:
    driver-class-name: com.mysql.jdbc.Driver
    url: jdbc:mysql://localhost:3306/ssm_db
    username: root
    password: root

4.2.6 測試

運行測試方法，我們會看到如下錯誤信息

錯誤信息顯示在 Spring 容器中沒有 BookDao 類型的 bean。為什么會出現這種情況呢？

原因是 Mybatis 會掃描接口并創(chuàng)建接口的代碼對象交給 Spring 管理，但是現在并沒有告訴 Mybatis 哪個是 dao 接口。而我們要解決這個問題需要在BookDao 接口上使用 @Mapper ，BookDao 接口改進為

@Mapper
public interface BookDao {
    @Select("select * from tbl_book where id = #{id}")
    public Book getById(Integer id);
}

注意：

SpringBoot 版本低于2.4.3(不含)，Mysql驅動版本大于8.0時，需要在url連接串中配置時區(qū) jdbc:mysql://localhost:3306/ssm_db?serverTimezone=UTC，或在MySQL數據庫端配置時區(qū)解決此問題

4.2.7 使用Druid數據源

現在我們并沒有指定數據源，SpringBoot 有默認的數據源，我們也可以指定使用 Druid 數據源，按照以下步驟實現

• 導入 Druid 依賴

  <dependency>
      <groupId>com.alibaba</groupId>
      <artifactId>druid</artifactId>
      <version>1.1.16</version>
  </dependency>
  

• 在 application.yml 配置文件配置

  可以通過 spring.datasource.type 來配置使用什么數據源。配置文件內容可以改進為

  spring:
    datasource:
      driver-class-name: com.mysql.cj.jdbc.Driver
      url: jdbc:mysql://localhost:3306/ssm_db?serverTimezone=UTC
      username: root
      password: root
      type: com.alibaba.druid.pool.DruidDataSource
  

后記
????????美好的一天，到此結束，下次繼續(xù)努力！欲知后續(xù)，請看下回分解，寫作不易，感謝大家的支持??！ ??????文章來源地址http://www.zghlxwxcb.cn/news/detail-833911.html

到了這里，關于快速上手Spring Boot整合，開發(fā)出優(yōu)雅可靠的Web應用！的文章就介紹完了。如果您還想了解更多內容，請在右上角搜索TOY模板網以前的文章或繼續(xù)瀏覽下面的相關文章，希望大家以后多多支持TOY模板網！