SSM框架学习（六、快速启动框架：SpringBoot3实战）

目录

一、SpringBoot3介绍

1.SpringBoot3简介

2.快速入门

3.入门总结 

（1）Question1：为什么依赖不需要写版本？

 （2）Question2：启动器（starter）是什么？

（3）Question3：@SpringBootApplication注解的功效？

 二、SpringBoot3配置文件

1.统一配置管理概述

2.属性配置文件使用 

3.YAML配置文件使用 

（1）yaml 格式介绍：

（2）yaml语法说明：

4.多环境配置和使用

三、SpringBoot3整合SpringMVC

1.实现过程

2.web相关配置

3.静态资源处理

（1）默认路径

（2）自定义路径

4.自定义拦截器（SpringMVC配置） 

四、SpringBoot3整合Druid数据源 

五、SpringBoot3整合Mybatis 

1.MyBatis整合步骤 

2.Mybatis整合实践

3.声明式事务整合配置

4.AOP整合配置 

六、SpringBoot3项目打包和运行 

 1.添加打包插件

2.执行打包

3.命令启动和参数说明 

一、SpringBoot3介绍

1.SpringBoot3简介

到目前为止，已经学习了多种配置Spring程序的方式。

但是无论使用XML、注解、Java配置类还是它们的混合用法，都会觉得配置文件过于复杂和繁琐。

SpringBoot 可以帮我们简单、快速地创建一个独立的、生产级别的 Spring 应用（底层是 Spring）。

大多数 SpringBoot 应用只需要编写少量配置即可快速整合 Spring 平台以及第三方技术。

SpringBoot的主要目标是：

① 为所有 Spring 开发提供更快速、可广泛访问的入门体验。

② 开箱即用，设置合理的默认值，但是也可以根据需求进行适当的调整。

③ 提供一系列大型项目通用的非功能性程序（如嵌入式服务器、安全性、指标、运行检查等）。

④ 约定大于配置，基本不需要主动编写配置类、也不需要 XML 配置文件。

总结：简化开发，简化配置，简化整合，简化部署，简化监控，简化运维。

 系统要求：

2.快速入门

 需求：浏览器发送/hello请求，返回"Hello,Spring Boot 3!"

开发步骤：

a. 创建Maven工程

b. 添加依赖（在 pom.xml 中 添加 springboot父工程依赖 , web启动器依赖)

SpringBoot 可以帮我们方便的管理项目依赖，在SpringBoot 提供了一个名为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>

为了让 SpringBoot 帮我们完成各种自动配置，我们必须引入Spring Boot提供的自动配置依赖，我们称为启动器。因为我们是web项目，这里我们引入web启动器。

    <!-- 导入对应的web启动器 -->
    <dependencies>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
            <!-- 不用写版本号 -->
        </dependency>
    </dependencies>

c. 编写启动引导类（springboot项目运行的入口）

@SpringBootApplication //启动类
public class Main {
    public static void main(String[] args) {
        SpringApplication.run(Main.class,args); //自动创建ioc容器，启动tomcat服务器软件
    }
}

 d. 编写处理器Controller

@RestController
@RequestMapping("hello")
public class HelloController {

    @RequestMapping("boot")
    public String hello(){
        return "hello springboot3!";
    }
}

e. 启动项目

3.入门总结 

（1）Question1：为什么依赖不需要写版本？

每个boot项目都有一个父项目 spring-boot-starter-parent

parent 的父项目是 spring-boot-dependencies

spring-boot-dependencies 中的 properties 标签，把所有常见的 jar 的依赖版本都声明好了。

 （2）Question2：启动器（starter）是什么？

 Spring Boot提供了一种叫做Starter的概念，它是一组预定义的依赖项集合，旨在简化Spring应用程序的配置和构建过程。

Starter包含了一组相关的依赖项，以便在启动应用程序时自动引入所需的库、配置和功能。

 主要作用如下：

① 简化依赖管理：Spring Boot Starter通过捆绑和管理一组相关的依赖项，减少了手动解析和配置依赖项的工作。只需引入一个相关的Starter依赖，即可获取应用程序所需的全部依赖。

② 自动配置：Spring Boot Starter在应用程序启动时自动配置所需的组件和功能。通过根据类路径和其他设置的自动检测，Starter可以自动配置Spring Bean、数据源、消息传递等常见组件，从而使应用程序的配置变得简单和维护成本降低。

