黑马课程

1. SpringBoot入门

SpringBoot 是由 Pivotal 团队提供的全新框架，其设计目的是用来简化 Spring 应用的初始搭建以及开发过程

回顾SpringMVC项目，和SpringBoot进行比较

1.1 SpringBoot入门案例

步骤1：创建SpringBoot项目

创建之前先设置好自己的maven本地仓库

注意这里Spring Boot的版本，3版本容易出现冲突，如果选择2版本暂时未发现报错

创建好的结构如下

• src, test, pom.xml这三个是必须有的

高版本springboot常见错误

之前选择了3.0.2版本的springboot，由于JDK版本较低是 JDK8 版本，所以会出现配置不统一而报错
即创建时选择了JDK8，而 SpringBoot3 最低要求是 JDK17
从而导致项目配置是JDK8，但Spring环境是JDK17，出现冲突

这种情况的解决思路：
1.升级JDK
2.对Spring降级（下面的方法，降到JDK8，实际上就和创建时选择版本2的SpringBoot一致了，只是用于修改已有项目）

• java: JDK isn't specified for module 'springboot'

  原因：.idea中存放了一些项目的配置信息，如果删除将报错此错误；
  方案：重启时会自动创建新的.idea，报错时重新打开一次项目即可

• java: 警告: 源发行版 17 需要目标发行版 17
  则检查以下三个地方的JDK版本是否正确（如这里是1.8版本）

  • Project Structure – Project – SDK （选择 1.8）

  • Project Structure – Modules – Language Level （选择 8）

  • Settings – Build,Execution,Deployment – Compiler – Project bytecode version （选择 8）
    以及同位置的Target bytecode version （输入8）

    

• 类文件具有错误的版本 61.0, 应为 52.0

  原因：之前创建时选择了3.0.2版本的springboot，版本过高
  解决：修改pom.xml里面的相关配置，如下

  <parent>
      <groupId>org.springframework.boot</groupId>
      <artifactId>spring-boot-starter-parent</artifactId>
      <version>2.7.8</version>
      <relativePath/> <!-- lookup parent from repository -->
  </parent>
  <properties>
      <java.version>1.8</java.version>
  </properties>
  

步骤2：创建BookController

package com.example.controller;

@RestController
@RequestMapping("/books")
public class BookController {
    @GetMapping("/{id}")
    public String getById(@PathVariable Integer id){
        System.out.println("id = "+id);
        return "hello, spring boot";
    }
}

步骤3：启动服务器并运行程序

直接运行创建项目时自动生成的SpringbootApplication程序，即可启动tomcat服务器
访问：http://localhost:8080/books/1，成功看到结果

• 不用再书写之前一大堆的配置类，springboot自动配置
• 不用手动导入依赖，Spring相关依赖已经在pom.xml自动创建
  spring-boot-starter-web和spring-boot-starter-test分别涵盖了spring web相关依赖和test相关依赖

pom.xml示例

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 https://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>
    <parent>
        <!-- 和之前的maven继承学习的，继承父工程的依赖 -->
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>2.7.8</version>
        <relativePath/> <!-- lookup parent from repository -->
    </parent>
    <groupId>com.example</groupId>
    <artifactId>springboot</artifactId>
    <version>0.0.1-SNAPSHOT</version>
    <properties>
        <java.version>1.8</java.version>
    </properties>
    
    <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>

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

1.2 官网创建SpringBoot

在1.1节，通过IDEA创建了SpringBoot项目，如果不使用IDEA，可以通过官网教程创建

进入SpringBoot官网：https://spring.io/projects/spring-boot

对项目进行配置

会下载一个springboot项目的zip文件

1.3 SpringBoot工程快速启动

问题导入

• 问题导入

  前端开发人员需要测试前端程序就需要后端开启服务器，这需要前端人员在自己电脑上安装Tomcat和Idea

• 解决方法

  后端将 SpringBoot 工程打成 jar 包，该 jar包运行不依赖于Tomcat和 Idea 这些工具，只需要连接到相同的 Mysql 数据库即可

