devbox
很楠不爱3
这个屌丝很懒，什么也没留下！
关注作者
热门标签
热门文章
当前位置:   article > 正文

spring Boot 2 基础篇 。内含 整合一个spring boot 的 小案例_springboot tensorflow2 pd

作者：很楠不爱3 | 2024-05-25 07:49:44

赞

踩

springboot tensorflow2 pd

目录

springBoot2基础篇

前言与开发环境

一、快速创建Boot项目

1.使用spring提供的快速构建

2.基于maven的手动构建

3.在Idea中隐藏指定文件/文件夹

二、SpringBoot简介

parent

starter

引导类

内嵌tomcat(辅助功能)

rest风格开发（知识补充）

快速复制模块

三、boot对应的配置文件

①修改默认端口号

②基础配置

③3种配置文件类型

③配置文件加载优先级

补充:属性提示消失解决方案

④yaml语法

⑤读取yaml中的数据

四、SpringBoot实现SSMP整合

①整合junit

②整合mybatis

③整合Druid

④综合案例实战

springBoot2基础篇

前言与开发环境

本篇笔记基于 黑马李老师的springBoot教学，具体视频连接：

黑马程序员SpringBoot2全套视频教程，springboot零基础到项目实战（spring boot2完整版）_哔哩哔哩_bilibilihttps://www.bilibili.com/video/BV15b4y1a7yG?p=24&share_source=copy_web

【注意】笔记内容并不完全与老师讲的一致，内容仅供参考！

看完后觉得有帮助的，动动小手点个赞再走叭  >.<  ^_^   谢谢啦！

部分截图以及来源于:CSDN博主「暗恋花香」的原创文章; 原文链接：Spring Boot 2 基础篇学习笔记_暗恋花香的博客-CSDN博客https://blog.csdn.net/qq_42324086/article/details/121184789

环境要求

  • Java8及以上；

  • Maven 3.5及以上；

学习资料

学习的前置知识：

课程单元前置知识要求
基础篇Java基础语法面向对象，封装，继承，多态，类与接口，集合，IO，网络编程等
基础篇Spring与SpringMVC知道Spring是用来管理bean，能够基于Restful实现页面请求交互功能
基础篇Mybatis与Mybatis-Plus基于Mybatis和MybatisPlus能够开发出包含基础CRUD功能的标准Dao模块
基础篇数据库MySQL能够读懂基础CRUD功能的SQL语句
基础篇服务器知道服务器与web工程的关系，熟悉web服务器的基础配置
基础篇maven知道maven的依赖关系，知道什么是依赖范围，依赖传递，排除依赖，可选依赖，继承
基础篇web技术（含vue，ElementUI)知道vue如何发送ajax请求，如何获取响应数据，如何进行数据模型双向绑定
应用篇Linux（CenterOS7）熟悉常用的Linux基础指令，熟悉Linux系统目录结构
应用篇实用开发技术缓存：Redis、MongoDB、…… 消息中间件:RocketMq、RabbitMq、……
原理篇Spring了解Spring加载bean的各种方式 知道Spring容器底层工作原理，能够阅读简单的Spring底层源码

看着略微有点多，其实还好吧，如果个别技术真的不会，在学习课程的时候多用心听就好，基础篇是可以跟着学下来了，后面的实用篇和原理篇就比较难了；

一、快速创建Boot项目

1.使用spring提供的快速构建

步骤①：创建一个空的项目，然后创建新模块，选择Spring Initializr，并配置模块相关基础信息；

如果外网访问不了，或者是构建的时候太慢了，那么就可以在创建工程时，切换选择starter服务路径(server url 点击一下就可以切换)，然后手工收入阿里云提供给我们的使用地址即可。地址：http://start.aliyun.com或https://start.aliyun.com，其他的步骤和下面的类似，只不过是变成中文的了；

步骤②：选择要创建的Boot项目的依赖，这里我们创建的是web项目，注意右下角的依赖是和我们左边打勾的依赖是一致的；

步骤③：开发控制器类

  1. //Rest模式
  2. @RestController
  3. @RequestMapping("/books")
  4. public class BookController {
  5.     @GetMapping
  6.     public String getById(){
  7.         System.out.println("springboot is running...");
  8.         return "springboot is running...";
  9.     }
  10. }

入门案例制作的SpringMVC的控制器基于Rest风格开发，当然此处使用原始格式制作SpringMVC的程序也是没有问题的，上例中的@RestController与@GetMapping注解是基于Restful开发的典型注解

步骤④：运行自动生成的Application类

步骤⑤：使用浏览器访问启动的服务器

访问程序的路径：

http://localhost:8080/books

到这里我们可以大胆推测一下，如果上面这两个文件（pom文件，自动生成的Application类）没有的话，SpringBoot肯定没法玩，看来核心就是这两个文件了。由于是制作第一个SpringBoot程序，先不要关注这两个文件的功能，后面详细讲解内部工作流程。

出现一个小问题：

原因：看了一下idea报告，发现idea自动找的插件版本是其他版本的，和自己设置的不同，导致idea在本地maven仓库查找不到对应的插件版本；

解决办法：加入版本依赖然后再重启idea，即可；

  1. <plugin>
  2. <groupId>org.springframework.boot</groupId>
  3. <artifactId>spring-boot-maven-plugin</artifactId>
  4. <version>2.3.4.RELEASE</version>
  5. </plugin>

2.基于maven的手动构建

步骤①：创建工程时，选择手工创建Maven工

步骤②：参照标准SpringBoot工程的pom文件，书写自己的pom文件即可

  1. <?xml version="1.0" encoding="UTF-8"?>
  2. <project xmlns="http://maven.apache.org/POM/4.0.0"
  3.          xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
  4.          xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
  5.     <modelVersion>4.0.0</modelVersion>
  6.  
  7.     <parent>
  8.         <groupId>org.springframework.boot</groupId>
  9.         <artifactId>spring-boot-starter-parent</artifactId>
  10.         <version>2.5.4</version>
  11.     </parent>
  12.  
  13.     <groupId>com.itheima</groupId>
  14.     <artifactId>springboot_01_04_quickstart</artifactId>
  15.     <version>1.0-SNAPSHOT</version>
  16.  
  17.     <properties>
  18.         <maven.compiler.source>8</maven.compiler.source>
  19.         <maven.compiler.target>8</maven.compiler.target>
  20.     </properties>
  21.  
  22.     <dependencies>
  23.         <dependency>
  24.             <groupId>org.springframework.boot</groupId>
  25.             <artifactId>spring-boot-starter-web</artifactId>
  26.         </dependency>
  27.     </dependencies>
  28.  
  29. </project>

用什么写什么，不用的都可以不写。当然，现在小伙伴们可能还不知道用什么和不用什么，最简单的就是复制粘贴了，随着后面的学习，你就知道哪些可以省略了。此处我删减了一些目前不是必须的东西，一样能用；

步骤③：之前运行SpringBoot工程需要一个类，这个缺不了，自己手写一个就行了，建议按照之前的目录结构来创建，先别玩花样，先学走后学跑。类名可以自定义，关联的名称一切修改即可

  1. @SpringBootApplication
  2. public class Application {
  3.     public static void main(String[] args) {
  4.         SpringApplication.run(<Application.class);
  5.     }
  6. }

关注：类上面的注解@SpringBootApplication千万别丢了，这个是核心，后面再介绍；

关注：类名可以自定义，只要保障下面代码中使用的类名和你自己定义的名称一样即可，也就是run方法中的那个class对应的名称；

步骤④：下面就可以自己创建一个Controller测试一下是否能用了，和之前没有差别了

看到这里其实应该能够想明白了，通过向导或者网站创建的SpringBoot工程其实就是帮你写了一些代码，而现在是自己手写，写的内容都一样，仅此而已。

温馨提示

如果你的计算机上从来没有创建成功过SpringBoot工程，自然也就没有下载过SpringBoot对应的坐标，那用手写创建的方式在不联网的情况下肯定该是不能用的。所谓手写，其实就是自己写别人帮你生成的东西，但是引用的坐标对应的资源必须保障maven仓库里面有才行，如果没有，还是要去下载的

3.在Idea中隐藏指定文件/文件夹

创建SpringBoot工程时，使用SpringBoot向导也好，阿里云也罢，其实都是为了一个目的，得到一个标准的SpringBoot工程文件结构。这个时候就有新的问题出现了，标准的工程结构中包含了一些未知的文件夹，在开发的时候看起来特别别扭，这一节就来说说这些文件怎么处理。

处理方案无外乎两种，如果你对每一个文件/目录足够了解，没有用的完全可以删除掉，或者不删除，但是看着别扭，就设置文件为看不到就行了。删除不说了，直接Delete掉就好了，这一节说说如何隐藏指定的文件或文件夹信息。

既然是在Idea下做隐藏功能，肯定隶属于Idea的设置，设置方式如下。

步骤①：打开设置，【Files】→【Settings】

步骤②：打开文件类型设置界面，【Editor】→【File Types】→【Ignored Files and Folders】，忽略文件或文件夹显示

步骤③：添加你要隐藏的文件名称或文件夹名称，可以使用*号通配符，表示任意，设置完毕即可到这里就做完了，其实就是Idea的一个小功能;

二、SpringBoot简介

结合前面的入门程序搭建来看，springboot为我们极大的简化了web项目的搭建，这些简化操作主要体现在下面四个方面：

  • parent

  • starter

  • 引导类

  • 内嵌tomcat

parent

SpringBoot关注到开发者在进行开发时，往往对依赖版本的选择具有固定的搭配格式，并且这些依赖版本的选择还不能乱搭配。比如A技术的2.0版与B技术的3.5版可以合作在一起，但是和B技术的3.7版合并使用时就有冲突。其实很多开发者都一直想做一件事情，就是将各种各样的技术配合使用的常见依赖版本进行收集整理，制作出了最合理的依赖版本配置方案，这样使用起来就方便多了。

SpringBoot一看这种情况so easy啊，于是将所有的技术版本的常见使用方案都给开发者整理了出来，以后开发者使用时直接用它提供的版本方案，就不用担心冲突问题了，相当于SpringBoot做了无数个技术版本搭配的列表，这个技术搭配列表的名字叫做parent。

parent自身具有很多个版本，每个parent版本中包含有几百个其他技术的版本号，不同的parent间使用的各种技术的版本号有可能会发生变化。当开发者使用某些技术时，直接使用SpringBoot提供的parent就行了，由parent帮助开发者统一的进行各种技术的版本管理

比如你现在要使用Spring配合MyBatis开发，没有parent之前怎么做呢？选个Spring的版本，再选个MyBatis的版本，再把这些技术使用时关联的其他技术的版本逐一确定下来。当你Spring的版本发生变化需要切换时，你的MyBatis版本有可能也要跟着切换，关联技术呢？可能都要切换，而且切换后还可能出现问题。现在这一切工作都可以交给parent来做了。你无需关注这些技术间的版本冲突问题，你只需要关注你用什么技术就行了，冲突问题由parent负责处理。

【有人可能会提出来，万一parent给我导入了一些我不想使用的依赖怎么办？记清楚，这一点很关键，parent仅仅帮我们进行版本管理，它不负责帮你导入坐标，说白了用什么还是你自己定，只不过版本不需要你管理了。整体上来说，使用parent可以帮助开发者进行版本的统一管理】

关注：parent定义出来以后，并不是直接使用的，仅仅给了开发者一个说明书，但是并没有实际使用，这个一定要确认清楚

那SpringBoot又是如何做到这一点的呢？可以查阅SpringBoot的配置源码，看到这些定义

  • 项目中的pom.xml中继承了一个坐标

  1. <parent>
  2.     <groupId>org.springframework.boot</groupId>
  3.     <artifactId>spring-boot-starter-parent</artifactId>
  4.     <version>2.5.4</version>
  5. </parent>

  • 打开后可以查阅到其中又继承了一个坐标

  1. <parent>
  2.     <groupId>org.springframework.boot</groupId>
  3.     <artifactId>spring-boot-dependencies</artifactId>
  4.     <version>2.5.4</version>
  5. </parent>

  • 这个坐标中定义了两组信息，第一组是各式各样的依赖版本号属性，下面列出依赖版本属性的局部，可以看的出来，定义了若干个技术的依赖版本号

  1. <properties>
  2.     <activemq.version>5.16.3</activemq.version>
  3.     <aspectj.version>1.9.7</aspectj.version>
  4.     <assertj.version>3.19.0</assertj.version>
  5.     <commons-codec.version>1.15</commons-codec.version>
  6.     <commons-dbcp2.version>2.8.0</commons-dbcp2.version>
  7.     <commons-lang3.version>3.12.0</commons-lang3.version>
  8.     <commons-pool.version>1.6</commons-pool.version>
  9.     <commons-pool2.version>2.9.0</commons-pool2.version>
  10.     <h2.version>1.4.200</h2.version>
  11.     <hibernate.version>5.4.32.Final</hibernate.version>
  12.     <hibernate-validator.version>6.2.0.Final</hibernate-validator.version>
  13.     <httpclient.version>4.5.13</httpclient.version>
  14.     <jackson-bom.version>2.12.4</jackson-bom.version>
  15.     <javax-jms.version>2.0.1</javax-jms.version>
  16.     <javax-json.version>1.1.4</javax-json.version>
  17.     <javax-websocket.version>1.1</javax-websocket.version>
  18.     <jetty-el.version>9.0.48</jetty-el.version>
  19.     <junit.version>4.13.2</junit.version>
  20. </properties>

第二组是各式各样的的依赖坐标信息，可以看出依赖坐标定义中没有具体的依赖版本号，而是引用了第一组信息中定义的依赖版本属性值

  1. <dependencyManagement>
  2.     <dependencies>
  3.         <dependency>
  4.             <groupId>org.hibernate</groupId>
  5.             <artifactId>hibernate-core</artifactId>
  6.             <version>${hibernate.version}</version>
  7.         </dependency>
  8.         <dependency>
  9.             <groupId>junit</groupId>
  10.             <artifactId>junit</artifactId>
  11.             <version>${junit.version}</version>
  12.         </dependency>
  13.     </dependencies>
  14. </dependencyManagement>

关注：上面的依赖坐标定义是出现在<dependencyManagement>标签中的，其实是对引用坐标的依赖管理，并不是实际使用的坐标。因此当你的项目中继承了这组parent信息后，在不使用对应坐标的情况下，前面的这组定义是不会具体导入某个依赖的；

关注：因为在maven中继承机会只有一次，上述继承的格式还可以切换成导入的形式进行，并且在阿里云的starter创建工程时就使用了此种形式

  1. <dependencyManagement>
  2.     <dependencies>
  3.         <dependency>
  4.             <groupId>org.springframework.boot</groupId>
  5.             <artifactId>spring-boot-dependencies</artifactId>
  6.             <version>${spring-boot.version}</version>
  7.             <type>pom</type>
  8.             <scope>import</scope>
  9.         </dependency>
  10.     </dependencies>
  11. </dependencyManagement>

总结

  1. 开发SpringBoot程序要继承spring-boot-starter-parent

  2. spring-boot-starter-parent中定义了若干个依赖管理

  3. 继承parent模块可以【避免】多个依赖使用相同技术时出现依赖【版本冲突】

  4. 继承parent的形式也可以采用 引入依赖 的形式实现效果

思考

parent中定义了若干个依赖版本管理，但是也没有使用，那这个设定也就不生效啊，究竟谁在使用这些定义呢？

starter

SpringBoot关注到开发者在实际开发时，对于依赖坐标的使用往往都有一些固定的组合方式，比如使用spring-webmvc就一定要使用spring-web。每次都要固定搭配着写，非常繁琐，而且格式固定，没有任何技术含量。

SpringBoot一看这种情况，看来需要给开发者带来一些帮助了。安排，把所有的技术使用的固定搭配格式都给开发出来，以后你用某个技术，就不用一次写一堆依赖了，还容易写错，我给你做一个东西，代表一堆东西，开发者使用的时候，直接用我做好的这个东西就好了，对于这样的固定技术搭配，SpringBoot给它起了个名字叫做starter。