③ 提供约定优于配置：Spring Boot Starter遵循“约定优于配置”的原则，通过提供一组默认设置和约定，减少了手动配置的需要。它定义了标准的配置文件命名约定、默认属性值、日志配置等，使得开发者可以更专注于业务逻辑而不是繁琐的配置细节。

④ 快速启动和开发应用程序：Spring Boot Starter使得从零开始构建一个完整的Spring Boot应用程序变得容易。它提供了主要领域（如Web开发、数据访问、安全性、消息传递等）的Starter，帮助开发者快速搭建一个具备特定功能的应用程序原型。

⑤ 模块化和可扩展性：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）Question3：@SpringBootApplication注解的功效？

@SpringBootApplication添加到启动类上，是一个组合注解，它的功效由具体的子注解实现。

/* 作用：
*       1.配置类 @SpringBootConfiguration（可以直接在本类中通过@Bean将组件加入ioc容器）
*       2.自动加载其他配置类 @EnableAutoConfiguration
*       3.扫描包 @ComponentScan（默认扫描当前类所在包及其子包的注解）
* */
@SpringBootApplication //启动类
public class Main {
    ...
}

 二、SpringBoot3配置文件

1.统一配置管理概述

SpringBoot 工程下，进行统一的配置管理。

我们想设置的任何参数（端口号、项目根路径、数据库连接信息等等）都得集中到一个固定位置和命名的配置文件（application.properties或application.yml）中。

配置文件应该放置在Spring Boot工程的 src/main/resources 目录下。这是因为 src/main/resources目录是 Spring Boot 默认的类路径（classpath），配置文件会被自动加载并可供应用程序访问。

细节：

① 集中式管理配置：统一在一个文件中完成程序功能参数设置（固定key）和自定义参数声明 。

② 位置：resources文件夹下，必须命名：application 后缀 .properties / .yaml / .yml 。

③ 如果同时存在 application.properties | application.yml(.yaml) ，.properties的优先级更高。

④ 配置基本都有默认值：

2.属性配置文件使用 

步骤：

① 编写配置文件

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

# 使用springboot提供的配置，修改程序的参数是固定的
server.servlet.context-path=/spring
server.port=8000

# 自定义配置
zs.name=zhangsan

注意：

功能配置参数说明，即固定 key 的命名见：

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

② 读取配置文件

@RestController
@RequestMapping("hello")
public class HelloController {

    @Value("${zs.name}")
    private String name;

    @RequestMapping("boot")
    public String hello() {
        return "hello " + name;
    }
}

 注意：springboot 使得读取配置更加简单，无需设置 @PropertySource

③ 测试效果 

3.YAML配置文件使用 

（1）yaml 格式介绍：

YAML（YAML Ain’t Markup Language）是一种基于层次结构的数据序列化格式，旨在提供一种易读、人类友好的数据表示方式。

与.properties文件相比，YAML格式有以下优势：

① 层次结构：YAML文件使用缩进和冒号来表示层次结构，使得数据之间的关系更加清晰和直观。这样可以更容易理解和维护复杂的配置，特别适用于深层次嵌套的配置情况。

② 自我描述性：YAML文件具有自我描述性，字段和值之间使用冒号分隔，并使用缩进表示层级关系。这使得配置文件更易于阅读和理解，并且可以减少冗余的标点符号和引号。

③ 注释支持：YAML格式支持注释，可以在配置文件中添加说明性的注释，使配置更具可读性和可维护性。相比之下，.properties文件不支持注释，无法提供类似的解释和说明。

④ 多行文本：YAML格式支持多行文本的表示，可以更方便地表示长文本或数据块。相比之下，.properties文件需要使用转义符或将长文本拆分为多行。

⑤ 类型支持：YAML格式天然支持复杂的数据类型，如列表、映射等。这使得在配置文件中表示嵌套结构或数据集合更加容易，而不需要进行额外的解析或转换。

⑥ 更好的可读性：由于YAML格式的特点，它更容易被人类读懂和解释。它减少了配置文件中需要的特殊字符和语法，让配置更加清晰明了，从而减少了错误和歧义。

（2）yaml语法说明：

① 数据结构用树形结构呈现，通过缩进来表示层级，

② 连续的项目（集合）通过减号 ” - ” 来表示

③ 键值结构里面的 key/value对 用冒号 ” : ” 来分隔。

④ YAML配置文件的扩展名是 yaml 或 yml

