六、快速啟動框架：SpringBoot3實戰

一、SpringBoot3介紹

1.1 SpringBoot3簡介

課程使用SpringBoot版本：3.0.5

https://docs.spring.io/spring-boot/docs/current/reference/html/getting-started.html#getting-started.introducing-spring-boot

到目前為止，你已經學習了多種配置Spring程序的方式。但是無論使用XML、注解、Java配置類還是他們的混合用法，你都會覺得配置文件過于復雜和繁瑣，讓人頭疼！

SpringBoot 幫我們簡單、快速地創建一個獨立的、生產級別的 Spring 應用（說明：SpringBoot底層是Spring），大多數 SpringBoot 應用只需要編寫少量配置即可快速整合 Spring 平臺以及第三方技術！

SpringBoot的主要目標是：

• 為所有 Spring 開發提供更快速、可廣泛訪問的入門體驗。
• 開箱即用，設置合理的默認值，但是也可以根據需求進行適當的調整。
• 提供一系列大型項目通用的非功能性程序（如嵌入式服務器、安全性、指標、運行檢查等）。
• 約定大于配置，基本不需要主動編寫配置類、也不需要 XML 配置文件。

總結：簡化開發，簡化配置，簡化整合，簡化部署，簡化監控，簡化運維。

1.2 系統要求

技術&工具	版本（or later）
maven	3.6.3 or later 3.6.3 或更高版本
Tomcat	10.0+
Servlet	9.0+
JDK	17+

1.3 快速入門

場景：瀏覽器發送 /hello請求，返回"Hello,Spring Boot 3!"

1. 開發步驟

   1. 創建Maven工程
   2. 添加依賴(springboot父工程依賴 , web啟動器依賴)
   3. 編寫啟動引導類(springboot項目運行的入口)
   4. 編寫處理器Controller
   5. 啟動項目

2. 創建項目

   

3. 添加依賴

   3.1 添加父工程坐標

   SpringBoot可以幫我們方便的管理項目依賴 , 在Spring Boot提供了一個名為spring-boot-starter-parent的工程，里面已經對各種常用依賴的版本進行了管理，我們的項目需要以這個項目為父工程，這樣我們就不用操心依賴的版本問題了，需要什么依賴，直接引入坐標(不需要添加版本)即可！

   <!--所有springboot項目都必須繼承自 spring-boot-starter-parent-->
   <parent><groupId>org.springframework.boot</groupId><artifactId>spring-boot-starter-parent</artifactId><version>3.0.5</version>
   </parent>
   

   3.2 添加web啟動器

   為了讓Spring Boot幫我們完成各種自動配置，我們必須引入Spring Boot提供的自動配置依賴，我們稱為啟動器。因為我們是web項目，這里我們引入web啟動器，在 pom.xml 文件中加入如下依賴：

   <dependencies>
   <!--web開發的場景啟動器--><dependency><groupId>org.springframework.boot</groupId><artifactId>spring-boot-starter-web</artifactId></dependency>
   </dependencies>
   

4. 創建啟動類

   創建package：com.atguigu

   創建啟動類：MainApplication

   package com.atguigu;import org.springframework.boot.SpringApplication;
   import org.springframework.boot.autoconfigure.SpringBootApplication;/*** @SpringBootApplication是一個特殊的注解，用于標識一個Spring Boot應用程序的入口類。它的主要作用是將三個常用注解組合在一起，簡化了配置的過程。** 具體而言，@SpringBootApplication注解包含以下三個注解的功能：*     @Configuration：將該類標識為應用程序的配置類。它允許使用Java代碼定義和配置Bean。*     @EnableAutoConfiguration：啟用Spring Boot的自動配置機制。它根據項目的依賴項自動配置Spring應用程序的行為。自動配置根據類路徑、注解和配置屬性等條件來決定要使用的功能和配置。*     @ComponentScan：自動掃描并加載應用程序中的組件，如控制器、服務、存儲庫等。它默認掃描@SpringBootApplication注解所在類的包及其子包中的組件。** 使用@SpringBootApplication注解，可以將上述三個注解的功能集中在一個注解上，簡化了配置文件的編寫和組件的加載和掃描過程。它是Spring Boot應用程序的入口點，標識了應用程序的主類，* 并告訴Spring Boot在啟動時應如何配置和加載應用程序。*/
   @SpringBootApplication
   public class MainApplication {//SpringApplication.run() 方法是啟動 Spring Boot 應用程序的關鍵步驟。它創建應用程序上下文、// 自動配置應用程序、啟動應用程序，并處理命令行參數，使應用程序能夠運行和提供所需的功能public static void main(String[] args) {SpringApplication.run(MainApplication.class,args);}
   }
   

5. 編寫處理器Controller

   創建package：com.atguigu.controller

   創建類：HelloController

   注意： IoC和DI注解需要在啟動類的同包或者子包下方可生效！無需指定，約束俗稱。

   package com.atguigu.controller;import org.springframework.web.bind.annotation.GetMapping;
   import org.springframework.web.bind.annotation.RestController;@RestController
   public class HelloController {@GetMapping("/hello")public String hello(){return "Hello,Spring Boot 3!";}}
   

6. 啟動測試

   

1.4 入門總結

1. 為什么依賴不需要寫版本？

   • 每個boot項目都有一個父項目spring-boot-starter-parent
   • parent的父項目是spring-boot-dependencies
   • 父項目 版本仲裁中心，把所有常見的jar的依賴版本都聲明好了。
   • 比如：mysql-connector-j

2. 啟動器(Starter)是何方神圣？

   Spring Boot提供了一種叫做Starter的概念，它是一組預定義的依賴項集合，旨在簡化Spring應用程序的配置和構建過程。Starter包含了一組相關的依賴項，以便在啟動應用程序時自動引入所需的庫、配置和功能。

   主要作用如下：

   1. 簡化依賴管理：Spring Boot Starter通過捆綁和管理一組相關的依賴項，減少了手動解析和配置依賴項的工作。只需引入一個相關的Starter依賴，即可獲取應用程序所需的全部依賴。
   2. 自動配置：Spring Boot Starter在應用程序啟動時自動配置所需的組件和功能。通過根據類路徑和其他設置的自動檢測，Starter可以自動配置Spring Bean、數據源、消息傳遞等常見組件，從而使應用程序的配置變得簡單和維護成本降低。
   3. 提供約定優于配置：Spring Boot Starter遵循“約定優于配置”的原則，通過提供一組默認設置和約定，減少了手動配置的需要。它定義了標準的配置文件命名約定、默認屬性值、日志配置等，使得開發者可以更專注于業務邏輯而不是繁瑣的配置細節。
   4. 快速啟動和開發應用程序：Spring Boot Starter使得從零開始構建一個完整的Spring Boot應用程序變得容易。它提供了主要領域（如Web開發、數據訪問、安全性、消息傳遞等）的Starter，幫助開發者快速搭建一個具備特定功能的應用程序原型。
   5. 模塊化和可擴展性：Spring Boot Starter的組織結構使得應用程序的不同模塊可以進行分離和解耦。每個模塊可以有自己的Starter和依賴項，使得應用程序的不同部分可以按需進行開發和擴展。
      
      Spring Boot提供了許多預定義的Starter，例如spring-boot-starter-web用于構建Web應用程序，spring-boot-starter-data-jpa用于使用JPA進行數據庫訪問，spring-boot-starter-security用于安全認證和授權等等。

   使用Starter非常簡單，只需要在項目的構建文件（例如Maven的pom.xml）中添加所需的Starter依賴，Spring Boot會自動處理依賴管理和配置。

   通過使用Starter，開發人員可以方便地引入和配置應用程序所需的功能，避免了手動添加大量的依賴項和編寫冗長的配置文件的繁瑣過程。同時，Starter也提供了一致的依賴項版本管理，確保依賴項之間的兼容性和穩定性。

   spring boot提供的全部啟動器地址：

   https://docs.spring.io/spring-boot/docs/current/reference/html/using.html#using.build-systems.starters

   命名規范：

   • 官方提供的場景：命名為：spring-boot-starter-*
   • 第三方提供場景：命名為：*-spring-boot-starter

