【愚公系列】2023年10月 Java教学课程 163-SpringBoot概述和基本使用

🏆 作者简介，愚公搬代码
🏆《头衔》：华为云特约编辑，华为云云享专家，华为开发者专家，华为产品云测专家，CSDN博客专家，阿里云专家博主，阿里云签约作者，腾讯云优秀博主，腾讯云内容共创官，掘金优秀博主，51CTO博客专家等。
🏆《近期荣誉》：2022年CSDN博客之星TOP2，2022年华为云十佳博主等。
🏆《博客内容》：.NET、Java、Python、Go、Node、前端、IOS、Android、鸿蒙、Linux、物联网、网络安全、大数据、人工智能、U3D游戏、小程序等相关领域知识。
🏆🎉欢迎 👍点赞✍评论⭐收藏

---

🚀一、SpringBoot概述

Spring Boot是一个开源的Java框架，用于快速构建基于Spring框架的Web应用程序和微服务。它采用了约定优于配置的原则，提供了自动配置和快速开发功能，使开发人员可以专注于业务逻辑而不是框架配置。Spring Boot还提供了丰富的功能和扩展，例如集成了Spring框架中的各种组件和模块，支持多种数据源、安全性、日志和监控等。Spring Boot还允许开发人员快速构建可部署的独立应用程序，并支持云计算平台和容器化部署。

🔎1.SpringBoot功能

🦋1.1 自动配置

下面是SpringBoot自动配置的一些功能及其对应的自动配置类：

功能	自动配置类
数据源自动配置	DataSourceAutoConfiguration
JdbcTemplate自动配置	JdbcTemplateAutoConfiguration
Hibernate自动配置	HibernateJpaAutoConfiguration
WebMvc自动配置	WebMvcAutoConfiguration
HttpMessageConverter自动配置	HttpMessageConvertersAutoConfiguration
静态资源自动配置	ResourceProperties
日志框架自动配置	LoggingAutoConfiguration
Logback自动配置	LogbackAutoConfiguration
Log4j2自动配置	Log4j2AutoConfiguration
缓存自动配置	CacheAutoConfiguration
EhCache自动配置	EhCacheCacheConfiguration
Hazelcast自动配置	HazelcastCacheConfiguration
Redis自动配置	RedisAutoConfiguration
模板引擎自动配置	FreeMarkerAutoConfiguration
Thymeleaf自动配置	ThymeleafAutoConfiguration
任务调度自动配置	TaskSchedulingAutoConfiguration
安全框架自动配置	SecurityAutoConfiguration

SpringBoot的自动配置功能可以提供很多便利，并且可以让开发者更快地构建应用程序。同时，SpringBoot的自动配置功能是高度可定制的，如果需要，开发者可以根据自己的需求自定义配置。

🦋1.2 起步依赖

Spring Boot起步依赖是一组预定义的依赖项集合，可以帮助开发者快速构建Spring应用程序。 Spring Boot起步依赖管理了各种不同的依赖项，包括Web框架，数据库驱动程序和安全性依赖项等。 这些依赖项通常被组织成一个或多个Maven或Gradle依赖项，可以很容易地添加到项目中。

使用Spring Boot起步依赖可以加速应用程序的开发过程，因为它们不需要手动添加大量的依赖项，而是直接添加一个起步依赖即可。

例如，如果您要创建一个Web应用程序，只需添加spring-boot-starter-web起步依赖项即可。 这将自动添加Spring MVC，Tomcat服务器和其他相关库。

以下是一些常见的Spring Boot起步依赖：

• spring-boot-starter-web：用于构建Web应用程序的起步依赖项。
• spring-boot-starter-data-jpa：用于与关系型数据库交互的起步依赖项，包括JPA和Hibernate。
• spring-boot-starter-security：用于提供基本安全功能的起步依赖项，如身份验证和授权。
• spring-boot-starter-test：用于编写单元测试的起步依赖项。

可以通过在Maven或Gradle中添加相应的起步依赖项来使用它们。

• starte
  • SpringBoot中常见项目名称，定义了当前项目使用的所有项目坐标，以达到减少依赖配置的目的