starter定义了使用某种技术时对于依赖的固定搭配格式，也是一种最佳解决方案，使用starter可以帮助开发者减少依赖配置

这个东西其实在入门案例里面已经使用过了，入门案例中的web功能就是使用这种方式添加依赖的。可以查阅SpringBoot的配置源码，看到这些定义

  • 项目中的pom.xml定义了使用SpringMVC技术，但是并没有写SpringMVC的坐标，而是添加了一个名字中包含starter的依赖

  1. <dependency>
  2.     <groupId>org.springframework.boot</groupId>
  3.     <artifactId>spring-boot-starter-web</artifactId>
  4. </dependency>

  • 在spring-boot-starter-web中又定义了若干个具体依赖的坐标

  1. <dependencies>
  2.     <dependency>
  3.         <groupId>org.springframework.boot</groupId>
  4.         <artifactId>spring-boot-starter</artifactId>
  5.         <version>2.5.4</version>
  6.         <scope>compile</scope>
  7.     </dependency>
  8.     <dependency>
  9.         <groupId>org.springframework.boot</groupId>
  10.         <artifactId>spring-boot-starter-json</artifactId>
  11.         <version>2.5.4</version>
  12.         <scope>compile</scope>
  13.     </dependency>
  14.     <dependency>
  15.         <groupId>org.springframework.boot</groupId>
  16.         <artifactId>spring-boot-starter-tomcat</artifactId>
  17.         <version>2.5.4</version>
  18.         <scope>compile</scope>
  19.     </dependency>
  20.     <dependency>
  21.         <groupId>org.springframework</groupId>
  22.         <artifactId>spring-web</artifactId>
  23.         <version>5.3.9</version>
  24.         <scope>compile</scope>
  25.     </dependency>
  26.     <dependency>
  27.         <groupId>org.springframework</groupId>
  28.         <artifactId>spring-webmvc</artifactId>
  29.         <version>5.3.9</version>
  30.         <scope>compile</scope>
  31.     </dependency>
  32. </dependencies>

之前提到过开发SpringMVC程序需要导入spring-webmvc的坐标和spring整合web开发的坐标，就是上面这组坐标中的最后两个了。

但是我们发现除了这两个还有其他的，比如第二个，叫做spring-boot-starter-json。看名称就知道，这个是与json有关的坐标了，但是看名字发现和最后两个又不太一样，它的名字中也有starter，打开看看里面有什么？

  1. <dependencies>
  2.     <dependency>
  3.         <groupId>org.springframework.boot</groupId>
  4.         <artifactId>spring-boot-starter</artifactId>
  5.         <version>2.5.4</version>
  6.         <scope>compile</scope>
  7.     </dependency>
  8.     <dependency>
  9.         <groupId>org.springframework</groupId>
  10.         <artifactId>spring-web</artifactId>
  11.         <version>5.3.9</version>
  12.         <scope>compile</scope>
  13.     </dependency>
  14.     <dependency>
  15.         <groupId>com.fasterxml.jackson.core</groupId>
  16.         <artifactId>jackson-databind</artifactId>
  17.         <version>2.12.4</version>
  18.         <scope>compile</scope>
  19.     </dependency>
  20.     <dependency>
  21.         <groupId>com.fasterxml.jackson.datatype</groupId>
  22.         <artifactId>jackson-datatype-jdk8</artifactId>
  23.         <version>2.12.4</version>
  24.         <scope>compile</scope>
  25.     </dependency>
  26.     <dependency>
  27.         <groupId>com.fasterxml.jackson.datatype</groupId>
  28.         <artifactId>jackson-datatype-jsr310</artifactId>
  29.         <version>2.12.4</version>
  30.         <scope>compile</scope>
  31.     </dependency>
  32.     <dependency>
  33.         <groupId>com.fasterxml.jackson.module</groupId>
  34.         <artifactId>jackson-module-parameter-names</artifactId>
  35.         <version>2.12.4</version>
  36.         <scope>compile</scope>
  37.     </dependency>
  38. </dependencies>

我们可以发现，这个starter中又包含了若干个坐标，其实就是使用SpringMVC开发通常都会使用到Json，使用json又离不开这里面定义的这些坐标，看来还真是方便，SpringBoot把我们开发中使用的东西能用到的都给提前做好了。你仔细看完会发现，里面有一些你没用过的。的确会出现这种过量导入的可能性，没关系，可以通过maven中的排除依赖剔除掉一部分。不过你不管它也没事，大不了就是过量导入呗。

到这里基本上得到了一个信息，使用starter可以帮开发者快速配置依赖关系。以前写依赖3个坐标的，现在写导入一个就搞定了，就是加速依赖配置的。

starter与parent的区别

朦朦胧胧中感觉starter与parent好像都是帮助我们简化配置的，但是功能又不一样，梳理一下。

starter是一个坐标中定了若干个坐标，以前写多个的，现在写一个，是用来减少依赖配置的书写量的

parent是定义了几百个依赖版本号，以前写依赖需要自己手工控制版本，现在由SpringBoot统一管理，这样就不存在版本冲突了，是用来减少依赖冲突的

实际开发应用方式

  • 实际开发中如果需要用什么技术，先去找有没有这个技术对应的starter

    • 如果有对应的starter，直接写starter，而且无需指定版本，版本由parent提供

    • 如果没有对应的starter，手写坐标即可

  • 实际开发中如果发现坐标出现了冲突现象，确认你要使用的可行的版本号，使用手工书写的方式添加对应依赖，覆盖SpringBoot提供给我们的配置管理

    • 方式一：直接写坐标

    • 方式二：覆盖<properties>中定义的版本号，就是下面这堆东西了，哪个冲突了覆盖哪个就OK了

    1. <properties>
    2.     <activemq.version>5.16.3</activemq.version>
    3.     <aspectj.version>1.9.7</aspectj.version>
    4.     <assertj.version>3.19.0</assertj.version>
    5.     <commons-codec.version>1.15</commons-codec.version>
    6.     <commons-dbcp2.version>2.8.0</commons-dbcp2.version>
    7.     <commons-lang3.version>3.12.0</commons-lang3.version>
    8.     <commons-pool.version>1.6</commons-pool.version>
    9.     <commons-pool2.version>2.9.0</commons-pool2.version>
    10.     <h2.version>1.4.200</h2.version>
    11.     <hibernate.version>5.4.32.Final</hibernate.version>
    12.     <hibernate-validator.version>6.2.0.Final</hibernate-validator.version>
    13.     <httpclient.version>4.5.13</httpclient.version>
    14.     <jackson-bom.version>2.12.4</jackson-bom.version>
    15.     <javax-jms.version>2.0.1</javax-jms.version>
    16.     <javax-json.version>1.1.4</javax-json.version>
    17.     <javax-websocket.version>1.1</javax-websocket.version>
    18.     <jetty-el.version>9.0.48</jetty-el.version>
    19.     <junit.version>4.13.2</junit.version>
    20. </properties>

温馨提示

SpringBoot官方给出了好多个starter的定义，方便我们使用，而且名称都是如下格式

命名规则：spring-boot-starter-技术名称

所以以后见了spring-boot-starter-aaa这样的名字，这就是SpringBoot官方给出的starter定义。那非官方定义的也有吗？有的，具体命名方式到整合章节再说。

总结

  1. 开发SpringBoot程序需要导入坐标时通常导入对应的starter

  2. 每个不同的starter根据功能不同，通常包含多个依赖坐标

  3. 使用starter可以实现快速配置的效果，达到简化配置的目的

引导类

配置说完了，我们发现SpringBoot确实帮助我们减少了很多配置工作，下面说一下程序是如何运行的。目前程序运行的入口就是SpringBoot工程创建时自带的那个类了，带有main方法的那个类，运行这个类就可以启动SpringBoot工程的运行

  1. @SpringBootApplication
  2. public class Springboot0101QuickstartApplication {
  3.     public static void main(String[] args) {
  4.         SpringApplication.run(Springboot0101QuickstartApplication.class, args);
  5.     }
  6. }

SpringBoot本身是为了加速Spring程序的开发的，而Spring程序运行的基础是需要创建自己的Spring容器对象（IoC容器）并将所有的对象交给Spring的容器管理，也就是一个一个的Bean。那使用了SpringBoot加速开发Spring程序，这个容器还在吗？这个疑问不用说，一定在。当前这个类运行后就会产生一个Spring容器对象，并且可以将这个对象保存起来，通过容器对象直接操作Bean。

  1. @SpringBootApplication
  2. public class Springboot0101QuickstartApplication {
  3.     public static void main(String[] args) {
  4.         ConfigurableApplicationContext ctx = SpringApplication.run(Springboot0101QuickstartApplication.class, args);
  5.         BookController bean = ctx.getBean(BookController.class);
  6.         System.out.println("bean======>" + bean);
  7.     }
  8. }

通过上述操作不难看出，其实SpringBoot程序启动还是创建了一个Spring容器对象。这个类在SpringBoot程序中是所有功能的入口，称这个类为引导类。

作为一个引导类最典型的特征就是当前类上方声明了一个注解@SpringBootApplication

总结

  1. SpringBoot工程提供引导类用来启动程序

  2. SpringBoot工程启动后创建并初始化Spring容器，引导类所在包及其子包的类的注解才会被主动扫描到

思考

程序现在已经运行了，通过引导类的main方法运行了起来。但是运行java程序不应该是执行完就结束了吗？但是我们现在明显是启动了一个web服务器啊，不然网页怎么能正常访问呢？这个服务器是在哪里写的呢？

内嵌tomcat(辅助功能)

当前我们做的SpringBoot入门案例勾选了Spirng-web的功能，并且导入了对应的starter。

  1. <dependency>
  2.     <groupId>org.springframework.boot</groupId>
  3.     <artifactId>spring-boot-starter-web</artifactId>
  4. </dependency>

SpringBoot发现，既然你要做web程序，肯定离不开使用web服务器，这样吧，帮人帮到底，送佛送到西。我帮你搞一个web服务器，你要愿意用的，直接使用就好了，干脆我再多给你几种选择，你随便切换。万一你不想用我给你提供的，也行，你可以自己搞。

由于这个功能不属于程序的主体功能，可用可不用，于是乎SpringBoot将其定位成辅助功能，别小看这么一个辅助功能，它可是帮我们开发者又减少了好多的设置性工作。

下面就围绕着这个内置的web服务器，也可以说是内置的tomcat服务器来研究几个问题

  1. 这个服务器在什么位置定义的

  2. 这个服务器是怎么运行的

  3. 这个服务器如果想换怎么换？虽然这个需求很垃圾，搞得开发者会好多web服务器一样，用别人提供好的不香么？非要自己折腾

内嵌Tomcat定义位置

说到定义的位置，我们就想，如果我们不开发web程序，用的着web服务器吗？肯定用不着啊。那如果这个东西被加入到你的程序中，伴随着什么技术进来的呢？肯定是web相关的功能啊，没错，就是前面导入的web相关的starter做的这件事。

  1. <dependency>
  2.     <groupId>org.springframework.boot</groupId>
  3.     <artifactId>spring-boot-starter-web</artifactId>
  4. </dependency>

打开查看web的starter导入了哪些东西

  1. <dependencies>
  2.     <dependency>
  3.         <groupId>org.springframework.boot</groupId>
  4.         <artifactId>spring-boot-starter</artifactId>
  5.         <version>2.5.4</version>
  6.         <scope>compile</scope>
  7.     </dependency>
  8.     <dependency>
  9.         <groupId>org.springframework.boot</groupId>
  10.         <artifactId>spring-boot-starter-json</artifactId>
  11.         <version>2.5.4</version>
  12.         <scope>compile</scope>
  13.     </dependency>
  14.     <dependency>
  15.         <groupId>org.springframework.boot</groupId>
  16.         <artifactId>spring-boot-starter-tomcat</artifactId>
  17.         <version>2.5.4</version>
  18.         <scope>compile</scope>
  19.     </dependency>
  20.     <dependency>
  21.         <groupId>org.springframework</groupId>
  22.         <artifactId>spring-web</artifactId>
  23.         <version>5.3.9</version>
  24.         <scope>compile</scope>
  25.     </dependency>
  26.     <dependency>
  27.         <groupId>org.springframework</groupId>
  28.         <artifactId>spring-webmvc</artifactId>
  29.         <version>5.3.9</version>
  30.         <scope>compile</scope>
  31.     </dependency>
  32. </dependencies>

第三个依赖就是这个tomcat对应的东西了，居然也是一个starter，再打开看看

  1. <dependencies>
  2.     <dependency>
  3.         <groupId>jakarta.annotation</groupId>
  4.         <artifactId>jakarta.annotation-api</artifactId>
  5.         <version>1.3.5</version>
  6.         <scope>compile</scope>
  7.     </dependency>
  8.     <dependency>
  9.         <groupId>org.apache.tomcat.embed</groupId>
  10.         <artifactId>tomcat-embed-core</artifactId>
  11.         <version>9.0.52</version>
  12.         <scope>compile</scope>
  13.         <exclusions>
  14.             <exclusion>
  15.                 <artifactId>tomcat-annotations-api</artifactId>
  16.                 <groupId>org.apache.tomcat</groupId>
  17.             </exclusion>
  18.         </exclusions>
  19.     </dependency>
  20.     <dependency>
  21.         <groupId>org.apache.tomcat.embed</groupId>
  22.         <artifactId>tomcat-embed-el</artifactId>
  23.         <version>9.0.52</version>
  24.         <scope>compile</scope>
  25.     </dependency>
  26.     <dependency>
  27.         <groupId>org.apache.tomcat.embed</groupId>
  28.         <artifactId>tomcat-embed-websocket</artifactId>
  29.         <version>9.0.52</version>
  30.         <scope>compile</scope>
  31.         <exclusions>
  32.             <exclusion>
  33.                 <artifactId>tomcat-annotations-api</artifactId>
  34.                 <groupId>org.apache.tomcat</groupId>
  35.             </exclusion>
  36.         </exclusions>
  37.     </dependency>
  38. </dependencies>

这里面有一个核心的坐标，tomcat-embed-core，叫做tomcat内嵌核心。就是这个东西把tomcat功能引入到了我们的程序中。目前解决了第一个问题，找到根儿了，谁把tomcat引入到程序中的？spring-boot-starter-web中的spring-boot-starter-tomcat做的。之所以你感觉很奇妙的原因就是，这个东西是默认加入到程序中了，所以感觉很神奇，居然什么都不做，就有了web服务器对应的功能，再来说第二个问题，这个服务器是怎么运行的

内嵌Tomcat运行原理

Tomcat服务器是一款软件，而且是一款使用java语言开发的软件，熟悉的小伙伴可能有印象，tomcat安装目录中保存有jar，好多个jar。

下面的问题来了，既然是使用java语言开发的，运行的时候肯定符合java程序运行的原理，java程序运行靠的是什么？对象呀，一切皆对象，万物皆对象。那tomcat运行起来呢？也是对象。

如果是对象，那Spring容器是用来管理对象的，这个对象能不能交给Spring容器管理呢？把吗去掉，是个对象都可以交给Spring容器管理，行了，这下通了。tomcat服务器运行其实是以对象的形式在Spring容器中运行的，怪不得我们没有安装这个tomcat，而且还能用。闹了白天这东西最后是以一个对象的形式存在，保存在Spring容器中悄悄运行的。具体运行的是什么呢？其实就是上前面提到的那个tomcat内嵌核心

  1. <dependencies>
  2.     <dependency>
  3.         <groupId>org.apache.tomcat.embed</groupId>
  4.         <artifactId>tomcat-embed-core</artifactId>
  5.         <version>9.0.52</version>
  6.         <scope>compile</scope>
  7.     </dependency>
  8. </dependencies>