3. @SpringBootApplication注解的功效？

   @SpringBootApplication添加到啟動類上，是一個組合注解，他的功效有具體的子注解實現！

   @SpringBootConfiguration
   @EnableAutoConfiguration
   @ComponentScan
   public @interface SpringBootApplication {}

   @SpringBootApplication注解是Spring Boot框架中的核心注解，它的主要作用是簡化和加速Spring Boot應用程序的配置和啟動過程。

   具體而言，@SpringBootApplication注解起到以下幾個主要作用：

   1. 自動配置：@SpringBootApplication注解包含了@EnableAutoConfiguration注解，用于啟用Spring Boot的自動配置機制。自動配置會根據應用程序的依賴項和類路徑，自動配置各種常見的Spring配置和功能，減少開發者的手動配置工作。它通過智能地分析類路徑、加載配置和條件判斷，為應用程序提供適當的默認配置。
   2. 組件掃描：@SpringBootApplication注解包含了@ComponentScan注解，用于自動掃描并加載應用程序中的組件，例如控制器（Controllers）、服務（Services）、存儲庫（Repositories）等。它默認會掃描@SpringBootApplication注解所在類的包及其子包中的組件，并將它們納入Spring Boot應用程序的上下文中，使它們可被自動注入和使用。
   3. 聲明配置類：@SpringBootApplication注解本身就是一個組合注解，它包含了@Configuration注解，將被標注的類聲明為配置類。配置類可以包含Spring框架相關的配置、Bean定義，以及其他的自定義配置。通過@SpringBootApplication注解，開發者可以將配置類與啟動類合并在一起，使得配置和啟動可以同時發生。
      總的來說，@SpringBootApplication注解的主要作用是簡化Spring Boot應用程序的配置和啟動過程。它自動配置應用程序、掃描并加載組件，并將配置和啟動類合二為一，簡化了開發者的工作量，提高了開發效率。

回顧復習

指明一下，視頻中是創建空的工程，然后創建子模塊

創建springboot-base-quick-01子模塊

導入依賴

<parent><!-- spring-boot--><groupId>org.springframework.boot</groupId><artifactId>spring-boot-starter-parent</artifactId><version>3.0.5</version></parent>

 <!-- 導入對應的啟動器即可--><dependencies><!-- starter -> [ spring-webmvc servlet jackson ] --><dependency><groupId>org.springframework.boot</groupId><artifactId>spring-boot-starter-web</artifactId>//這里不用寫版本，因為上面springboot已經自帶聲明版本了</dependency></dependencies>

在Main類作為啟動類，添加注解和Main.class

//1.配置類 @SpringBootConfiguration
//2.自動加載配置 @EnableAutoConfiguration 自動加載其他的配置類
//3.@ComponentScan 默認是當前類所在的包,子包的注解
@SpringBootApplication  //啟動類
public class Main {public static void main(String[] args) {// 1.創建ioc容器,加載配置  2.啟動內置的web服務器SpringApplication.run(Main.class,args); //自動創建ioc容器,啟動tomcat服務器軟件}

在同Main類同包下創建controller包以及相應的類

package com.atguigu.controller;import org.springframework.beans.factory.annotation.Value;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;/*** projectName: com.atguigu.controller** @author: 趙偉風* description:*/@RestController
@RequestMapping("hello")
public class HelloController {@Value("${zwf.name}")private String name;@GetMapping("boot")public String hello(){System.out.println(name);return "hello springboot3!!";}
}

編寫配置類

resources下的application.properties類

# ??springboot?????,??????? key????!
server.port=80
server.servlet.context-path=/ergouzi
#指明端口，指明訪問路徑# ?????
zwf.name=???
zwf.age=18

到controller層的類HelloController類中去讀值

 @Value("${zwf.name}")private String name;@GetMapping("boot")public String hello(){System.out.println(name);return "hello springboot3!!";}

二、SpringBoot3配置文件

2.1 統一配置管理概述

SpringBoot工程下，進行統一的配置管理，你想設置的任何參數（端口號、項目根路徑、數據庫連接信息等等)都集中到一個固定位置和命名的配置文件（application.properties或application.yml）中！

配置文件應該放置在Spring Boot工程的src/main/resources目錄下。這是因為src/main/resources目錄是Spring Boot默認的類路徑（classpath），配置文件會被自動加載并可供應用程序訪問。

功能配置參數說明：

https://docs.spring.io/spring-boot/docs/current/reference/html/application-properties.html#appendix.application-properties

細節總結：

• 集中式管理配置。統一在一個文件完成程序功能參數設置和自定義參數聲明 。

• 位置：resources文件夾下，必須命名application 后綴 .properties / .yaml / .yml 。

• 如果同時存在application.properties | application.yml(.yaml) , properties的優先級更高。

• 配置基本都有默認值。

  

2.2 屬性配置文件使用

1. 配置文件

   在 resource 文件夾下面新建 application.properties 配置文件

   # application.properties 為統一配置文件
   # 內部包含: 固定功能的key,自定義的key
   # 此處的配置信息,我們都可以在程序中@Value等注解讀取# 固定的key
   # 啟動端口號
   server.port=80 # 自定義
   spring.jdbc.datasource.driverClassName=com.mysql.cj.jdbc.driver
   spring.jdbc.datasource.url=jdbc:mysql:///springboot_01
   spring.jdbc.datasource.username=root
   spring.jdbc.datasource.password=root
   

2. 讀取配置文件

   package com.atguigu.properties;import org.springframework.beans.factory.annotation.Value;
   import org.springframework.stereotype.Component;@Component
   public class DataSourceProperties {@Value("${spring.jdbc.datasource.driverClassName}")private String driverClassName;@Value("${spring.jdbc.datasource.url}")private String url;@Value("${spring.jdbc.datasource.username}")private String username;@Value("${spring.jdbc.datasource.password}")private String password;// 生成get set 和 toString方法public String getDriverClassName() {return driverClassName;}public void setDriverClassName(String driverClassName) {this.driverClassName = driverClassName;}public String getUrl() {return url;}public void setUrl(String url) {this.url = url;}public String getUsername() {return username;}public void setUsername(String username) {this.username = username;}public String getPassword() {return password;}public void setPassword(String password) {this.password = password;}@Overridepublic String toString() {return "DataSourceProperties{" +"driverClassName='" + driverClassName + '\'' +", url='" + url + '\'' +", username='" + username + '\'' +", password='" + password + '\'' +'}';}
   }
   

3. 測試效果

   在controller注入，輸出進行測試

   @Autowired
   private DataSourceProperties dataSourceProperties ;@RequestMapping(path = "/hello")
   public String sayHello() {System.out.println(dataSourceProperties);return "Hello Spring Boot ! " ;
   }
   