打包

构建 SpringBoot 工程时自动在 pom.xml 中配置了如下插件

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

此时只需要package命令即可在target目录下生成对应的jar包

启动

进入jar包所在位置，在cmd命令行中输入

java -jar springboot-0.0.1-SNAPSHOT.jar

可以看到和在IDEA一样的执行结果

之前的maven项目也可以打成jar包，但不能像这样通过java -jar命令直接启动
依赖于 spring-boot-maven-plugin 插件

1.4 SpringBoot概述

SpringBoot程序的优点针对的是Spring的缺点

• 自动配置。这个是用来解决Spring程序配置繁琐的问题
• 起步依赖。这个是用来解决Spring程序依赖设置繁琐的问题
• 辅助功能（内置服务器,…）。在启动SpringBoot程序时既没有使用本地的tomca也没有使用tomcat插件，而是使用SpringBoot内置的服务器

起步依赖

• 在pom.xml中配置，相当于之前Spring里面的各种依赖导入

使用 Spring Initializr 方式创建的 Maven 工程的的 pom.xml 配置文件中自动生成了很多包含 starter 的依赖

<parent>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-parent</artifactId>
    <version>2.7.8</version>
    <relativePath/> <!-- lookup parent from repository -->
</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>

spring-boot-starter-parent

查看该jar包，发现它又继承自spring-boot-dependencies

<parent>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-dependencies</artifactId>
    <version>2.7.8</version>
</parent>

spring-boot-starter-parent主要是配置了插件管理<pluginManagement>
它的父工程spring-boot-dependencies才是配置了各种依赖及其版本

spring-boot-dependencies里面主要有<properties>，<dependencyManagement>，<build> 3个配置

• properties

  定义了各个技术软件依赖的版本，避免了考虑版本的兼容问题
  这里的版本是和SpringBoot的版本相对应的，比如这里的SpringBoot对应的是2.7.8版本，那么几个之前用过的依赖版本如下

  <servlet-api.version>4.0.1</servlet-api.version>
  <mysql.version>8.0.32</mysql.version>
  

• dependencyManagement

  相当于对所依赖jar包进行版本管理的管理器，它并没有导入依赖，只是锁定了版本
  子工程如果需要某个依赖，只需要引入依赖的 groupid 和 artifactId 不需要定义 version，例如

  <dependency>
      <groupId>com.mysql</groupId>
      <artifactId>mysql-connector-j</artifactId>
      <version>${mysql.version}</version>
      <exclusions>
          <exclusion>
              <groupId>com.google.protobuf</groupId>
              <artifactId>protobuf-java</artifactId>
          </exclusion>
      </exclusions>
  </dependency>
  

  里面还有一些版本号直接写明的依赖，表示不建议更改版本，如

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

• build

  里面主要是<buildManagement>对各种插件进行了版本锁定

！如果由于版本原因报错：com.mysql:mysql-connector-j:jar:unknown was not found 等，还是可以自己指定版本号来解决

spring-boot-starter-web

包含了如下的依赖

<dependencies>
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter</artifactId>
        <version>2.7.8</version>
        <scope>compile</scope>
    </dependency>
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-json</artifactId>
        <version>2.7.8</version>
        <scope>compile</scope>
    </dependency>
    <!-- 这个依赖使得项目内置了一个tomcat，这也是之前java -jar能够运行的原因 -->
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-tomcat</artifactId>
        <version>2.7.8</version>
        <scope>compile</scope>
    </dependency>
    <!-- SpringMVC相关jar包 -->
    <dependency>
        <groupId>org.springframework</groupId>
        <artifactId>spring-web</artifactId>
        <version>5.3.25</version>
        <scope>compile</scope>
    </dependency>
    <dependency>
        <groupId>org.springframework</groupId>
        <artifactId>spring-webmvc</artifactId>
        <version>5.3.25</version>
        <scope>compile</scope>
    </dependency>
</dependencies>

spring-boot-starter-test

里面主要是<dependencies>标签，定义和测试相关的jar包，例如之前用过的spring-test就在这里引入