那既然是个对象，如果把这个对象从Spring容器中去掉是不是就没有web服务器的功能呢？是这样的，通过依赖排除可以去掉这个web服务器功能

  1. <dependencies>
  2.     <dependency>
  3.         <groupId>org.springframework.boot</groupId>
  4.         <artifactId>spring-boot-starter-web</artifactId>
  5.         <exclusions>
  6.             <exclusion>
  7.                 <groupId>org.springframework.boot</groupId>
  8.                 <artifactId>spring-boot-starter-tomcat</artifactId>
  9.             </exclusion>
  10.         </exclusions>
  11.     </dependency>
  12. </dependencies>

上面对web-starter做了一个操作，使用maven的排除依赖去掉了使用tomcat的starter。这下好了，容器中肯定没有这个对象了，重新启动程序可以观察到程序运行了，但是并没有像之前那样运行后会等着用户发请求，而是直接停掉了，就是这个原因了。

更换内嵌Tomcat

那根据上面的操作我们思考是否可以换个服务器呢？必须的嘛。根据SpringBoot的工作机制，用什么技术，加入什么依赖就行了。SpringBoot提供了3款内置的服务器

  • tomcat(默认)：apache出品，粉丝多，应用面广，负载了若干较重的组件

  • jetty：更轻量级，负载性能远不及tomcat

  • undertow：负载性能勉强跑赢tomcat

    想用哪个，加个坐标就OK。前提是把tomcat排除掉，因为tomcat是默认加载的。

  1. <dependencies>
  2.     <dependency>
  3.         <groupId>org.springframework.boot</groupId>
  4.         <artifactId>spring-boot-starter-web</artifactId>
  5.         <exclusions>
  6.             <exclusion>
  7.                 <groupId>org.springframework.boot</groupId>
  8.                 <artifactId>spring-boot-starter-tomcat</artifactId>
  9.             </exclusion>
  10.         </exclusions>
  11.     </dependency>
  12.     <dependency>
  13.         <groupId>org.springframework.boot</groupId>
  14.         <artifactId>spring-boot-starter-jetty</artifactId>
  15.     </dependency>
  16. </dependencies>

现在就已经成功替换了web服务器，核心思想就是用什么加入对应坐标就可以了。如果有starter，优先使用starter。

总结

  1. 内嵌Tomcat服务器是SpringBoot辅助功能之一

  2. 内嵌Tomcat工作原理是将Tomcat服务器作为对象运行，并将该对象交给Spring容器管理

  3. 变更内嵌服务器思想是去除现有服务器，添加全新的服务器

rest风格开发（知识补充）

什么是 rest ：REST（Representational State Transfer）表现形式状态转换

优点：

  • 隐藏资源的访问行为， 无法通过地址得知对资源是何种操作；只有使用了对应的请求方法才能访问相关的数据；

  • 书写简化

按照REST风格访问资源时使用行为动作区分对资源进行了何种操作：(这四个动作必须要熟练，现在企业开发几乎已经把这个风格作为开发规范了)

注意:

上述行为是约定方式，约定不是规范，可以打破，所以称REST风格，而不是REST规范; 描述模块的名称通常使用复数，也就是加s的格式描述，表示此类资源,而非单个资源，例如: users、 books、 accounts…

使用rest风格开发方式:

方式一

①:设定http请求动作(动词)

使用 @RequestMapping 注解的 method 属性声明请求的方式

使用 @RequestBody 注解 获取请求体内容。直接使用得到是 key=value&key=value…结构的数据。get 请求方式不适用。

使用@ResponseBody 注解实现将 controller 方法返回的对象，通过json数据转换器(比如:fastjson,jkson..)把对象转换为 json ，然后响应给客户端。

@RequestMapping(value="/users",method=RequestMethod.POST)

②设定请求参数(路径变量)

使用@PathVariable 用于绑定 url 中的占位符。例如：请求 url 中 /delete/{id}，这个{id}就是 url 占位符。

③@RequestBody @RequestParam @PathVariable区别

方式二

使用 @RestController 注解开发 RESTful 风格，这个是方式一点简化版本；

注解名称：@RestController

类型：类注解

位置：基于springMVC的restful开发控制器类定义上方

作用：设置当前控制器为restful风格，等同于@controller与@ResponseBody两个注解组合的功能

案例:

  1. @RestController
  2. public class BookControleler{
  3.     
  4. }

然后使用使用 @GetMapping @PostMapping @PutMapping @DeleteMapping 简化 @RequestMapping 注解的开发；

注意：使用restful风格开发，前端的请求要和controller中的方法相对应才能访问成功，才能获取到相关的资源，否则前后端都会报错的！

快速复制模块

原则：

  • 保留工程基础结构

  • 抹掉原始工程痕迹

把无关的文件痕迹全部删除，只留下src文件和pom文件就行；

然后对pom文件中的坐标进行修改，把<artifactId>springBoot-day0x</artifactId>修改成项目的文件名；

 

这样模板要复制的模板文件就创建好了，接下来就行把模板导入开发工具，我们这里使用的是idea，注意一定要先修改好pom文件再去把文件导入到idea,不然都话idea加载我们的pom文件后再去修改的话，就会很麻烦的；

选择改好的目标文件导入，然后刷新maven就行；

小结:

  1. 在工作空间中复制对应工程，并修改工程名称

  2. 删除与Idea相关配置文件，仅保留src目录与pom.xml文件

  3. 修改pom.xml文件中的artifactId与新工程/模块名相同

  4. 删除name标签（可选）

  5. 保留备份工程供后期使用

三、boot对应的配置文件

①修改默认端口号

SpringBoot默认配置文件application.properties，通过键值对配置对应属性；

  • 修改配置

    修改服务器端口

    1. # 服务器端口配制
    2. server.port=80

小结:

  1. SpringBoot默认配置文件为application.properties

②基础配置

修改配置： 修改服务器端口 server.port=80

关闭运行日志图标（banner） spring.main.banner-mode=off

设置日志显示级别 logging.level.root=debug

等等；

  1. # 服务器端口配置
  2. server.port=80
  3.  
  4. # 修改banner
  5. # spring.main.banner-mode=off
  6. # spring.banner.image.location=logo.png   注意这个logo.png的图片资源要在resource资源目录下才可以直接这样写
  7.  
  8. # 日志  boot的默认的控制台日志级别是info
  9. logging.level.root=info

  1. SpringBoot内置属性配置查询 Common Application Properties 官方文档中参考文档第一项：Application Propertie

小结:

  1. SpringBoot中导入对应的starter依赖后，才会提供对应配置属性

  2. 书写SpringBoot配置采用关键字+提示形式书写

③3种配置文件类型

配置文件格式:application.properties

SpringBoot提供了多种属性配置方式,肯定有更加简介的配置方式;

application.properties

server.port=80

application.yml

  1. server:
  2.   port: 81

application.yaml

  1. server:
  2.   port: 82

小结:

SpringBoot提供了3种配置文件的格式; ①properties（传统格式/默认格式） ②yml（主流格式） ③yaml

问题引入：如果三个配置文件都存在resource文件目录下，那么谁会生效？

③配置文件加载优先级

  • SpringBoot配置文件加载顺序 application.properties > application.yml > application.yaml

  • 常用配置文件种类 application.yml

小结:

  1. 配置文件间的加载优先级 properties（最高） yml yaml（最低）

  2. 不同配置文件中相同配置按照加载优先级相互覆盖 (高优先级配置内容会覆盖低优先级配置内容)，但是不同配置文件中不同配置会全部保留；

补充:属性提示消失解决方案

可能有些小伙伴会基于各种各样的原因导致配置文件中没有提示，这个确实很让人头疼，所以下面给大家说一下如果自动提示功能消失了怎么解决。

先要明确一个核心，就是自动提示功能不是SpringBoot技术给我们提供的，是我们在Idea工具下编程，这个编程工具给我们提供的。明白了这一点后，再来说为什么会出现这种现象。其实这个自动提示功能消失的原因还是蛮多的，如果想解决这个问题，就要知道为什么会消失，大体原因有如下3种：

  1. Idea认为你现在写配置的文件不是个配置文件，所以拒绝给你提供提示功能

  2. Idea认定你是合理的配置文件，但是Idea加载不到对应的提示信息

步骤①：打开设置，【Files】→【Project Structure...】

步骤②：在弹出窗口中左侧选择【Facets】，右侧选中Spring路径下对应的模块名称，也就是你自动提示功能消失的那个模块

步骤③：点击Customize Spring Boot按钮，此时可以看到当前模块对应的配置文件是哪些了。如果没有你想要称为配置文件的文件格式，就有可能无法弹出提示

步骤④：选择添加配置文件，然后选中要作为配置文件的具体文件就OK了

到这里就做完了，其实就是Idea的一个小功能：

总结

  1. 指定SpringBoot配置文件

    • Setting → Project Structure → Facets

    • 选中对应项目/工程

    • Customize Spring Boot

    • 选择配置文件

④yaml语法

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

  1. 优点：

    • 容易阅读

    • 容易与脚本语言交互

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

  2. YAML文件扩展名

    • .yml（主流）

    • .yaml

  • 对于文件自身在书写时，具有严格的语法格式要求，具体如下：

  1. 大小写敏感

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

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

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

  5. #号 表示注释

上述规则不要死记硬背，按照书写习惯慢慢适应，并且在Idea下由于具有提示功能，慢慢适应着写格式就行了。核心的一条规则要记住，数据前面要加空格与冒号隔开

下面列出常见的数据书写格式，熟悉一下

  1. boolean: TRUE  						#TRUE,true,True,FALSE,false，False均可
  2. float: 3.14    						#6.8523015e+5  #支持科学计数法
  3. int: 123       						#0b1010_0111_0100_1010_1110    #支持二进制、八进制、十六进制
  4. null: ~        						#使用~表示null
  5. string: HelloWorld      			#字符串可以直接书写
  6. string2: "Hello World"  			#可以使用双引号包裹特殊字符
  7. date: 2018-02-17        			#日期必须使用yyyy-MM-dd格式
  8. datetime: 2018-02-17T15:02:31+08:00 #时间和日期之间使用T连接，最后使用+代表时区

此外，yaml格式中也可以表示数组，在属性名书写位置的下方使用减号作为数据开始符号，每行书写一个数据，减号与数据间空格分隔

  1. subject:
  2. 	- Java
  3. 	- 前端
  4. 	- 大数据
  5. enterprise:
  6. 	name: itcast
  7.     age: 16
  8.     subject:
  9.     	- Java
  10.         - 前端
  11.         - 大数据
  12. likes: [王者荣耀,刺激战场]			#数组书写缩略格式
  13. users:							 #对象数组格式一
  14.   - name: Tom
  15.    	age: 4
  16.   - name: Jerry
  17.     age: 5
  18. users:							 #对象数组格式二
  19.   -  
  20.     name: Tom
  21.     age: 4
  22.   -   
  23.     name: Jerry
  24.     age: 5			    
  25. users2: [ { name:Tom , age:4 } , { name:Jerry , age:5 } ]	#对象数组缩略格式

总结

  1. yaml语法规则

    • 大小写敏感

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

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

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

    • #号 表示注释

  2. 注意属性名冒号后面与数据之间有一个空格

  3. 字面值、对象数据格式、数组数据格式

思考

现在我们已经知道了yaml具有严格的数据格式要求，并且已经可以正确的书写yaml文件了，那这些文件书写后其实是在定义一些数据。这些数据时给谁用的呢？大部分是SpringBoot框架内部使用，但是如果我们想配置一些数据自己使用，能不能用呢？答案是可以的，那如何读取yaml文件中的数据呢？

⑤读取yaml中的数据

1.单一属性数据

使用@Value读取单个数据，属性名引用方式：${一级属性名.二级属性名……}

记得使用@Value注解时，要将该注入写在某一个指定的Spring管控的bean的属性名上方（进行属性注入的这个类必须是spring容器管控的）。现在就可以读取到对应的单一数据行了

总结

  1. 使用@Value配合SpEL读取单个数据

  2. 如果数据存在多层级，依次书写层级名称即可

2.读取全部数据

读取单一数据可以解决读取数据的问题，但是如果定义的数据量过大，这么一个一个书写肯定会累死人的，SpringBoot提供了一个对象，能够把所有的数据都封装到这一个对象中，这个对象叫做Environment，使用自动装配注解可以将所有的yaml数据封装到这个对象中;

数据封装到了Environment对象中，获取属性时，通过Environment的接口操作进行，具体方法时getProperties（String），参数填写属性名即可

总结

  1. 使用Environment对象封装全部配置信息

  2. 使用@Autowired自动装配数据到Environment对象中

3.yaml文件中的数据引用

如果你在书写yaml数据时，经常出现如下现象，比如很多个文件都具有相同的目录前缀

  1. center:
  2. 	dataDir: /usr/local/fire/data
  3.     tmpDir: /usr/local/fire/tmp
  4.     logDir: /usr/local/fire/log
  5.     msgDir: /usr/local/fire/msgDir

或者

  1. center:
  2. 	dataDir: D:/usr/local/fire/data
  3.     tmpDir: D:/usr/local/fire/tmp
  4.     logDir: D:/usr/local/fire/log
  5.     msgDir: D:/usr/local/fire/msgDir

这个时候你可以使用引用格式来定义数据，其实就是搞了个变量名，然后引用变量了，格式如下：

  1. baseDir: /usr/local/fire
  2.  
  3. center:
  4.     dataDir: ${baseDir}/data
  5.     tmpDir: ${baseDir}/tmp
  6.     logDir: ${baseDir}/log
  7.     msgDir: ${baseDir}/msgDir

还有一个注意事项，在书写字符串时，如果需要使用转义字符，需要将数据字符串使用双引号包裹起来

lesson: "Spring\tboot\nlesson"

总结

  1. 在配置文件中可以使用${属性名}方式引用属性值

  2. 如果属性中出现特殊字符，可以使用双引号包裹起来作为字符解析

4.读取对象数据（主流）

单一数据读取书写比较繁琐，全数据封装又封装的太厉害了，每次拿数据还要一个一个的getProperties（）,总之用起来都不是很舒服。由于Java是一个面向对象的语言，很多情况下，我们会将一组数据封装成一个对象。SpringBoot也提供了【可以将一组yaml对象数据封装一个Java对象】的操作

首先定义一个对象，并将该对象纳入Spring管控的范围(这一步容易忘记)，也就是定义成一个bean，然后使用注解@ConfigurationProperties指定该对象加载哪一组yaml中配置的信息。

这个@ConfigurationProperties必须告诉他加载的数据前缀是什么，这样当前前缀下的所有属性就封装到这个对象中。记得数据属性名要与对象的变量名一一对应啊，不然没法封装。其实以后如果你要定义一组数据自己使用，就可以先写一个对象，然后定义好属性，下面到配置中根据这个格式书写即可。

自定义对象封装指定数据的作用：比如封装与数据库连接相关的配置

温馨提示

细心的小伙伴会发现一个问题，自定义的这种数据在yaml文件中书写时没有弹出提示，是这样的，咱们到原理篇再揭秘如何弹出提示。

总结

  1. 使用@ConfigurationProperties注解绑定配置信息到封装类中；

  2. 封装类需要定义为Spring管理的bean，否则无法进行属性注入；

四、SpringBoot实现SSMP整合

①整合junit

我们先来看一下不使用SpringBoot技术时，Spring整合JUnit的制作方式

  1. //加载spring整合junit专用的类运行器
  2. @RunWith(SpringJUnit4ClassRunner.class)
  3. //指定对应的配置信息
  4. @ContextConfiguration(classes = SpringConfig.class)
  5. public class AccountServiceTestCase {
  6.     //注入你要测试的对象  
  7.     @Autowired
  8.     private AccountService accountService;
  9.     @Test
  10.     public void testGetById(){
  11.         //执行要测试的对象对应的方法
  12.         System.out.println(accountService.findById(2));
  13.     }
  14. }

其中核心代码是前两个注解，

第一个注解@RunWith是设置Spring专用于测试的类运行器，简单说就是Spring程序执行程序有自己的一套独立的运行程序的方式，不能使用JUnit提供的类运行方式了，必须指定一下，但是格式是固定的，琢磨一下，每次都指定一样的东西，这个东西写起来没有技术含量啊，