<?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.itheima</groupId>
    <artifactId>springboot-01-quickstart</artifactId>
    <version>0.0.1-SNAPSHOT</version>
    <dependencies>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>
    </dependencies>
</project>

<project xmlns="http://maven.apache.org/POM/4.0.0"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance">
    <modelVersion>4.0.0</modelVersion>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-dependencies</artifactId>
    <version>2.5.0</version>
    <packaging>pom</packaging>
    <properties>
        <servlet-api.version>4.0.1</servlet-api.version>        
        ...
    </properties>
</project>

• parent
  • 所有SpringBoot项目要继承的项目，定义了若干个坐标版本号（依赖管理，而非依赖），以达到减少依赖冲突的目的

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance">
    <modelVersion>4.0.0</modelVersion>
    <parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-dependencies</artifactId>
        <version>2.5.0</version>
    </parent>
    <artifactId>spring-boot-starter-parent</artifactId>
    <packaging>pom</packaging>    
    ...
</project>

• 实际开发
  • 使用任意坐标时，仅书写GAV中的G和A，V由SpringBoot提供
  • 如发生坐标错误，再指定version（要小心版本冲突）

<?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">
    <parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>2.5.0</version>
    </parent>
    <dependencies>
        <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>
</project>

🦋1.3 辅助功能

SpringBoot提供了许多有用的辅助功能，包括：

1. 自动配置：SpringBoot会根据你在项目中添加的依赖库自动配置许多功能，例如数据库连接、Web服务、安全性等，简化了项目的配置工作。

2. 快速构建：SpringBoot提供了许多快速构建工具，例如Spring Initializr，可以快速生成一个基础项目，包括必要的依赖和配置文件。

3. 嵌入式服务器：SpringBoot支持使用内置的Tomcat或Jetty服务器，让你可以轻松地将应用程序部署到云平台上。

4. 视图模板：SpringBoot提供了许多视图模板，例如Thymeleaf和Freemarker，使得开发Web应用程序变得更加简单和快速。

5. Actuator：Actuator提供了许多与应用程序运行状况有关的监控和管理功能，例如查看应用程序的Health、Metrics、配置信息等。

• SpringBoot程序启动

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

• SpringBoot在创建项目时，采用jar的打包方式

• SpringBoot的引导类是项目的入口，运行main方法就可以启动项目

• 使用maven依赖管理变更起步依赖项

注意：Spring Boot 并不是对 Spring 功能上的增强，而是提供了一种快速使用 Spring 的方式。

🦋1.4 分析SpringBoot的自动配置：以tomcat启动为例

1. 查看自动配置的spring-boot-autoconfigure的包下的配置文件spring.factories

   

2. 文件中包含所有Web容器(Tomcat)自动启动的配置类

   org.springframework.boot.autoconfigure.web.servlet.ServletWebServerFactoryAutoConfiguration,\ 
   

3. 找到Tomcat的启动类

   

4. 进入ServerProperties类中查看代码，可以看到端口号的set方法

   public void setPort(Integer port) {
   	this.port = port;
   }
   

5. 在ServerProperties类中存在一个静态内部类Tomcat，配置了服务器的属性

   

6. 查看默认配置：spring-configuration-metadata.json文件，大约在1213行

   {
       "name": "server.port",
       "type": "java.lang.Integer",
       "description": "Server HTTP port.",
       "sourceType": "org.springframework.boot.autoconfigure.web.ServerProperties",
       "defaultValue": 8080
   }
   

🚀二、SpringBoot快速入门

🔎1.入门案例开发步骤

需求：搭建SpringBoot工程，定义HelloController.hello()方法，返回”Hello SpringBoot!”。

实现步骤：

①创建Maven项目

②导入SpringBoot起步依赖

<!-- 1.使用spring-boot的父模块 -->
<parent>
    <artifactId>spring-boot-starter-parent</artifactId>
    <groupId>org.springframework.boot</groupId>
    <version>3.1.5</version>
</parent>

<dependencies>
    <!-- 2. 使用web的起步依赖 -->
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-web</artifactId>
    </dependency>
