SpringBoot3学习记录（有ssm基础）

一、SpringBoot3 介绍

SpringBoot3 简介

SpringBoot3 快速入门

入门总结

1.为什么依赖不需要写版本

2.Startrer（启动器）是什么

3.@SpringBootApplication

二、SpringBoot3 配置文件

统一配置管理

使用yaml配置文件（推荐）

读取配置文件

多环境配置和使用

三、SpringBoot3 整合 SpringMVC

实现过程

SpringMvc相关的配置：

静态资源处理

自定义拦截器

四、SpringBoot3 整合 Druid

操作过程

五、SpringBoot3 整合 Mybatis

1.Mybatis整合步骤

2.mybatis整合实践

3.声明式事务整合配置

4.AOP整合配置

六、SpringBoot3 项目打包和运行

一、SpringBoot3 介绍

SpringBoot3 简介

spring的配置文件或配置类太过繁琐，当编写微服务项目时，每有一个子项目，都需要编写对应的配置文件或配置类等。而SpringBoot能帮我们简单，快速地创建一个独立，生产级别的Spring应用（SpringBoot底层是Spring），大多数SpringBoot应用只需要编写少量配置即可快速整合Spring平台以及第三方技术。

简单来说，SpringBoot整合了Spring，简化了开发。

SpringBoot主要目的：

为所有spring开发提供更快捷、可广泛访问的入门体验
设置合理的默认值，也可以根据需求进行适当的调整
提供一系列大型项目通用的非功能性程序（如内置服务器、安全性、指标、运行检查等）
约定大于配置，基本不需要主动编写配置文件或配置类

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

SpringBoot3 系统要求：

maven 3.6.3+

Tomcat 10.0+

Servlet 9.0+

JDK 17+

SpringBoot3 快速入门

场景：通过浏览器发送 /hello 请求，返回“Hello，SpringBoot 3”

操作步骤：

1.创建Maven工程：springboot_mvc

2.添加依赖（SpringBoot父工程依赖，web启动器依赖）

    <parent>
<!--        只要把它作为父工程，此项目就是一个springboot工程-->
        <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>
    </dependencies>

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

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

4.编程处理类（controller）

@Controller
@RequestMapping("hello")
@ResponseBody
public class HelloController {
    @GetMapping
    public String hello(){
        return "Hello，SpringBoot 3";
    }

}

5.启动项目

运行Main就行

入门总结

1.为什么依赖不需要写版本

父项目spring-boot-starter-parent的父工程spring-boot-dependencies（版本仲裁中心）中把常见的依赖版本都声明好了。

2.Startrer（启动器）是什么

SpringBoot提出了Starter的概念，它是一组预定义的依赖项集合，旨在简化Spring项目的配置和构建过程。Starter包含了一组相关依赖项，以便在启动项目时自动引入需要的库，配置和功能，

（注意：不仅仅是导入库）。

像上面项目中导入了spring-boot-starter-web这个启动器，以往要web开发需要导入依赖：spring-webmvc，servlet，json等，还要写对应的配置文件或配置类。但web启动器内部帮我们导入web相关的依赖，还帮我们导入一些相应的web配置。

Start启动器有两种：官方提供和第三方提供。

官方提供的，一般命名为：spring-boot-starter-*

第三方提供的，一般命名为：*-spring-boot-starter

官方启动器：Developing with Spring Boothttps://docs.spring.io/spring-boot/docs/current/reference/html/using.html?spm=wolai.workspace.0.0.68b623067jPfWP#using.build-systems.starters

启动器与依赖传递：

依赖传递是MAVEN底层实现，它并不全面，如：要使用mybatis，需要导入mysql，druid，mybatis。

启动器是人为根据开发场景设置的，会根据场景包装对应的依赖，如：mybatis的启动器就会包含对应的依赖和配置。

3.@SpringBootApplication

@SpringBootApplication添加到启动类上，是一个组合注解，它的子注解有：

@SpringBootConfiguration

@EnableAuotConfiguration

@ComponentScan

@SpringBootConfiguration：声明当前类是配置类，如果之后想要添加ioc对象可以直接在该类下添加。

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

@EnableAutoConfiguration：自动加载配置类，加载我们编写的配置类和SpringBoot内部自带的配置类。

@ComponentScan：默认扫描当前类所在包以及子包的注解。

Main方法中的SpringApplication.run(Main.class, args)的功能为：

1.创建ioc容器，加载配置

2.启动内置的tomcat服务器

二、SpringBoot3 配置文件

统一配置管理

SpringBoot项目下，进行统一配置管理，如何想设置的参数（端口号，项目根路径，数据库连接信息等等）都集中在一个固定位置和命名的配置文件（application.properties、application.yml、application.yaml）中。

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

在这个配置文件中使用两种方式设置参数：

1.固定的key配置参数（官方提供）

Common Application Propertieshttps://docs.spring.io/spring-boot/docs/current/reference/html/application-properties.html?spm=wolai.workspace.0.0.68b623067jPfWP#appendix.application-properties