<dependency>
    <groupId>org.springframework</groupId>
    <artifactId>spring-test</artifactId>
    <version>5.3.25</version>
    <scope>compile</scope>
</dependency>

引导类和自动配置

引导类

SpringBoot项目在创建时，会自动创建一个SpringbootApplication的引导类，如下

package com.example;

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

• SpringBoot在创建项目时，采用jar的打包方式
• SpringBoot的引导类是项目的入口，运行main方法就可以启动项目
• pom.xml中配置了 spring-boot-starter-web 依赖，该依赖中又包含tomcat依赖，因此运行引导类可以启动工程

自动配置

@SpringBootApplication注解：会将引导类所在的包及其子包都扫描一遍

切换web服务器（辅助功能）

之前用的都是tomcat服务器，如果需要换成jetty服务器（nexus私服就是用的jetty服务器），可以按如下设置

步骤1：排除掉tomcat服务器

在项目的pom.xml文件中找到spring-boot-starter-web，并设置排除掉tomcat

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

此时再运行引导类，发现启动后很快停止，因为未能启动tomcat服务器

步骤2：引入jetty服务器

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

此时再启动，就可以看到jetty服务器被启动了

jetty比tomcat更轻量级，扩展性更好，谷歌应用引擎（GAE）已经全面切换为jetty
大型应用仍使用tomcat

2. SpringBoot配置文件

2.1 配置文件格式

springboot项目创建后，在resources下会创建一个空的application.properties配置文件，修改端口号等都在此文件中配置
也可以将application.properties换成application.yml、application.yaml

• application.properties

  server.port=80
  

• application.yml

  必须有空格

  server:
  	port: 81
  

• application.yaml

  必须有空格

  server:
  	port: 82
  

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

• 一般写yml配置文件
• 三个配置文件的先后优先级是：properties、yml、yaml

如果配置文件有问题，可以在如下地方进行SpringBoot的配置文件设置

2.2 yaml格式

YAML（YAML Ain’t Markup Language），一种数据序列化格式

优点

• 容易阅读

  yaml 类型的配置文件比 xml 类型的配置文件更容易阅读，结构更加清晰

• 容易与脚本语言交互

• 以数据为核心，重数据轻格式

  yaml 更注重数据，而 xml 更注重格式

YAML 文件扩展名：

• .yml (主流)
• .yaml

语法规则

• 大小写敏感

• 属性层级关系使用多行描述，每行结尾使用冒号结束

• 使用缩进表示层级关系，同层级左侧对齐，只允许使用空格（不允许使用Tab键）

• 属性值前面添加空格（属性名与属性值之间使用冒号+空格作为分隔）

• # 表示注释

• 数组数据在数据书写位置的下方使用减号作为数据开始符号，每行书写一个数据，减号与数据间空格分隔，例如

  subject:
      - Java
      - 前端
      - 大数据
  

2.3 yaml配置文件数据读取

编写application.yml文件

lesson: SpringBoot

server:
  port: 80

enterprise:
  name: company
  age: 16
  tel: 123456789
  subject:
    - java
    - c
    - python

方法一：@Value

在BookController中获取application.yml方式

@Value("${lesson}")
private String lesson;
@Value("${server.port}")
private Integer port;
@Value("${enterprise.subject[0]}")
private String subject00;

方法二：Environment

package com.example.controller;

@RestController
@RequestMapping("/books")
public class BookController {
    @Autowired
    private Environment environment;

    @GetMapping("/{id}")
    public String getById(@PathVariable Integer id){
        System.out.println(environment.getProperty("enterprise.age"));
        return "hello, spring boot";
    }
}

在框架中常使用，一般开发很少用

方法三：实体类（常用）

package com.example.domain;

@Component
@ConfigurationProperties(prefix = "enterprise")
public class Enterprise {
    private String name;
    private int age;
    private String tel;
    private String[] subject;
	//省略getter, setter, toString
}

package com.example.controller;

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

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

3. 多环境配置

