基础篇包含如何创建一个SpringBoot工程、SpringBoot的基础配置语法格式、常见实用技术整合、整合综合应用。
小简从 0 开始学 Java 知识之 Java-学习路线 中的《SpringBoot-基础篇》,不定期更新所学笔记,期待一年后的蜕变吧!
章节 | 学习目标 |
---|---|
基础篇 | 能够创建SpringBoot工程基于SpringBoot实现ssm/ssmp整合 |
章节 | 前置知识 | 要求 |
---|---|---|
基础篇 | 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请求,如何获取响应数据,如何进行数据模型双向绑定 |
继承spring-boot-starter-parent;添加依赖spring-boot-starter-web
<parent>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-parent</artifactId>
<version>2.7.0</version>
</parent>
<dependencies>
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-web</artifactId>
</dependency>
</dependencies>
@SpringBootApplication
public class MainApplication {
public static void main(String[] args) {
SpringApplication.run(MainApplication.class,args);
}
}
@SpringBootApplication
注解相当于使用 @Configuration
、@EnableAutoConfiguration
和 @ComponentScan
及他们的默认属性
@Configuration
作为配置类替代xml配置文件
@EnableAutoConfiguration
启用 SpringBoot 的自动配置机制
@ComponentScan
自动扫描所有 Spring 组件
@RestController
public class HelloController {
@GetMapping
public String home(){
return "Hello, Spring Boot 2!";
}
}
直接运行主程序 MainApplication
中的 main
方法,访问 http://127.0.0.1:8080
,将会输出Hello, Spring Boot 2!
Spring Boot 包括了一个 Maven 插件,它可以将项目打包成一个可执行 jar
<build>
<plugins>
<plugin>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-maven-plugin</artifactId>
<version>2.7.0</version>
</plugin>
</plugins>
</build>
点击 IDEA 右侧的 Maven ⇒ 点击生命周期 ⇒ 点击 clean ⇒ 点击 package,target 目录下就会生成 jar 包,执行如下命令即可运行 jar 包
java -jar springBoot-learn-1.0-SNAPSHOT.jar
Spring Initailizr是创建 Spring Boot 工程的脚手架,以后就创建 SpringBoot 项目就不用创建空白Maven项目,而是创建 Spring Initailizr 项目
Spirng程序相比,SpringBoot程序在开发的过程中各个层面均具有优势
类配置文件 | Spring | SpringBoot |
---|---|---|
pom文件中的坐标 | 手工添加 | 勾选添加 |
web3.0配置类 | 手工制作 | 无 |
Spring/SpringMVC配置类 | 手工制作 | 无 |
控制器 | 手工制作 | 手工制作 |
创建新模块,选择Spring Initializr,并配置模块相关基础信息
@RestController
public class HelloController {
@GetMapping
public String home(){
return "Hello, Spring Boot 2!";
}
}
直接运行主程序 MainApplication
中的 main
方法,访问 http://127.0.0.1:8080
,将会输出Hello, Spring Boot 2!
SpringBoot带来的好处:
下面结合入门程序来说说这些简化操作都在哪些方面进行体现的,一共分为4个方面
SpringBoot 关注到开发者在进行开发时,往往对依赖版本的选择具有固定的搭配格式,并且这些依赖版本的选择还不能乱搭配。比如 A 技术的 2.0 版与 B 技术的 3.5 版可以合作在一起,但是和 B 技术的 3.7 版合并使用时就有冲突。于是 SpringBoot 做了无数个最合理的技术版本搭配列表,这个技术搭配列表的名字叫做parent。
一句话总结:使用parent可以帮助开发者进行版本的统一管理
那SpringBoot又是如何做到这一点的呢?可以查阅SpringBoot的配置源码,看到这些定义
<parent>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-parent</artifactId>
<version>2.5.4</version>
</parent>
<parent>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-dependencies</artifactId>
<version>2.5.4</version>
</parent>
这个坐标中定义了两组信息,
第一组是各式各样的依赖版本号
<properties>
<activemq.version>5.16.3</activemq.version>
<aspectj.version>1.9.7</aspectj.version>
<assertj.version>3.19.0</assertj.version>
<javax-json.version>1.1.4</javax-json.version>
<javax-websocket.version>1.1</javax-websocket.version>
<jetty-el.version>9.0.48</jetty-el.version>
<junit.version>4.13.2</junit.version>
......
</properties>
第二组是各式各样的的依赖坐标信息。可以看出依赖坐标定义中没有具体的依赖版本号,而是引用了第一组信息中定义的依赖版本属性值
<dependencyManagement>
<dependencies>
<dependency>
<groupId>org.hibernate</groupId>
<artifactId>hibernate-core</artifactId>
<version>${hibernate.version}</version>
</dependency>
<dependency>
<groupId>junit</groupId>
<artifactId>junit</artifactId>
<version>${junit.version}</version>
</dependency>
</dependencies>
</dependencyManagement>
关注:上面的依赖坐标定义是出现在<dependencyManagement>标签中的,其实是对引用坐标的依赖管理,并不是实际使用的坐标。因此当你的项目中继承了这组parent信息后,在不使用对应坐标的情况下,这组定义是不会具体导入某个依赖的
关注:因为在maven中继承机会只有一次,上述继承的格式还可以切换成导入的形式进行,并且在阿里云的starter创建工程时就使用了此种形式
<dependencyManagement>
<dependencies>
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-dependencies</artifactId>
<version>${spring-boot.version}</version>
<type>pom</type>
<scope>import</scope>
</dependency>
</dependencies>
</dependencyManagement>
总结
SpringBoot 关注到开发者在实际开发时,对于依赖坐标的使用往往都有一些固定的组合方式,比如使用 spring-webmvc 就一定要使用 spring-web。每次都要固定搭配着写,非常繁琐。于是 SpringBoot 把所有的技术使用固定搭配格式都给开发出来,以后你用某个技术,就不用一次写一堆依赖了,直接用固定搭配格式就好了。这个固定技术搭配的名字叫做starter。
一句话总结:使用starter可以帮助开发者减少依赖配置
那SpringBoot又是如何做到这一点的呢?可以查阅SpringBoot的配置源码,看到这些定义
command + shift + option + U
:以图的方式显示项目中依赖之间的关系。
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-web</artifactId>
</dependency>
<dependencies>
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter</artifactId>
<version>2.5.4</version>
<scope>compile</scope>
</dependency>
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-json</artifactId>
<version>2.5.4</version>
<scope>compile</scope>
</dependency>
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-tomcat</artifactId>
<version>2.5.4</version>
<scope>compile</scope>
</dependency>
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-web</artifactId>
<version>5.3.9</version>
<scope>compile</scope>
</dependency>
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-webmvc</artifactId>
<version>5.3.9</version>
<scope>compile</scope>
</dependency>
</dependencies>
发现里面有个 spring-boot-starter-json。看名称就知道,这个是与json有关的坐标了,但是看名字发现和最后两个又不太一样,它的名字中也有starter,打开看看里面有什么?
<dependencies>
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter</artifactId>
<version>2.5.4</version>
<scope>compile</scope>
</dependency>
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-web</artifactId>
<version>5.3.9</version>
<scope>compile</scope>
</dependency>
<dependency>
<groupId>com.fasterxml.jackson.core</groupId>
<artifactId>jackson-databind</artifactId>
<version>2.12.4</version>
<scope>compile</scope>
</dependency>
<dependency>
<groupId>com.fasterxml.jackson.datatype</groupId>
<artifactId>jackson-datatype-jdk8</artifactId>
<version>2.12.4</version>
<scope>compile</scope>
</dependency>
<dependency>
<groupId>com.fasterxml.jackson.datatype</groupId>
<artifactId>jackson-datatype-jsr310</artifactId>
<version>2.12.4</version>
<scope>compile</scope>
</dependency>
<dependency>
<groupId>com.fasterxml.jackson.module</groupId>
<artifactId>jackson-module-parameter-names</artifactId>
<version>2.12.4</version>
<scope>compile</scope>
</dependency>
</dependencies>
我们可以发现,这个starter中又包含了若干个坐标,其实就是使用SpringMVC开发通常都会使用到Json,使用json又离不开这里面定义的这些坐标,看来还真是方便,SpringBoot把我们开发中使用的东西能用到的都给提前做好了。你仔细看完会发现,里面有一些你没用过的。的确会出现这种过量导入的可能性,没关系,可以通过maven中的排除依赖剔除掉一部分。不过你不管它也没事,大不了就是过量导入呗。
到这里基本上得到了一个信息,使用starter可以帮开发者快速配置依赖关系。以前写依赖3个坐标的,现在写导入一个就搞定了,就是加速依赖配置的。
starter与parent的区别
朦朦胧胧中感觉starter与parent好像都是帮助我们简化配置的,但是功能又不一样,梳理一下。
starter是一个坐标中定了若干个坐标,以前写多个的,现在写一个,是用来减少依赖配置的书写量的
parent是定义了几百个依赖版本号,以前写依赖需要自己手工控制版本,现在由SpringBoot统一管理,
这样就不存在版本冲突了,是用来减少依赖冲突的
实际开发应用方式
实际开发中如果需要用什么技术,先去找有没有这个技术对应的starter
实际开发中如果发现坐标出现了冲突现象,确认你要使用的可行的版本号,使用手工书写的方式添加对应依赖,覆盖SpringBoot提供给我们的配置管理
<properties>
<mysql.version>5.1.43</mysql.version>
</properties>
温馨提示
SpringBoot官方给出了好多个starter的定义,方便我们使用,而且名称都是如下格式
命名规则:spring-boot-starter-技术名称
那非官方定义的也有吗?有的,而且名称都是如下格式
命名规则:技术名称-spring-boot-starter
或者: 技术名称-boot-starter(技术名称过长,简化命名)
总结
程序是如何运行的。目前程序运行的入口就是SpringBoot工程创建时自带的那个类了,带有main方法的那个类,运行这个类就可以启动SpringBoot工程的运行
@SpringBootApplication
public class SpringbootApplication {
public static void main(String[] args) {
SpringApplication.run(SpringbootApplication.class, args);
}
}
SpringBoot本身是为了加速Spring程序的开发的,而Spring程序运行的基础是需要创建自己的Spring容器对象(IoC容器)并将所有的对象交给Spring的容器管理,也就是一个一个的Bean。当这个类运行后就会产生一个Spring容器对象,并且可以将这个对象保存起来,通过容器对象直接操作Bean。
@SpringBootApplication
public class SpringbootApplication {
public static void main(String[] args) {
//1、返回我们IOC容器
ConfigurableApplicationContext run = SpringApplication.run(MainApplication.class, args);
//2、查看容器里面的组件
String[] names = run.getBeanDefinitionNames();
for (String name : names) {
System.out.println(name);
}
}
}
作为一个引导类最典型的特征就是当前类上方声明了一个注解@SpringBootApplication
总结
当前我们做的SpringBoot入门案例勾选了Spirng-web的功能,并且导入了对应的starter。
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-web</artifactId>
</dependency>
SpringBoot发现,既然你要做web程序,肯定离不开使用web服务器,我再帮你搞一个web服务器,你要愿意用的,直接使用就好了,干脆我再多给你几种选择,你随便切换。万一你不想用我给你提供的,也行,你可以自己搞。
由于这个功能不属于程序的主体功能,可用可不用,于是乎SpringBoot将其定位成辅助功能。
下面就围绕着这个内置的web服务器,也可以说是内置的tomcat服务器来研究几个问题
内嵌Tomcat定义位置
说到定义的位置,我们就想,如果我们不开发web程序,用的着web服务器吗?肯定用不着啊。那如果这个东西被加入到你的程序中,伴随着什么技术进来的呢?肯定是web相关的功能啊,没错,就是前面导入的web相关的starter做的这件事。
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-web</artifactId>
</dependency>
打开查看web的starter导入了哪些东西
<dependencies>
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter</artifactId>
<version>2.5.4</version>
<scope>compile</scope>
</dependency>
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-json</artifactId>
<version>2.5.4</version>
<scope>compile</scope>
</dependency>
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-tomcat</artifactId>
<version>2.5.4</version>
<scope>compile</scope>
</dependency>
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-web</artifactId>
<version>5.3.9</version>
<scope>compile</scope>
</dependency>
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-webmvc</artifactId>
<version>5.3.9</version>
<scope>compile</scope>
</dependency>
</dependencies>
第三个依赖就是这个tomcat对应的东西了,居然也是一个starter,再打开看看
<dependencies>
<dependency>
<groupId>jakarta.annotation</groupId>
<artifactId>jakarta.annotation-api</artifactId>
<version>1.3.5</version>
<scope>compile</scope>
</dependency>
<dependency>
<groupId>org.apache.tomcat.embed</groupId>
<artifactId>tomcat-embed-core</artifactId>
<version>9.0.52</version>
<scope>compile</scope>
<exclusions>
<exclusion>
<artifactId>tomcat-annotations-api</artifactId>
<groupId>org.apache.tomcat</groupId>
</exclusion>
</exclusions>
</dependency>
<dependency>
<groupId>org.apache.tomcat.embed</groupId>
<artifactId>tomcat-embed-el</artifactId>
<version>9.0.52</version>
<scope>compile</scope>
</dependency>
<dependency>
<groupId>org.apache.tomcat.embed</groupId>
<artifactId>tomcat-embed-websocket</artifactId>
<version>9.0.52</version>
<scope>compile</scope>
<exclusions>
<exclusion>
<artifactId>tomcat-annotations-api</artifactId>
<groupId>org.apache.tomcat</groupId>
</exclusion>
</exclusions>
</dependency>
</dependencies>
这里面有一个核心的坐标,tomcat-embed-core,叫做tomcat内嵌核心。就是这个东西把tomcat功能引入到了我们的程序中。目前解决了第一个问题。谁把tomcat引入到程序中的?spring-boot-starter-web中的spring-boot-starter-tomcat做的。
内嵌Tomcat运行原理
Tomcat服务器是一款软件,而且是一款使用java语言开发的软件下面的问题来了,既然是使用java语言开发的,运行的时候肯定符合java程序运行的原理,java程序运行靠的是什么?对象呀,一切皆对象,万物皆对象。那tomcat运行起来呢?也是对象。
如果是对象,那Spring容器是用来管理对象的,tomcat服务器运行其实是以对象的形式在Spring容器中运行的。具体运行的是什么呢?其实就是上前面提到的那个tomcat内嵌核心
<dependencies>
<dependency>
<groupId>org.apache.tomcat.embed</groupId>
<artifactId>tomcat-embed-core</artifactId>
<version>9.0.52</version>
<scope>compile</scope>
</dependency>
</dependencies>
那既然是个对象,如果把这个对象从Spring容器中去掉是不是就没有web服务器的功能呢?是这样的,通过依赖排除可以去掉这个web服务器功能
<dependencies>
<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>
</dependencies>
重新启动程序可以观察到程序运行了,但是并没有像之前那样运行后会等着用户发请求,而是直接停掉了。
更换内嵌Tomcat
根据SpringBoot的工作机制,用什么技术,加入什么依赖就行了。SpringBoot提供了3款内置的服务器
想用哪个,加个坐标就OK。前提是把tomcat排除掉,因为tomcat是默认加载的。
<dependencies>
<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>
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-jetty</artifactId>
</dependency>
</dependencies>
现在就已经成功替换了web服务器,核心思想就是用什么加入对应坐标就可以了。如果有starter,优先使用starter。
总结
SpringBoot 通过 resources 目录下的配置文件 application.properties
就可以修改默认的配置
例如 将 tomcat 的默认端口8080改成80,输入port后,自带提示带提示
server.port=80
重新运行,浏览器输入http://localhost
即可
这个配置项和什么有关?在pom中注释掉导入的spring-boot-starter-web,然后刷新工程,你会发现配置的提示消失了。闹了半天是设定使用了什么技术才能做什么配置。
更多配置项请参考:Common Application Properties
总结
SpringBoot除了支持properties格式的配置文件,还支持另外两种格式的配置文件。分别如下:
server.port=80
推荐使用
)server:
port: 81
server:
port: 82
yml 格式和 yaml 格式除了文件名后缀不一样,格式完全一样,所以可以合并成一种格式来看。
YAML(YAML Ain’t Markup Language) 是一种较为人性化的数据序列化语言 ,语法比较简洁直观,特点是使用空格来表达层次结构,其最大优势在于数据结构方面的表达,所以 YAML 更多应用于编写配置文件,其文件一般以 .yml 为后缀。
yaml 非常适合用来做以数据为中心的配置文件。所以我们可以用 yaml 代替之前的 properties
:
”后有空格数据类型
k: v
行内写法: k: {k1:v1,k2:v2,k3:v3}
#或
k:
k1: v1
k2: v2
k3: v3
行内写法: k: [v1,v2,v3]
#或
k:
- v1
- v2
- v3
users: #对象数组格式
- name: Tom
age: 4
- name: Jerry
age: 5
users2: [ { name:Tom , age:4 } , { name:Jerry , age:5 } ] #对象数组缩略格式
示例
@Data
public class Person {
private String userName;
private Boolean boss;
private Date birth;
private Integer age;
private Pet pet;
private String[] interests;
private List<String> animal;
private Map<String, Object> score;
private Set<Double> salarys;
private Map<String, List<Pet>> allPets;
}
@Data
public class Pet {
private String name;
private Double weight;
}
# yaml表示以上对象
person:
userName: zhangsan
boss: false
birth: 2019/12/12 20:12:33
age: 18
pet:
name: tomcat
weight: 23.4
interests: [篮球,游泳]
animal:
- jerry
- mario
score:
english:
first: 30
second: 40
third: 50
math: [131,140,148]
chinese: {first: 128,second: 136}
salarys: [3999,4999.98,5999.99]
allPets:
sick:
- {name: tom}
- {name: jerry,weight: 47}
health: [{name: mario,weight: 47}]
如果你在书写yaml数据时,经常出现如下现象,比如很多个文件都具有相同的目录前缀
center:
dataDir: /usr/local/fire/data
tmpDir: /usr/local/fire/tmp
logDir: /usr/local/fire/log
msgDir: /usr/local/fire/msgDir
或者
center:
dataDir: D:/usr/local/fire/data
tmpDir: D:/usr/local/fire/tmp
logDir: D:/usr/local/fire/log
msgDir: D:/usr/local/fire/msgDir
这个时候你可以使用引用格式来定义数据,其实就是搞了个变量名,然后引用变量了,格式如下:
baseDir: /usr/local/fire
center:
dataDir: ${baseDir}/data
tmpDir: ${baseDir}/tmp
logDir: ${baseDir}/log
msgDir: ${baseDir}/msgDir
还有一个注意事项,在书写字符串时,如果需要使用转义字符,需要将数据字符串使用双引号包裹起来
lesson: "Spring\tboot\nlesson"
总结
yaml中保存的单个数据,可以使用Spring中的注解直接读取,使用@Value
可以读取单个数据,属性名引用方式:${一级属性名.二级属性名……}
总结
读取单一数据可以解决读取数据的问题,但是如果定义的数据量过大,这么一个一个书写肯定会累死人的,SpringBoot提供了一个对象,能够把所有的数据都封装到这一个对象中,这个对象叫做Environment,使用自动装配注解 @Autowired 可以将所有的yaml数据封装到这个对象中
数据封装到了Environment对象中,通过方法 getProperty(“属性名”) 获取数据
总结
单一数据读取书写比较繁琐,全数据封装又封装的太厉害了,每次拿数据还要一个一个的 getProperty() ,总之用起来都不是很舒服。由于Java是一个面向对象的语言,很多情况下,我们会将一组数据封装成一个对象。SpringBoot也提供了可以将一组yaml对象数据封装一个Java对象的操作
首先定义一个对象,并将该对象纳入Spring管控的范围,也就是定义成一个bean,然后使用注解@ConfigurationProperties(prefix = "数据前缀")
指定该对象加载哪一组yaml中配置的信息。
@ConfigurationProperties 必须指定加载的数据前缀是什么,这样当前前缀下的所有属性就封装到这个对象中。记得数据属性名要与对象的变量名一一对应,不然没法封装。其实以后如果你要定义一组数据自己使用,就可以先写一个对象,然后定义好属性,下面到配置中根据这个格式书写即可。
总结
温馨提示
细心的小伙伴会发现一个问题,自定义的这种数据在yaml文件中书写时没有弹出提示,解决方法如下。
配置提示 configuration-processor
自定义的类和配置文件绑定一般没有提示。若要提示,添加如下依赖:
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-configuration-processor</artifactId>
<optional>true</optional>
</dependency>
<build>
<plugins>
<plugin>
<configuration>
<excludes>
<exclude>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-configuration-processor</artifactId>
</exclude>
</excludes>
</configuration>
</plugin>
</plugins>
</build>
再在自定义的类上添加配置注解
@ConfigurationProperties(prefix = "xxx")//读取文件中所有以xxx开头的属性,并和bean中的字段进行匹配
@Component //标注类为Spring容器的Bean
测试
@ConfigurationProperties(prefix = "user")
@Component //标注类为Spring容器的Bean
@NoArgsConstructor //无参构造
@AllArgsConstructor //有参构造
@Data
@EqualsAndHashCode
public class User {
private String name;
private Integer age;
}
在配置文件 application.yml 中输入 user 就会得到 name 和 age 的输入提示
整合第三方技术通用方式
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-test</artifactId>
<scope>test</scope>
</dependency>
@SpringBootTest
class SpringbootJunitTests {
//注入你要测试的对象
@Autowired
private BookDao bookDao;
@Test
void contextLoads() {
//执行要测试的对象对应的方法
bookDao.save();
System.out.println("two...");
}
}
第一种方式使用属性的形式进行,在注解 @SpringBootTest 中添加 classes 属性指定配置类
@SpringBootTest(classes = SpringbootJunitApplication.class)
class SpringbootJunitApplicationTests {
//注入你要测试的对象
@Autowired
private BookDao bookDao;
@Test
void contextLoads() {
//执行要测试的对象对应的方法
bookDao.save();
System.out.println("two...");
}
}
第二种方式回归原始配置方式,仍然使用 @ContextConfiguration 注解进行,效果是一样的
@SpringBootTest
@ContextConfiguration(classes = SpringbootJunitApplication.class)
class SpringbootJunitApplicationTests {
//注入你要测试的对象
@Autowired
private BookDao bookDao;
@Test
void contextLoads() {
//执行要测试的对象对应的方法
bookDao.save();
System.out.println("two...");
}
}
总结
步骤①:创建模块时勾选要使用的技术,MyBatis,由于要操作数据库,还要勾选对应数据库
或者手工导入 MyBatis 的 starter 和对应数据库的坐标
<dependency>
<groupId>org.mybatis.spring.boot</groupId>
<artifactId>mybatis-spring-boot-starter</artifactId>
<version>2.2.2</version>
</dependency>
<dependency>
<groupId>mysql</groupId>
<artifactId>mysql-connector-java</artifactId>
<scope>runtime</scope>
</dependency>
步骤②:配置数据源相关信息,没有这个信息你连接哪个数据库都不知道
spring:
datasource:
driver-class-name: com.mysql.cj.jdbc.Driver
url: jdbc:mysql://localhost:3306/ssm_db?serverTimezone=Asia/Shanghai
username: root
password: root
测试
SET NAMES utf8;
SET FOREIGN_KEY_CHECKS = 0;
-- ----------------------------
-- Table structure for tbl_book
-- ----------------------------
DROP TABLE IF EXISTS `tbl_book`;
CREATE TABLE `tbl_book` (
`id` int NOT NULL AUTO_INCREMENT,
`name` varchar(50) CHARACTER SET utf8 COLLATE utf8_general_ci NULL DEFAULT NULL,
`type` varchar(100) CHARACTER SET utf8 COLLATE utf8_general_ci NULL DEFAULT NULL,
`description` varchar(100) CHARACTER SET utf8 COLLATE utf8_general_ci NULL DEFAULT NULL,
PRIMARY KEY (`id`) USING BTREE
) ENGINE = InnoDB CHARACTER SET = utf8 COLLATE = utf8_general_ci ROW_FORMAT = Dynamic;
-- ----------------------------
-- Records of tbl_book
-- ----------------------------
INSERT INTO `tbl_book` VALUES (1, '三体', '科幻', '大刘的巅峰之作,将中国科幻推向世界舞台。总共分为三部曲:《地球往事》、《黑暗森林》、《死神永生》。');
INSERT INTO `tbl_book` VALUES (2, '格林童话', '童话', '睡前故事。');
INSERT INTO `tbl_book` VALUES (3, 'Spring 5设计模式', '计算机理论', '深入Spring源码剖析Spring源码中蕴含的10大设计模式');
INSERT INTO `tbl_book` VALUES (4, 'Spring MVC+ MyBatis开发从入门到项目实战', '计算机理论', '全方位解析面向Web应用的轻量级框架,带你成为Spring MVC开发高手');
INSERT INTO `tbl_book` VALUES (5, '轻量级Java Web企业应用实战', '计算机理论', '源码级剖析Spring框架,适合已掌握Java基础的读者');
INSERT INTO `tbl_book` VALUES (6, 'Java核心技术卷|基础知识(原书第11版)', '计算机理论', 'Core Java第11版,Jolt大奖获奖作品,针对Java SE9、10、 11全面更新');
INSERT INTO `tbl_book` VALUES (7, '深入理解Java虚拟机', '计算机理论', '5个维度全面剖析JVM,面试知识点全覆盖');
INSERT INTO `tbl_book` VALUES (8, 'Java编程思想(第4版)', '计算机理论', 'Java学习必读经典殿堂级著作!赢得了全球程序员的广泛赞誉');
INSERT INTO `tbl_book` VALUES (9, '零基础学Java (全彩版)', '计算机理论', '零基础自学编程的入门]图书,由浅入深,详解Java语言的编程思想和核心技术');
INSERT INTO `tbl_book` VALUES (10, '直播就该这么做:主播高效沟通实战指南', '市场营销', '李子柒、李佳琦、薇娅成长为网红的秘密都在书中');
INSERT INTO `tbl_book` VALUES (11, '直播销讲实战一本通', '市场营销', '和秋叶一起学系列网络营销书籍');
INSERT INTO `tbl_book` VALUES (12, '直播带货:淘宝、天猫直播从新手到高手', '市场营销', '一本教你如何玩转直播的书, 10堂课轻松实现带货月入3W+');
INSERT INTO `tbl_book` VALUES (13, 'Spring实战第5版', '计算机理论', 'Spring入门经典教程,深入理解Spring原理技术内幕');
INSERT INTO `tbl_book` VALUES (14, 'Spring 5核心原理与30个类手写实战', '计算机理论', '十年沉淀之作,写Spring精华思想');
SET FOREIGN_KEY_CHECKS = 1;
public class Book {
private Integer id;
private String type;
private String name;
private String description;
}
@Mapper
public interface BookDao {
@Select("select * from tbl_book where id = #{id}")
public Book getById(Integer id);
}
@SpringBootTest
class Springboot05MybatisApplicationTests {
@Autowired
private BookDao bookDao;
@Test
void contextLoads() {
System.out.println(bookDao.getById(1));
}
}
总结
步骤①:导入对应的 starter 和数据库驱动
<dependency>
<groupId>com.baomidou</groupId>
<artifactId>mybatis-plus-boot-starter</artifactId>
<version>3.4.3</version>
</dependency>
<dependency>
<groupId>mysql</groupId>
<artifactId>mysql-connector-java</artifactId>
<scope>runtime</scope>
</dependency>
步骤②:配置数据源相关信息
spring:
datasource:
driver-class-name: com.mysql.cj.jdbc.Driver
url: jdbc:mysql://localhost:3306/ssm_db
username: root
password: root
步骤③:配置表名的通用前缀名
数据库的表名定义规则是tbl_模块名称,为了能和实体类相对应,需要设置所有表名的通用前缀名
mybatis-plus:
global-config:
db-config:
table-prefix: tbl_ #设置所有表的通用前缀名称为tbl_
步骤④:配置运行日志
使用MP后开发者不需要书写SQL语句了,这样程序运行的时候总有一种感觉,一切的一切都是黑盒的,作为开发者我们啥也不知道就完了。如果程序正常运行还好,如果报错了,这个时候就很崩溃,你甚至都不知道从何下手,因为传递参数、封装SQL语句这些操作完全不是你干预开发出来的,所以查看执行期运行的SQL语句就成为当务之急。SpringBoot整合MP的时候充分考虑到了这点,通过配置的形式就可以查阅执行期SQL语句,配置如下
mybatis-plus:
global-config:
db-config:
table-prefix: tbl_
id-type: auto
configuration:
log-impl: org.apache.ibatis.logging.stdout.StdOutImpl #配置日志
测试
public class Book {
private Integer id;
private String type;
private String name;
private String description;
}
@Mapper
public interface BookDao extends BaseMapper<Book> {
}
核心在于Dao接口继承了一个BaseMapper的接口,这个接口中帮助开发者预定了若干个常用的API接口,简化了通用API接口的开发工作。
@SpringBootTest
class SpringbootApplicationTests {
@Autowired
private BookDao bookDao;
@Test
void contextLoads() {
System.out.println(bookDao.selectById(2));
System.out.println(bookDao.selectList(null));
}
}
总结
前面整合 MyBatis 和 MyBatis-Plus 的时候,使用的数据源对象都是SpringBoot默认的数据源对象 HiKari,下面我们手工控制一下,自己指定了一个数据源对象 Druid。
步骤①:导入对应的starter
<dependencies>
<dependency>
<groupId>com.alibaba</groupId>
<artifactId>druid-spring-boot-starter</artifactId>
<version>1.2.6</version>
</dependency>
</dependencies>
步骤②:修改配置
spring:
datasource:
druid:
driver-class-name: com.mysql.cj.jdbc.Driver
url: jdbc:mysql://localhost:3306/ssm_db?serverTimezone=UTC
username: root
password: root
#除了这4个常规配置外,还有druid专用的其他配置。通过提示功能可以打开druid相关的配置查阅
总结
步骤①:导入对应的starter 和依赖
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-data-redis</artifactId>
</dependency>
<!--连接池依赖-->
<dependency>
<groupId>org.apache.commons</groupId>
<artifactId>commons-pool2</artifactId>
<version>2.6.0</version>
</dependency>
步骤②:修改配置
spring:
redis:
host: 127.0.0.1 #指定redis所在的host
port: 6379 #指定redis的端口
password: 123456 #设置redis密码
lettuce:
pool:
max-active: 8 #最大连接数
max-idle: 8 #最大空闲数
min-idle: 0 #最小空闲数
max-wait: 100ms #连接等待时间
测试
@SpringBootTest
class SpringRedisApplicationTests {
@Resource
private RedisTemplate redisTemplate;
@Test
void testString() {
// 1.通过RedisTemplate获取操作String类型的ValueOperations对象
ValueOperations ops = redisTemplate.opsForValue();
// 2.插入一条数据
ops.set("name","jianjian");
// 3.获取数据
String name = (String) ops.get("name");
System.out.println("name = " + name);
}
}
本章将实现一个基于 SpringBoot -Vue 的 CRUD 整合 Demo 项目地址:https://github.com/jwt1399/SpringBoot-Vue-CRUD
entity层即数据库实体层,也称为 POJO 层(Plain Ordinary Java Object,即简单普通的java对象)或 model 层。 entity层的作用为存放实体类Bean。 一般数据库一张表对应一个实体类,类属性同表字段一一对应。
dao层即数据持久层,也称为mapper层。 dao层的作用为访问数据库,向数据库发送sql语句,完成数据的增删改查任务。
service层即业务逻辑层。 service层的作用为完成功能设计。 service层调用dao层接口,接收dao层返回的数据,完成项目的基本功能设计。
controller层即控制层。 controller层的功能为请求和响应控制。 controller层负责前后端交互,接受前端请求,调用service层,接收service层返回的数据,最后返回具体的页面和数据到客户端。
Lombok
快速制作实体类MyBatis-Plus
,制作数据层测试MyBatis-Plus
进行增量开发,制作业务层测试类Restful
开发,使用PostMan
测试接口功能VUE+ElementUI
制作,前后端联调,页面数据处理,页面消息处理创建新项目,加载要使用的技术对应的starter,修改配置文件格式为yml格式,并把web访问端口先设置成80。
pom.xml
<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>
application.yml
server:
port: 80
数据表
-- ----------------------------
-- Table structure for tbl_book
-- ----------------------------
DROP TABLE IF EXISTS `tbl_book`;
CREATE TABLE `tbl_book` (
`id` int(11) NOT NULL AUTO_INCREMENT,
`type` varchar(20) CHARACTER SET utf8 COLLATE utf8_general_ci NULL DEFAULT NULL,
`name` varchar(50) CHARACTER SET utf8 COLLATE utf8_general_ci NULL DEFAULT NULL,
`description` varchar(255) CHARACTER SET utf8 COLLATE utf8_general_ci NULL DEFAULT NULL,
PRIMARY KEY (`id`) USING BTREE
) ENGINE = InnoDB AUTO_INCREMENT = 51 CHARACTER SET = utf8 COLLATE = utf8_general_ci ROW_FORMAT = Dynamic;
-- ----------------------------
-- Records of tbl_book
-- ----------------------------
INSERT INTO `tbl_book` VALUES (1, '计算机理论', 'Spring实战 第5版', 'Spring入门经典教程,深入理解Spring原理技术内幕');
INSERT INTO `tbl_book` VALUES (2, '计算机理论', 'Spring 5核心原理与30个类手写实战', '十年沉淀之作,手写Spring精华思想');
INSERT INTO `tbl_book` VALUES (3, '计算机理论', 'Spring 5 设计模式', '深入Spring源码剖析Spring源码中蕴含的10大设计模式');
INSERT INTO `tbl_book` VALUES (4, '计算机理论', 'Spring MVC+MyBatis开发从入门到项目实战', '全方位解析面向Web应用的轻量级框架,带你成为Spring MVC开发高手');
INSERT INTO `tbl_book` VALUES (5, '计算机理论', '轻量级Java Web企业应用实战', '源码级剖析Spring框架,适合已掌握Java基础的读者');
INSERT INTO `tbl_book` VALUES (6, '计算机理论', 'Java核心技术 卷I 基础知识(原书第11版)', 'Core Java 第11版,Jolt大奖获奖作品,针对Java SE9、10、11全面更新');
INSERT INTO `tbl_book` VALUES (7, '计算机理论', '深入理解Java虚拟机', '5个维度全面剖析JVM,大厂面试知识点全覆盖');
INSERT INTO `tbl_book` VALUES (8, '计算机理论', 'Java编程思想(第4版)', 'Java学习必读经典,殿堂级著作!赢得了全球程序员的广泛赞誉');
INSERT INTO `tbl_book` VALUES (9, '计算机理论', '零基础学Java(全彩版)', '零基础自学编程的入门图书,由浅入深,详解Java语言的编程思想和核心技术');
INSERT INTO `tbl_book` VALUES (10, '市场营销', '直播就该这么做:主播高效沟通实战指南', '李子柒、李佳琦、薇娅成长为网红的秘密都在书中');
INSERT INTO `tbl_book` VALUES (11, '市场营销', '直播销讲实战一本通', '和秋叶一起学系列网络营销书籍');
INSERT INTO `tbl_book` VALUES (12, '市场营销', '直播带货:淘宝、天猫直播从新手到高手', '一本教你如何玩转直播的书,10堂课轻松实现带货月入3W+');
实体类
public class Book {
private Integer id;
private String type;
private String name;
private String description;
}
实体类的开发可以手工生成get/set方法,然后覆盖toString()方法。不过这一套操作书写很繁琐,可以使用 Lombok
简化JavaBean开发。
引入 Lombok,用注解代替构造器、getter/setter、toString()等代码,新版 IDEA 已集成 Lombok 插件,无需下载
<dependency>
<groupId>org.projectlombok</groupId>
<artifactId>lombok</artifactId>
</dependency>
//简化JavaBean开发
@NoArgsConstructor //无参构造
@AllArgsConstructor //有参构造
@Data
public class Book {
private Integer id;
private String type;
private String name;
private String description;
}
Lombok 还可以简化日志开发,例如下面代码
@Slf4j
@RestController
public class HelloController {
@RequestMapping("/hello")
public String handle(@RequestParam("name") String name){
log.info("请求进来了....");
return "Hello, Spring Boot 2!"+"你好:"+name;
}
}
步骤①:导入MyBatisPlus与Druid对应的starter,当然mysql的驱动不能少
<dependency>
<groupId>com.baomidou</groupId>
<artifactId>mybatis-plus-boot-starter</artifactId>
<version>3.4.3</version>
</dependency>
<dependency>
<groupId>com.alibaba</groupId>
<artifactId>druid-spring-boot-starter</artifactId>
<version>1.2.6</version>
</dependency>
<dependency>
<groupId>mysql</groupId>
<artifactId>mysql-connector-java</artifactId>
<scope>runtime</scope>
</dependency>
步骤②:配置数据库连接相关的数据源配置
spring:
datasource:
druid:
driver-class-name: com.mysql.cj.jdbc.Driver
url: jdbc:mysql://localhost:3306/ssm_db?serverTimezone=Asia/Shanghai
username: root
password: root
步骤③:配置MP相关配置
mybatis-plus:
global-config:
db-config:
table-prefix: tbl_ #设置表名通用前缀
id-type: auto #设置主键id字段的生成策略为参照数据库设定的策略,当前数据库设置id生成策略为自增
configuration:
log-impl: org.apache.ibatis.logging.stdout.StdOutImpl #配置标准输出日志
步骤④:使用MP的标准通用接口BaseMapper加速开发,别忘了@Mapper和泛型的指定
@Mapper
public interface BookDao extends BaseMapper<Book> {
}
步骤⑤:制作测试类测试结果
package com.jianjian.dao;
@SpringBootTest
public class BookDaoTests {
@Autowired
private BookDao bookDao;
@Test
void testGetById(){
System.out.println(bookDao.selectById(1));
}
@Test
void testSave(){
Book book = new Book();
book.setType("测试数据123");
book.setName("测试数据123");
book.setDescription("测试数据123");
bookDao.insert(book);
}
@Test
void testUpdate(){
Book book = new Book();
book.setId(17);
book.setType("测试数据abcdefg");
book.setName("测试数据123");
book.setDescription("测试数据123");
bookDao.updateById(book);
}
@Test
void testDelete(){
bookDao.deleteById(16);
}
@Test
void testGetAll(){
bookDao.selectList(null);
}
}
总结
MyBatis-Plus自带分页插件,只要需要定义MP拦截器并将其设置为Spring管控的bean即可实现分页功能
@Configuration
public class MPConfig {
@Bean
public MybatisPlusInterceptor mybatisPlusInterceptor(){
//创建MP的拦截器栈
MybatisPlusInterceptor interceptor = new MybatisPlusInterceptor();
//初始化了分页拦截器,并添加到拦截器栈中
//如果后期开发其他功能,需要添加全新的拦截器,按照此行的格式继续add进去新的拦截器就可以了。
interceptor.addInnerInterceptor(new PaginationInnerInterceptor());
return interceptor;
}
}
MP提供的分页操作API如下
@Test
void testGetPage(){
IPage page = new Page(2,5);
bookDao.selectPage(page, null);
System.out.println(page.getCurrent()); //当前页码值
System.out.println(page.getSize()); //每页显示数
System.out.println(page.getTotal()); //数据总量
System.out.println(page.getPages()); //总页数
System.out.println(page.getRecords()); //详细数据
}
其中selectPage
方法需要传入一个封装分页数据的IPage
对象,可以通过new的形式创建这个对象。创建此对象时就需要指定分页的两个基本数据
可以通过创建Page对象时利用构造方法初始化这两个数据
IPage page = new Page(2,5);
将该对象传入到查询方法selectPage后,可以得到查询结果,但是我们会发现当前操作查询结果返回值仍然是一个IPage对象,这又是怎么回事?
IPage page = bookDao.selectPage(page, null);
原来这个IPage对象中封装了若干个数据,而查询的结果作为IPage对象封装的一个数据存在的,可以理解为查询结果得到后,又塞到了这个IPage对象中,其实还是为了高度的封装。
总结
以往我们写条件查询要自己动态拼写复杂的SQL语句,现在简单了,MP将这些操作都制作成API接口,调用一个又一个的方法就可以实现各种套件的拼装。
下面的操作就是执行一个模糊匹配对应的操作,由like条件书写变为了like方法的调用
@Test
void testGetBy(){
//封装查询条件的对象
QueryWrapper<Book> qw = new QueryWrapper<>();
//查询条件
qw.like("name","Spring");
bookDao.selectList(qw);
}
由于属性字段名的书写存在着安全隐患,比如查询字段name,当前是以字符串的形态书写的,万一写错,编译器还没有办法发现,只能将问题抛到运行器通过异常堆栈告诉开发者,不太友好。
MP针对字段检查进行了功能升级,全面支持Lambda表达式。由QueryWrapper对象升级为LambdaQueryWrapper对象,这下就解决了上述问题的出现
@Test
void testGetBy2(){
String name = "1";
LambdaQueryWrapper<Book> lqw = new LambdaQueryWrapper<Book>();
lqw.like(Book::getName,"Spring");
bookDao.selectList(lqw);
}
为了便于开发者动态拼写SQL,防止将null数据作为条件使用,MP还提供了动态拼装SQL的快捷书写方式
@Test
void testGetBy3(){
String name = "Spring";
LambdaQueryWrapper<Book> lqw = new LambdaQueryWrapper<Book>();
//if(name != null) lqw.like(Book::getName,name); //方式一:JAVA代码控制
lqw.like(name != null,Book::getName,name); //方式二:API接口提供控制开关
bookDao.selectList(lqw);
}
总结
初学者认为业务层就是调用数据层,更精准的说法应该是组织业务逻辑功能,并根据业务需求,对数据持久层发起调用。
一个常识性的知识普及一下,业务层的方法名定义一定要与业务有关,例如登录操作
login(String username,String password);
而数据层的方法名定义一定与业务无关,是一定,不是可能,也不是有可能,例如根据用户名密码查询
selectByUserNameAndPassword(String username,String password);
我们在开发的时候是可以根据完成的工作不同划分成不同职能的开发团队的。
比如开发数据层的团队,拿到的需求文档要求可能是这样的
接口:传入用户名与密码字段,查询出对应结果,结果是单条数据
接口:传入ID字段,查询出对应结果,结果是单条数据
接口:传入离职字段,查询出对应结果,结果是多条数据
但是开发业务层功能团队,拿到的需求文档要求差别就很大
接口:传入用户名与密码字段,对用户名字段做长度校验,4-15位,对密码字段做长度校验,8到24位,对喵喵喵字段做特殊字符校验,不允许存在空格,查询结果为对象。如果为null,返回BusinessException,封装消息码INFO_LOGON_USERNAME_PASSWORD_ERROR
所以说业务层方法定义与数据层方法定义差异化很大
步骤①:业务层接口定义如下:
public interface BookService {
Boolean save(Book book);
Boolean update(Book book);
Boolean delete(Integer id);
Book getById(Integer id);
List<Book> getAll();
IPage<Book> getPage(int currentPage,int pageSize);
}
步骤②:业务层实现类如下,转调数据层即可
@Service
public class BookServiceImpl implements BookService {
@Autowired
private BookDao bookDao;
@Override
public Boolean save(Book book) {
return bookDao.insert(book) > 0;
}
@Override
public Boolean update(Book book) {
return bookDao.updateById(book) > 0;
}
@Override
public Boolean delete(Integer id) {
return bookDao.deleteById(id) > 0;
}
@Override
public Book getById(Integer id) {
return bookDao.selectById(id);
}
@Override
public List<Book> getAll() {
return bookDao.selectList(null);
}
@Override
public IPage<Book> getPage(int currentPage, int pageSize) {
IPage page = new Page(currentPage,pageSize);
return bookDao.selectPage(page,null);
}
}
步骤③:对业务层接口进行测试
@SpringBootTest
public class BookServiceTests {
@Autowired
private BookService bookService;
@Test
void testGetById(){
System.out.println(bookService.getById(4));
}
@Test
void testSave(){
Book book = new Book();
book.setType("测试数据123");
book.setName("测试数据123");
book.setDescription("测试数据123");
bookService.save(book);
}
@Test
void testUpdate(){
Book book = new Book();
book.setId(17);
book.setType("-----------------");
book.setName("测试数据123");
book.setDescription("测试数据123");
bookService.update(book);
}
@Test
void testDelete(){
bookService.delete(18);
}
@Test
void testGetAll(){
bookService.getAll();
}
@Test
void testGetPage(){
IPage<Book> page = bookService.getPage(2, 5);
System.out.println(page.getCurrent());
System.out.println(page.getSize());
System.out.println(page.getTotal());
System.out.println(page.getPages());
System.out.println(page.getRecords());
}
}
总结
MP不仅提供了数据层快速开发方案,MP也给了业务层一个通用接口,不推荐使用,其实就是一个封装+继承的思想,实际开发慎用
步骤①:业务层接口快速开发
public interface IBookService extends IService<Book> {
//添加非通用操作API接口
}
步骤②:业务层接口实现类快速开发,继承的类需要传入两个泛型,一个是数据层接口,另一个是实体类
@Service
public class BookServiceImpl extends ServiceImpl<BookDao, Book> implements IBookService {
@Autowired
private BookDao bookDao;
//添加非通用操作API
}
如果感觉MP提供的功能不足以支撑你的使用需要,可以在原始接口基础上接着定义新的API接口就行了
总结
步骤①:控制层接口如下,基于Restful开发
@RestController
@RequestMapping("/books")
public class BookController {
@Autowired
private BookService bookService;
@GetMapping
public List<Book> getAll(){
return bookService.list();
}
@PostMapping
public Boolean save(@RequestBody Book book){
return bookService.save(book);
}
@PutMapping
public Boolean update(@RequestBody Book book){
return bookService.modify(book);
}
@DeleteMapping("{id}")
public Boolean delete(@PathVariable Integer id){
return bookService.delete(id);
}
@GetMapping("{id}")
public Book getById(@PathVariable Integer id){
return bookService.getById(id);
}
@GetMapping("{currentPage}/{pageSize}")
public IPage<Book> getPage(@PathVariable int currentPage,@PathVariable int pageSize){
return bookService.getPage(currentPage,pageSize, null);
}
}
步骤②:Postman测试,关注提交类型,对应上即可,不然就会报405的错误码了
总结
为何要返回统一格式。为方便使用已封装好,导入项目即可使用:https://jwt1399.lanzouv.com/iINu80bfh1sd
现在大多数web项目基本都是前后端分离模式,这种模式会涉及到一个前后端对接问题,所以一套完善且规范的接口是非常有必要的,不仅能够提高对接效率,也可以让我的代码看起来更加简洁优雅。本节将解决如何返回统一的标准格式以及处理全局异常。
如果SpringBoot不使用统一返回格式,默认会有如下三种返回情况。
@GetMapping("/getUserName")
public String getUserName(){
return "Hello";
}
// 返回结果:Hello
@GetMapping("/getUserName")
public User getUserName(){
return new User("Hello",18);
}
// 返回结果:
{
"name": "Hello",
"age": "18"
}
@GetMapping("/getUserName")
public static String getUserName(){
HashMap hashMap = new HashMap();
return hashMap.get(0).toString(); // 模拟一个空指针异常
}
// 返回结果:
{
"timestamp": "2022-09-09T12:56:06.549+00:00",
"status": 500,
"error": "Internal Server Error",
"path": "/getUserName"
}
对于上面这几种情况,如果整个项目没有定义统一的返回格式,不同开发人员可能会定义不同的返回格式,这样会使前后端对接出现一些问题。
一个标准的返回格式至少包含3部分:
code: 状态码
message: 接口调用的提示信息
data: 返回数据
步骤①:定义数据返回格式
@Data
@Data
@NoArgsConstructor
@AllArgsConstructor
public class Result<T> {
private int code;
private String message;
private T data;
/**
* 成功
*/
public static <T> Result<T> success(T data) {
Result<T> result = new Result<T>();
result.setCode(ResultMsgEnum.SUCCESS.getCode());
result.setMessage(ResultMsgEnum.SUCCESS.getMessage());
result.setData(data);
return result;
}
/**
* 失败
*/
public static <T> Result<T> fail(ResultMsgEnum resultMsgEnum) {
Result<T> result = new Result<T>();
result.setCode(resultMsgEnum.getCode());
result.setMessage(resultMsgEnum.getMessage());
return result;
}
}
步骤②:定义状态码
@Getter
@NoArgsConstructor
@AllArgsConstructor
public enum ResultMsgEnum {
SUCCESS(0, "成功"),
FAIL(-1, "失败"),
TEST_ERROR(400, "发生错误啦!");
private int code;
private String message;
}
步骤③:使用
上面定义了数据返回格式和状态码,下面在接口中使用。
//示例1
@GetMapping("/getUserName")
public Result getUserName(){
return Result.success("Hello");
}
//示例2
@GetMapping("/getUserName")
public static Result getUserName(){
HashMap hashMap = new HashMap();
return Result.success(hashMap.get(0).toString()); // 模拟一个空指针异常
}
返回结果如下
# 示例1结果
{
"code": 0,
"message": "成功",
"data": "Hello"
}
# 示例2结果
{
"timestamp": "2022-09-09T14:45:21.875+00:00",
"status": 500,
"error": "Internal Server Error",
"path": "/getUserName"
}
通过在Controller层调用Result.success()对返回结果进行包装后返回给前端,虽然能够满足日常需求,但是当有大量的接口时,每一个接口中都使用Result.success()来包装返回信息就会增加很多重复代码,而且遇到异常数据格式无法统一。
前面步骤不够优雅,可以继续改进,用 @RestControllerAdvice 注解,拦截下后端返回的数据,实现 ResponseBodyAdvice 接口对数据做一层包装再返回给前端。
ResponseBodyAdvice
: 该接口是SpringMVC 4.1提供的,它允许在 执行@ResponseBody后自定义返回数据,用来封装统一数据格式返回;拦截Controller方法的返回值,统一处理返回值/响应体,一般用来统一返回格式,加解密,签名等@RestControllerAdvice
: 该注解是Controller的增强版,可以全局捕获抛出的异常,全局数据绑定,全局数据预处理。
步骤①:新建ResponseAdvice类,该类用于统一封装controller中接口的返回结果。实现ResponseBodyAdvice接口,实现supports、beforeBodyWrite方法。
@RestControllerAdvice
public class ResponseAdvice implements ResponseBodyAdvice<Object> {
@Autowired
private ObjectMapper objectMapper;
/**
* 是否开启功能 true:开启
*/
@Override
public boolean supports(MethodParameter methodParameter, Class<? extends HttpMessageConverter<?>> aClass) {
return true;
}
/**
* 处理返回结果
*/
@Override
public Object beforeBodyWrite(Object o, MethodParameter methodParameter, MediaType mediaType, Class<? extends HttpMessageConverter<?>> aClass, ServerHttpRequest serverHttpRequest, ServerHttpResponse serverHttpResponse) {
//处理字符串类型数据
if(o instanceof String){
try {
return objectMapper.writeValueAsString(Result.success(o));
} catch (JsonProcessingException e) {
e.printStackTrace();
}
}
//返回类型是否已经封装
if(o instanceof Result){
return o;
}
return Result.success(o);
}
}
步骤②:测试,无需转换格式,直接使用
@GetMapping("/getUserName")
public static String getUserName(){
HashMap hashMap = new HashMap();
return hashMap.get(0).toString(); // 模拟一个空指针异常
}
返回结果如下,可以看到返回结果与在Result中定义的参数类型相同。
{
"code": 0,
"message": "成功",
"data": {
"timestamp": "2022-09-09T14:37:19.902+00:00",
"status": 500,
"error": "Internal Server Error",
"path": "/getUserName"
}
}
遇到异常时,第一时间想到的应该是try…catch,不过这种方式会导致大量代码重复,维护困难等问题,这里不用手写try…catch,由全局异常处理器统一捕获;对于自定义异常,只能通过全局异常处理器来处理,使用全局异常处理器最大的便利就是程序员在写代码时不再需要手写 try…catch了。
步骤①:首先新增一个类,增加@RestControllerAdvice
注解,如果我们有想要拦截的异常类型,就新增一个方法,使用@ExceptionHandler
注解修饰,注解参数为目标异常类型。
例如:controller中接口发生Exception异常时,就会进入到Execption方法中进行捕获,将杂乱的异常信息,转换成指定格式后交给ResponseAdvice方法进行统一格式封装并返回给前端。
@RestControllerAdvice
@Slf4j
public class ExceptionAdvice {
@ExceptionHandler(Exception.class)
public Result Execption(Exception e) {
log.error("未知异常!", e);
//e.printStackTrace();
return Result.fail(ResultMsgEnum.TEST_ERROR);
}
//还可定义其它拦截异常方法
//。。。。。。
}
步骤②:测试,再次调用接口getUserName查看返回结果
@GetMapping("/getUserName")
public static String getUserName(){
HashMap hashMap = new HashMap();
return hashMap.get(0).toString(); // 模拟一个空指针异常
}
返回结果
{
"code": 400,
"message": "发生错误啦!",
"data": null
}
前面实现了消息一致性,为了方便使用作如下封装,只需引用到项目中即可
步骤①:定义数据返回格式
@Data
@Data
@NoArgsConstructor
@AllArgsConstructor
public class Result<T> {
private int code;
private String message;
private T data;
/**
* 成功
*/
public static <T> Result<T> success(T data) {
Result<T> result = new Result<T>();
result.setCode(ResultMsgEnum.SUCCESS.getCode());
result.setMessage(ResultMsgEnum.SUCCESS.getMessage());
result.setData(data);
return result;
}
/**
* 失败
*/
public static <T> Result<T> fail(ResultMsgEnum resultMsgEnum) {
Result<T> result = new Result<T>();
result.setCode(resultMsgEnum.getCode());
result.setMessage(resultMsgEnum.getMessage());
return result;
}
}
步骤②:定义状态码
@Getter
@NoArgsConstructor
@AllArgsConstructor
public enum ResultMsgEnum {
SUCCESS(0, "成功"),
FAIL(-1, "失败"),
TEST_ERROR(400, "发生错误啦!");
private int code;
private String message;
}
步骤③:统一接口
@RestControllerAdvice
public class ResponseAdvice implements ResponseBodyAdvice<Object> {
@Autowired
private ObjectMapper objectMapper;
/**
* 是否开启功能 true:开启
*/
@Override
public boolean supports(MethodParameter methodParameter, Class<? extends HttpMessageConverter<?>> aClass) {
return true;
}
/**
* 处理返回结果
*/
@Override
public Object beforeBodyWrite(Object o, MethodParameter methodParameter, MediaType mediaType, Class<? extends HttpMessageConverter<?>> aClass, ServerHttpRequest serverHttpRequest, ServerHttpResponse serverHttpResponse) {
//处理字符串类型数据
if(o instanceof String){
try {
return objectMapper.writeValueAsString(Result.success(o));
} catch (JsonProcessingException e) {
e.printStackTrace();
}
}
//返回类型是否已经封装
if(o instanceof Result){
return o;
}
return Result.success(o);
}
}
步骤④:全局异常
@RestControllerAdvice
@Slf4j
public class ExceptionAdvice {
@ExceptionHandler(Exception.class)
public Result Execption(Exception e) {
log.error("未知异常!", e);
//e.printStackTrace();
return Result.fail(ResultMsgEnum.TEST_ERROR);
}
//还可定义其它异常方法
//。。。。。。
}
总结
参考
前端页面下载:https://jwt1399.lanzouv.com/ibQNG0bet3yh
将页面保存到 resources/static目录中,建议执行maven的clean生命周期,避免缓存的问题出现。
如果成功访问:http://127.0.0.1/pages/books.html,即表明接入成功
在进行具体的功能开发之前,先做前后端联通性的测试,通过页面发送异步提交(axios)
//列表
getAll() {
axios.get("/books").then((res)=>{
console.log(res.data);
});
},
//钩子函数,VUE对象初始化完成后自动执行
created() {
this.getAll();
},
只要后台代码能够正常工作,前端能够在日志中接收到数据,就证明前后端是通的,即可进行下一步的功能开发了
总结
列表功能主要操作就是加载完数据,将数据展示到页面上,此处要利用VUE的数据模型绑定,发送请求得到数据,然后页面上读取指定数据即可
a.页面数据模型定义
data:{
dataList: [],//当前页要展示的列表数据
...
},
b.异步请求获取数据
//列表
getAll() {
axios.get("/books").then((res)=>{
this.dataList = res.data.data;
});
},
c.钩子函数调用请求
//钩子函数,VUE对象初始化完成后自动执行
created() {
this.getAll();
},
这样在页面加载时就可以获取到数据,并且由VUE将数据展示到页面上了
添加功能首先要进行数据收集窗口弹窗的展示,添加后隐藏弹窗即可。因为这个弹窗一直存在,因此当页面加载时首先设置这个弹窗为不可显示状态,需要展示时切换状态即可
a.表单窗口默认状态
data:{
dialogFormVisible: false,//添加表单是否可见
...
},
b.切换为显示状态
//弹出添加窗口
handleCreate() {
this.dialogFormVisible = true;
},
c.定义清理数据操作
由于每次添加数据都是使用同一个弹窗录入数据,所以每次操作的痕迹将在下一次操作时展示出来,需要在每次操作之前清理掉上次操作的痕迹
//重置表单
resetForm() {
this.formData = {};
},
d.切换弹窗状态时清理数据
//弹出添加窗口
handleCreate() {
this.dialogFormVisible = true;
this.resetForm();
},
e.添加操作
//添加
handleAdd () {
//发送异步请求
axios.post("/books",this.formData).then((res)=>{
//如果操作成功,关闭弹层,显示数据
if(res.data.code == 0){
this.dialogFormVisible = false;
this.$message.success("添加成功");
}else {
this.$message.error("添加失败");
}
}).finally(()=>{
this.getAll();//重载数据,避免添加后数据不显示
});
},
f.取消添加操作
//取消
cancel(){
this.dialogFormVisible = false;
this.$message.info("操作取消");
},
总结
模仿添加操作制作删除功能,差别之处在于删除操作仅传递一个待删除的数据id到后台即可
a.删除操作
// 删除
handleDelete(row) {
axios.delete("/books/"+row.id).then((res)=>{
if(res.data.flag){
this.$message.success("删除成功");
}else{
this.$message.error("删除失败");
}
}).finally(()=>{
this.getAll();
});
},
b.删除操作提示信息
// 删除
handleDelete(row) {
//1.弹出提示框
this.$confirm("此操作永久删除当前数据,是否继续?","提示",{type:'info'}).then(()=>{
//2.删除业务
axios.delete("/books/"+row.id).then((res)=>{
if(res.data.code == 0){
this.$message.success("删除成功");
}else {
this.$message.error("删除失败");
}
}).finally(()=>{
this.getAll();
});
}).catch(()=>{
//3.取消删除
this.$message.info("取消删除操作");
});
},
总结
修改功能可以说是列表功能、删除功能与添加功能的合体。几个相似点如下:
a.查询并展示数据
//弹出编辑窗口
handleUpdate(row) {
axios.get("/books/"+row.id).then((res)=>{
if(res.data.code == 0){
//展示弹层,加载数据
this.formData = res.data.data;
this.dialogFormVisibleEdit = true;
}else {
this.$message.error("数据同步失败");
}
});
},
b.修改操作
//修改
handleEdit() {
axios.put("/books",this.formData).then((res)=>{
//如果操作成功,关闭弹层并刷新页面
if(res.data.code == 0){
this.dialogFormVisibleEdit = false;
this.$message.success("修改成功");
}else {
this.$message.error("修改失败");
}
}).finally(()=>{
this.getAll();
});
},
c.取消修改操作
//取消
cancel(){
this.dialogFormVisible = false;
this.dialogFormVisibleEdit = false;
this.$message.info("操作取消");
},
总结
分页功能的制作用于替换前面的查询全部,
a.ElementUI分页组件
<!--分页组件-->
<div class="pagination-container">
<el-pagination
class="pagiantion"
@current-change="handleCurrentChange"
@size-change="handleSizeChange"
:current-page="pagination.currentPage"
:page-size="pagination.pageSize"
layout="total,sizes, prev, pager, next, jumper"
:page-sizes="[5, 10, 15, 20]"
:total="pagination.total">
</el-pagination>
</div>
b.配合分页组件,封装分页对应的数据模型
data:{
//分页相关模型数据
pagination: {
currentPage: 1, //当前页码
pageSize:10, //每页显示的记录数
total:0, //总记录数
}
},
c.修改查询全部功能为分页查询,通过路径变量传递页码信息参数
getAll() {
axios.get("/books/"+this.pagination.currentPage+"/"+this.pagination.pageSize)
.then((res)=>{
console.log(res.data.data);
});
},
d.页面根据分页操作结果读取对应数据,并进行数据模型绑定
getAll() {
axios.get("/books/"+this.pagination.currentPage+"/"+this.pagination.pageSize)
.then((res)=>{
//console.log(res.data.data);
this.dataList = res.data.data.records;
this.pagination.currentPage = res.data.data.current;
this.pagination.pageSize = res.data.data.size;
this.pagination.total = res.data.data.total;
})
},
f.对切换页码操作设置调用当前分页操作
//切换页码
handleCurrentChange(currentPage) {
this.pagination.currentPage = currentPage;
this.getAll();
},
g.对切换每页显示条数操作设置调用当前记录数操作
//切换每页条数
handleSizeChange(pageSize){
this.pagination.pageSize = pageSize;
this.getAll();
}
总结
由于使用了分页功能,当最后一页只有一条数据时,删除操作就会出现BUG,最后一页无数据但是独立展示,对分页查询功能进行后台功能维护,如果当前页码值大于最大页码值,重新执行查询。其实这个问题解决方案很多,这里给出比较简单的一种处理方案
@GetMapping("{currentPage}/{pageSize}")
public IPage<Book> getPage(@PathVariable int currentPage, @PathVariable int pageSize){
IPage<Book> page = bookService.getPage(currentPage, pageSize);
//如果当前页码值大于了总页码值,那么重新执行查询操作,使用最大页码值作为当前页码值
if( currentPage > page.getPages()){
page = bookService.getPage((int)page.getPages(), pageSize);
}
return page;
}
删除一条数据之后,主键id不连续的问题解决
#删除id列
alter table tbl_book drop id;
#新增id列,设为主键,并自增
ALTER TABLE tbl_book ADD id INT NOT NULL PRIMARY KEY AUTO_INCREMENT FIRST;
条件查询可以理解为分页查询的时候除了携带分页数据再多带几个数据的查询。这些多带的数据就是查询条件。
页面发送请求时,两个分页数据仍然使用路径变量,其他条件采用动态拼装url参数的形式传递
a.页面封装查询条件字段
pagination: {
//分页相关模型数据
currentPage: 1, //当前页码
pageSize:10, //每页显示的记录数
total:0, //总记录数
name: "",
type: "",
description: ""
},
b.页面添加查询条件字段对应的数据模型绑定名称
<div class="filter-container">
<el-input placeholder="图书类别" v-model="pagination.type" class="filter-item"/>
<el-input placeholder="图书名称" v-model="pagination.name" class="filter-item"/>
<el-input placeholder="图书描述" v-model="pagination.description" class="filter-item"/>
<el-button @click="getAll()" class="dalfBut">查询</el-button>
<el-button type="primary" class="butT" @click="handleCreate()">新建</el-button>
</div>
c.将查询条件组织成url参数,添加到请求url地址中
getAll() {
//1.获取查询条件,拼接查询条件
param = "?name="+this.pagination.name;
param += "&type="+this.pagination.type;
param += "&description="+this.pagination.description;
//console.log(param);
axios.get("/books/"+this.pagination.currentPage+"/"+this.pagination.pageSize+param)
.then((res)=>{
//console.log(res.data.data);
this.pagination.currentPage = res.data.data.current;
this.pagination.pageSize = res.data.data.size;
this.pagination.total = res.data.data.total;
this.dataList = res.data.data.records;
})
},
d.后台代码中定义实体类封查询条件
@GetMapping("{currentPage}/{pageSize}")
public IPage<Book> getPage(@PathVariable int currentPage, @PathVariable int pageSize,Book book){
System.out.println("参数=====>"+book);
IPage<Book> page = bookService.getPage(currentPage, pageSize, book);
//如果当前页码值大于了总页码值,那么重新执行查询操作,使用最大页码值作为当前页码值
if( currentPage > page.getPages()){
page = bookService.getPage((int)page.getPages(), pageSize, book);
}
return page;
}
e.对应业务层接口与实现类进行修正
public interface BookService {
IPage<Book> getPage(int currentPage,int pageSize,Book book);
}
@Service
public class BookServiceImpl implements BookService {
@Override
public IPage<Book> getPage(int currentPage, int pageSize, Book book) {
IPage page = new Page(currentPage,pageSize);
LambdaQueryWrapper<Book> lqw = new LambdaQueryWrapper<Book>();
lqw.like(Strings.isNotEmpty(book.getName()),Book::getName,book.getName());
lqw.like(Strings.isNotEmpty(book.getType()),Book::getType,book.getType());
lqw.like(Strings.isNotEmpty(book.getDescription()),Book::getDescription,book.getDescription());
return bookDao.selectPage(page,lqw);
}
}
总结