   瀏覽器訪問路徑，控制臺查看效果

   

2.3 YAML配置文件使用

1. yaml格式介紹

   YAML（YAML Ain’t Markup Language）是一種基于層次結構的數據序列化格式，旨在提供一種易讀、人類友好的數據表示方式。

   與.properties文件相比，YAML格式有以下優勢：

   1. 層次結構：YAML文件使用縮進和冒號來表示層次結構，使得數據之間的關系更加清晰和直觀。這樣可以更容易理解和維護復雜的配置，特別適用于深層次嵌套的配置情況。
   2. 自我描述性：YAML文件具有自我描述性，字段和值之間使用冒號分隔，并使用縮進表示層級關系。這使得配置文件更易于閱讀和理解，并且可以減少冗余的標點符號和引號。
   3. 注釋支持：YAML格式支持注釋，可以在配置文件中添加說明性的注釋，使配置更具可讀性和可維護性。相比之下，.properties文件不支持注釋，無法提供類似的解釋和說明。
   4. 多行文本：YAML格式支持多行文本的表示，可以更方便地表示長文本或數據塊。相比之下，.properties文件需要使用轉義符或將長文本拆分為多行。
   5. 類型支持：YAML格式天然支持復雜的數據類型，如列表、映射等。這使得在配置文件中表示嵌套結構或數據集合更加容易，而不需要進行額外的解析或轉換。
   6. 更好的可讀性：由于YAML格式的特點，它更容易被人類讀懂和解釋。它減少了配置文件中需要的特殊字符和語法，讓配置更加清晰明了，從而減少了錯誤和歧義。
      綜上所述，YAML格式相對于.properties文件具有更好的層次結構表示、自我描述性、注釋支持、多行文本表示、復雜數據類型支持和更好的可讀性。這些特點使YAML成為一種有力的配置文件格式，尤其適用于復雜的配置需求和人類可讀的場景。然而，選擇使用YAML還是.properties取決于實際需求和團隊的偏好，簡單的配置可以使用.properties，而復雜的配置可以選擇YAML以獲得更多的靈活性和可讀性

2. yaml語法說明

   1. 數據結構用樹形結構呈現，通過縮進來表示層級，
   2. 連續的項目（集合）通過減號 ” - ” 來表示
   3. 鍵值結構里面的key/value對用冒號 ” : ” 來分隔。
   4. YAML配置文件的擴展名是yaml 或 yml
   5. 例如：

      # YAML配置文件示例
      app_name: 我的應用程序
      version: 1.0.0
      author: 張三database:host: localhostport: 5432username: adminpassword: password123features:- 登錄- 注冊- 儀表盤settings:analytics: truetheme: dark
      

3. 配置文件

   spring:jdbc:datasource:driverClassName: com.mysql.jdbc.Driverurl: jdbc:mysql:///springboot_02username: rootpassword: rootserver:port: 80
   

4. 讀取配置文件

   讀取方式和properties一致

   package com.atguigu.properties;import org.springframework.beans.factory.annotation.Value;
   import org.springframework.stereotype.Component;@Component
   public class DataSourceProperties {@Value("${spring.jdbc.datasource.driverClassName}")private String driverClassName;@Value("${spring.jdbc.datasource.url}")private String url;@Value("${spring.jdbc.datasource.username}")private String username;@Value("${spring.jdbc.datasource.password}")private String password;// 生成get set 和 toString方法public String getDriverClassName() {return driverClassName;}public void setDriverClassName(String driverClassName) {this.driverClassName = driverClassName;}public String getUrl() {return url;}public void setUrl(String url) {this.url = url;}public String getUsername() {return username;}public void setUsername(String username) {this.username = username;}public String getPassword() {return password;}public void setPassword(String password) {this.password = password;}@Overridepublic String toString() {return "DataSourceProperties{" +"driverClassName='" + driverClassName + '\'' +", url='" + url + '\'' +", username='" + username + '\'' +", password='" + password + '\'' +'}';}
   }
   

5. 測試效果

   在controller注入，輸出進行測試

   @Autowired
   private DataSourceProperties dataSourceProperties ;@RequestMapping(path = "/hello")
   public String sayHello() {System.out.println(dataSourceProperties);return "Hello Spring Boot ! " ;
   }
   

   瀏覽器訪問路徑，控制臺查看效果

   

2.4 批量配置文件注入

@ConfigurationProperties是SpringBoot提供的重要注解, 他可以將一些配置屬性批量注入到bean對象。

1. 創建類，添加屬性和注解

   在類上通過@ConfigurationProperties注解聲明該類要讀取屬性配置

   prefix=“spring.jdbc.datasource” 讀取屬性文件中前綴為spring.jdbc.datasource的值。前綴和屬性名稱和配置文件中的key必須要保持一致才可以注入成功

   package com.atguigu.properties;import org.springframework.boot.context.properties.ConfigurationProperties;
   import org.springframework.stereotype.Component;@Component
   @ConfigurationProperties(prefix = "spring.jdbc.datasource")
   public class DataSourceConfigurationProperties {private String driverClassName;private String url;private String username;private String password;public String getDriverClassName() {return driverClassName;}public void setDriverClassName(String driverClassName) {this.driverClassName = driverClassName;}public String getUrl() {return url;}public void setUrl(String url) {this.url = url;}public String getUsername() {return username;}public void setUsername(String username) {this.username = username;}public String getPassword() {return password;}public void setPassword(String password) {this.password = password;}@Overridepublic String toString() {return "DataSourceConfigurationProperties{" +"driverClassName='" + driverClassName + '\'' +", url='" + url + '\'' +", username='" + username + '\'' +", password='" + password + '\'' +'}';}
   }
   

2. 測試效果

   @RestController
   public class HelloController {@Autowiredprivate DataSourceProperties dataSourceProperties;@Autowiredprivate DataSourceConfigurationProperties dataSourceConfigurationProperties;@GetMapping("/hello")public String hello(){System.out.println("dataSourceProperties = " + dataSourceProperties);System.out.println("dataSourceConfigurationProperties = " + dataSourceConfigurationProperties);return "Hello,Spring Boot 3!";}
   }
   

   瀏覽器訪問路徑，控制臺查看效果

   

2.5 多環境配置和使用

1. 需求

   在Spring Boot中，可以使用多環境配置來根據不同的運行環境（如開發、測試、生產）加載不同的配置。SpringBoot支持多環境配置讓應用程序在不同的環境中使用不同的配置參數，例如數據庫連接信息、日志級別、緩存配置等。

   以下是實現Spring Boot多環境配置的常見方法：

   1. 屬性文件分離：將應用程序的配置參數分離到不同的屬性文件中，每個環境對應一個屬性文件。例如，可以創建application-dev.properties、application-prod.properties和application-test.properties等文件。在這些文件中，可以定義各自環境的配置參數，如數據庫連接信息、端口號等。然后，在application.properties中通過spring.profiles.active屬性指定當前使用的環境。Spring Boot會根據該屬性來加載對應環境的屬性文件，覆蓋默認的配置。
   2. YAML配置文件：與屬性文件類似，可以將配置參數分離到不同的YAML文件中，每個環境對應一個文件。例如，可以創建application-dev.yml、application-prod.yml和application-test.yml等文件。在這些文件中，可以使用YAML語法定義各自環境的配置參數。同樣，通過spring.profiles.active屬性指定當前的環境，Spring Boot會加載相應的YAML文件。
   3. 命令行參數(動態)：可以通過命令行參數來指定當前的環境。例如，可以使用--spring.profiles.active=dev來指定使用開發環境的配置。
      通過上述方法，Spring Boot會根據當前指定的環境來加載相應的配置文件或參數，從而實現多環境配置。這樣可以簡化在不同環境之間的配置切換，并且確保應用程序在不同環境中具有正確的配置。

2. 多環境配置（基于方式b實踐）