回顾：之前在学习Maven时，多环境是通过在父工程中配置 <profiles>实现的

3.1 yml配置

在 application.yml 中使用 --- 来分割不同的配置，设置多环境

# 设置启动的环境
spring:
  profiles:
    active: dev

---
#开发
spring:
  profiles: dev
server:
  port: 80

---
#生产
spring:
  profiles: pro
server:
  port: 81

---
#测试
spring:
  profiles: test
server:
  port: 82

这种写法会提示过时，新的写法为

# 设置启动的环境
spring:
  profiles:
    active: dev

---
#开发
spring:
  config:
    activate:
      on-profile: dev
server:
  port: 80

可以自己选择哪种写法

3.2 properties配置

创建application.properties，如下

#设置启动的环境
spring.profiles.active=dev

创建application-dev.properties，如下

server.port=8080

同样还需要创建 application-pro.properties，application-test.properties，即可完成多环境配置

3.3 命令行配置

步骤1：打包

• package前先clean一下

• 如果有中文，打包可能报错，修改项目编码
  

• 打包方式：maven项目里面的Lifecycle

步骤2：指定环境运行项目

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

在jar包所在目录下（target下），打开cmd，输入如上命令
如果在命令行指定了port，它的优先级高于配置文件中的设置

3.4 配置方式的优先级

见springboot官网

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

3.5 多环境开发兼容问题

这部分很少用，了解即可

maven中可以配置多环境（pom.xml），springboot也可以配置多环境（application.yml），如果都配置了，谁的优先级更高？

• pom.xml的优先级高于application.yml

现在有这样一个需求

• 要求springboot和maven的环境统一

• 希望springboot能读取maven里的多环境设置，使得springboot里面的环境设置跟随maven

• 实现：在pom.xml指定默认环境，但不指定端口号；这个默认环境要被maven和springboot通用
  application.yml会设置具体的、不同环境下的端口号，但默认环境将跟随pom.xml里面的设置

步骤1：Maven中设置多环境属性（pom.xml）

<profiles>
    <!-- 开发环境 -->
    <profile>
        <id>dev</id>
        <properties>
            <profile.active>dev</profile.active>
        </properties>
        <!-- 默认环境-->
        <activation>
            <activeByDefault>true</activeByDefault>
        </activation>
    </profile>
    <!-- 生产环境 -->
    <profile>
        <id>pro</id>
        <properties>
            <profile.pro>pro</profile.pro>
        </properties>
    </profile>
    <!-- 测试环境 -->
    <profile>
        <id>test</id>
        <properties>
            <profile.pro>test</profile.pro>
        </properties>
    </profile>
</profiles>

步骤2：在springboot中也设置多环境（application.yml）

# 设置启动的环境
spring:
  profiles:
    active: ${profile.active}
---
#开发
spring:
  profiles: dev
server:
  port: 80
---
#生产
spring:
  profiles: pro
server:
  port: 81
---
#测试
spring:
  profiles: test
server:
  port: 82

步骤3：开启插件（pom.xml）

允许占位符解析

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

步骤4：打包
此时打包之后，application.yml里面的active: ${profiles.active}就变为active: dev了
路径：springboot\target\springboot-0.0.1-SNAPSHOT.jar\BOOT-INF\classes\application.yml

3.6 配置文件分类

• jar包内部的配置文件

  resouces/application.yml 和 resources/config/application.yml

  • 后者的优先级高于前者

  • resouces/application.yml 相当于不稳定版本，时常向里面修改
    resources/config/application.yml 相当于发布版本

• jar包外部的配置文件

  问题：临时配置如果太多，在命令行测试jar包时，就不得不加上一堆属性

  • 解决方法：在路径下添加临时配置文件，它的优先级项目里的配置文件

  • 且同样的，config里面的配置文件优先级高于外面的配置文件

    

  • 运行程序，发现在target/config/目录下的application.yml具有最高优先级

    java -jar springboot-0.0.1-SNAPSHOT.jar
    

    如下载各种软件，如tomcat，里面会携带各种类似的配置文件