</dependencies>

③定义Controller

package com.itheima.controller;

import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;

@RestController
@RequestMapping("/demo1")
public class Demo1QuckStartController {

    @RequestMapping("/hello")
    public String hello() {
        System.out.println("你好！Spring Boot!");
        return "Hello, Spring Boot!";
    }
}

④编写引导类

package com.itheima;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;

/**
 * 1.类命名约定：以Application结尾
 * 2.这个类应该放在其它所有类的同级包或父包中
 * 3.启动类需要添加注解 @SpringBootApplication
 */
@SpringBootApplication
public class QuickStartApplication {

    public static void main(String[] args) {
        //启动Spring的应用程序: 1. 启动类的类名  2. main函数上参数
        SpringApplication.run(QuickStartApplication.class, args);
    }
}

⑤启动测试

🔎2.快速构建SpringBoot

注意事项：

jar支持命令行启动需要依赖maven插件支持，请确认打包时是否具有SpringBoot对应的maven插件。

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

① 对SpringBoot项目打包（执行Maven构建指令package）

② 执行启动指令

java -jar spring-boot-quick-start-0.0.1-SNAPSHOT.jar	# 项目的名称根据实际情况修改

运行效果

🚀三、SpringBoot起步依赖原理分析

• 在spring-boot-starter-parent中定义了各种技术的版本信息，组合了一套最优搭配的技术版本。

• 在各种starter中，定义了完成该功能需要的坐标合集，其中大部分版本信息来自于父工程。

• 我们的工程继承parent，引入starter后，通过依赖传递，就可以简单方便获得需要的jar包，并且不会存在版本冲突等问题。

🚀四、SpringBoot配置-配置文件分类

🔎1.修改服务器端口和自动提示功能消失解决方案

🦋1.1 修改服务器端口

SpringBoot是基于约定的，所以很多配置都有默认值，但如果想使用自己的配置替换默认配置的话，就可以使用application.properties或者application.yml（application.yaml）进行配置。

1. 默认配置文件名称：application

2. 在同一级目录下优先级为：properties>yml > yaml

例如：配置内置Tomcat的端口

• application.properties

server.port=80

• application.yml

server:
  port: 81

• application.yaml

server:
  port: 82

🦋1.2 自动提示功能消失解决方案

0. 先创建Spring的启动类，即包含了main函数和@SpringBootApplication的那个类。如果已经存在生成则忽略这步。

1. 选择File -> Project Structure -> Modules -> 点右边的加号

   

2. 如果没有出现相应的配置文件，则点最右边的绿色按钮，出现对话框，点左边的加号，添加新的配置文件，配置完成点确定以后显示以下窗口
   

🔎2.SpringBoot配置

🦋2.1 yaml基本语法

• 大小写敏感
• 数据值前边必须有空格，作为分隔符
• 使用缩进表示层级关系
• 缩进时不允许使用Tab键，只允许使用空格（各个系统 Tab对应的 空格数目可能不同，导致层次混乱）。
• 缩进的空格数目不重要，只要相同层级的元素左侧对齐即可
• ‘’#" 表示注释，从这个字符一直到行尾，都会被解析器忽略。

server: 
	port: 8080  
    address: 127.0.0.1
name: abc

🦋2.2 yaml数据格式

对象(map)：键值对的集合。

person:  
   name: zhangsan
# 行内写法
person: {name: zhangsan}

数组：一组按次序排列的值

address:
  - beijing
  - shanghai
# 行内写法
address: [beijing,shanghai]

纯量：单个的、不可再分的值

msg1: 'hello \n world'  # 单引忽略转义字符
msg2: "hello \n world"  # 双引识别转义字符

参数引用

name: lisi 
person:
  name: ${name} # 引用上边定义的name值

🦋2.3 获取数据

@Value

#获取普通配置
@Value("${name}")
private String name;
#获取对象属性
@Value("${person.name}")
private String name2;
#获取数组
@Value("${address[0]}")
private String address1;
#获取纯量
@Value("${msg1}")
private String msg1;

Evironment

@Autowired
private Environment env;