   創建開發、測試、生產三個環境的配置文件
   application-dev.yml（開發）

   spring:jdbc:datasource:driverClassName: com.mysql.cj.jdbc.Driverurl: jdbc:mysql:///devusername: rootpassword: root
   

   application-test.yml（測試）

   spring:jdbc:datasource:driverClassName: com.mysql.cj.jdbc.Driverurl: jdbc:mysql:///testusername: rootpassword: root
   

   application-prod.yml（生產）

   spring:jdbc:datasource:driverClassName: com.mysql.cj.jdbc.Driverurl: jdbc:mysql:///produsername: rootpassword: root
   

3. 環境激活

   spring:profiles:active: dev
   

4. 測試效果

   

   注意 :

   如果設置了spring.profiles.active，并且和application有重疊屬性，以active設置優先。

   如果設置了spring.profiles.active，和application無重疊屬性，application設置依然生效！

回顧復習

創建新模塊，springboot-base-application-02(注意如果自己沒有創建父工程那就相當于新的項目，重新設置一下，組件名稱)

配置依賴，使其成為boot工程

<parent><!-- spring-boot--><groupId>org.springframework.boot</groupId><artifactId>spring-boot-starter-parent</artifactId><version>3.0.5</version></parent>

導入web依賴

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

將Main 作為啟動類

package com.atguigu;import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;@SpringBootApplication  //自己是一個配置類,自動加載其他啟動器配置類(ioc),掃描當前啟動類所在的包和子包的ioc和di注解
public class Main {public static void main(String[] args) {SpringApplication.run(Main.class,args);}
}

配置文件編寫方式1：properties

application.properties

# web ????????? ?????
# properties
# key = value# application???? - springboot - ?????????????? - ??key????
# key???? server.port server.servlet.context-path ????
server.port=80
server.servlet.context-path=/bootzwf.info.age=18
zwf.info.name=???
zwf.root.username=root
zwf.root.password=123456

方式2：.yml或.yaml都可以

application.yml

# server.port=80
# server.servlet.context-path=/boot# yaml有層次,可以繼承的配置文件格式
# key:
# 縮進key:   -> key.key# springboot規定的配置,有特殊含義
server:port: 80servlet:context-path: /boot# 數據庫連接信息     測試庫  開發的庫  上線zwf:user:username: adminapplication #注意空格gfs:- a- b- c#zwf:
#  user:
#    username: root
#    password: 123456
#    gfs:
#      - a
#      - b
#      - c
#    gfs:
#      - 高圓圓
#      - 范冰冰spring:profiles:active: test,dev # 激活外部的配置  application-test | application-dev# 外部配置的key和application key重復  外部的覆蓋內部!!# jar  --active=test

讀取配置的值

方式1：通過…層級的模式

創建pojo包下的User實體類

package com.atguigu.pojo;import lombok.Data;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.boot.context.properties.ConfigurationProperties;
import org.springframework.stereotype.Component;import java.util.List;/*** projectName: com.atguigu.pojo** @author: 趙偉風**   讀取配置的方式1: @Value*       直接可以在屬性上添加即可*       @Value(key必須寫全了)*       @value只能讀取單個值*   批量配置讀取:*      @ConfigurationProperties(prefix = "zwf.user") 通用的前綴*      實體類*        屬性名 = 最后一個key的值*      優勢1: 方便 不用一個一個讀取*      優勢2: 可以給集合類型賦值**/
@Data
@Component
@ConfigurationProperties(prefix = "zwf.user")
public class User {//@Value("${zwf.user.username}") //diprivate String username; //等于key//@Value("${zwf.user.password}") //diprivate String password;//@Value("${zwf.user.gfs}") //diprivate List<String> gfs;
}

創建controller層的UserController類

package com.atguigu.controller;import com.atguigu.pojo.User;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;/*** projectName: com.atguigu.controller** @author: 趙偉風* description:*/@RestController
@RequestMapping("user")
public class UserController {@Autowiredprivate User user;@GetMapping("show")public User show(){return user;}}

方式二：批量讀取

只需要在類上加上

@ConfigurationProperties(prefix = "zwf.user")

多種環境

三、SpringBoot3整合SpringMVC

3.1 實現過程

1. 創建程序

2. 引入依賴

   <?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 http://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>3.0.5</version></parent><groupId>com.atguigu</groupId><artifactId>springboot-starter-springmvc-03</artifactId><version>1.0-SNAPSHOT</version><properties><maven.compiler.source>17</maven.compiler.source><maven.compiler.target>17</maven.compiler.target><project.build.sourceEncoding>UTF-8</project.build.sourceEncoding></properties><dependencies><!--        web開發的場景啟動器 --><dependency><groupId>org.springframework.boot</groupId><artifactId>spring-boot-starter-web</artifactId></dependency></dependencies></project>
   

3. 創建啟動類

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

4. 創建實體類

   package com.atguigu.pojo;public class User {private String username ;private String password ;private Integer age ;private String sex ;public String getUsername() {return username;}public void setUsername(String username) {this.username = username;}public String getPassword() {return password;}public void setPassword(String password) {this.password = password;}public Integer getAge() {return age;}public void setAge(Integer age) {this.age = age;}public String getSex() {return sex;}public void setSex(String sex) {this.sex = sex;}
   }
   

5. 編寫Controller

   package com.atguigu.controller;import com.atguigu.pojo.User;
   import org.springframework.stereotype.Controller;
   import org.springframework.web.bind.annotation.GetMapping;
   import org.springframework.web.bind.annotation.RequestMapping;
   import org.springframework.web.bind.annotation.ResponseBody;@Controller
   @RequestMapping("/user")
   public class UserController {@GetMapping("/getUser")@ResponseBodypublic User getUser(){User user = new User();user.setUsername("楊過");user.setPassword("123456");user.setAge(18);user.setSex("男");return user;}
   }
   

6. 訪問測試

   

3.2 web相關配置

位置：application.yml

# web相關的配置
# https://docs.spring.io/spring-boot/docs/current/reference/html/application-properties.html#appendix.application-properties.server
server:# 端口號設置port: 80# 項目根路徑servlet:context-path: /boot

當涉及Spring Boot的Web應用程序配置時，以下是五個重要的配置參數：

1. server.port: 指定應用程序的HTTP服務器端口號。默認情況下，Spring Boot使用8080作為默認端口。您可以通過在配置文件中設置server.port來更改端口號。
2. server.servlet.context-path: 設置應用程序的上下文路徑。這是應用程序在URL中的基本路徑。默認情況下，上下文路徑為空。您可以通過在配置文件中設置server.servlet.context-path屬性來指定自定義的上下文路徑。
3. spring.mvc.view.prefix和spring.mvc.view.suffix: 這兩個屬性用于配置視圖解析器的前綴和后綴。視圖解析器用于解析控制器返回的視圖名稱，并將其映射到實際的視圖頁面。spring.mvc.view.prefix定義視圖的前綴，spring.mvc.view.suffix定義視圖的后綴。
4. spring.resources.static-locations: 配置靜態資源的位置。靜態資源可以是CSS、JavaScript、圖像等。默認情況下，Spring Boot會將靜態資源放在classpath:/static目錄下。您可以通過在配置文件中設置spring.resources.static-locations屬性來自定義靜態資源的位置。
5. spring.http.encoding.charset和spring.http.encoding.enabled: 這兩個屬性用于配置HTTP請求和響應的字符編碼。spring.http.encoding.charset定義字符編碼的名稱（例如UTF-8），spring.http.encoding.enabled用于啟用或禁用字符編碼的自動配置。

這些是在Spring Boot的配置文件中與Web應用程序相關的一些重要配置參數。根據您的需求，您可以在配置文件中設置這些參數來定制和配置您的Web應用程序

3.3 靜態資源處理

在WEB開發中我們需要引入一些靜態資源 , 例如 : HTML , CSS , JS , 圖片等 , 如果是普通的項目靜態資源可以放在項目的webapp目錄下。現在使用Spring Boot做開發 , 項目中沒有webapp目錄 , 我們的項目是一個jar工程，那么就沒有webapp，我們的靜態資源該放哪里呢？

1. 默認路徑