4. SpringBoot整合

4.1 SpringBoot整合Junit

Spring整合Junit

@RunWith(SpringJUnit4ClassRunner.class)//设置运行器
@ContextConfiguration(classes = SpringConfig.class)//加载环境
public class UserServiceTest {
    @Autowired
    private BookService bookService;//注入测试对象
    
    @Test
    public void testSave(){//测试功能
        bookService.save();
    }
}

SpringBoot整合Junit

生成SpringBoot项目时，在test里面会自动生成一个SpringbootApplicationTests类，只需要在contextLoads里面调用方法，即可测试

package com.example;

@SpringBootTest
class SpringbootApplicationTests {
    @Autowired
    private BookService bookService;
    @Test
    void contextLoads() {
        bookService.save();
    }
}

• 在引导类com.example.SpringbootApplicationTests上有注解@SpringBootTest
  它会自动扫描引导类所在的包及子包org.example，因此被@Service标注的BookServiceImpl会成为Bean，实现自动注入

• 测试类会自动加载引导类，即初始化Spring的环境

  • 测试类必须在引导类的包或子包中，这里是com.example

    

• 如果测试类位置不对，可以通过如下命令为其指定启动类的位置

  @SpringBootTest(classes = SpringbootApplication.class)
  

4.2 SpringBoot整合MyBatis

Spring整合MyBatis

• 编写配置类
  • SpringConfig：配置Spring扫描bean，引入JdbcConfig，MybatisConfig
  • JdbcConfig：设置数据库连接参数和数据源
  • MybatisConfig：获取SqlSessionFactory对象，定义映射配置（扫描dao包）

SpringBoot整合MyBatis

步骤1：创建项目和导入依赖

在创建选择依赖时，勾选以下三项：Web/Spring Web，SQL/MyBatis Framework，MySQL Driver

也可以为已经现有项目直接添加依赖来完成整合
添加的依赖版本仍需要和原项目的springboot版本相吻合！

新增了依赖

<!-- 整合mybatis相关 -->
<dependency>
    <groupId>org.mybatis.spring.boot</groupId>
    <artifactId>mybatis-spring-boot-starter</artifactId>
    <version>2.3.0</version>
</dependency>
<dependency>
    <groupId>com.mysql</groupId>
    <artifactId>mysql-connector-j</artifactId>
    <scope>runtime</scope>
</dependency>
<dependency>
    <groupId>com.alibaba</groupId>
    <artifactId>druid</artifactId>
    <version>1.1.16</version>
</dependency>

• 注意创建项目不会自动添加 druid 依赖，需要手动添加一下

这里要根据springboot版本，有的版本用的是如下mysql依赖

<dependency>
    <groupId>mysql</groupId>
    <artifactId>mysql-connector-java</artifactId>
    <scope>runtime</scope>
</dependency>

步骤2：准备数据库表并创建实体类

package com.example.domain;

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

步骤3：编写dao文件

package com.example.dao;

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

• 注意这里要添加@Mapper注解，而不是@Repository

步骤4：编写配置文件application.yml

spring:
  datasource:
    driver-class-name: com.mysql.jdbc.Driver
    url: jdbc:mysql://localhost:3306/ssm_db?useSSL=false
    username: root
    password: 123456
    #下面配置数据源，使用druid
    type: com.alibaba.druid.pool.DruidDataSource

• 如果SpringBoot版本是2.7.8，可能提示你的jdbc驱动过时了，让更换为com.mysql.cj.jdbc.Driver，改不改都行

步骤5：测试

package com.example;

@SpringBootTest
class SpringbootApplicationTests {
    @Autowired
    private BookDao bookDao;
    @Test
    void contextLoads() {
        Book book = bookDao.getById(1);
        System.out.println(book);
    }
}

运行即可获得数据库内容

• springboot节省了大量的配置编写

报错解决：serverTimezone=UTC

SpringBoot版本低于2.4.3(不含)，Mysql驱动版本大于8.0时，需要在url连接串中配置时区
jdbc:mysql://localhost:3306/ssm_db?useSSL=false&serverTimezone=UTC
或在MySQL数据库端配置时区解决此问题