第二个注解@ContextConfiguration是用来设置Spring核心配置文件或配置类的，简单说就是加载Spring的环境你要告诉Spring具体的环境配置是在哪里写的，虽然每次加载的文件都有可能不同，但是仔细想想，如果文件名是固定的，这个貌似也是一个固定格式。似然有可能是固定格式，那就有可能每次都写一样的东西，也是一个没有技术含量的内容书写

SpringBoot就抓住上述两条没有技术含量的内容书写进行开发简化，能走默认值的走默认值，能不写的就不写，具体格式如下

  1. @SpringBootTest
  2. class Springboot04JunitApplicationTests {
  3.     //注入你要测试的对象  我们在springboot测试的工作之所以能够取得这种测试的对象，是因为被测试的对象是在spring容器中取得的，要拿到spring容器才行,使用默认的加载类的话，那么这个默认加载类所在包及其子包的注解会被spring主动扫描，如果使用的不是默认的加载类的话，那么就需要我们人为的告诉spring去这个测试类的主类在哪里
  4.     @Autowired
  5.     private BookDao bookDao;
  6.     @Test
  7.     void contextLoads() {
  8.         //执行要测试的对象对应的方法
  9.         bookDao.save();
  10.         System.out.println("two...");
  11.     }
  12. }

看看这次简化成什么样了，一个注解就搞定了，而且还没有参数，再体会SpringBoot整合其他技术的优势在哪里，就两个字——简化。使用一个注解@SpringBootTest替换了前面两个注解。【至于内部是怎么回事？和之前一样，只不过都走默认值。】

这个时候有人就问了，你加载的配置类或者配置文件是哪一个？就是我们前面启动程序使用的引导类。如果想手工指定引导类有两种方式，第一种方式使用属性的形式进行，在注解@SpringBootTest中添加classes属性指定配置类

  1. @SpringBootTest(classes = Springboot04JunitApplication.class)//如果这里使用的是默认的加载类(boot程序入口)的话，那么这里就不用写classes的位置(约定大于配置)
  2. class Springboot04JunitApplicationTests {
  3.     //注入你要测试的对象
  4.     @Autowired
  5.     private BookDao bookDao;
  6.     @Test
  7.     void contextLoads() {
  8.         //执行要测试的对象对应的方法
  9.         bookDao.save();
  10.         System.out.println("two...");
  11.     }
  12. }

第二种方式回归原始配置方式，仍然使用@ContextConfiguration注解进行，效果是一样的

  1. @SpringBootTest
  2. @ContextConfiguration(classes = Springboot04JunitApplication.class)
  3. class Springboot04JunitApplicationTests {
  4.     //注入你要测试的对象
  5.     @Autowired
  6.     private BookDao bookDao;
  7.     @Test
  8.     void contextLoads() {
  9.         //执行要测试的对象对应的方法
  10.         bookDao.save();
  11.         System.out.println("two...");
  12.     }
  13. }

温馨提示

使用SpringBoot整合JUnit需要保障导入test对应的starter，由于初始化项目时此项是默认导入的，所以此处没有提及，其实和之前学习的内容一样，用什么技术导入对应的starter即可。

总结

  1. 导入测试对应的starter

  2. 测试类使用@SpringBootTest修饰

  3. 使用自动装配的形式添加要测试的对象

  4. 测试类如果存在于引导类所在包或子包中无需指定引导类

  5. 测试类如果不存在于引导类所在的包或子包中需要通过classes属性指定引导类

②整合mybatis

spring整合mybatis

步骤1：导入坐标，MyBatis坐标不能少，Spring整合MyBatis还有自己专用的坐标，此外Spring进行数据库操作的jdbc坐标是必须的，剩下还有mysql驱动坐标，本例中使用了Druid数据源，这个倒是可以不要；

  1. <dependencies>
  2.     <dependency>
  3.         <groupId>com.alibaba</groupId>
  4.         <artifactId>druid</artifactId>
  5.         <version>1.1.16</version>
  6.     </dependency>
  7.     <dependency>
  8.         <groupId>org.mybatis</groupId>
  9.         <artifactId>mybatis</artifactId>
  10.         <version>3.5.6</version>
  11.     </dependency>
  12.     <dependency>
  13.         <groupId>mysql</groupId>
  14.         <artifactId>mysql-connector-java</artifactId>
  15.         <version>5.1.47</version>
  16.     </dependency>
  17.     <!--1.导入mybatis与spring整合的jar包-->
  18.     <dependency>
  19.         <groupId>org.mybatis</groupId>
  20.         <artifactId>mybatis-spring</artifactId>
  21.         <version>1.3.0</version>
  22.     </dependency>
  23.     <!--导入spring操作数据库必选的包-->
  24.     <dependency>
  25.         <groupId>org.springframework</groupId>
  26.         <artifactId>spring-jdbc</artifactId>
  27.         <version>5.2.10.RELEASE</version>
  28.     </dependency>
  29. </dependencies>

步骤2：配置Spring核心配置；

  1. @Configuration
  2. @ComponentScan("com.itheima")
  3. @PropertySource("jdbc.properties")
  4. public class SpringConfig {
  5. }

步骤3：MyBatis要交给Spring接管的bean

  1. //定义mybatis专用的配置类
  2. @Configuration
  3. public class MyBatisConfig {
  4. //    定义创建SqlSessionFactory对应的bean
  5.     @Bean
  6.     public SqlSessionFactoryBean sqlSessionFactory(DataSource dataSource){
  7.         //SqlSessionFactoryBean是由mybatis-spring包提供的，专用于整合用的对象
  8.         SqlSessionFactoryBean sfb = new SqlSessionFactoryBean();
  9.         //设置数据源替代原始配置中的environments的配置
  10.         sfb.setDataSource(dataSource);
  11.         //设置类型别名替代原始配置中的typeAliases的配置
  12.         sfb.setTypeAliasesPackage("com.itheima.domain");
  13.         return sfb;
  14.     }
  15. //    定义加载所有的映射配置
  16.     @Bean
  17.     public MapperScannerConfigurer mapperScannerConfigurer(){
  18.         MapperScannerConfigurer msc = new MapperScannerConfigurer();
  19.         msc.setBasePackage("com.itheima.dao");
  20.         return msc;
  21.     }
  22.  
  23. }

步骤4:数据库连接信息（properties格式）

  1. jdbc.driver=com.mysql.jdbc.Driver
  2. jdbc.url=jdbc:mysql://localhost:3306/spring_db?useSSL=false
  3. jdbc.username=root
  4. jdbc.password=root

步骤5：读取数据库连接配置文件，配置数据源，并且把数据源交给spring容器管理

  1. @Configuration
  2. public class JdbcConfig {
  3.     @Value("${jdbc.driver}")
  4.     private String driver;
  5.     @Value("${jdbc.url}")
  6.     private String url;
  7.     @Value("${jdbc.username}")
  8.     private String userName;
  9.     @Value("${jdbc.password}")
  10.     private String password;
  11.  
  12.     @Bean("dataSource")
  13.     public DataSource dataSource(){
  14.         DruidDataSource ds = new DruidDataSource();
  15.         ds.setDriverClassName(driver);
  16.         ds.setUrl(url);
  17.         ds.setUsername(userName);
  18.         ds.setPassword(password);
  19.         return ds;
  20.     }
  21. }

Boot整合MyBaits（要求掌握）

步骤①：创建模块时勾选要使用的技术，MyBatis，由于要操作数据库，还要勾选对应数据库

 

或者手工导入对应技术的starter，和对应数据库的坐标

  1. <dependencies>
  2.     <!--1.导入对应的starter-->
  3.     <dependency>
  4.         <groupId>org.mybatis.spring.boot</groupId>
  5.         <artifactId>mybatis-spring-boot-starter</artifactId>
  6.         <version>2.2.0</version>
  7.     </dependency>
  8.  
  9.     <dependency>
  10.         <groupId>mysql</groupId>
  11.         <artifactId>mysql-connector-java</artifactId>
  12.         <scope>runtime</scope>
  13.     </dependency>
  14. </dependencies>

步骤②：配置数据源相关信息，没有这个信息你连接哪个数据库都不知道;

注意: 虽然我们使用的MySQL是5.7，但是我们引入的Boot是2.6.6的起步依赖，这个boot版本的MySQL默认的是依赖架构包是8,所以这里我们要使用MySQL8的一些配置要求， 主要是：时区和驱动；如下：

  1. #2.配置相关信息
  2. spring:
  3.   datasource:
  4.   	# 根据自己的数据库的版本来配置这个driver的信息，数据库5和8是不一样的，这里的配置是8版本的MySQL
  5.     driver-class-name: com.mysql.cj.jdbc.Driver
  6.     url: jdbc:mysql://localhost:3306/ssm_db?serverTimezone=UTC
  7.     username: root
  8.     password: root

创建表:

  1. DROP TABLE IF EXISTS `tbl_book`;
  2. CREATE TABLE `tbl_book`  (
  3.   `id` int(11) NOT NULL AUTO_INCREMENT,
  4.   `type` varchar(20) CHARACTER SET utf8 COLLATE utf8_general_ci NULL DEFAULT NULL,
  5.   `name` varchar(50) CHARACTER SET utf8 COLLATE utf8_general_ci NULL DEFAULT NULL,
  6.   `description` varchar(255) CHARACTER SET utf8 COLLATE utf8_general_ci NULL DEFAULT NULL,
  7.   PRIMARY KEY (`id`) USING BTREE
  8. ) ENGINE = InnoDB AUTO_INCREMENT = 51 CHARACTER SET = utf8 COLLATE = utf8_general_ci ROW_FORMAT = Dynamic;
  9.  
  10. -- ----------------------------
  11. -- Records of tbl_book
  12. -- ----------------------------
  13. INSERT INTO `tbl_book` VALUES (1, '计算机理论', 'Spring实战 第5版', 'Spring入门经典教程，深入理解Spring原理技术内幕');
  14. INSERT INTO `tbl_book` VALUES (2, '计算机理论', 'Spring 5核心原理与30个类手写实战', '十年沉淀之作，手写Spring精华思想');
  15. INSERT INTO `tbl_book` VALUES (3, '计算机理论', 'Spring 5 设计模式', '深入Spring源码剖析Spring源码中蕴含的10大设计模式');
  16. INSERT INTO `tbl_book` VALUES (4, '计算机理论', 'Spring MVC+MyBatis开发从入门到项目实战', '全方位解析面向Web应用的轻量级框架，带你成为Spring MVC开发高手');
  17. INSERT INTO `tbl_book` VALUES (5, '计算机理论', '轻量级Java Web企业应用实战', '源码级剖析Spring框架，适合已掌握Java基础的读者');
  18. INSERT INTO `tbl_book` VALUES (6, '计算机理论', 'Java核心技术 卷I 基础知识（原书第11版）', 'Core Java 第11版，Jolt大奖获奖作品，针对Java SE9、10、11全面更新');
  19. INSERT INTO `tbl_book` VALUES (7, '计算机理论', '深入理解Java虚拟机', '5个维度全面剖析JVM，大厂面试知识点全覆盖');
  20. INSERT INTO `tbl_book` VALUES (8, '计算机理论', 'Java编程思想（第4版）', 'Java学习必读经典,殿堂级著作！赢得了全球程序员的广泛赞誉');
  21. INSERT INTO `tbl_book` VALUES (9, '计算机理论', '零基础学Java（全彩版）', '零基础自学编程的入门图书，由浅入深，详解Java语言的编程思想和核心技术');
  22. INSERT INTO `tbl_book` VALUES (10, '市场营销', '直播就该这么做：主播高效沟通实战指南', '李子柒、李佳琦、薇娅成长为网红的秘密都在书中');
  23. INSERT INTO `tbl_book` VALUES (11, '市场营销', '直播销讲实战一本通', '和秋叶一起学系列网络营销书籍');
  24. INSERT INTO `tbl_book` VALUES (12, '市场营销', '直播带货：淘宝、天猫直播从新手到高手', '一本教你如何玩转直播的书，10堂课轻松实现带货月入3W+');

数据库中表对应的实体类：

  1. public class Book {
  2.     private Integer id;
  3.     private String type;
  4.     private String name;
  5.     private String description;
  6. }

映射接口（Dao）

  1. @Mapper  //@Mapper注解是由Mybatis框架中定义的一个描述数据层接口的注解，注解往往起到的都是一个描述性作用，用于告诉sprigng框架此接口的实现类由Mybatis负责创建，并将其实现类对象存储到spring容器中public interface BookDao {    
  2. @Select("select * from tbl_book where id = #{id}")    
  3. public Book getById(Integer id);
  4. }

测试类

  1. @SpringBootTest
  2. class Springboot05MybatisApplicationTests {
  3.     @Autowired
  4.     private BookDao bookDao;
  5.     @Test
  6.     void contextLoads() {
  7.         System.out.println(bookDao.getById(1));
  8.     }
  9. }
  10.

完美，开发从此变的就这么简单。再体会一下SpringBoot如何进行第三方技术整合的，是不是很优秀？具体内部的原理到原理篇再展开讲解;

注意：当前使用的SpringBoot版本是2.6.6，对应的坐标设置中Mysql驱动使用的是8x版本。当SpringBoot2.4.3（不含）版本之前会出现一个小BUG，就是MySQL驱动升级到8以后要求强制配置时区，如果不设置会出问题。解决方案很简单，驱动url上面添加上对应设置就行了

  1. #2.配置相关信息
  2. spring:
  3.   datasource:
  4.     driver-class-name: com.mysql.cj.jdbc.Driver
  5.     url: jdbc:mysql://localhost:3306/ssm_db?serverTimezone=UTC
  6.     username: root
  7.     password: root

这里设置的UTC是全球标准时间，你也可以理解为是英国时间，中国处在东八区，需要在这个基础上加上8小时，这样才能和中国地区的时间对应的，也可以修改配置不写UTC，写Asia/Shanghai也可以解决这个问题。

  1. #2.配置相关信息
  2. spring:
  3.   datasource:
  4.     driver-class-name: com.mysql.cj.jdbc.Driver
  5.     url: jdbc:mysql://localhost:3306/ssm_db?serverTimezone=Asia/Shanghai
  6.     username: root
  7.     password: root

如果不想每次都设置这个东西，也可以去修改mysql中的配置文件mysql.ini，在mysqld项中添加default-time-zone=+8:00也可以解决这个问题。其实方式方法很多，这里就说这么多吧。

此外在运行程序时还会给出一个提示，说数据库驱动过时的警告，根据提示修改配置即可，弃用com.mysql.jdbc.Driver，换用com.mysql.cj.jdbc.Driver。前面的例子中已经更换了驱动了，在此说明一下。

  1. Loading class `com.mysql.jdbc.Driver'. This is deprecated. 
  2. The new driver class is `com.mysql.cj.jdbc.Driver'. 
  3. The driver is automatically registered via the SPI and manual loading of the driver class is generally unnecessary.

总结

  1. 整合操作需要勾选MyBatis技术，也就是导入MyBatis对应的starter

  2. 数据库连接相关信息转换成配置

  3. 数据库SQL映射需要添加@Mapper被容器识别到

  4. MySQL 8.X驱动强制要求设置时区

    • 修改url，添加serverTimezone设定

    • 修改MySQL数据库配置

  5. 驱动类过时，提醒更换为com.mysql.cj.jdbc.Driver

③整合Druid

使用SpringBoot整合了3个技术了，发现套路基本相同，导入对应的starter，然后做配置，各位小伙伴需要一直强化这套思想。下面再整合一个技术，继续深入强化此思想。

前面整合MyBatis和MP的时候，使用的数据源对象都是SpringBoot默认的数据源对象，下面我们手工控制一下，自己指定了一个数据源对象，Druid(数据连接池工具)。