System.out.println(env.getProperty("person.name"));

System.out.println(env.getProperty("address[0]"));

🦋2.4 自定义封装获取数据

• 将对象添加Spring容器中，在类上添加@Component注解
• 在类上添加@ConfigurationProperties(prefix=“指定前缀”)
• 添加get和set方法，toString方法
• 在控制器中注入下面Enterprise对象

@Component
@ConfigurationProperties(prefix = "enterprise")
@Data
public class Enterprise {

    private String name;
    private Integer age;
    private String tel;
    private String subject[];
}

注：如果使用lombok需要在pom.xml中导入坐标

<dependency>
    <groupId>org.projectlombok</groupId>
    <artifactId>lombok</artifactId>
</dependency>

• 当输入@ConfigurationProperties注解的时候，自定义对象封装数据警告解决方案

在pom.xml文件添加以下

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

🔎3.多环境开发配置

🦋3.1 旧写法

1. profile是用来完成不同环境下，配置动态切换功能的。

2. profile配置方式

   ​ 多profile文件方式：提供多个配置文件，每个代表一种环境。

   ​ application-dev.properties/yml 开发环境

   ​ application-test.properties/yml 测试环境

   ​ application-pro.properties/yml 生产环境

   ​ yml多文档方式：

​ 在yml中使用 — 分隔不同配置

3. profile激活方式

• 配置文件： 再配置文件中配置：spring.profiles.active=dev
• 虚拟机参数：在VM options 指定：-D spring.profiles.active=dev
• 命令行参数：java –jar xxx.jar --spring.profiles.active=dev

🦋3.2 新写法

☀️3.2.1 多环境启动配置

• yaml文件多环境启动

基本配置

新的写法

application.yml

spring:
  profiles:
    active: pro
    
---
spring:
  config:
    activate:
      on-profile: pro
server:
  port: 80

---
spring:
  config:
    activate:
      on-profile: test
server:
  port: 81

---
spring:
  config:
    activate:
      on-profile: dev
server:
  port: 82

• properties文件多环境启动

#主启动配置文件 application.properties
spring.profiles.active=pro

#环境分类配置文件 application-pro.properties
server.port=80

#环境分类配置文件 application-dev.properties
server.port=81

#环境分类配置文件application-test.properties
server.port=82

☀️3.2.2 多环境启动命令格式

• 带参数启动SpringBoot

# 指定哪个配置名
java –jar springboot.jar --spring.profiles.active=test
# 指定具体的参数
java –jar springboot.jar --server.port=88
# 同时指定配置名 端口号
java –jar springboot.jar --server.port=88 --spring.profiles.active=test

☀️3.2.3 多环境开发控制

Maven与SpringBoot多环境兼容（步骤）

先将application.properties中配置全部先注释了

1. Maven中设置多环境属性

<profiles>
    <profile>
        <id>dev_env</id>
        <properties>
            <profile.active>dev</profile.active>
        </properties>
        <!-- 默认激活 -->
        <activation>
            <activeByDefault>true</activeByDefault>
        </activation>
    </profile>
    
    <profile>
        <id>pro_env</id>
        <properties>
            <profile.active>pro</profile.active>
        </properties>
    </profile>
    
    <profile>
        <id>test_env</id>
        <properties>
            <profile.active>test</profile.active>
        </properties>
    </profile>
</profiles>

2. SpringBoot中引用Maven属性

3. 对资源文件开启对默认占位符的解析

<build>
    <plugins>
        <plugin>
            <artifactId>maven-resources-plugin</artifactId>
            <configuration>
                <encoding>utf-8</encoding>
                <useDefaultDelimiters>true</useDefaultDelimiters>
            </configuration>
        </plugin>
    </plugins>
</build>

4. 启动查看控制台输出的结果

   

注：如果application-dev.properties中的配置也存在，则优先使用这里面的配置，再使用yml中的配置

🔎4.SpringBoot配置-项目内部配置文件加载顺序

加载顺序为上文的排列顺序，高优先级配置的属性会生效