在pom.xml将springboot的version改为2.4.2，即可看到这个相关报错

5. 案例：SpringBoot整合SSM

需求：将之前的ssm项目springmvc-ssm转为springboot项目

5.1 搭建项目

创建springboot项目

<dependencies>
    <!-- mybatis相关 -->
    <dependency>
        <groupId>org.mybatis.spring.boot</groupId>
        <artifactId>mybatis-spring-boot-starter</artifactId>
        <version>2.3.0</version>
    </dependency>
    <dependency>
        <groupId>com.mysql</groupId>
        <artifactId>mysql-connector-j</artifactId>
        <scope>runtime</scope>
    </dependency>
    <dependency>
        <groupId>com.alibaba</groupId>
        <artifactId>druid</artifactId>
        <version>1.1.16</version>
    </dependency>
    <!-- web相关 -->
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-web</artifactId>
    </dependency>
    <!-- 测试类相关 -->
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-test</artifactId>
        <scope>test</scope>
    </dependency>
</dependencies>

application.yml

#TODO 配置数据源相关信息

server:
  port: 80
  
spring:
  datasource:
    driver-class-name: com.mysql.jdbc.Driver
    url: jdbc:mysql://localhost:3306/ssm_db?useSSL=false&serverTimeZone=UTC
    username: root
    password: 123456
    type: com.alibaba.druid.pool.DruidDataSource

5.2 功能模块

domain

package com.example.domain;

public class Book {
    private Integer id;
    private String name;
    private String type;
    private String description;
    //省略了setter, getter, toString
}

dao

package com.example.dao;

//TODO 添加@Mapper
@Mapper
public interface BookDao {
    @Insert("insert into tbl_book values (null, #{type}, #{name}, #{description})")
    public int save(Book book);
    @Delete("delete from tbl_book where id = #{id}")
    public int delete(Integer id);
    @Update("update tbl_book set type = #{type}, name = #{name}, description = #{description} where id = #{id}")
    public int update(Book book);
    @Select("select * from tbl_book where id = #{id}")
    public Book getById(Integer id);
    @Select("select * from tbl_book")
    public List<Book> getAll();
}

service

package com.example.service;

@Transactional
public interface BookService {
    public boolean save(Book book);
    public boolean delete(Integer id);
    public boolean update(Book book);
    public Book getById(Integer id);
    public List<Book> getAll();
}

package com.example.service.impl;

@Service
public class BookServiceImpl implements BookService {
    @Autowired
    private BookDao bookDao;
    @Override
    public boolean save(Book book) {
        System.out.println(book);
        return bookDao.save(book) > 0;
    }
    @Override
    public boolean delete(Integer id) {
        return bookDao.delete(id) > 0;
    }
    @Override
    public boolean update(Book book) {
        return bookDao.update(book) > 0;
    }
    @Override
    public Book getById(Integer id) {
        if(id == 1){
            //模拟异常，抛出自定义的业务异常类
            throw new BussinessException(Code.BUSINESS_ERROR, "查询失败，请重试！");
        }
        return bookDao.getById(id);
    }
    @Override
    public List<Book> getAll() {
        return bookDao.getAll();
    }
}

exception

统一异常处理

BussinessException

package com.example.exception;

public class BussinessException extends RuntimeException{
    private Integer code;
    //构造器
    public BussinessException(Integer code, String message){
        super(message);
        this.code = code;
    }
    public BussinessException(Integer code, String message, Throwable cause){
        super(message, cause);
        this.code = code;
    }
    //getter, setter
}

SystemException

package com.example.exception;

public class SystemException extends RuntimeException{
    private Integer code;
    //构造器
    public SystemException(Integer code, String message){
        super(message);
        this.code = code;
    }
    public SystemException(Integer code, String message, Throwable cause){
        super(message, cause);
        this.code = code;
    }
    //getter, setter
}

controller

Code

package com.example.controller;