   在springboot中就定義了靜態資源的默認查找路徑：

   package org.springframework.boot.autoconfigure.web;
   //..................
   public static class Resources {private static final String[] CLASSPATH_RESOURCE_LOCATIONS = new String[]{"classpath:/META-INF/resources/", "classpath:/resources/", "classpath:/static/", "classpath:/public/"};private String[] staticLocations;private boolean addMappings;private boolean customized;private final Chain chain;private final Cache cache;public Resources() {this.staticLocations = CLASSPATH_RESOURCE_LOCATIONS;this.addMappings = true;this.customized = false;this.chain = new Chain();this.cache = new Cache();}
   //...........        
   

   默認的靜態資源路徑為：

   · classpath:/META-INF/resources/

   · classpath:/resources/

   · classpath:/static/

   · classpath:/public/

   我們只要靜態資源放在這些目錄中任何一個，SpringMVC都會幫我們處理。 我們習慣會把靜態資源放在classpath:/static/ 目錄下。在resources目錄下創建index.html文件

   

   打開瀏覽器輸入 : http://localhost:8080/index.html

2. 覆蓋路徑

   # web相關的配置
   # https://docs.spring.io/spring-boot/docs/current/reference/html/application-properties.html#appendix.application-properties.server
   server:# 端口號設置port: 80# 項目根路徑servlet:context-path: /boot
   spring:web:resources:# 配置靜態資源地址,如果設置,會覆蓋默認值static-locations: classpath:/webapp
   

   

   訪問地址：http://localhost/boot/login.html

3.4 自定義攔截器(SpringMVC配置)

1. 攔截器聲明

   package com.atguigu.interceptor;import jakarta.servlet.http.HttpServletRequest;
   import jakarta.servlet.http.HttpServletResponse;
   import org.springframework.stereotype.Component;
   import org.springframework.web.servlet.HandlerInterceptor;
   import org.springframework.web.servlet.ModelAndView;@Component
   public class MyInterceptor implements HandlerInterceptor {@Overridepublic boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {System.out.println("MyInterceptor攔截器的preHandle方法執行....");return true;}@Overridepublic void postHandle(HttpServletRequest request, HttpServletResponse response, Object handler, ModelAndView modelAndView) throws Exception {System.out.println("MyInterceptor攔截器的postHandle方法執行....");}@Overridepublic void afterCompletion(HttpServletRequest request, HttpServletResponse response, Object handler, Exception ex) throws Exception {System.out.println("MyInterceptor攔截器的afterCompletion方法執行....");}
   }
   

2. 攔截器配置

   正常使用配置類，只要保證，配置類要在啟動類的同包或者子包方可生效！

   package com.atguigu.config;import com.atguigu.interceptor.MyInterceptor;
   import org.springframework.beans.factory.annotation.Autowired;
   import org.springframework.context.annotation.Configuration;
   import org.springframework.web.servlet.config.annotation.InterceptorRegistry;
   import org.springframework.web.servlet.config.annotation.WebMvcConfigurer;@Configuration
   public class MvcConfig implements WebMvcConfigurer {@Autowiredprivate MyInterceptor myInterceptor ;/*** /**  攔截當前目錄及子目錄下的所有路徑 /user/**   /user/findAll  /user/order/findAll* /*   攔截當前目錄下的以及子路徑   /user/*     /user/findAll* @param registry*/@Overridepublic void addInterceptors(InterceptorRegistry registry) {registry.addInterceptor(myInterceptor).addPathPatterns("/**");}
   }
   

3. 攔截器效果測試

   

回顧復習

創建springboot-base-springmvc-03模塊（注意如果沒有父工程那么還是要編寫組件）

導入相應的依賴

 <parent><groupId>org.springframework.boot</groupId><artifactId>spring-boot-starter-parent</artifactId><version>3.0.5</version></parent>

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

指定啟動類

package com.atguigu;import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;@SpringBootApplication
public class Main {public static void main(String[] args) {SpringApplication.run(Main.class,args);}
}

controller層編寫HelloController類

package com.atguigu.controller;import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.ResponseBody;/*** projectName: com.atguigu.controller** @author: 趙偉風* description:*/@Controller
@ResponseBody
public class HelloController {@GetMapping("hello")public String ret(){return "hello";}
}

編寫application.yaml

# springmvc相關的web配置
# serverkey
server:port: 80 # 端口號 默認是8080servlet:context-path: /boot #設置項目根路徑spring:web:resources:static-locations: classpath:/webapp  #配置靜態資源文件夾# 一旦你配置了默認的靜態資源文件夾就無法訪問了  static public resources META-INF/resources# 外部訪問靜態資源的時候，不需要寫靜態資源文件夾

訪問靜態資源

默認的是放在resources下的static包下訪問，如果放在其他如：webapp 下則需要設置yml

注意訪問路徑不用加webapp

spring:web:resources:static-locations: classpath:/webapp  #配置靜態資源文件夾# 一旦你配置了默認的靜態資源文件夾就無法訪問了  static public resources META-INF/resources# 外部訪問靜態資源的時候，不需要寫靜態資源文件夾

攔截器使用

創建interceptor包下的M有Interceptor類

package com.atguigu.interceptor;import jakarta.servlet.http.HttpServletRequest;
import jakarta.servlet.http.HttpServletResponse;
import org.springframework.web.servlet.HandlerInterceptor;/*** projectName: com.atguigu.interceptor** @author: 趙偉風* description:*/
public class MyInterceptor implements HandlerInterceptor {@Overridepublic boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {System.out.println("request = " + request + ", response = " + response + ", handler = " + handler);return true;}
}

編寫配置類

config包下的web M v從Config類

package com.atguigu.config;import com.atguigu.interceptor.MyInterceptor;
import org.springframework.context.annotation.Configuration;
import org.springframework.web.servlet.config.annotation.InterceptorRegistry;
import org.springframework.web.servlet.config.annotation.WebMvcConfigurer;/*** projectName: com.atguigu.config** @author: 趙偉風* description:*/@Configuration
public class WebMvcConfig  implements WebMvcConfigurer {@Overridepublic void addInterceptors(InterceptorRegistry registry) {registry.addInterceptor(new MyInterceptor());}
}

四、SpringBoot3整合Druid數據源

1. 創建程序

2. 引入依賴