在没有指定数据源时，我们的配置如下：

  1. #2.配置相关信息
  2. spring:
  3.   datasource:
  4.     driver-class-name: com.mysql.cj.jdbc.Driver
  5.     url: jdbc:mysql://localhost:3306/ssm_db?serverTimezone=Asia/Shanghai
  6.     username: root
  7.     password: root

此时虽然没有指定数据源，但是根据SpringBoot的德行，肯定帮我们选了一个它认为最好的数据源对象，这就是HiKari。通过启动日志可以查看到对应的身影。

上述信息中每一行都有HiKari的身影，如果需要更换数据源，其实只需要两步即可。

  1. 导入对应的技术坐标

  2. 配置使用指定的数据源类型

下面就切换一下数据源对象

步骤①：导入对应的坐标（注意，是坐标，此处不是starter）

  1. <dependencies>
  2.     <dependency>
  3.         <groupId>com.alibaba</groupId>
  4.         <artifactId>druid</artifactId>
  5.         <version>1.1.16</version>
  6.     </dependency>
  7. </dependencies>

步骤②：修改配置，在数据源配置中有一个type属性，专用于指定数据源类型

  1. spring:
  2.   datasource:
  3.     driver-class-name: com.mysql.cj.jdbc.Driver
  4.     url: jdbc:mysql://localhost:3306/ssm_db?serverTimezone=UTC
  5.     username: root
  6.     password: root
  7.     type: com.alibaba.druid.pool.DruidDataSource

这里其实要提出一个问题的，目前的数据源配置格式是一个通用格式，不管你换什么数据源都可以用这种形式进行配置。但是新的问题又来了，如果对数据源进行个性化的配置，例如配置数据源对应的连接数量，这个时候就有新的问题了。每个数据源技术对应的配置名称都一样吗？肯定不是啊，各个厂商不可能提前商量好都写一样的名字啊，怎么办？就要使用专用的配置格式了。这个时候上面这种通用格式就不能使用了，怎么办？还能怎么办？按照SpringBoot整合其他技术的通用规则来套啊，导入对应的starter，进行相应的配置即可。

步骤①：导入对应的starter

  1. <dependencies>
  2.     <dependency>
  3.         <groupId>com.alibaba</groupId>
  4.         <artifactId>druid-spring-boot-starter</artifactId>
  5.         <version>1.2.6</version>
  6.     </dependency>
  7. </dependencies>

步骤②：修改配置

  1. spring:
  2.   datasource:
  3.     druid:
  4.       driver-class-name: com.mysql.cj.jdbc.Driver
  5.       url: jdbc:mysql://localhost:3306/ssm_db?serverTimezone=UTC
  6.       username: root
  7.       password: root

注意观察，配置项中，在datasource下面并不是直接配置url这些属性的，而是先配置了一个druid节点，然后再配置的url这些东西。言外之意，url这个属性时druid下面的属性，那你能想到吗？除了这4个常规配置外，还有druid专用的其他配置。通过提示功能可以打开druid相关的配置查阅；

与druid相关的配置超过200条以上，这就告诉你，如果想做druid相关的配置，使用这种格式就可以了，这里就不展开描述了，太多了。

这是我们做的第4个技术的整合方案，还是那两句话：导入对应starter，使用对应配置。没了，SpringBoot整合其他技术就这么简单粗暴。

总结

  1. 整合Druid需要导入Druid对应的starter

  2. 根据Druid提供的配置方式进行配置

  3. 整合第三方技术通用方式

    • 导入对应的starter

    • 根据提供的配置格式，配置非默认值对应的配置项

④综合案例实战

0.模块创建

对于这个案例如果按照企业开发的形式进行应该制作后台微服务，前后端分离的开发。

我知道这个对初学的小伙伴要求太高了，咱们简化一下。后台做单体服务器，前端不使用前后端分离的制作了。

一个服务器即充当后台服务调用，又负责前端页面展示，降低学习的门槛。

下面我们就可以创建一个新的模块，加载要使用的技术对应的starter，修改配置文件格式为yml格式，并把web访问端口先设置成80。

pom.xml

  1. <dependencies>
  2.     <dependency>
  3.         <groupId>org.springframework.boot</groupId>
  4.         <artifactId>spring-boot-starter-web</artifactId>
  5.     </dependency>
  6.     <dependency>
  7.         <groupId>org.springframework.boot</groupId>
  8.         <artifactId>spring-boot-starter-test</artifactId>
  9.         <scope>test</scope>
  10.     </dependency>
  11. </dependencies>

application.yml 

  1. server:
  2.   port: 80

1.实体类开发与表的创建

本案例对应的模块表结构如下：

  1. -- ----------------------------
  2. -- Table structure for tbl_book
  3. -- ----------------------------
  4. DROP TABLE IF EXISTS `tbl_book`;
  5. CREATE TABLE `tbl_book`  (
  6.   `id` int(11) NOT NULL AUTO_INCREMENT,
  7.   `type` varchar(20) CHARACTER SET utf8 COLLATE utf8_general_ci NULL DEFAULT NULL,
  8.   `name` varchar(50) CHARACTER SET utf8 COLLATE utf8_general_ci NULL DEFAULT NULL,
  9.   `description` varchar(255) CHARACTER SET utf8 COLLATE utf8_general_ci NULL DEFAULT NULL,
  10.   PRIMARY KEY (`id`) USING BTREE
  11. ) ENGINE = InnoDB AUTO_INCREMENT = 51 CHARACTER SET = utf8 COLLATE = utf8_general_ci ROW_FORMAT = Dynamic;
  12.  
  13. -- ----------------------------
  14. -- Records of tbl_book
  15. -- ----------------------------
  16. INSERT INTO `tbl_book` VALUES (1, '计算机理论', 'Spring实战 第5版', 'Spring入门经典教程，深入理解Spring原理技术内幕');
  17. INSERT INTO `tbl_book` VALUES (2, '计算机理论', 'Spring 5核心原理与30个类手写实战', '十年沉淀之作，手写Spring精华思想');
  18. INSERT INTO `tbl_book` VALUES (3, '计算机理论', 'Spring 5 设计模式', '深入Spring源码剖析Spring源码中蕴含的10大设计模式');
  19. INSERT INTO `tbl_book` VALUES (4, '计算机理论', 'Spring MVC+MyBatis开发从入门到项目实战', '全方位解析面向Web应用的轻量级框架，带你成为Spring MVC开发高手');
  20. INSERT INTO `tbl_book` VALUES (5, '计算机理论', '轻量级Java Web企业应用实战', '源码级剖析Spring框架，适合已掌握Java基础的读者');
  21. INSERT INTO `tbl_book` VALUES (6, '计算机理论', 'Java核心技术 卷I 基础知识（原书第11版）', 'Core Java 第11版，Jolt大奖获奖作品，针对Java SE9、10、11全面更新');
  22. INSERT INTO `tbl_book` VALUES (7, '计算机理论', '深入理解Java虚拟机', '5个维度全面剖析JVM，大厂面试知识点全覆盖');
  23. INSERT INTO `tbl_book` VALUES (8, '计算机理论', 'Java编程思想（第4版）', 'Java学习必读经典,殿堂级著作！赢得了全球程序员的广泛赞誉');
  24. INSERT INTO `tbl_book` VALUES (9, '计算机理论', '零基础学Java（全彩版）', '零基础自学编程的入门图书，由浅入深，详解Java语言的编程思想和核心技术');
  25. INSERT INTO `tbl_book` VALUES (10, '市场营销', '直播就该这么做：主播高效沟通实战指南', '李子柒、李佳琦、薇娅成长为网红的秘密都在书中');
  26. INSERT INTO `tbl_book` VALUES (11, '市场营销', '直播销讲实战一本通', '和秋叶一起学系列网络营销书籍');
  27. INSERT INTO `tbl_book` VALUES (12, '市场营销', '直播带货：淘宝、天猫直播从新手到高手', '一本教你如何玩转直播的书，10堂课轻松实现带货月入3W+');

根据上述表结构，制作对应的实体类

实体类

  1. public class Book {
  2.     private Integer id;
  3.     private String type;
  4.     private String name;
  5.     private String description;
  6. }

实体类的开发可以自动通过工具手工生成get/set方法，然后覆盖toString()方法，方便调试，等等。不过这一套操作书写很繁琐，有对应的工具可以帮助我们简化开发，介绍一个小工具，lombok。

Lombok，一个Java类库，提供了一组注解，简化POJO实体类开发，SpringBoot目前默认集成了lombok技术，并提供了对应的版本控制，所以只需要提供对应的坐标即可，在pom.xml中添加lombok的坐标。

  1. <dependencies>
  2.     <!--lombok-->
  3.     <dependency>
  4.         <groupId>org.projectlombok</groupId>
  5.         <artifactId>lombok</artifactId>
  6.     </dependency>
  7. </dependencies>

使用lombok可以通过一个注解@Data完成一个实体类对应的getter，setter，toString，equals，hashCode等操作的快速添加

  1. import lombok.Data;
  2. @Data
  3. public class Book {
  4.     private Integer id;
  5.     private String type;
  6.     private String name;
  7.     private String description;
  8. }

到这里实体类就做好了，是不是比不使用lombok简化好多，这种工具在Java开发中还有N多，后面课程中遇到了能用的东西时，在不增加各位小伙伴大量的学习时间的情况下，尽量多给大家介绍一些

总结

  1. 实体类制作

  2. 使用lombok简化开发

    • 导入lombok无需指定版本，由SpringBoot提供版本

    • @Data注解

2.数据层开发——基础CRUD

数据层开发本次使用MyBatisPlus技术，数据源使用前面学习的Druid，学都学了都用上

步骤①：导入MyBatisPlus与Druid对应的starter，当然mysql的驱动不能少

  1. <dependencies>
  2.     <dependency>
  3.         <groupId>com.baomidou</groupId>
  4.         <artifactId>mybatis-plus-boot-starter</artifactId>
  5.         <version>3.4.3</version>
  6.     </dependency>
  7.     <dependency>
  8.         <groupId>com.alibaba</groupId>
  9.         <artifactId>druid-spring-boot-starter</artifactId>
  10.         <version>1.2.6</version>
  11.     </dependency>
  12.     <dependency>
  13.         <groupId>mysql</groupId>
  14.         <artifactId>mysql-connector-java</artifactId>
  15.         <scope>runtime</scope>
  16.     </dependency>
  17. </dependencies>

步骤②：配置数据库连接相关的数据源配置

  1. server:
  2.   port: 80
  3.  
  4. spring:
  5.   datasource:
  6.     druid:
  7.       driver-class-name: com.mysql.cj.jdbc.Driver
  8.       url: jdbc:mysql://localhost:3306/ssm_db?serverTimezone=UTC
  9.       username: root
  10.       password: root

步骤③：使用MP的标准通用接口BaseMapper加速开发，别忘了@Mapper和泛型的指定

  1. @Mapper
  2. public interface BookDao extends BaseMapper<Book> {
  3. }

步骤④：制作测试类测试结果，这个测试类制作是个好习惯，不过在企业开发中往往都为加速开发跳过此步，且行且珍惜吧

  1. package com.itheima.dao;
  2.  
  3. import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
  4. import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
  5. import com.baomidou.mybatisplus.core.metadata.IPage;
  6. import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
  7. import com.itheima.domain.Book;
  8. import org.junit.jupiter.api.Test;
  9. import org.springframework.beans.factory.annotation.Autowired;
  10. import org.springframework.boot.test.context.SpringBootTest;
  11.  
  12. @SpringBootTest
  13. public class BookDaoTestCase {
  14.  
  15.     @Autowired
  16.     private BookDao bookDao;
  17.  
  18.     @Test
  19.     void testGetById(){
  20.         System.out.println(bookDao.selectById(1));
  21.     }
  22.  
  23.     @Test
  24.     void testSave(){
  25.         Book book = new Book();
  26.         book.setType("测试数据123");
  27.         book.setName("测试数据123");
  28.         book.setDescription("测试数据123");
  29.         bookDao.insert(book);
  30.     }
  31.  
  32.     @Test
  33.     void testUpdate(){
  34.         Book book = new Book();
  35.         book.setId(17);
  36.         book.setType("测试数据abcdefg");
  37.         book.setName("测试数据123");
  38.         book.setDescription("测试数据123");
  39.         bookDao.updateById(book);
  40.     }
  41.  
  42.     @Test
  43.     void testDelete(){
  44.         bookDao.deleteById(16);
  45.     }
  46.  
  47.     @Test
  48.     void testGetAll(){
  49.         bookDao.selectList(null);
  50.     }
  51. }

温馨提示

MP技术默认的主键生成策略为雪花算法，生成的主键ID长度较大，和目前的数据库设定规则不相符，需要配置一下使MP使用数据库的主键生成策略，方式嘛还是老一套，做配置。在application.yml中添加对应配置即可，具体如下

  1. server:
  2.   port: 80
  3.  
  4. spring:
  5.   datasource:
  6.     druid:
  7.       driver-class-name: com.mysql.cj.jdbc.Driver
  8.       url: jdbc:mysql://localhost:3306/ssm_db?serverTimezone=UTC
  9.       username: root
  10.       password: root
  11.  
  12. mybatis-plus:
  13.   global-config:
  14.     db-config:
  15.       table-prefix: tbl_		#设置表名通用前缀
  16.       id-type: auto				#设置主键id字段的生成策略为参照数据库设定的策略，当前数据库设置id生成策略为自增

查看MP运行日志

在进行数据层测试的时候，因为基础的CRUD操作均由MP给我们提供了，所以就出现了一个局面，开发者不需要书写SQL语句了，这样程序运行的时候总有一种感觉，一切的一切都是黑盒的，作为开发者我们啥也不知道就完了。如果程序正常运行还好，如果报错了，这个时候就很崩溃，你甚至都不知道从何下手，因为传递参数、封装SQL语句这些操作完全不是你干预开发出来的，所以查看执行期运行的SQL语句就成为当务之急。

SpringBoot整合MP的时候充分考虑到了这点，通过配置的形式就可以查阅执行期SQL语句，配置如下

  1. mybatis-plus:
  2.   global-config:
  3.     db-config:
  4.       table-prefix: tbl_
  5.       id-type: auto
  6.   configuration:
  7.     log-impl: org.apache.ibatis.logging.stdout.StdOutImpl

再来看运行结果，此时就显示了运行期执行SQL的情况。

  1. Creating a new SqlSession
  2. SqlSession [org.apache.ibatis.session.defaults.DefaultSqlSession@2c9a6717] was not registered for synchronization because synchronization is not active
  3. JDBC Connection [com.mysql.cj.jdbc.ConnectionImpl@6ca30b8a] will not be managed by Spring
  4. ==>  Preparing: SELECT id,type,name,description FROM tbl_book
  5. ==> Parameters: 
  6. <==    Columns: id, type, name, description
  7. <==        Row: 1, 计算机理论, Spring实战 第5版, Spring入门经典教程，深入理解Spring原理技术内幕
  8. <==        Row: 2, 计算机理论, Spring 5核心原理与30个类手写实战, 十年沉淀之作，手写Spring精华思想
  9. <==        Row: 3, 计算机理论, Spring 5 设计模式, 深入Spring源码剖析Spring源码中蕴含的10大设计模式
  10. <==        Row: 4, 计算机理论, Spring MVC+MyBatis开发从入门到项目实战, 全方位解析面向Web应用的轻量级框架，带你成为Spring MVC开发高手
  11. <==        Row: 5, 计算机理论, 轻量级Java Web企业应用实战, 源码级剖析Spring框架，适合已掌握Java基础的读者
  12. <==        Row: 6, 计算机理论, Java核心技术 卷I 基础知识（原书第11版）, Core Java 第11版，Jolt大奖获奖作品，针对Java SE9、10、11全面更新
  13. <==        Row: 7, 计算机理论, 深入理解Java虚拟机, 5个维度全面剖析JVM，大厂面试知识点全覆盖
  14. <==        Row: 8, 计算机理论, Java编程思想（第4版）, Java学习必读经典,殿堂级著作！赢得了全球程序员的广泛赞誉
  15. <==        Row: 9, 计算机理论, 零基础学Java（全彩版）, 零基础自学编程的入门图书，由浅入深，详解Java语言的编程思想和核心技术
  16. <==        Row: 10, 市场营销, 直播就该这么做：主播高效沟通实战指南, 李子柒、李佳琦、薇娅成长为网红的秘密都在书中
  17. <==        Row: 11, 市场营销, 直播销讲实战一本通, 和秋叶一起学系列网络营销书籍
  18. <==        Row: 12, 市场营销, 直播带货：淘宝、天猫直播从新手到高手, 一本教你如何玩转直播的书，10堂课轻松实现带货月入3W+
  19. <==        Row: 13, 测试类型, 测试数据, 测试描述数据
  20. <==        Row: 14, 测试数据update, 测试数据update, 测试数据update
  21. <==        Row: 15, -----------------, 测试数据123, 测试数据123
  22. <==      Total: 15