例如：

# 功能配置参数（固定key）
server:
  port: 8000
  servlet:
    context-path: /spring


# 自定义配置
zs:
  name: zhangsan
  age: 18
  pet:
    - dog
    - cat
    - rabbit

注意：

① ：和 - 后都需要加一个空格，然后写值（即：key: value）

② 读取方式：

a. 通过 @Value 注解，直接在属性上添加即可

        缺点：@Value(”${key}“)中的 key 必须写全，且 @Value 只能读取单个值，不能读取集合！

b. 批量配置读取 @ConfigurationProperties 

        优点：方便，不用一个个读取，且可以给集合类型赋值

@ConfigurationProperties 是 SpringBoot 提供的重要注解, 在类上通过 @ConfigurationProperties 注解声明该类要读取属性配置，他可以将一些配置属性批量注入到 bean对象。

prefix="zs" 读取属性文件中通用前缀为 zs 的值，前缀 + 属性名称和配置文件中的 key 必须要保持一致才可以注入成功。

@Data
@Component
@ConfigurationProperties(prefix = "zs") //批量读取以"zs"开头的
public class User {
    private String name;//属性名等于最后一个key的值

    private int age;

    private List<String> pet;
}

在controller注入，输出进行测试 

@RestController
@RequestMapping("user")
public class UserController {
    @Autowired
    private User user;

    @GetMapping("show")
    public User show(){
        return user;
    }
}

 运行结果：

注意：

通用前缀 + 属性名 = yml 中 key 的全名！

如果 通用前缀和属性名 之间还存在key，需要创建一个嵌套类来匹配。 

如：

application.yml：

# 自定义配置  
zs:  
  name: zhangsan  
  age: 18  
  have:  
    pet:  
      - dog  
      - cat  
      - rabbit

User类：

@Data  
@Component  
@ConfigurationProperties(prefix = "zs")  
public class User {  
    private String name;  
    private int age;  
    private Have have;  

    @Data  
    public static class Have {  
        private List<String> pet; // 这里是 pet 对应 "have.pet"  
    }  
}  

4.多环境配置和使用

在Spring Boot中，可以使用多环境配置来根据不同的运行环境（如开发、测试、生产）加载不同的配置。

SpringBoot支持多环境配置让应用程序在不同的环境中使用不同的配置参数，例如数据库连接信息、日志级别、缓存配置等。

 实现Spring Boot多环境配置的常见方法：

① 属性文件分离：将应用程序的配置参数分离到不同的属性文件中，每个环境对应一个属性文件。例如，可以创建application-dev.properties、application-prod.properties和application-test.properties等文件。在这些文件中，可以定义各自环境的配置参数，如数据库连接信息、端口号等。然后，在application.properties中通过spring.profiles.active属性指定当前使用的环境。Spring Boot会根据该属性来加载对应环境的属性文件，覆盖默认的配置。

② YAML配置文件：与属性文件类似，可以将配置参数分离到不同的YAML文件中，每个环境对应一个文件。例如，可以创建application-dev.yml、application-prod.yml和application-test.yml等文件。在这些文件中，可以使用YAML语法定义各自环境的配置参数。同样，在 application.yml 中通过 spring.profiles.active 属性指定当前的环境，Spring Boot会加载相应的YAML文件。

③ 命令行参数(动态)：可以通过命令行参数来指定当前的环境。例如，可以在命令行使用--spring.profiles.active=dev 来指定使用开发环境的配置。

通过上述方法，Spring Boot 会根据当前指定的环境来加载相应的配置文件或参数，从而实现多环境配置。这样可以简化在不同环境之间的配置切换，并且确保应用程序在不同环境中具有正确的配置。

实现（基于方式 ②）：

创建开发、测试、生产三个环境的配置文件

a. application-dev.yml（开发）

spring:
  jdbc:
    datasource:
      driverClassName: com.mysql.cj.jdbc.Driver
      url: jdbc:mysql:///dev
      username: root
      password: root

 application-test.yml（测试）

spring:
  jdbc:
    datasource:
      driverClassName: com.mysql.cj.jdbc.Driver
      url: jdbc:mysql:///test
      username: root
      password: root

application-prod.yml（生产）

spring:
  jdbc:
    datasource:
      driverClassName: com.mysql.cj.jdbc.Driver
      url: jdbc:mysql:///prod
      username: root
      password: root