   <?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 http://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>3.0.5</version></parent><groupId>com.atguigu</groupId><artifactId>springboot-starter-druid-04</artifactId><version>1.0-SNAPSHOT</version><properties><maven.compiler.source>17</maven.compiler.source><maven.compiler.target>17</maven.compiler.target><project.build.sourceEncoding>UTF-8</project.build.sourceEncoding></properties><dependencies><!--  web開發的場景啟動器 --><dependency><groupId>org.springframework.boot</groupId><artifactId>spring-boot-starter-web</artifactId></dependency><!-- 數據庫相關配置啟動器 jdbctemplate 事務相關--><dependency><groupId>org.springframework.boot</groupId><artifactId>spring-boot-starter-jdbc</artifactId></dependency><!-- druid啟動器的依賴  --><dependency><groupId>com.alibaba</groupId><artifactId>druid-spring-boot-3-starter</artifactId><version>1.2.18</version></dependency><!-- 驅動類--><dependency><groupId>mysql</groupId><artifactId>mysql-connector-java</artifactId><version>8.0.28</version></dependency><dependency><groupId>org.projectlombok</groupId><artifactId>lombok</artifactId><version>1.18.28</version></dependency></dependencies><!--    SpringBoot應用打包插件--><build><plugins><plugin><groupId>org.springframework.boot</groupId><artifactId>spring-boot-maven-plugin</artifactId></plugin></plugins></build></project>
   

3. 啟動類

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

4. 配置文件編寫

   添加druid連接池的基本配置

   spring:datasource:# 連接池類型 type: com.alibaba.druid.pool.DruidDataSource# Druid的其他屬性配置 springboot3整合情況下,數據庫連接信息必須在Druid屬性下!druid:url: jdbc:mysql://localhost:3306/day01username: rootpassword: rootdriver-class-name: com.mysql.cj.jdbc.Driver# 初始化時建立物理連接的個數initial-size: 5# 連接池的最小空閑數量min-idle: 5# 連接池最大連接數量max-active: 20# 獲取連接時最大等待時間，單位毫秒max-wait: 60000# 申請連接的時候檢測，如果空閑時間大于timeBetweenEvictionRunsMillis，執行validationQuery檢測連接是否有效。test-while-idle: true# 既作為檢測的間隔時間又作為testWhileIdel執行的依據time-between-eviction-runs-millis: 60000# 銷毀線程時檢測當前連接的最后活動時間和當前時間差大于該值時，關閉當前連接(配置連接在池中的最小生存時間)min-evictable-idle-time-millis: 30000# 用來檢測數據庫連接是否有效的sql 必須是一個查詢語句(oracle中為 select 1 from dual)validation-query: select 1# 申請連接時會執行validationQuery檢測連接是否有效,開啟會降低性能,默認為truetest-on-borrow: false# 歸還連接時會執行validationQuery檢測連接是否有效,開啟會降低性能,默認為truetest-on-return: false# 是否緩存preparedStatement, 也就是PSCache,PSCache對支持游標的數據庫性能提升巨大，比如說oracle,在mysql下建議關閉。pool-prepared-statements: false# 要啟用PSCache，必須配置大于0，當大于0時，poolPreparedStatements自動觸發修改為true。在Druid中，不會存在Oracle下PSCache占用內存過多的問題，可以把這個數值配置大一些，比如說100max-pool-prepared-statement-per-connection-size: -1# 合并多個DruidDataSource的監控數據use-global-data-source-stat: truelogging:level:root: debug
   

5. 編寫Controller

   @Slf4j
   @Controller
   @RequestMapping("/user")
   public class UserController {@Autowiredprivate JdbcTemplate jdbcTemplate;@GetMapping("/getUser")@ResponseBodypublic User getUser(){String sql = "select * from users where id = ? ; ";User user = jdbcTemplate.queryForObject(sql, new BeanPropertyRowMapper<>(User.class), 1);log.info("查詢的user數據為:{}",user.toString());return user;}}
   

6. 啟動測試

7. 問題解決

   通過源碼分析，druid-spring-boot-3-starter目前最新版本是1.2.18，雖然適配了SpringBoot3，但缺少自動裝配的配置文件，需要手動在resources目錄下創建META-INF/spring/org.springframework.boot.autoconfigure.AutoConfiguration.imports，文件內容如下!

   com.alibaba.druid.spring.boot3.autoconfigure.DruidDataSourceAutoConfigure
   

   

回顧復習

創建springboot-base-druid-04模塊

導入依賴

 <parent><groupId>org.springframework.boot</groupId><artifactId>spring-boot-starter-parent</artifactId><version>3.0.5</version></parent>

 <dependencies><!--  web開發的場景啟動器 --><dependency><groupId>org.springframework.boot</groupId><artifactId>spring-boot-starter-web</artifactId></dependency><!-- 數據庫相關配置啟動器 jdbctemplate 事務相關--><dependency><groupId>org.springframework.boot</groupId><artifactId>spring-boot-starter-jdbc</artifactId></dependency><!-- druid啟動器的依賴  --><dependency><groupId>com.alibaba</groupId><artifactId>druid-spring-boot-3-starter</artifactId><version>1.2.18</version></dependency><!-- 驅動類--><dependency><groupId>mysql</groupId><artifactId>mysql-connector-java</artifactId><version>8.0.28</version></dependency><dependency><groupId>org.projectlombok</groupId><artifactId>lombok</artifactId><version>1.18.28</version></dependency></dependencies>

創建application.yaml配置文件

spring:datasource:type: com.alibaba.druid.pool.DruidDataSource  #使用druid連接池#username: 賬號 # 如果你springboot2整合druid連接池！使用此信息配置賬號#password:druid:url: jdbc:mysql://localhost:3306/day01username: rootpassword: rootdriver-class-name: com.mysql.cj.jdbc.Driver# 初始化時建立物理連接的個數initial-size: 5# 連接池的最小空閑數量min-idle: 5# 連接池最大連接數量max-active: 20# 獲取連接時最大等待時間，單位毫秒max-wait: 60000# 申請連接的時候檢測，如果空閑時間大于timeBetweenEvictionRunsMillis，執行validationQuery檢測連接是否有效。test-while-idle: true# 既作為檢測的間隔時間又作為testWhileIdel執行的依據time-between-eviction-runs-millis: 60000# 銷毀線程時檢測當前連接的最后活動時間和當前時間差大于該值時，關閉當前連接(配置連接在池中的最小生存時間)min-evictable-idle-time-millis: 30000# 用來檢測數據庫連接是否有效的sql 必須是一個查詢語句(oracle中為 select 1 from dual)validation-query: select 1# 申請連接時會執行validationQuery檢測連接是否有效,開啟會降低性能,默認為truetest-on-borrow: false# 歸還連接時會執行validationQuery檢測連接是否有效,開啟會降低性能,默認為truetest-on-return: false# 是否緩存preparedStatement, 也就是PSCache,PSCache對支持游標的數據庫性能提升巨大，比如說oracle,在mysql下建議關閉。pool-prepared-statements: false# 要啟用PSCache，必須配置大于0，當大于0時，poolPreparedStatements自動觸發修改為true。在Druid中，不會存在Oracle下PSCache占用內存過多的問題，可以把這個數值配置大一些，比如說100max-pool-prepared-statement-per-connection-size: -1# 合并多個DruidDataSource的監控數據use-global-data-source-stat: true

注意boot2 是spring:
datasource:
type: com.alibaba.druid.pool.DruidDataSource *#使用druid連接池
#username: 賬號 # *如果你springboot2整合druid**連接池！使用此信息配置賬號
#password:

但是boot3要變了，如上

創建pojo包下的User類

package com.atguigu.pojo;import lombok.Data;/*** projectName: com.atguigu.pojo** @author: 趙偉風* description:*/@Data
public class User {private Integer id;private String name;private Integer age;private String email;
}

編寫controller包下的User Controller類

package com.atguigu.controller;import com.atguigu.pojo.User;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.expression.spel.ast.Literal;
import org.springframework.jdbc.core.BeanPropertyRowMapper;
import org.springframework.jdbc.core.JdbcTemplate;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;import java.util.List;/*** projectName: com.atguigu.controller** @author: 趙偉風* description:*/@RestController
@RequestMapping("user")
public class UserController {@Autowiredprivate JdbcTemplate jdbcTemplate;@GetMapping("list")public List<User> list(){//數據庫String sql ="select * from user;";List<User> list = jdbcTemplate.query(sql, new BeanPropertyRowMapper<>(User.class));return list;}
}

這里不用三層架構，直接寫的數據庫sql語句

創建啟動類Main

package com.atguigu;import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;@SpringBootApplication
public class Main {public static void main(String[] args) {SpringApplication.run(Main.class,args);}
}

解決druid 在boot3不兼容的方法

在resources目錄下創建

org.springframework.boot.autoconfigure.AutoConfiguration.imports文件

在里面寫

com.alibaba.druid.spring.boot3.autoconfigure.DruidDataSourceAutoConfigure

即可解決

五、SpringBoot3整合Mybatis

5.1 MyBatis整合步驟

1. 導入依賴：在您的Spring Boot項目的構建文件（如pom.xml）中添加MyBatis和數據庫驅動的相關依賴。例如，如果使用MySQL數據庫，您需要添加MyBatis和MySQL驅動的依賴。
2. 配置數據源：在application.properties或application.yml中配置數據庫連接信息，包括數據庫URL、用戶名、密碼、mybatis的功能配置等。
3. 創建實體類：創建與數據庫表對應的實體類。
4. 創建Mapper接口：創建與數據庫表交互的Mapper接口。
5. 創建Mapper接口SQL實現： 可以使用mapperxml文件或者注解方式
6. 創建程序啟動類
7. 注解掃描：在Spring Boot的主應用類上添加@MapperScan注解，用于掃描和注冊Mapper接口。
8. 使用Mapper接口：在需要使用數據庫操作的地方，通過依賴注入或直接實例化Mapper接口，并調用其中的方法進行數據庫操作。

5.2 Mybatis整合實踐

1. 創建項目

2. 導入依賴