2.自定义key配置参数（示例application.properties格式）

如：qiu.name=qiu

在组件中可以使用@Value(${key})接收参数

#使用SpringBoot提供的key修改程序的参数
server.port=81
#项目访问根路径
server.servlet.context-path=/qiu
#自定义key配置参数
qiu.name=qiu
qiu.age=22

@Controller
@RequestMapping("hello")
@ResponseBody
public class HelloController {
    @Value("${qiu.name}")
    private String name;
    @GetMapping
    public String hello(){
        System.out.println(name);
        return "Hello，SpringBoot 3";
    }

}

使用yaml配置文件（推荐）

yaml语法：1.数据结构有树状结构呈现，通过缩进表示层级

2.连续的项目（集合）通过减号"- "来表示（减号后面有一个空格）

3.键值结构key/value使用": "（冒号后面有一个空格）

4.yaml配置文件的拓展名为：yml或yaml

server:
  port: 82
  servlet:
    context-path: /qiu
qiu:
  user:
    name: qiu
    age: 22
    py:
      - a
      - b
      - c

读取配置文件

方式1：@Value("${key}")：该注解本身使用的是di注入，因此使用该注解的类需要放到ioc容器。

@Data
@Component
public class User {
    @Value("${qiu.user.name}")
    private String name;
    @Value("${qiu.user.age}")
    private int age;
    @Value("${qiu.user.py}")
    private List<String> py;
}

@Value注解key必须写全，而且只能读取单个值。

方式2：@ConfigurationProperties注解，将注解内prefix指向要赋值的key那一层。

该注解会把对应的属性赋值（只有类中属性名与指定的那一层key值相同才会赋值）

qiu:
  user:
    name: qiu2
    age: 23
    py:
      - a
      - b
      - c
    pys:
      sex: 1

@Data
@Component
@ConfigurationProperties(prefix = "qiu.user")
public class User {
//    @Value("${qiu.user.name}")
    private String name;
//    @Value("${qiu.user.age}")
    private int age;
//    @Value("${qiu.user.py}")
    private List<String> py;
    private String sex;
}

该测试无误。

多环境配置和使用

在开发一个项目过程中会有不同的时期：开发，测试，生产。对应不同的时期所使用的配置参数可能不同（数据库，日志级别等等）。

这时我们可以在application.yaml(properties)之外再创建文件名如：application-test.yaml（application-*.yaml）的配置文件，再使用application.yaml中的spring.profiles.active: test来激活application-test.yaml。

当配置文件内容太多时，也可以使用该方法，如：druid的配置内容可以放在application-druid.yaml。

如果有多个配置文件需要激活在后面加 " , " 分隔。如：application-test.yaml，application-dev.yaml可以在application.yaml中使用："spring.profiles.active: test,dev"。

如果配置文件有重复的key，会按顺序覆盖。

当项目完成后会被打成一个jar包，我们在执行项目时可以添加命令在启动项目时动态指定要激活哪个配置。

三、SpringBoot3 整合 SpringMVC

实现过程

创建maven项目

继承父工程：spring-boot-starter-parent

导入web开发场景的启动器：spring-boot-starter-web

定义启动类

@SpringBootApplication
public class Main {

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

编写controller层

@Controller
@ResponseBody
@RequestMapping("/hello")
public class HelloController {
    @GetMapping
    public String hello(){
        return "你好，springboot";
    }

}

运行启动类即可访问：localhost:8080/hello

SpringMvc相关的配置：

server.port 端口号

server.servlet.context-path 项目访问根路径

spring.resources.static.locations 静态资源的位置

spring.http.encoding.charset Http请求的字符编码

spring.http.encoding.enabled 响应的字符编码

静态资源处理

我们如何访问项目静态资源？

方式1：将资源放到默认的文件夹

classpath:/META-INF/resources/
classpath:/resources/（该文件夹与项目自带的resources文件夹不同）
classpath:/static/
classpath:/public/

方式2：使用spring.web.resources.static-locations: … 修改

自定义拦截器

1.声明拦截器

public class MyInterceptor implements HandlerInterceptor {

    @Override
    public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {
        System.out.println("MyInterceptor.preHandle");
        return true;
    }
}

2.创建配置类

@Configuration
public class WebConfig implements WebMvcConfigurer {

    @Override
    public void addInterceptors(InterceptorRegistry registry) {
        registry.addInterceptor(new MyInterceptor());
    }
}

只要配置类放在启动类的包或子包下，SpringBoot就会自动扫描。

四、SpringBoot3 整合 Druid

整合Druid连接池一般整合两个功能：数据库连接池功能和监控页面。

但暂时只整合连接池功能，因为druid 1.2.18 目前对springboot3整合并不是很好。

操作过程

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>

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

2.配置文件编写

spring:
  datasource:
    # 连接池类型 
    type: com.alibaba.druid.pool.DruidDataSource