其中清晰的标注了当前执行的SQL语句是什么，携带了什么参数，对应的执行结果是什么，所有信息应有尽有。

此处设置的是日志的显示形式，当前配置的是控制台输出，当然还可以由更多的选择，根据需求切换即可。 

总结

  1. 手工导入starter坐标（2个），mysql驱动（1个）

  2. 配置数据源与MyBatisPlus对应的配置

  3. 开发Dao接口（继承BaseMapper）

  4. 制作测试类测试Dao功能是否有效

  5. 使用配置方式开启日志，设置日志输出方式为标准输出即可查阅SQL执行日志

3.数据层开发——分页功能制作

前面仅仅是使用了MP提供的基础CRUD功能，实际上MP给我们提供了几乎所有的基础操作，这一节说一下如果实现数据库端的分页操作

MP提供的分页操作API如下

  1. @Test
  2. void testGetPage(){
  3.     IPage page = new Page(2,5);
  4.     bookDao.selectPage(page, null);
  5.     System.out.println(page.getCurrent());
  6.     System.out.println(page.getSize());
  7.     System.out.println(page.getTotal());
  8.     System.out.println(page.getPages());
  9.     System.out.println(page.getRecords());
  10. }

其中selectPage方法需要传入一个封装分页数据的对象，可以通过new的形式创建这个对象，当然这个对象也是MP提供的，别选错包了。创建此对象时就需要指定分页的两个基本数据

  • 当前显示第几页

  • 每页显示几条数据

可以通过创建Page对象时利用构造方法初始化这两个数据

IPage page = new Page(2,5);

将该对象传入到查询方法selectPage后，可以得到查询结果，但是我们会发现当前操作查询结果返回值仍然是一个IPage对象，这又是怎么回事？

IPage page = bookDao.selectPage(page, null);

原来这个IPage对象中封装了若干个数据，而查询的结果作为IPage对象封装的一个数据存在的，可以理解为查询结果得到后，又塞到了这个IPage对象中，其实还是为了高度的封装，一个IPage描述了分页所有的信息。下面5个操作就是IPage对象中封装的所有信息了

  1. @Test
  2. void testGetPage(){
  3.     IPage page = new Page(2,5);
  4.     bookDao.selectPage(page, null);
  5.     System.out.println(page.getCurrent());		//当前页码值
  6.     System.out.println(page.getSize());			//每页显示数
  7.     System.out.println(page.getTotal());		//数据总量
  8.     System.out.println(page.getPages());		//总页数
  9.     System.out.println(page.getRecords());		//详细数据
  10. }

到这里就知道这些数据如何获取了，但是当你去执行这个操作时，你会发现并不像我们分析的这样，实际上这个分页当前是无效的。为什么这样呢？这个要源于MP的内部机制。

对于MySQL的分页操作使用limit关键字进行，而并不是所有的数据库都使用limit关键字实现的，这个时候MP为了制作的兼容性强，将分页操作设置为基础查询操作的升级版，你可以理解为IPhone6与IPhone6S-PLUS的关系。

基础操作中有查询全部的功能，而在这个基础上只需要升级一下（PLUS）就可以得到分页操作。所以MP将分页操作做成了一个开关，你用分页功能就把开关开启，不用就不需要开启这个开关。而我们现在没有开启这个开关，所以分页操作是没有的。这个开关是通过MP的拦截器的形式存在的，其中的原理这里不分析了，有兴趣的小伙伴可以学习MyBatisPlus这门课程进行详细解读。具体设置方式如下

定义MP拦截器并将其设置为Spring管控的bean

  1. //配置第三方bean的标准方式
  2. @Configuration
  3. public class MPConfig {
  4.     @Bean
  5.     public MybatisPlusInterceptor mybatisPlusInterceptor(){
  6.         MybatisPlusInterceptor interceptor = new MybatisPlusInterceptor();
  7.         //为mybatis-plus加我们需要的拦截器，这里我们只需要分页的拦截器
  8.         interceptor.addInnerInterceptor(new PaginationInnerInterceptor());
  9.         return interceptor;
  10.     }
  11. }

上述代码第一行是创建MP的拦截器栈，这个时候拦截器栈中没有具体的拦截器，第二行是初始化了分页拦截器，并添加到拦截器栈中。如果后期开发其他功能，需要添加全新的拦截器，按照第二行的格式继续add进去新的拦截器就可以了。

总结

  1. 使用IPage封装分页数据

  2. 分页操作依赖MyBatisPlus分页拦截器实现功能

  3. 借助MyBatisPlus日志查阅执行SQL语句

4.数据层开发——条件查询功能制作

除了分页功能，MP还提供有强大的条件查询功能。以往我们写条件查询要自己动态拼写复杂的SQL语句，现在简单了，MP将这些操作都制作成API接口，调用一个又一个的方法就可以实现各种套件的拼装。这里给大家普及一下基本格式，详细的操作还是到MP的课程中查阅吧

下面的操作就是执行一个模糊匹配对应的操作，由like条件书写变为了like方法的调用

  1. @Test
  2. void testGetBy(){
  3.     //条件查询对象，这个QueryWrapper为我们封装了条件查询的语句,我们只需要传查询条件就可以动态的为我们生成查询语句
  4.     QueryWrapper<Book> qw = new QueryWrapper<>();
  5.     //把查询操作转换成api操作
  6.     qw.like("name","Spring");
  7.     bookDao.selectList(qw);
  8. }

其中第一句QueryWrapper对象是一个用于封装查询条件的对象，该对象可以动态使用API调用的方法添加条件，最终转化成对应的SQL语句。第二句就是一个条件了，需要什么条件，使用QueryWapper对象直接调用对应操作即可。比如做大于小于关系，就可以使用lt或gt方法，等于使用eq方法，等等，此处不做更多的解释了。

这组API使用还是比较简单的，但是关于属性字段名的书写存在着安全隐患，比如查询字段name，当前是以字符串的形态书写的，万一写错，编译器还没有办法发现，只能将问题抛到运行器通过异常堆栈告诉开发者，不太友好。

MP针对字段检查进行了功能升级，这样可以避免字段名的拼写错误，全面支持Lambda表达式，就有了下面这组API。由QueryWrapper对象升级为LambdaQueryWrapper对象，这下就变了上述问题的出现

  1. @Test
  2. void testGetBy2(){
  3.     String name = "1";
  4.     LambdaQueryWrapper<Book> lqw = new LambdaQueryWrapper<Book>();
  5.     lqw.like(Book::getName,name);
  6.     bookDao.selectList(lqw);
  7. }

为了便于开发者【动态拼写SQL】，防止将null数据作为条件使用，MP还提供了动态拼装SQL的快捷书写方式

  1. @Test
  2. void testGetBy2(){
  3.     String name = "1";
  4.     LambdaQueryWrapper<Book> lqw = new LambdaQueryWrapper<Book>();
  5.     //if(name != null) lqw.like(Book::getName,name);		//方式一：JAVA代码控制
  6.     lqw.like(name != null,Book::getName,name);				//方式二：API接口提供控制开关
  7.     bookDao.selectList(lqw);
  8. }

其实就是个格式，没有区别。关于MP的基础操作就说到这里吧，如果这一块知识不太熟悉的小伙伴还是去完整的学习一下MP的知识吧，这里只是蜻蜓点水的用了几个操作而已。

总结

  1. 使用QueryWrapper对象封装查询条件

  2. 推荐使用LambdaQueryWrapper对象

  3. 所有查询操作封装成方法调用

  4. 查询条件支持动态条件拼装

5.业务层开发

数据层开发告一段落，下面进行业务层开发，其实标准业务层开发很多初学者认为就是调用数据层，怎么说呢？这个理解是没有大问题的，更精准的说法应该是组织业务逻辑功能，并根据业务需求，对数据持久层发起调用。有什么差别呢？目标是为了组织出符合需求的业务逻辑功能，至于调不调用数据层还真不好说，有需求就调用，没有需求就不调用。

一个常识性的知识普及一下，业务层的方法名定义一定要与业务有关，例如登录操作

login(String username,String password);

而数据层的方法名定义一定与业务无关，是一定，不是可能，也不是有可能，例如根据用户名密码查询

selectByUserNameAndPassword(String username,String password);

我们在开发的时候是可以根据完成的工作不同划分成不同职能的开发团队的。比如一个哥们制作数据层，他就可以不知道业务是什么样子，拿到的需求文档要求可能是这样的

  1. 接口：传入用户名与密码字段，查询出对应结果，结果是单条数据
  2. 接口：传入ID字段，查询出对应结果，结果是单条数据
  3. 接口：传入离职字段，查询出对应结果，结果是多条数据

但是进行业务功能开发的哥们，拿到的需求文档要求差别就很大

  1. 接口：传入用户名与密码字段，对用户名字段做长度校验，4-15位，对密码字段做长度校验，8到24位，对喵喵喵字段做特殊字符校验；
  2. 不允许存在空格，查询结果为对象。如果为null，返回BusinessException，封装消息码INFO_LOGON_USERNAME_PASSWORD_ERROR

你比较一下，能是一回事吗？差别太大了，所以说业务层方法定义与数据层方法定义差异化很大，只不过有些入门级的开发者手懒或者没有使用过公司相关的ISO标准化文档而已。

多余的话不说了，咱们做案例就简单制作了，业务层接口定义如下：

  1. public interface BookService {
  2.     Boolean save(Book book);
  3.     Boolean update(Book book);
  4.     Boolean delete(Integer id);
  5.     Book getById(Integer id);
  6.     List<Book> getAll();
  7.     IPage<Book> getPage(int currentPage,int pageSize);
  8. }

业务层实现类如下，转调数据层即可

  1. @Service
  2. public class BookServiceImpl implements BookService {
  3.  
  4.     @Autowired
  5.     private BookDao bookDao;
  6.  
  7.     @Override
  8.     public Boolean save(Book book) {
  9.         return bookDao.insert(book) > 0;
  10.     }
  11.  
  12.     @Override
  13.     public Boolean update(Book book) {
  14.         return bookDao.updateById(book) > 0;
  15.     }
  16.  
  17.     @Override
  18.     public Boolean delete(Integer id) {
  19.         return bookDao.deleteById(id) > 0;
  20.     }
  21.  
  22.     @Override
  23.     public Book getById(Integer id) {
  24.         return bookDao.selectById(id);
  25.     }
  26.  
  27.     @Override
  28.     public List<Book> getAll() {
  29.         return bookDao.selectList(null);
  30.     }
  31.  
  32.     @Override
  33.     public IPage<Book> getPage(int currentPage, int pageSize) {
  34.         IPage page = new Page(currentPage,pageSize);
  35.         bookDao.selectPage(page,null);
  36.         return page;
  37.     }
  38. }

别忘了对业务层接口进行测试，测试类如下 【注意:业务层的方法必须进行测试，如果不做这个业务层的测试的话，那么后续写代码可能就会陷入无限的bug中】

  1. @SpringBootTest
  2. public class BookServiceTest {
  3.     @Autowired
  4.     private IBookService bookService;
  5.  
  6.     @Test
  7.     void testGetById(){
  8.         System.out.println(bookService.getById(4));
  9.     }
  10.     @Test
  11.     void testSave(){
  12.         Book book = new Book();
  13.         book.setType("测试数据123");
  14.         book.setName("测试数据123");
  15.         book.setDescription("测试数据123");
  16.         bookService.save(book);
  17.     }
  18.     @Test
  19.     void testUpdate(){
  20.         Book book = new Book();
  21.         book.setId(17);
  22.         book.setType("-----------------");
  23.         book.setName("测试数据123");
  24.         book.setDescription("测试数据123");
  25.         bookService.updateById(book);
  26.     }
  27.     @Test
  28.     void testDelete(){
  29.         bookService.removeById(18);
  30.     }
  31.  
  32.     @Test
  33.     void testGetAll(){
  34.         bookService.list();
  35.     }
  36.  
  37.     @Test
  38.     void testGetPage(){
  39.         IPage<Book> page = new Page<Book>(2,5);
  40.         bookService.page(page);
  41.         System.out.println(page.getCurrent());
  42.         System.out.println(page.getSize());
  43.         System.out.println(page.getTotal());
  44.         System.out.println(page.getPages());
  45.         System.out.println(page.getRecords());
  46.     }
  47.  
  48. }

总结

  1. Service接口名称定义成业务名称，并与Dao接口名称进行区分

  2. 制作测试类测试Service功能是否有效

业务层快速开发

其实MP技术不仅提供了数据层快速开发方案，业务层MP也给了一个通用接口，个人观点不推荐使用，凑合能用吧，其实就是一个封装+继承的思想，代码给出，实际开发慎用；

使用MyBatisPlus提供有业务层通用接口（ISerivce）与业务层通用实现类（ServiceImpl<M,T>） 在通用类基础上做功能重载或功能追加。注意重载时不要覆盖原始操作，避免原始提供的功能丢失；

业务层接口快速开发

  1. public interface IBookService extends IService<Book> {
  2.      //快捷键 Ctrl+f3 就可以看见这个这个接口继承这个类实现了哪些方法，这个接口帮我们实现了通用是api
  3.     
  4.     //自己实现非通用操作API接口
  5.     //没有自动生成的方法我们需要自己单独定义,如下;不过唯一需要注意的是要避免我们的方法名和自动生成的方法的方法名冲突
  6.  
  7.     Boolean saveBook( Book book);
  8.  
  9.     Boolean modify(Book book);
  10.  
  11.     Boolean delete(Integer id);
  12.     
  13.     IPage<Book> getPage(Integer currentPage,Integer pageSize);
  14.  
  15. }

业务层接口实现类快速开发，关注继承的类需要传入两个泛型，一个是数据层接口，另一个是实体类

  1. @Service
  2. public class BookServiceImpl extends ServiceImpl<BookDao, Book> implements IBookService {
  3.     
  4. 	//使用这个mybatis的功能的时候要继承一个类，这两个泛型,一个是数据层接口，另一个是实体类
  5.  
  6.     
  7.     @Autowired
  8.     private BookDao bookDao;
  9. 	//添加非通用操作API
  10.     
  11.     //下面这些实现方法是自己定义的,或者是可以理解为没有自动生成的   
  12.     @Override
  13.     public Boolean saveBook(Book book) {
  14.         return bookDao.insert(book) > 0;
  15.     }
  16.  
  17.     @Override
  18.     public Boolean modify(Book book) {
  19.         return bookDao.updateById(book) > 0;
  20.     }
  21.  
  22.     @Override
  23.     public Boolean delete(Integer id) {
  24.         return bookDao.deleteById(id) > 0;
  25.     }
  26.     
  27.     @Override
  28.     public IPage<Book> getPage(Integer currentPage, Integer pageSize) {
  29.  
  30.         IPage page = new Page(currentPage,pageSize);
  31.         bookDao.selectPage(page,null);
  32.         return page;
  33.     }
  34. }

如果感觉MP提供的功能不足以支撑你的使用需要，其实是一定不能支撑的，因为需求不可能是通用的，在原始接口基础上接着定义新的API接口就行了，此处不再说太多了，就是自定义自己的操作了，但是不要和已有的API接口名冲突即可。