public class Code {
    //操作成功
    public static final Integer SAVE_OK = 20011;
    public static final Integer DELETE_OK = 20021;
    public static final Integer UPDATE_OK = 20031;
    public static final Integer GET_OK = 20041;
    //操作失败
    public static final Integer SAVE_ERR = 20010;
    public static final Integer DELETE_ERR = 20020;
    public static final Integer UPDATE_ERR = 20030;
    public static final Integer GET_ERR = 20040;
    //定义异常类型
    public static final Integer SYSTEM_ERR = 50001;
    public static final Integer BUSINESS_ERROR = 50002;
    public static final Integer SYSTEM_UNKNOWN_ERR = 59999;
}

Result

统一前后端发送数据格式

package com.example.controller;

public class Result {
    private Integer code;
    private Object data;
    private String msg;
    //构造器
    public Result(){}
    public Result(Integer code, Object data){
        this.code = code;
        this.data = data;
    }
    public Result(Integer code, Object data, String msg){
        this.code = code;
        this.data = data;
        this.msg = msg;
    }
    //getter, setter, toString
}

ProjectExceptionAdvice

异常处理器

package com.example.controller;

@RestControllerAdvice
public class ProjectExceptionAdvice {
    //1. 拦截系统异常
    @ExceptionHandler(SystemException.class)
    public Result doSystemException(SystemException ex){
        //记录日志
        //发送消息给运维
        //发送消息给开发人员
        return new Result(ex.getCode(), null, ex.getMessage());
    }
    //2. 拦截业务异常
    @ExceptionHandler(BussinessException.class)
    public Result doBussinessException(SystemException ex){
        return new Result(ex.getCode(), null, ex.getMessage());
    }
    //3. 拦截其他异常
    @ExceptionHandler(Exception.class)
    public Result doException(Exception ex){
        //记录日志
        //发送消息给运维
        //发送消息给开发人员
        return new Result(Code.SYSTEM_UNKNOWN_ERR, null, "系统繁忙，请稍后重试");
    }
}

BookController

package com.example.controller;

@RestController
@RequestMapping("/books")
public class BookController {
    @Autowired
    private BookService bookService;
    @PostMapping
    public Result save(@RequestBody Book book){
        boolean flag = bookService.save(book);
        return new Result(flag?Code.SAVE_OK:Code.SAVE_ERR, flag);
    }
    @DeleteMapping("/{id}")
    public Result delete(@PathVariable Integer id){
        boolean flag = bookService.delete(id);
        return new Result(flag?Code.DELETE_OK:Code.DELETE_ERR, flag);
    }
    @PutMapping
    public Result update(@RequestBody Book book){
        boolean flag = bookService.update(book);
        return new Result(flag?Code.UPDATE_OK:Code.UPDATE_ERR, flag);
    }
    @GetMapping("/{id}")
    public Result getById(@PathVariable Integer id){
        Book book = bookService.getById(id);
        Integer code = book != null ? Code.GET_OK : Code.GET_ERR;
        String msg = book != null ? "查询成功" : "数据查询失败，请重试！";
        return new Result(code, book, msg);
    }
    @GetMapping
    public Result getAll(){
        List<Book> bookList = bookService.getAll();
        Integer code = bookList != null ? Code.GET_OK : Code.GET_ERR;
        String msg = bookList != null ? "查询成功" : "数据查询失败，请重试！";
        return new Result(code, bookList, msg);
    }
}

5.3 单元测试

package com.example;

@SpringBootTest
class SpringbootApplicationTests {
    @Autowired
    private BookService bookService;
    @Test
    public void testGetById(){
        Book book = bookService.getById(2);
        System.out.println(book);
    }
    @Test
    public void testGetAll(){
        List<Book> bookList = bookService.getAll();
        System.out.println(bookList);
    }
}

可以使用postman进行测试

5.4 静态资源

将之前的做好的前端项目拷贝到 resource/static 目录下

启动引导类，浏览器访问页面：http://localhost/pages/books.html
在前端可以设置一个index.html页面如下

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

然后访问：http://localhost，即可达到主页