b. 环境激活（application.yml）

spring:
  profiles:
    active: dev

细节：

① 可以一次性激活多个，使配置更加清晰，规则！

例如，可以将 mybatis 的配置信息写在 application-mybatis.yml 中，将druid 连接池的配置信息写在 application-druid.yml 中，激活时可以写 active: mybatis,druid。

② 如果 active 中激活的外部配置和 application.yml 中存在相同的 key，以 active 设置的优先！

外部的（active）会覆盖内部的（application.yml）。

三、SpringBoot3整合SpringMVC

1.实现过程

① 创建程序，引入依赖

<?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>

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

    <groupId>com.mihoyo</groupId>
    <artifactId>springboot-base-springmvc-03</artifactId>
    <version>1.0-SNAPSHOT</version>

    <!-- web开发的场景启动器 -->
    <dependencies>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>
    </dependencies>
</project>

② 创建启动类

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

③ 编写Controller

@RestController
public class HelloController {

    @GetMapping("hello")
    public String ret() {
        return "hello";
    }
}

2.web相关配置

位置：application.yml

# web相关的配置
# https://docs.spring.io/spring-boot/docs/current/reference/html/application-properties.html#appendix.application-properties.server
server:
  # 端口号设置
  port: 8000
  # 项目根路径
  servlet:
    context-path: /boot

当涉及 Spring Boot 的Web应用程序配置时，以下是五个常用的重要配置参数：

① server.port：指定应用程序的 HTTP 服务器端口号。默认情况下，Spring Boot使用8080作为默认端口。您可以通过在配置文件中设置server.port来更改端口号。

② server.servlet.context-path：设置应用程序的上下文路径。这是应用程序在URL中的基本路径。默认情况下，上下文路径为空。您可以通过在配置文件中设置server.servlet.context-path属性来指定自定义的上下文路径。

③ spring.mvc.view.prefix 和 spring.mvc.view.suffix：这两个属性用于配置视图解析器的前缀和后缀。视图解析器用于解析控制器返回的视图名称，并将其映射到实际的视图页面。spring.mvc.view.prefix定义视图的前缀，spring.mvc.view.suffix定义视图的后缀。

④ spring.resources.static-locations：配置静态资源的位置。静态资源可以是CSS、JavaScript、图像等。默认情况下，Spring Boot会将静态资源放在 classpath:/static 目录下。您可以通过在配置文件中设置spring.resources.static-locations属性来自定义静态资源的位置。

⑤ spring.http.encoding.charset 和 spring.http.encoding.enabled：这两个属性用于配置HTTP 请求和响应的字符编码。spring.http.encoding.charset定义字符编码的名称（例如UTF-8），spring.http.encoding.enabled用于启用或禁用字符编码的自动配置。

这些是在Spring Boot的配置文件中与Web应用程序相关的一些重要配置参数。根据你的需求，您可以在配置文件中设置这些参数来定制和配置您的Web应用程序。

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 文件。

② 路径 Ⅱ 是在 resources 文件夹下，再创建一个 resources 文件夹。

（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

注意：

静态资源地址自定义路径之后，默认的路径就无法使用了！

此时，login.html 能够访问到，但index.html无法再访问了 

4.自定义拦截器（SpringMVC配置） 

① 拦截器声明

public class MyInterceptor implements HandlerInterceptor {
    @Override
    public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {
        System.out.println("MyInterceptor拦截器的preHandle方法执行....");
        return true;
    }

    @Override
    public void postHandle(HttpServletRequest request, HttpServletResponse response, Object handler, ModelAndView modelAndView) throws Exception {
        System.out.println("MyInterceptor拦截器的postHandle方法执行....");
    }

    @Override
    public void afterCompletion(HttpServletRequest request, HttpServletResponse response, Object handler, Exception ex) throws Exception {
        System.out.println("MyInterceptor拦截器的afterCompletion方法执行....");
    }
}

② 拦截器配置

@Configuration
public class WebMvcConfig implements WebMvcConfigurer {
    @Override
    public void addInterceptors(InterceptorRegistry registry) {
        registry.addInterceptor(new MyInterceptor());
    }
}

注意：

正常使用配置类即可，只要保证，配置类要在启动类的同包或者子包方可生效！

四、SpringBoot3整合Druid数据源 

步骤：

① 创建程序，引入依赖