总结

  1. 使用通用接口（ISerivce<T>）快速开发Service

  2. 使用通用实现类（ServiceImpl<M,T>）快速开发ServiceImpl

  3. 可以在通用接口基础上做功能重载或功能追加

  4. 注意重载时不要覆盖原始操作，避免原始提供的功能丢失

6.表现层开发(controller)

终于做到表现层了，做了这么多都是基础工作。其实你现在回头看看，哪里还有什么SpringBoot的影子？前面1,2步就搞完了。继续完成表现层制作吧，咱们表现层的开发使用基于Restful的表现层接口开发，功能测试通过Postman工具进行

表现层接口如下:

  1. @RestController
  2. @RequestMapping("/books")
  3. public class BookController2 {
  4.  
  5.     @Autowired
  6.     private IBookService bookService;
  7.  
  8.     @GetMapping
  9.     public List<Book> getAll(){
  10.         return bookService.list();
  11.     }
  12.  
  13.     @PostMapping
  14.     public Boolean save(@RequestBody Book book){
  15.         return bookService.save(book);
  16.     }
  17.  
  18.     @PutMapping
  19.     public Boolean update(@RequestBody Book book){
  20.         return bookService.modify(book);
  21.     }
  22.  
  23.     @DeleteMapping("{id}")
  24.     public Boolean delete(@PathVariable Integer id){
  25.         return bookService.delete(id);
  26.     }
  27.  
  28.     @GetMapping("{id}")
  29.     public Book getById(@PathVariable Integer id){
  30.         return bookService.getById(id);
  31.     }
  32.  
  33.     @GetMapping("{currentPage}/{pageSize}")
  34.     public IPage<Book> getPage(@PathVariable int currentPage,@PathVariable int pageSize){
  35.         return bookService.getPage(currentPage,pageSize, null);
  36.     }
  37. }

在实用Postman测试时关注提交类型，对应上即可，不然就会报405的错误码了

普通GET请求

PUT请求传递json数据，后台实用@RequestBody接收数据

GET请求传递路径变量，后台实用@PathVariable接收数据

总结

  1. 基于Restful制作表现层接口

    • 新增：POST

    • 删除：DELETE

    • 修改：PUT

    • 查询：GET

  2. 接收参数

    • 实体数据：@RequestBody

    • 路径变量：@PathVariable

7.表现层消息一致性处理(重点)

该节主要是讲：后端的数据要以什么样的形式返回给前端；

目前我们通过Postman测试后业务层接口功能时通的，但是这样的结果给到前端开发者会出现一个小问题。不同的操作结果所展示的数据格式差异化严重

增删改操作结果

true

查询单个数据操作结果

  1. {
  2.     "id": 1,
  3.     "type": "计算机理论",
  4.     "name": "Spring实战 第5版",
  5.     "description": "Spring入门经典教程"
  6. }

查询全部数据操作结果

  1. [
  2.     {
  3.         "id": 1,
  4.         "type": "计算机理论",
  5.         "name": "Spring实战 第5版",
  6.         "description": "Spring入门经典教程"
  7.     },
  8.     {
  9.         "id": 2,
  10.         "type": "计算机理论",
  11.         "name": "Spring 5核心原理与30个类手写实战",
  12.         "description": "十年沉淀之作"
  13.     }
  14. ]

每种不同操作返回的数据格式都不一样，而且还不知道以后还会有什么格式，这样的结果让前端人员看了是很容易让人崩溃的，必须将所有操作的操作结果数据格式统一起来，需要设计表现层返回结果的模型类，【用于后端与前端进行数据格式统一】，也称为前后端数据协议

  1. package com.itheima.utils;
  2.  
  3. import lombok.Data;
  4.  
  5. /**
  6.  * @author 
  7.  * @create 2022/4/6
  8.  */
  9. @Data
  10. public class R {
  11. 	//无惨构造
  12.     public R(){}
  13.  
  14.     //不负责携带数据的构造
  15.     public R (Boolean flag){
  16.         this.flag = flag;
  17.     }
  18.  
  19.     //这个构造主要是给查询用的,因为查询不仅要携带数据,还要返回操作的成功与否
  20.     public R (Boolean flag,Object data){
  21.         this.flag = flag;
  22.     }
  23.     
  24.     public R (Boolean flag,String msg){
  25.         this.flag= flag;
  26.         this.msg = msg;
  27.     }
  28.     
  29.     private Boolean flag;
  30.     private Object data;
  31.     private String msg; //统一异常处理返回信息
  32.  
  33.  
  34. }

其中flag用于标识操作是否成功，data用于封装操作数据，现在的数据格式就变了

  1. {
  2.     "flag": true,
  3.     "data":{
  4.         "id": 1,
  5.         "type": "计算机理论",
  6.         "name": "Spring实战 第5版",
  7.         "description": "Spring入门经典教程"
  8.     }
  9. }

表现层开发格式也需要转换一下

 

结果这么一折腾，全格式统一，现在后端发送给前端的数据格式就统一了，免去了不少前端解析数据的麻烦。

总结

  1. 设计统一的返回值结果类型便于前端开发读取数据

  2. 返回值结果类型可以根据需求自行设定，没有固定格式

  3. 返回值结果模型类用于后端与前端进行数据格式统一，也称为前后端数据协议

8.前后端联通性测试

后端的表现层接口开发完毕，就可以进行前端的开发了。

将前端人员开发的页面保存到lresources目录下的static目录中，建议执行maven的clean生命周期，避免缓存的问题出现。

在进行具体的功能开发之前，先做联通性的测试，通过页面发送异步提交（axios），这一步调试通过后再进行进一步的功能开发

  1. //列表
  2. getAll() {
  3. 	axios.get("/books").then((res)=>{
  4. 		console.log(res.data);
  5. 	});
  6. },

只要后台代码能够正常工作，前端能够在日志中接收到数据，就证明前后端是通的，也就可以进行下一步的功能开发了

总结

  1. 单体项目中页面放置在resources/static目录下

  2. created钩子函数用于初始化页面时发起调用

  3. 页面使用axios发送异步请求获取数据后确认前后端是否联通

9.页面基础功能开发

F-1.列表功能（非分页版）

列表功能主要操作就是加载完数据，将数据展示到页面上，此处要利用VUE的数据模型绑定，发送请求得到数据，然后页面上读取指定数据即可

页面数据模型定义

  1. data:{
  2. 	dataList: [],//当前页要展示的列表数据
  3. 	...
  4. },

异步请求获取数据

  1. //列表
  2. getAll() {
  3.     axios.get("/books").then((res)=>{
  4.         this.dataList = res.data.data;
  5.     });
  6. },

这样在页面加载时就可以获取到数据，并且由VUE将数据展示到页面上了

总结：

  1. 将查询数据返回到页面，利用前端数据绑定进行数据展示

F-2.添加功能

添加功能用于收集数据的表单是通过一个弹窗展示的，因此在添加操作前首先要进行弹窗的展示，添加后隐藏弹窗即可。因为这个弹窗一直存在，因此当页面加载时首先设置这个弹窗为不可显示状态，需要展示，切换状态即可

默认状态

  1. data:{
  2. 	dialogFormVisible: false,//添加表单是否可见
  3. 	...
  4. },

切换为显示状态

  1. //弹出添加窗口
  2. handleCreate() {
  3. 	this.dialogFormVisible = true;
  4. },

由于每次添加数据都是使用同一个弹窗录入数据，所以每次操作的痕迹将在下一次操作时展示出来，需要在每次操作之前清理掉上次操作的痕迹

定义清理数据操作

  1. //重置表单  为什么要重置表单？那是因为我们每一次添加数据的时候上一次添加的数据还会残留在表单中，这会影响用户体验，那么我们应该什么时候重置表单呢？其实要么就是用户输入数据后点击添加按钮的时候重置表单，要么就是用户再次点击弹窗的时候重置表单，，明显第二种用户体验更加好
  2. resetForm() {
  3.     this.formData = {};
  4. },

切换弹窗状态时清理数据

  1. //弹出添加窗口
  2. handleCreate() {
  3.     this.dialogFormVisible = true;
  4.     this.resetForm();
  5. },

至此准备工作完成，下面就要调用后台完成添加操作了

添加操作

  1. //添加
  2. handleAdd () {
  3.     //发送异步请求
  4.     axios.post("/books",this.formData).then((res)=>{
  5.         //如果操作成功，关闭弹层，显示数据
  6.         if(res.data.flag){
  7.             this.dialogFormVisible = false;
  8.             this.$message.success("添加成功");
  9.         }else {
  10.             this.$message.error("添加失败");
  11.         }
  12.     }).finally(()=>{
  13.         //不管添加成功与否，都要刷新页面
  14.         this.getAll();
  15.     });
  16. },

  1. 将要保存的数据传递到后台，通过post请求的第二个参数传递json数据到后台

  2. 根据返回的操作结果决定下一步操作

    • 如何是true就关闭添加窗口，显示添加成功的消息

    • 如果是false保留添加窗口，显示添加失败的消息

  3. 无论添加是否成功，页面均进行刷新，动态加载数据（对getAll操作发起调用）

取消添加操作

  1. //取消
  2. cancel(){
  3.     this.dialogFormVisible = false; //关闭弹窗
  4.     this.dialogFormVisible4Edit = false; //用户点击编辑,然后取消编辑时，弹窗消失
  5.     this.$message.info("操作取消");  //提醒用户
  6. },

总结

  1. 请求方式使用POST调用后台对应操作

  2. 添加操作结束后动态刷新页面加载数据

  3. 根据操作结果不同，显示对应的提示信息

  4. 弹出添加Div时清除表单数据

F-3.删除功能

模仿添加操作制作删除功能，差别之处在于删除操作仅传递一个待删除的数据id到后台即可

删除操作

  1. // 删除
  2. handleDelete(row) {
  3.     axios.delete("/books/"+row.id).then((res)=>{
  4.         if(res.data.flag){
  5.             this.$message.success("删除成功");
  6.         }else{
  7.             this.$message.error("数据同步失败，自动刷新");
  8.         }
  9.     }).finally(()=>{
  10.         this.getAll();
  11.     });
  12. },

删除操作提示信息

  1. // 删除
  2. handleDelete(row) {
  3.     //1.弹出提示框  这个$confirm里面的第一个参数是用户操作是提醒用户的信息, 第二个参数是 弹出窗口的的提示信息，  第三个参数是提示信息的类型
  4.     this.$confirm("此操作永久删除当前数据，是否继续？","提示",{
  5.         type:'info'
  6.     }).then(()=>{
  7.         //2.做删除业务
  8.         axios.delete("/books/"+row.id).then((res)=>{
  9.        		if(res.data.flag){
  10.             	this.$message.success("删除成功");
  11.         	}else{
  12.             	this.$message.error("删除失败");
  13.         	}
  14.         }).finally(()=>{
  15.             //不管执行成功与否,都要刷新页面
  16.             this.getAll();
  17.         });
  18.     }).catch(()=>{
  19.         //3.取消删除
  20.         this.$message.info("取消删除操作");
  21.     });
  22. }，

element里面的scope.row里面的row是什么？下面是我点击对ID为1 的商品进行删除，然后在控制台打印这个row,我们发现，这个id为1的商品的所有数据都在row里面；

总结

  1. 请求方式使用Delete调用后台对应操作

  2. 删除操作需要传递当前行数据对应的id值到后台

  3. 删除操作结束后动态刷新页面加载数据

  4. 根据操作结果不同，显示对应的提示信息

  5. 删除操作前弹出提示框避免误操作

F-4.修改功能

修改功能可以说是列表功能、删除功能与添加功能的合体。几个相似点如下：

  1. 页面也需要有一个弹窗用来加载修改的数据，这一点与添加相同，都是要弹窗,需要弹出进行编辑；

  2. 弹出窗口中要加载待修改的数据(数据回显)，而数据需要通过查询得到，这一点与查询全部相同，都是要查数据

  3. 查询操作需要将要修改的数据id发送到后台，这一点与删除相同，都是传递id到后台

  4. 查询得到数据后需要展示到弹窗中，这一点与查询全部相同，都是要通过数据模型绑定展示数据

  5. 修改数据时需要将被修改的数据传递到后台，这一点与添加相同，都是要传递数据

    所以整体上来看，修改功能就是前面几个功能的大合体

    查询并展示数据

  1. //弹出编辑窗口
  2. handleUpdate(row) {
  3.     axios.get("/books/"+row.id).then((res)=>{
  4.         // && res.data.data != null 这个条件是为了防止a用户对已经删除的数据(b用户删除的)进行操作,然后导致else的操作无法执行
  5.         if(res.data.flag&& res.data.data != null){
  6.             //弹出窗口编辑
  7.             this.dialogFormVisible4Edit = true;
  8.             //对展示的弹出进行数据的加载
  9.             this.formData = res.data.data;
  10.         }else{
  11.             this.$message.error("数据同步失败，自动刷新");
  12.         }
  13.     }).finally(()=>{
  14.                     //重新加载数据
  15.                     this.getAll();
  16.                 });
  17. },

修改操作

  1. //修改
  2. handleEdit() {
  3.     axios.put("/books",this.formData).then((res)=>{
  4.         //如果操作成功，关闭弹层并刷新页面
  5.         if(res.data.flag){
  6.             this.dialogFormVisible4Edit = false;
  7.             this.$message.success("修改成功");
  8.         }else {
  9.             this.$message.error("修改失败，请重试");
  10.         }
  11.     }).finally(()=>{
  12.         this.getAll();
  13.     });
  14. },

总结

  1. 加载要修改数据通过传递当前行数据对应的id值到后台查询数据（同删除与查询全部）

  2. 利用前端双向数据绑定将查询到的数据进行回显（同查询全部）

  3. 请求方式使用PUT调用后台对应操作（同新增传递数据）

  4. 修改操作结束后动态刷新页面加载数据（同新增）

  5. 根据操作结果不同，显示对应的提示信息（同新增）

10.业务消息一致性处理(重点)

目前的功能制作基本上达成了正常使用的情况，什么叫正常使用呢？也就是这个程序不出BUG，如果我们搞一个BUG出来，你会发现程序马上崩溃掉。比如后台手工抛出一个异常，看看前端接收到的数据什么样子

  1. {
  2.     "timestamp": "2021-09-15T03:27:31.038+00:00",
  3.     "status": 500,
  4.     "error": "Internal Server Error",
  5.     "path": "/books"
  6. }

面对这种情况，前端的同学又不会了，这又是什么格式？怎么和之前的格式不一样？

  1. {
  2.     "flag": true,
  3.     "data":{
  4.         "id": 1,
  5.         "type": "计算机理论",
  6.         "name": "Spring实战 第5版",
  7.         "description": "Spring入门经典教程"
  8.     }
  9. }

看来不仅要对正确的操作数据格式做处理，还要对错误的操作数据格式做同样的格式处理

首先在当前的数据结果中添加消息字段，用来兼容后台出现的操作消息

  1. @Data
  2. public class R{
  3.     private Boolean flag;
  4.     private Object data;
  5.     private String msg;		//用于封装消息
  6. }

后台代码也要根据情况做处理，当前是模拟的错误

  1. @PostMapping
  2. public R save(@RequestBody Book book) throws IOException {
  3.     Boolean flag = bookService.insert(book);
  4.     return new R(flag , flag ? "添加成功^_^" : "添加失败-_-!");
  5. }

然后在表现层做统一的异常处理，使用SpringMVC提供的异常处理器做统一的异常处理

  1. @RestControllerAdvice
  2. public class ProjectExceptionAdvice {
  3.     @ExceptionHandler(Exception.class)
  4.     public R doOtherException(Exception ex){
  5.         //记录日志
  6.         //发送消息给运维
  7.         //发送邮件给开发人员,ex对象发送给开发人员
  8.         ex.printStackTrace(); //一定要打印异常，不要吞异常
  9.         return new R(false,"系统错误，请稍后再试！");
  10.     }
  11. }