• file:./config/：当前项目下的/config目录下
• file:./ ：当前项目的根目录
• classpath:/config/：classpath的/config目录
• classpath:/ ：classpath的根目录

🔎5.SpringBoot配置-项目外部配置加载顺序

外部配置文件的使用是为了对能不文件的配合

1.命令行

java -jar app.jar --name="Spring“ --server.port=9000

2.指定配置文件位置

 java -jar myproject.jar --spring.config.location=e://application.properties

3.外部不带profile的properties文件

    classpath:/config/application.properties
    classpath:/application.properties

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

🚀五、SpringBoot第三方-项目整合

🔎1.SpringBoot整合Junit

准备数据：创建业务层和实现类

package com.itheima.service;

public interface BookService {

    /**
     * 保存书籍
     */
    void save();
}

package com.itheima.service.impl;

import com.itheima.service.BookService;
import org.springframework.stereotype.Service;

@Service
public class BookServiceImpl implements BookService {
    /**
     * 保存书籍
     */
    @Override
    public void save() {
        System.out.println("业务层：保存书籍");
    }
}

【第一步】添加整合junit起步依赖(可以直接勾选)

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

【第二步】编写测试类

@SpringBootTest
public class BookTest {

    @Autowired
    private BookService bookService;

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

🔎2.SpringBoot整合SSM

🦋2.1 XML方式整合MyBatis

①搭建SpringBoot工程

②引入mybatis起步依赖，添加mysql驱动

<dependencies>
    <dependency>
        <groupId>org.mybatis.spring.boot</groupId>
        <artifactId>mybatis-spring-boot-starter</artifactId>
        <version>2.1.0</version>
    </dependency>