   <parent><groupId>org.springframework.boot</groupId><artifactId>spring-boot-starter-parent</artifactId><version>3.0.5</version>
   </parent><dependencies><dependency><groupId>org.springframework.boot</groupId><artifactId>spring-boot-starter-web</artifactId></dependency><dependency><groupId>org.mybatis.spring.boot</groupId><artifactId>mybatis-spring-boot-starter</artifactId><version>3.0.1</version></dependency><!-- 數據庫相關配置啟動器 --><dependency><groupId>org.springframework.boot</groupId><artifactId>spring-boot-starter-jdbc</artifactId></dependency><!-- druid啟動器的依賴  --><dependency><groupId>com.alibaba</groupId><artifactId>druid-spring-boot-3-starter</artifactId><version>1.2.18</version></dependency><!-- 驅動類--><dependency><groupId>mysql</groupId><artifactId>mysql-connector-java</artifactId><version>8.0.28</version></dependency><dependency><groupId>org.projectlombok</groupId><artifactId>lombok</artifactId><version>1.18.28</version></dependency></dependencies>
   

3. 配置文件

   server:port: 80servlet:context-path: /
   spring:datasource:type: com.alibaba.druid.pool.DruidDataSourcedruid:url: jdbc:mysql:///day01username: rootpassword: rootdriver-class-name: com.mysql.cj.jdbc.Drivermybatis:configuration:  # setting配置auto-mapping-behavior: fullmap-underscore-to-camel-case: truelog-impl: org.apache.ibatis.logging.slf4j.Slf4jImpltype-aliases-package: com.atguigu.pojo # 配置別名mapper-locations: classpath:/mapper/*.xml # mapperxml位置
   

4. 實體類準備

   package com.atguigu.pojo;public class User {private String account ;private String password ;private Integer id ;public String getAccount() {return account;}public void setAccount(String account) {this.account = account;}public String getPassword() {return password;}public void setPassword(String password) {this.password = password;}public Integer getId() {return id;}public void setId(Integer id) {this.id = id;}@Overridepublic String toString() {return "User{" +"account='" + account + '\'' +", password='" + password + '\'' +", id=" + id +'}';}
   }
   

5. Mapper接口準備

   public interface UserMapper {List<User> queryAll();
   }
   

6. Mapper接口實現（XML）

   位置：resources/mapper/UserMapper.xml

   <?xml version="1.0" encoding="UTF-8" ?>
   <!DOCTYPE mapperPUBLIC "-//mybatis.org//DTD Mapper 3.0//EN""https://mybatis.org/dtd/mybatis-3-mapper.dtd">
   <!-- namespace = 接口的全限定符 -->
   <mapper namespace="com.atguigu.mapper.UserMapper"><select id="queryAll" resultType="user">select * from users</select></mapper>
   

7. 編寫三層架構代碼

   偽代碼，不添加業務接口！

   1. controller

      @Slf4j
      @Controller
      @RequestMapping("/user")
      public class UserController {@Autowiredprivate UserService userService;@GetMapping("/list")@ResponseBodypublic List<User> getUser(){List<User> userList = userService.findList();log.info("查詢的user數據為:{}",userList);return userList;}}
      

   2. service

      @Slf4j
      @Service
      public class UserService {@Autowiredprivate UserMapper userMapper;public List<User> findList(){List<User> users = userMapper.queryAll();log.info("查詢全部數據:{}",users);return users;}
      }
      

8. 啟動類和接口掃描

   @MapperScan("com.atguigu.mapper") //mapper接口掃描配置
   @SpringBootApplication
   public class MainApplication {public static void main(String[] args) {SpringApplication.run(MainApplication.class,args);}
   }

9. 啟動測試

5.3 聲明式事務整合配置

依賴導入:

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

注：SpringBoot項目會自動配置一個 DataSourceTransactionManager，所以我們只需在方法（或者類）加上 @Transactional 注解，就自動納入 Spring 的事務管理了

@Transactional
public void update(){User user = new User();user.setId(1);user.setPassword("test2");user.setAccount("test2");userMapper.update(user);
}

5.4 AOP整合配置

依賴導入:

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

直接使用aop注解即可:

@Component
@Aspect
public class LogAdvice {@Before("execution(* com..service.*.*(..))")public void before(JoinPoint joinPoint){System.out.println("LogAdvice.before");System.out.println("joinPoint = " + joinPoint);}}

回顧復習

創建模塊springboot-base-mybatis-05 還是和上面講的一樣，父工程

導入依賴

 <parent><groupId>org.springframework.boot</groupId><artifactId>spring-boot-starter-parent</artifactId><version>3.0.5</version></parent>