页面上得到数据后，先判定是否有后台传递过来的消息，标志就是当前操作是否成功，如果返回操作结果false，就读取后台传递的消息

  1. //添加
  2. handleAdd () {
  3. 	//发送ajax请求
  4.     axios.post("/books",this.formData).then((res)=>{
  5.         //如果操作成功，关闭弹层，显示数据
  6.         if(res.data.flag){
  7.             this.dialogFormVisible = false;
  8.             this.$message.success("添加成功");
  9.         }else {
  10.             this.$message.error(res.data.msg);			//消息来自于后台传递过来，而非固定内容
  11.         }
  12.     }).finally(()=>{
  13.         this.getAll();
  14.     });
  15. },

总结

  1. 使用注解@RestControllerAdvice定义SpringMVC异常处理器用来处理异常的

  2. 异常处理器必须被扫描加载，否则无法生效

  3. 表现层返回结果的模型类中添加消息属性用来传递消息到页面

11.页面功能开发

F-5.分页功能

分页功能的制作用于替换前面的查询全部，其中要使用到elementUI提供的分页组件

  1. <!--分页组件-->
  2. <div class="pagination-container">
  3.     <el-pagination
  4. 		class="pagiantion"
  5. 		@current-change="handleCurrentChange"
  6. 		:current-page="pagination.currentPage"
  7. 		:page-size="pagination.pageSize"
  8. 		layout="total, prev, pager, next, jumper"
  9. 		:total="pagination.total">
  10.     </el-pagination>
  11. </div>

为了配合分页组件，封装分页对应的数据模型

  1. data:{
  2. 	pagination: {	
  3. 		//分页相关模型数据
  4. 		currentPage: 1,	//当前页码
  5. 		pageSize:10,	//每页显示的记录数
  6. 		total:0,		//总记录数
  7. 	}
  8. },

修改查询全部功能为分页查询，通过路径变量传递页码信息参数

  1. getAll() {
  2.     axios.get("/books/"+this.pagination.currentPage+"/"+this.pagination.pageSize).then((res) => {
  3.     });
  4. },

这个执行的结果是: 执行的结果里面携带了分页相关的数据；

后台提供对应的分页功能

  1. @GetMapping("/{currentPage}/{pageSize}")
  2. public R getAll(@PathVariable Integer currentPage,@PathVariable Integer pageSize){
  3.     IPage<Book> pageBook = bookService.getPage(currentPage, pageSize);
  4.     return new R(null != pageBook ,pageBook);
  5. }

页面根据分页操作结果读取对应数据，并进行数据模型绑定

  1. getAll() {
  2.     axios.get("/books/"+this.pagination.currentPage+"/"+this.pagination.pageSize).then((res) => {
  3.         //这些数据是从响应体中获取的
  4.         this.pagination.total = res.data.data.total;
  5.         this.pagination.currentPage = res.data.data.current;
  6.         this.pagination.pagesize = res.data.data.size;
  7.         this.dataList = res.data.data.records;
  8.     });
  9. },

对切换页码操作设置调用当前分页操作

  1. //切换页码
  2. handleCurrentChange(currentPage) {
  3.     //修改页码值为当前选中的页码值
  4.     this.pagination.currentPage = currentPage;
  5.     //执行查询
  6.     this.getAll();
  7. },

分页插件里面的几个参数代表什么数据要清楚:

总结

  1. 使用el分页组件

  2. 定义分页组件绑定的数据模型

  3. 异步调用获取分页数据

  4. 分页数据页面回显

F-6.删除功能维护

由于使用了分页功能，当最后一页只有一条数据时，删除操作就会出现BUG，最后一页无数据但是独立展示，对分页查询功能进行后台功能维护，如果当前页码值大于最大页码值，重新执行查询。其实这个问题解决方案很多，这里给出比较简单的一种处理方案

  1. @GetMapping("{currentPage}/{pageSize}")
  2. public R getPage(@PathVariable int currentPage,@PathVariable int pageSize){
  3.     IPage<Book> page = bookService.getPage(currentPage, pageSize);
  4.     //如果当前页码值大于了总页码值，那么重新执行查询操作，使用最大页码值作为当前页码值
  5.     if( currentPage > page.getPages()){
  6.         //再次进行分页查询,不过不是使用当前页面进行查询,直接使用总页数进行查询
  7.         page = bookService.getPage((int)page.getPages(), pageSize);
  8.     }
  9.     return new R(true, page);
  10. }

F-7.条件查询功能（重点）

最后一个功能来做条件查询，其实条件查询可以理解为分页查询的时候除了携带分页数据再多带几个数据的查询。这些多带的数据就是查询条件。比较一下不带条件的分页查询与带条件的分页查询差别之处，这个功能就好做了

  • 页面封装的数据：带不带条件影响的仅仅是一次性传递到后台的数据总量，由传递2个分页相关的数据转换成2个分页数据加若干个条件

  • 后台查询功能：查询时由不带条件，转换成带条件，反正不带条件的时候查询条件对象使用的是null，现在换成具体条件，差别不大

  • 查询结果：不管带不带条件，出来的数据只是有数量上的差别，其他都差别，这个可以忽略

    经过上述分析，看来需要在页面发送请求的格式方面做一定的修改，后台的调用数据层操作时发送修改，其他没有区别

    页面发送请求时，两个分页数据仍然使用路径变量，其他条件采用动态拼装url参数的形式传递

    页面封装查询条件字段

    1. pagination: {		
    2. //分页相关模型数据
    3. 	currentPage: 1,		//当前页码
    4. 	pageSize:10,		//每页显示的记录数
    5. 	total:0,			//总记录数
    6. 	name: "",
    7. 	type: "",
    8. 	description: ""
    9. },

    页面添加查询条件字段对应的数据模型绑定名称(进行数据双向绑定)

    1. <div class="filter-container">
    2.     <el-input placeholder="图书类别" v-model="pagination.type" class="filter-item"/>
    3.     <el-input placeholder="图书名称" v-model="pagination.name" class="filter-item"/>
    4.     <el-input placeholder="图书描述" v-model="pagination.description" class="filter-item"/>
    5.     <el-button @click="getAll()" class="dalfBut">查询</el-button>
    6.     <el-button type="primary" class="butT" @click="handleCreate()">新建</el-button>
    7. </div>

    将查询条件组织成url参数，添加到请求url地址中，这里可以借助其他类库快速开发，当前使用手工形式拼接，降低学习要求

    1. getAll() {
    2.     //1.获取查询条件,拼接查询条件
    3.     param = "?name="+this.pagination.name;
    4.     param += "&type="+this.pagination.type;
    5.     param += "&description="+this.pagination.description;
    6.     //查看查询条件
    7.     //console.log("-----------------"+ param);
    8.     axios.get("/books/"+this.pagination.currentPage+"/"+this.pagination.pageSize+param).then((res) => {
    9.         this.dataList = res.data.data.records;
    10.     });
    11. },

    后台代码中定义实体类封查询条件

    1. @GetMapping("{currentPage}/{pageSize}")
    2. public R getAll(@PathVariable int currentPage,@PathVariable int pageSize,Book book) {
    3.     IPage<Book> page = bookService.getPage(currentPage, pageSize,book);
    4.         //如果当前页码值大于了总页码值，那么重新执行查询操作，使用最大页码值作为当前页码值
    5.         if( currentPage > page.getPages()){
    6.             //再次进行分页查询,不过不是使用当前页面进行查询,直接使用总页数进行查询
    7.             page = bookService.getPage((int)page.getPages(), pageSize,book);
    8.         }
    9.         return new R(true, page);
    10.     }
    11. }

    对应业务层接口与实现类进行修正

    1. public interface IBookService extends IService<Book> {
    2.     
    3.     //再接口中重新添加一个这样的重载方法,然后在实现类重写就行
    4.     IPage<Book> getPage(Integer currentPage,Integer pageSize,Book queryBook);
    5. }
    1. @Service
    2. public class BookServiceImpl2 extends ServiceImpl<BookDao,Book> implements IBookService {
    3.     public IPage<Book> getPage(Integer currentPage,Integer pageSize,Book queryBook){
    4.         IPage page = new Page(currentPage,pageSize);
    5.         LambdaQueryWrapper<Book> lqw = new LambdaQueryWrapper<Book>();
    6.  //三个动态条件  第一个参数是布尔,表示要不要使用后面参数作为查询条件,第二个参数是从实体类中获取的条件属性名,第三个参数是具体的查询条件属性
    7.         lqw.like(Strings.isNotEmpty(queryBook.getName()),Book::getName,queryBook.getName());
    8.         lqw.like(Strings.isNotEmpty(queryBook.getType()),Book::getType,queryBook.getType());
    9.         lqw.like(Strings.isNotEmpty(queryBook.getDescription()),Book::getDescription,queryBook.getDescription());
    10.         return bookDao.selectPage(page,lqw);
    11.     }
    12. }

    页面回显数据

    1. getAll() {
    2.     //1.获取查询条件,拼接查询条件
    3.     param = "?name="+this.pagination.name;
    4.     param += "&type="+this.pagination.type;
    5.     param += "&description="+this.pagination.description;
    6.     console.log("-----------------"+ param);
    7.     axios.get("/books/"+this.pagination.currentPage+"/"+this.pagination.pageSize+param).then((res) => {
    8.         this.pagination.total = res.data.data.total;
    9.         this.pagination.currentPage = res.data.data.current;
    10.         this.pagination.pagesize = res.data.data.size;
    11.         this.dataList = res.data.data.records;
    12.     });
    13. },

总结

  1. 定义查询条件数据模型（当前封装到分页数据模型中）

  2. 异步调用分页功能并通过请求参数传递数据到后台

最后页面完整的script函数

  1. <script>
  2.     var vue = new Vue({
  3.         el: '#app',
  4.         data:{
  5.             dataList: [],//当前页要展示的列表数据
  6.             dialogFormVisible: false,//添加表单是否可见
  7.             dialogFormVisible4Edit:false,//编辑表单是否可见
  8.             formData: {},//表单数据
  9.             rules: {//校验规则
  10.                 type: [{ required: true, message: '图书类别为必填项', trigger: 'blur' }],
  11.                 name: [{ required: true, message: '图书名称为必填项', trigger: 'blur' }]
  12.             },
  13.             pagination: {//分页相关模型数据
  14.                 currentPage: 1,//当前页码
  15.                 pageSize:10,//每页显示的记录数
  16.                 total:0,//总记录数
  17.                 name: "",
  18.                 type: "",
  19.                 description: ""
  20.             }
  21.         },
  22.  
  23.         //钩子函数，VUE对象初始化完成后自动执行
  24.         created() {
  25.             //调用查询全部数据的操作
  26.             this.getAll();
  27.         },
  28.  
  29.         methods: {
  30.             //列表
  31.             // getAll() {
  32.             //     //发送异步请求
  33.             //     axios.get("/books").then((res)=>{
  34.             //         //console.log(res.data);
  35.             //         //注意,通过上面的控制台输出测试,我们发现res.data是后端返回给我们的数据(是封装数据的实体类),
  36.             //         // 但是我们并不是需要后端返回的所有的数据,所以我们可以从后端返回的数据中直接取我们需要部分的数据，可以把返回的数据看作一个对象,我们只需要对象里面的data属性
  37.             //         this.dataList = res.data.data;
  38.             //     });
  39.             // },
  40.  
  41.             //弹出添加窗口
  42.             handleCreate() {
  43.                 this.dialogFormVisible = true;
  44.                 this.resetForm();
  45.             },
  46.  
  47.             //重置表单
  48.             resetForm() {
  49.                 this.formData = {};
  50.             },
  51.  
  52.             //添加
  53.             handleAdd () {
  54.                 //发送异步请求
  55.                 axios.post("/books",this.formData).then((res)=>{
  56.                     //如果操作成功，关闭弹层，显示数据
  57.                     if(res.data.flag){
  58.                         this.dialogFormVisible = false;
  59.                         this.$message.success("添加成功");
  60.                     }else {
  61.                         this.$message.error(res.data.msg);                    }
  62.                 }).finally(()=>{
  63.                     //不管添加成功与否，都要刷新页面
  64.                     this.getAll();
  65.                 });
  66.             },
  67.  
  68.             //取消
  69.             cancel(){
  70.                 this.dialogFormVisible = false;
  71.                 this.dialogFormVisible4Edit = false;
  72.                 this.$message.info("操作取消");
  73.             },
  74.             // 删除
  75.             handleDelete(row) {
  76.                 //不知道这个row是什么都话,自己可以打印看一下
  77.                 //console.log(row);
  78.                 //1.弹出提示框
  79.                 this.$confirm("此操作永久删除当前数据，是否继续？","提示",{
  80.                     type:'info'
  81.                 }).then(()=>{
  82.                     //2.做删除业务
  83.                     axios.delete("/books/"+row.id).then((res)=>{
  84.                         if(res.data.flag){
  85.                             this.$message.success("删除成功");
  86.                         }else{
  87.                             this.$message.error("数据同步失败，自动刷新");
  88.                         }
  89.                     }).finally(()=>{
  90.                         //不管执行成功与否,都要刷新页面
  91.                         this.getAll();
  92.                     });
  93.                 }).catch(()=>{
  94.                     //3.取消删除
  95.                     this.$message.info("取消删除操作");
  96.                 });
  97.             },
  98.  
  99.             //弹出编辑窗口
  100.             handleUpdate(row) {
  101.                 axios.get("/books/"+row.id).then((res)=>{
  102.                     if(res.data.flag && res.data.data != null){
  103.                         //弹出窗口编辑
  104.                         this.dialogFormVisible4Edit = true;
  105.                         //对展示的弹出进行数据的加载
  106.                         this.formData = res.data.data;
  107.                     }else{
  108.                         this.$message.error("数据同步失败，自动刷新");
  109.                     }
  110.                 }).finally(()=>{
  111.                     //重新加载数据
  112.                     this.getAll();
  113.                 });
  114.             },
  115.  
  116.             //修改
  117.             handleEdit() {
  118.                 axios.put("/books",this.formData).then((res)=>{
  119.                     //如果操作成功，关闭弹层并刷新页面
  120.                     if(res.data.flag){
  121.                         this.dialogFormVisible4Edit = false;
  122.                         this.$message.success("修改成功");
  123.                     }else {
  124.                         this.$message.error("修改失败，请重试");
  125.                     }
  126.                 }).finally(()=>{
  127.                     this.getAll();
  128.                 });
  129.             },
  130.  
  131.             //分页查询  
  132.             getAll() {
  133.                 //条件查询
  134.                 //1.获取查询条件,拼接查询条件
  135.                 param = "?name="+this.pagination.name;
  136.                 param += "&type="+this.pagination.type;
  137.                 param += "&description="+this.pagination.description;
  138.                 //查看查询条件
  139.                 //console.log("-----------------"+ param);
  140.  
  141.                //分页查询
  142.                 axios.get("/books/"+this.pagination.currentPage+"/"+this.pagination.pageSize + param).then((res) => {
  143.                     this.pagination.total = res.data.data.total;
  144.                     this.pagination.currentPage = res.data.data.current;
  145.                     this.pagination.pagesize = res.data.data.size;
  146.                     this.dataList = res.data.data.records;
  147.                 });
  148.             },
  149.  
  150.             //切换页码
  151.             handleCurrentChange(currentPage) {
  152.                 //修改页码值为当前选中的页码值
  153.                 this.pagination.currentPage = currentPage;
  154.                 //执行查询
  155.                 this.getAll();
  156.             },
  157.         }
  158.     })
  159.  
  160. </script>
声明：本文内容由网友自发贡献，不代表【wpsshop博客】立场，版权归原作者所有，本站不承担相应法律责任。如您发现有侵权的内容，请联系我们。转载请注明出处：https://www.wpsshop.cn/w/很楠不爱3/article/detail/621175
推荐阅读
相关标签

Copyright © 2003-2013 www.wpsshop.cn 版权所有，并保留所有权利。

  

闽ICP备14008679号