<?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>

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

    <groupId>com.mihoyo</groupId>
    <artifactId>springboot-base-druid-04</artifactId>
    <version>1.0-SNAPSHOT</version>


    <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.21</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>

② 配置文件编写（添加 druid 连接池的基本配置）

spring:
  datasource:
    # 连接池类型
    type: com.alibaba.druid.pool.DruidDataSource
    # 如果是springboot2整合druid，可以此方式直接配置账号密码
    # username: 账号
    # password: 密码
    # Druid的其他属性配置 springboot3整合情况下,数据库连接信息必须在Druid属性下!
    druid:
      url: jdbc:mysql://localhost:3306/jdbc
      username: root
      password: 123456
      driver-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检测连接是否有效,开启会降低性能,默认为true
      test-on-borrow: false
      # 归还连接时会执行validationQuery检测连接是否有效,开启会降低性能,默认为true
      test-on-return: false
      # 是否缓存preparedStatement, 也就是PSCache,PSCache对支持游标的数据库性能提升巨大，比如说oracle,在mysql下建议关闭。
      pool-prepared-statements: false
      # 要启用PSCache，必须配置大于0，当大于0时，poolPreparedStatements自动触发修改为true。在Druid中，不会存在Oracle下PSCache占用内存过多的问题，可以把这个数值配置大一些，比如说100
      max-pool-prepared-statement-per-connection-size: -1
      # 合并多个DruidDataSource的监控数据
      use-global-data-source-stat: true

  logging:
    level:
      root: debug

③ 编写实体类User

@Data
public class User {
    private Integer id;
    private String name;
    private String password;
    private String email;
    private Date birthday;
}

④ 编写controller

@RestController
@RequestMapping("user")
public class UserController {

    @Autowired
    private JdbcTemplate jdbcTemplate;

    @GetMapping("list")
    public List<User> list() {
        //省略三层架构，直接对数据库查
        String sql = "select * from users";
        List<User> list = jdbcTemplate.query(sql, new BeanPropertyRowMapper<>(User.class));
        return list;
    }
}

⑤ 编写启动类

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

运行结果：

注意：

① druid-spring-boot-3-starter 如果版本过低的话，虽然适配了SpringBoot3，但缺少自动装配的配置文件，需要手动在resources目录下创建：

META-INF/spring/org.springframework.boot.autoconfigure.AutoConfiguration.imports，文件内容如下：

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

② 只要添加了 spring-boot-starter-jdbc，即 jdbc 相关的启动器，jdbcTemplate 就已经自动被添加到 ioc 容器中了，我们可以直接通过 @Autowired 获取。

五、SpringBoot3整合Mybatis 

1.MyBatis整合步骤 

① 导入依赖：在您的Spring Boot项目的构建文件（如pom.xml）中添加MyBatis和数据库驱动的相关依赖。例如，如果使用MySQL数据库，您需要添加MyBatis和MySQL驱动的依赖。

② 配置数据源：在 application.properties 或 application.yml 中配置数据库连接信息，包括数据库URL、用户名、密码、mybatis的功能配置等。

③ 创建实体类：创建与数据库表对应的实体类。

④ 创建Mapper接口：创建与数据库表交互的Mapper接口。

⑤ 创建Mapper接口SQL实现： 可以使用mapperxml文件或者注解方式

⑥ 创建程序启动类

⑦ 注解扫描：在Spring Boot的主应用类上添加@MapperScan注解，用于扫描和注册Mapper接口。

⑧ 使用Mapper接口：在需要使用数据库操作的地方，通过依赖注入或直接实例化Mapper接口，并调用其中的方法进行数据库操作。

2.Mybatis整合实践

① 创建项目，导入依赖

<?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.mihoyo</groupId>
    <artifactId>springboot-base-mybatis-05</artifactId>
    <version>1.0-SNAPSHOT</version>

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

        <!-- mybatis相关配置启动器 -->
        <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.21</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>
</project>

② 编写配置文件

# druid连接池
spring:
  datasource:
    type: com.alibaba.druid.pool.DruidDataSource
    druid:
      url: jdbc:mysql:///jdbc
      username: root
      password: 123456
      driver-class-name: com.mysql.cj.jdbc.Driver