    <dependency>
        <groupId>mysql</groupId>
        <artifactId>mysql-connector-java</artifactId>
        <!--<scope>runtime</scope>-->
    </dependency>
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-test</artifactId>
        <scope>test</scope>
    </dependency>
</dependencies>

③编写DataSource和MyBatis相关配置

application.yml

# datasource
spring:
  datasource:
    url: jdbc:mysql:///springboot?serverTimezone=UTC
    username: root
    password: root
    driver-class-name: com.mysql.cj.jdbc.Driver


# mybatis
mybatis:
  mapper-locations: classpath:mapper/*Mapper.xml # mapper映射文件路径
  type-aliases-package: com.itheima.springbootmybatis.domain

  # config-location:  # 指定mybatis的核心配置文件

④定义表和实体类

public class User {
    private int id;
    private String username;
    private String password;


    public int getId() {
        return id;
    }

    public void setId(int id) {
        this.id = id;
    }

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

    @Override
    public String toString() {
        return "User{" +
                "id=" + id +
                ", username='" + username + '\'' +
                ", password='" + password + '\'' +
                '}';
    }
}

⑤编写dao和mapper文件/纯注解开发

编写dao

@Mapper
@Repository
public interface UserXmlMapper {

    public List<User> findAll();
}

mapper.xml

<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN" "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
<mapper namespace="com.itheima.springbootmybatis.mapper.UserXmlMapper">
    <select id="findAll" resultType="user">
        select * from t_user
    </select>
</mapper>

🦋2.2 纯注解方式整合MyBatis

1. 创建新模块，选择Spring初始化，并配置模块相关基础信息

可以换成阿里云的URL：https://start.aliyun.io

2. 选择当前模块需要使用的技术集

3. 可以删除多余的文件，只保留必须的

   

4. 删除后的结构

   

5. 修改pom.xml文件如下：

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

<dependencies>
    <!-- mybatis -->
    <dependency>
        <groupId>org.mybatis.spring.boot</groupId>
        <artifactId>mybatis-spring-boot-starter</artifactId>
        <version>2.2.0</version>
    </dependency>

    <!-- 连接池 -->
    <dependency>
        <groupId>com.alibaba</groupId>
        <artifactId>druid</artifactId>
        <version>1.2.6</version>
    </dependency>

    <!-- 测试 -->
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-test</artifactId>
    </dependency>

    <!-- lombok -->
    <dependency>
        <groupId>org.projectlombok</groupId>
        <artifactId>lombok</artifactId>
    </dependency>

    <!-- mysql驱动 -->
    <dependency>
        <groupId>mysql</groupId>
        <artifactId>mysql-connector-java</artifactId>
        <version>5.1.43</version>
        <scope>runtime</scope>
    </dependency>

</dependencies>

4. 配置application.yml，如果没有提示信息，按前面的步骤配置

   

5. 设置数据源参数，使用之前的ssm_db数据库

spring:
  # 数据库连接池的配置
  datasource:
    type: com.alibaba.druid.pool.DruidDataSource
    driver-class-name: com.mysql.cj.jdbc.Driver
    url: jdbc:mysql://localhost:3306/ssm_db?serverTimezone=UTC
    username: root
    password: root

# Mybatis的配置
mybatis:
  type-aliases-package: com.itheima.domain
  configuration:
    map-underscore-to-camel-case: true
    log-impl: org.apache.ibatis.logging.stdout.StdOutImpl

注意事项：SpringBoot版本低于2.4.3(不含)，Mysql驱动版本大于8.0时，需要在url连接串中配置时区，或在MySQL数据库端配置时区解决此问题

jdbc:mysql://localhost:3306/ssm_db?serverTimezone=UTC

5. 定义数据层接口与映射配置

@Data
public class Book {

    private Integer id;
    private String type;
    private String name;
    private String description;

}

6. 接口上添加**@Mapper**注解
   另一种做法：在SpringBoot的启动类上使用@MapperScan(“com.itheima.dao”)注解，做一次就可以了

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

7. 测试类中注入dao接口，测试功能。如果bookDao下有红线，如果能正常执行，则忽略。

@SpringBootTest
class SpringBootMybatisApplicationTest {
    @Autowired
    private BookDao bookDao;

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

8. 将启动类向上移动到com.itheima这一级

🦋2.3 SpringBoot实现ssm整合

1. 在上面的SpringBoot工程，添加SpringMVC依赖。

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

2. 复制原型目录下SpringMVC工程各种资源(主java类、页面、测试类)到static目录下

   默认的静态资源访问路径有四个:

   • classpath:/META-INF/resources/
   • classpath:/resources/
   • classpath:/static/
   • classpath:/public

   说明: 只要静态资源放在这些目录中任何一个，SpringMVC都会帮我们处理。

3. 在static目录中提供index.html页面，跳转到"pages/books.html"

<script>
    location.href="pages/books.html"
</script>

4. 其它的Java代码直接复制到相应的目录下即可

🔎3.SpringBoot整合redis

①搭建SpringBoot工程

②引入redis起步依赖

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

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

③配置redis相关属性

spring:
  redis:
    host: 127.0.0.1 # redis的主机ip
    port: 6379

④注入RedisTemplate模板

⑤编写测试方法，测试

@RunWith(SpringRunner.class)
@SpringBootTest
public class SpringbootRedisApplicationTests {

    @Autowired
    private RedisTemplate redisTemplate;

    @Test
    public void testSet() {
        //存入数据
        redisTemplate.boundValueOps("name").set("zhangsan");
    }

    @Test
    public void testGet() {
        //获取数据
        Object name = redisTemplate.boundValueOps("name").get();
        System.out.println(name);
    }

}

---

🚀感谢：给读者的一封信

亲爱的读者，

我在这篇文章中投入了大量的心血和时间，希望为您提供有价值的内容。这篇文章包含了深入的研究和个人经验，我相信这些信息对您非常有帮助。

如果您觉得这篇文章对您有所帮助，我诚恳地请求您考虑赞赏1元钱的支持。这个金额不会对您的财务状况造成负担，但它会对我继续创作高质量的内容产生积极的影响。

我之所以写这篇文章，是因为我热爱分享有用的知识和见解。您的支持将帮助我继续这个使命，也鼓励我花更多的时间和精力创作更多有价值的内容。

如果您愿意支持我的创作，请扫描下面二维码，您的支持将不胜感激。同时，如果您有任何反馈或建议，也欢迎与我分享。

再次感谢您的阅读和支持！

最诚挚的问候， “愚公搬代码”