 <dependencies><dependency><groupId>org.springframework.boot</groupId><artifactId>spring-boot-starter-web</artifactId></dependency><dependency><groupId>org.mybatis.spring.boot</groupId><artifactId>mybatis-spring-boot-starter</artifactId><version>3.0.1</version></dependency><!-- 數據庫相關配置啟動器 --><dependency><groupId>org.springframework.boot</groupId><artifactId>spring-boot-starter-jdbc</artifactId></dependency><!-- druid啟動器的依賴  --><dependency><groupId>com.alibaba</groupId><artifactId>druid-spring-boot-3-starter</artifactId><version>1.2.18</version></dependency><!-- 驅動類--><dependency><groupId>mysql</groupId><artifactId>mysql-connector-java</artifactId><version>8.0.28</version></dependency><dependency><groupId>org.projectlombok</groupId><artifactId>lombok</artifactId><version>1.18.28</version></dependency><dependency><groupId>org.springframework.boot</groupId><artifactId>spring-boot-starter-aop</artifactId></dependency></dependencies>

創建Java下的mapper包下的UserMapper接口

package com.atguigu.mapper;import com.atguigu.pojo.User;import java.util.List;/*** projectName: com.atguigu.mapper** @author: 趙偉風* description:*/
public interface UserMapper {List<User> queryAll();int delete(int i);
}

創建resources下的mappers下的UserMapper.xml文件

<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE mapperPUBLIC "-//mybatis.org//DTD Mapper 3.0//EN""https://mybatis.org/dtd/mybatis-3-mapper.dtd">
<!-- namespace = 接口的全限定符 -->
<mapper namespace="com.atguigu.mapper.UserMapper"><select id="queryAll" resultType="user">select * from user;</select><delete id="delete">delete from user where id = #{id}</delete></mapper>

編寫application.yml文件

# druid連接池
spring:datasource:type: com.alibaba.druid.pool.DruidDataSourcedruid:url: jdbc:mysql://localhost:3306/day01username: rootpassword: rootdriver-class-name: com.mysql.cj.jdbc.Driver# mybatis -徹底拋棄mybatis-config.xml
# mapperxml文件的位置  settings的配置  別名的配置...
mybatis:mapper-locations: classpath:/mappers/*.xml  #指定xml文件的位置type-aliases-package: com.atguigu.pojo #起別名configuration:map-underscore-to-camel-case: trueauto-mapping-behavior: fulllog-impl: org.apache.ibatis.logging.slf4j.Slf4jImpl

解決druid 在boot3不兼容的方法

在resources目錄下創建

org.springframework.boot.autoconfigure.AutoConfiguration.imports文件

在里面寫

com.alibaba.druid.spring.boot3.autoconfigure.DruidDataSourceAutoConfigure

編寫啟動類

package com.atguigu;import org.mybatis.spring.annotation.MapperScan;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;@MapperScan("com.atguigu.mapper") //mapper接口所在的的位置！
@SpringBootApplication
public class Main {public static void main(String[] args) {SpringApplication.run(Main.class,args);}
}

注意：在application.yml文件中指定的是mapper xml文件位置 而在啟動類的注解是mapper接口的位置

@MapperScan(“com.atguigu.mapper”) //mapper接口所在的的位置！

然后就是實現功能，Usermapper接口的放吧編寫，User Mapper.xml文件中編寫，

controller包下的UserController類編寫，然后再啟動項目

聲明式事務

編寫service包下的UserService類

package com.atguigu.service;import com.atguigu.mapper.UserMapper;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;/*** projectName: com.atguigu.service** @author: 趙偉風* description:*/@Service
public class UserService {@Autowiredprivate UserMapper userMapper;@Transactionalpublic void delete( ){int rows = userMapper.delete(1);System.out.println("rows = " + rows);
//        int i = 1/0;}
}

然后去mapper.xml去編寫對應的語句

然后到controller包下的UserController類去編寫

package com.atguigu.controller;import com.atguigu.mapper.UserMapper;
import com.atguigu.pojo.User;
import com.atguigu.service.UserService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;import java.util.List;/*** projectName: com.atguigu.controller** @author: 趙偉風* description:*/@RestController
@RequestMapping("user")
public class UserController {@Autowiredprivate UserMapper userMapper;@Autowiredprivate UserService userService;@GetMappingpublic List<User> query(){userService.delete();return null;}
}

aop整合配置

導入依賴

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

編寫advice包下的LogAdvice類

package com.atguigu.advice;import org.aspectj.lang.JoinPoint;
import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.annotation.Before;
import org.springframework.core.annotation.Order;
import org.springframework.stereotype.Component;/*** projectName: com.atguigu.advice** @author: 趙偉風* description:*/
@Component
@Aspect
@Order(5)
public class LogAdvice {@Before("execution(* com..service.*.*(..))")public void before(JoinPoint point){String className = point.getTarget().getClass().getSimpleName();String methodName = point.getSignature().getName();System.out.println(className+"::"+methodName+" 開始執行了！");}
}

六、SpringBoot3項目打包和運行

6.1 添加打包插件

在Spring Boot項目中添加spring-boot-maven-plugin插件是為了支持將項目打包成可執行的可運行jar包。如果不添加spring-boot-maven-plugin插件配置，使用常規的java -jar命令來運行打包后的Spring Boot項目是無法找到應用程序的入口點，因此導致無法運行。

<!--    SpringBoot應用打包插件-->
<build><plugins><plugin><groupId>org.springframework.boot</groupId><artifactId>spring-boot-maven-plugin</artifactId></plugin></plugins>
</build>

6.2 執行打包

在idea點擊package進行打包

可以在編譯的target文件中查看jar包

6.3 命令啟動和參數說明

java -jar命令用于在Java環境中執行可執行的JAR文件。下面是關于java -jar命令的說明：

命令格式：java -jar  [選項] [參數] <jar文件名>

1. -D<name>=<value>：設置系統屬性，可以通過System.getProperty()方法在應用程序中獲取該屬性值。例如：java -jar -Dserver.port=8080 myapp.jar。
2. -X：設置JVM參數，例如內存大小、垃圾回收策略等。常用的選項包括：
   • -Xmx<size>：設置JVM的最大堆內存大小，例如 -Xmx512m 表示設置最大堆內存為512MB。
   • -Xms<size>：設置JVM的初始堆內存大小，例如 -Xms256m 表示設置初始堆內存為256MB。
3. -Dspring.profiles.active=<profile>：指定Spring Boot的激活配置文件，可以通過application-<profile>.properties或application-<profile>.yml文件來加載相應的配置。例如：java -jar -Dspring.profiles.active=dev myapp.jar。

啟動和測試：

注意： -D 參數必須要在jar之前！否者不生效！

回顧復習

導入插件

    <!--    SpringBoot應用打包插件--><build><plugins><plugin><groupId>org.springframework.boot</groupId><artifactId>spring-boot-maven-plugin</artifactId></plugin></plugins></build>

maven →clear→package

然后target就會出現打包好的 .jar包

將其指定一個文件夾路徑 染后在對應的路徑下 輸入cmd

java -jar tab 補全 ctrl +c 終止

為了后期更改方便通常是在properties.yml文件不寫，然后在執行jar包時填寫相應的配置

eg:指定端口 Java -jar -Dserver.port=8888 springboot-base-mybatis-05-1.0-SNAPSHOT.jar

eg: Java -jar -Dserver.port=8888 -Dspring.profiles.active=xxxx,jj springboot-base-mybatis-05-1.0-SNAPSHOT.jar