# mybatis相关配置（彻底摒弃 mybatis-config.xml）
mybatis:
  # 指定mapper.xml文件位置
  mapper-locations: classpath:/mappers/*.xml
  # 别名的配置
  type-aliases-package: com.mihoyo.pojo
  # setting的设置
  configuration:
    # 驼峰式映射
    map-underscore-to-camel-case: true
    # 开启resultMap自动映射
    auto-mapping-behavior: full
    # 开启logback日志输出
    log-impl: org.apache.ibatis.logging.slf4j.Slf4jImpl

③ 实体类准备

@Data
public class User {
    private Integer id;
    private String name;
    private String password;
    private String email;
    private Date birthday;
}

④ Mapper接口准备

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

⑤ Mapper接口实现（XML）

<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE mapper
        PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
        "https://mybatis.org/dtd/mybatis-3-mapper.dtd">

<mapper namespace="com.mihoyo.mapper.UserMapper">
    <select id="queryAll" resultType="user">
        select * from users
    </select>
</mapper>

⑥ 编写三层架构代码（伪代码，不添加 service 层）

@RestController
@RequestMapping("user")
public class UserController {
    @Autowired
    private UserMapper userMapper;

    @GetMapping
    public List<User> query(){
        return userMapper.queryAll();
    }

}

⑦ 启动类和接口扫描

@MapperScan("com.mihoyo.mapper") //指定mapper接口所在位置,将mapper的代理对象加入ioc容器
@SpringBootApplication
public class Main {

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

注意：

该方式下，mapper 接口和 mapper.xml 不必在放在一个文件夹下。

原因：mapper 接口和 mapper.xml已经分开指定，mapper接口在启动类中通过 @MapperScan 指定，mapper.xml 在 application.yml 中通过 mybatis.mapper-locations 指定。

3.声明式事务整合配置

依赖导入：

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

a. controller

@RestController
@RequestMapping("user")
public class UserController {
    @Autowired
    private UserService userService;

    @GetMapping
    public void delete(){
        userService.delete();
    }
}

b. service

@Service
public class UserService {
    @Autowired
    private UserMapper userMapper;

    @Transactional
    public void delete() {
        int rows = userMapper.delete(1);
        System.out.println("rows = " + rows);
        int i = 1 / 0;//制造异常，检测事务是否回滚
    }
}

注意：

SpringBoot项目会自动配置一个 DataSourceTransactionManager，所以我们只需在方法（或者类）加上 @Transactional 注解，就自动纳入 Spring 的事务管理了。 

c. mapper

mapper 接口：

public interface UserMapper {

    int delete(int i);
}

mapper.xml：

<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE mapper
        PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
        "https://mybatis.org/dtd/mybatis-3-mapper.dtd">

<mapper namespace="com.mihoyo.mapper.UserMapper">
    <delete id="delete">
        delete from users where id = #{id}
    </delete>
</mapper>

运行结果：

4.AOP整合配置 

依赖导入：

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

编写增强类，直接使用aop注解即可:  

@Component
@Aspect
@Order(5)
public class LogAdivce {
    @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项目打包和运行 

 1.添加打包插件

在SpringBoot项目中添加 spring-boot-maven-plugin 插件是为了支持将项目打包成可执行的可运行jar 包。

如果不添加 spring-boot-maven-plugin 插件配置，使用常规的 java -jar 命令来运行打包后的 SpringBoot 项目是无法找到应用程序的入口点，因此导致无法运行。

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

2.执行打包

在 idea 点击 package 进行打包

可以在编译的 target 文件中查看 jar 包

3.命令启动和参数说明 

 java -jar 命令用于在 Java 环境中执行可执行的 JAR 文件。

下面是关于java -jar命令的说明：

命令格式：java -jar  [选项] [参数] <jar文件名>

① -D<name>=<value>：设置系统属性，可以通过System.getProperty()方法在应用程序中获取该属性值。例如：java -jar -Dserver.port=8080 myapp.jar。

② -X：设置JVM参数，例如内存大小、垃圾回收策略等。常用的选项包括：

        -Xmx<size>：设置JVM的最大堆内存大小，例如 -Xmx512m 表示设置最大堆内存为512MB。

        -Xms<size>：设置JVM的初始堆内存大小，例如 -Xms256m 表示设置初始堆内存为256MB。

③ -Dspring.profiles.active=<profile>：指定Spring Boot的激活配置文件，可以通过 application-<profile>.properties 或 application-<profile>.yml文件来加载相应的配置。例如：java -jar -Dspring.profiles.active=dev myapp.jar。

启动和测试：

注意： -D 参数必须要在jar之前，否者不生效！