    # Druid的其他属性配置 springboot3整合情况下,数据库连接信息必须在Druid属性下!
    druid:
      url: jdbc:mysql://localhost:3306/springboot
      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

3.创建pojo类和controller层

@Data
public class User {
    private Integer id;
    private String name;
    private Integer age;
    private String email;
}

@Controller
@RequestMapping("user")
@ResponseBody
public class UserController {
    @Autowired
    private JdbcTemplate jdbcTemplate;
    @GetMapping
    public List<User> show(){
        String sql = "select * from user";
        List<User> users = jdbcTemplate.query(sql,new BeanPropertyRowMapper<>(User.class));
        return users;
    }
}

当导入jdbc启动器，springboot会帮我们完成配置类的加载，JdbcTemplate会自动放到ioc容器中，我们需要时注入就行。

4.编写启动类并启动

启动项目时会报错，因为springboot3和druid 1.2.18 不兼容，缺少自动装配的配置文件。（druid版本为1.2.20时已兼容，启动时不会报错）

解决方法：在resources目录下创建

META-INF/spring/org.springframework.boot.autoconfigure.AutoConfiguration.imports

文件，文件内容为

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

五、SpringBoot3 整合 Mybatis

1.Mybatis整合步骤

1.1.导入依赖：添加MyBatis和数据库驱动的相关依赖，如使用Mysql数据库，添加MyBatis和MySQL驱动的依赖。

1.2.配置数据源：在application.yaml中配置数据库连接信息（url，username，password，driver，mybatis的功能配置等）。

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

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

1.5.创建Mapper接口SQL实现：使用mapper.xml文件或注解方式。

1.6创建程序启动类

1.7.注解扫描：在启动类上添加@MapperScan注解，用于扫描和注册Mapper接口。

1.8.使用Mapper接口

2.mybatis整合实践

创建项目：springboot-mybatis

导入依赖：

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

配置文件：

server:
  port: 80
  servlet:
    context-path: /
spring:
  datasource:
    type: com.alibaba.druid.pool.DruidDataSource
    druid:
      url: jdbc:mysql:///springboot_mybatis
      username: root
      password: 123456
      driver-class-name: com.mysql.cj.jdbc.Driver

mybatis:
  configuration:  # setting配置
    auto-mapping-behavior: full
    map-underscore-to-camel-case: true
    log-impl: org.apache.ibatis.logging.slf4j.Slf4jImpl
  type-aliases-package: com.qiu.pojo # 配置别名
  mapper-locations: classpath:/mapper/*.xml # mapperxml位置

druid会报错，记得之前的操作。

创建实体类：

@Data
@ToString
public class User {
    private String account ;
    private String password ;
    private Integer id ;
}

创建Mapper接口：

public interface UserMapper {

    List<User> queryAll();
}

创建Mapper接口SQL实现：由于application.yaml已经设置了mapperxml的位置，因此只需要在resources下创建mapper.Usermapper.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">
<!-- namespace = 接口的全限定符 -->
<mapper namespace="com.qiu.mapper.UserMapper">

    <select id="queryAll" resultType="user">
        select * from user
    </select>

</mapper>

创建启动类：

@SpringBootApplication
@MapperScan("com.qiu.mapper")//mapper接口所在的位置
public class Main {
    public static void main(String[] args) {
//        System.out.println("Hello world!");
        SpringApplication.run(Main.class,args);
    }
}

注解扫描：

在启动类上添加@MapperScan，以前想要mapper接口和mapperxml对应上我们需要为两个文件创建统一的文件路径，但springboot可以在application.json中指定mapperxml的路径，在启动类上@MapperScan上指定mapper接口的路径，这样就不需要两个文件的统一路径。

controller操作：

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

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

访问localhost:80/user

3.声明式事务整合配置

导入依赖

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

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

    @Transactional
    public void addUser(){
        User user = new User();
        user.setId(4);
        user.setAccount("user4");
        user.setPassword("pass4");
        userMapper.addUser(user);
    }

4.AOP整合配置

导入依赖

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

直接使用注解即可：com.qiu.advice.LogAdvice

@Component
@Aspect
@Order(4)
public class LogAdvice {
    @Before("execution(* com..service.*.*(..))")
    public void before(JoinPoint joinPoint){
        String classname = joinPoint.getClass().getSimpleName();
        String methodname = joinPoint.getSignature().getName();
        System.out.println("methodname = " + methodname+" classname = " + classname);
    }
}

六、SpringBoot3 项目打包和运行

在普通的web工程中，要打包需要打成war包，然后再tomcat服务器中运行。

在springboot工程中，由于内置了tomcat，所以可以直接打成jar包，使用命令执行java -jar xx。

1.添加打包插件：不使用插件也可以把项目打成jar包，但运行时会找不到项目入口，所以需要使用springboot的打包插件

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

2.打包

3.命令启动和命令参数

命令参数：

命令格式：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。

命令示例：java -jar -Dserver.port=81 springboot-mybatis-1.0-SNAPSHOT.jar

java -jar -Dserver.port=81 -Dspring.profiles.active=test,dev springboot-mybatis-1.0-SNAPSHOT.jar