SpringBoot笔记
接触了一大批优秀的框架。
文章目录
- 一、SpringBoot 概述
- 二、SpringBoot 快速入门
-
- 1. 前期准备
- 2. 快速创建SpringBoot项目
- 3. 其他方式创建SpringBoot项目
- 4. SpringBoot的三种启动方式
- 三、 SpringBoo项目结构
-
- 1. 目录结构
- 2. 父工程
- 3. 起步依赖/启动器（starter）
- 4. 辅助功能
- 四、配置文件
-
- 1. 配置文件格式
-
- 1.1 修改服务器端口
- 1.2 解决SpringBoot配置文件没有提示问题
- 1.3 SpringBoot配置文件加载顺序
- 2. YAML
-
- 2.1 为什么要用YAML？
- 2.2 YAML基本语法
- 2.3 YAML数据类型
- 2.4获取主配置文件信息的三种方式
- 3. 多环境配置
-
- 3.1 通过application.yml文件多环境启动配置
- 3.2 多环境启动命令格式
- 3.3 通过maven多环境开发配置
- 3.4 配置文件分类
- 五、SpringBoot整合JUnit
-
- 1. 回顾Spring整合JUnit
- 2. SpringBoot整合JUnit
- 六、SpringBoot整合SpringMVC
-
- 1. 设置拦截器
- 2. 静态资源访问
- 七、SpringBoot整合MyBatis
-
- 1. 回顾Spring整合MyBatis
- 2. SpringBoot整合MyBatis
- 3. 切换数据库连接池
-
- 3.1 切换Druid连接池
- 3.2 通过starter整合Druid
- 八、彩蛋
-
- 1. 插件
-
- 1.1 JBLSpringBootAppGen 插件
- 1.2 Grep Console（对控制台的日志进行过滤且加上不同背景色）
- 1.3 .ignore （生成git过滤推送的文件，里面可以指定生成的模板）
- 1.4 CodeGlance Pro（代码地图）
- 1.5 其他插件
- 2. IDEA设置
-
- 2.1 设置行号与方法分割符
- 2.2 高亮显示修改目录
- 2.3 自动导包
- 2.4 设置Maven的Reload操作 （刷新maven坐标）
- 2.5 设置输入忽略大小写
- 2.6 ctrl + 鼠标滚轮：调节字体大小
- 3. IDEA常用的快捷键
一、SpringBoot 概述
SpringBoot 可以轻松创建独立的、基于Sring的生产级应用程序，而这只需要一些Spring很少的配置。SpringBoot 是现在最主流的开发框架，它提供一站式的开发体验，大幅度提高我们的开发效率。
Spring官网：https://spring.io/
springBoot官网：https://spring.io/projects/spring-boot
随着 Spring 不断的发展，涉及的领域越来越多，项目整合开发需要配置各种各样的文件，慢慢变得不那么简单易用，违背了最初的理念，甚至人称配置地狱。SpringBoot 正是在这样的一个背景下被抽象出来的开发框架，目的为了让大家更容易的使用 Spring 、更容易的集成各种常用的中间件、开源软件；
Spring的缺点：配置繁琐、依赖设置繁琐。
SpringBoot是由Pivotal团队提供的全新框架，其设计目的是用来简化Spring应用的初始搭建以及开发过程。也就是说，它并不是用来替代 Spring 的解决方案，而是和 Spring 框架紧密结合用于提升 Spring 开发体验的工具。SpringBoot 以约定优于配置的核心思想，默认帮我们进行了很多设置，多数 SpringBoot 应用只需要很少的 Spring 配置。同时它集成了大量常用的第三方库配置（例如 Redis、MongoDB、JPA、RabbitMQ、Quartz 等等），SpringBoot 应用中这些第三方库几乎可以零配置的开箱即用。
简单来说就是SpringBoot其实不是什么新的框架，它默认配置了很多框架的使用方式，就像maven整合了所有的jar包，spring boot整合了很多框架 (spring-boot-starter-xxx）。
SpringBoot 出生名门，从一开始就站在一个比较高的起点，又经过这几年的发展，生态足够完善，SpringBoot 已经当之无愧成为 Java 领域最热门的技术。
SpringBoot功能：
-
创建独立的Spring应用程序。
-
内嵌web容器Tomcat、Jetty或Undertow（无需部署war包，通过打好的jar包就可以直接运行应用程序）。
-
提供一站式的 “starter” 依赖，以简化Maven配置（需要整合什么框架，直接导对应框架的starter依赖即可）。
-
尽可能自动配置Spring和第三方库（除非特殊情况，否则几乎不需要我们进行配置）。
-
提供生产就绪功能，如：指标、运动状况检查和外部化配置。
-
没有代码生成，也没有XML配置要求。
总结：SpringBoot用来简化Spring应用的初始搭建以及开发过程(只需Spring很少的配置)，特点：约定优于配置。
不要被框架限制了自己，学框架使用、思想、底层原理(如设计模式等等)。
二、SpringBoot 快速入门
1. 前期准备
在maven的setting.xml文件中配置阿里云仓库镜像、jdk编译版本。
<mirrors>
<mirror>
<id>nexus-aliyunid>
<mirrorOf>centralmirrorOf>
<name>Nexus aliyunname>
<url>http://maven.aliyun.com/nexus/content/groups/publicurl>
mirror>
mirrors>
<profiles>
<profile>
<id>jdk-1.8id>
<activation>
<activeByDefault>trueactiveByDefault>
<jdk>1.8jdk>
activation>
<properties>
<maven.compiler.source>1.8maven.compiler.source>
<maven.compiler.target>1.8maven.compiler.target>
<maven.compiler.compilerVersion>1.8maven.compiler.compilerVersion>
properties>
profile>
profiles>
在IDEA中配置maven：在不联网的情况下使用本地插件构建项目。
-DarchetypeCatalog=internal -Dfile.encoding=GB2312
2. 快速创建SpringBoot项目
通Maven项目导依赖和插件，以及编写主类构建 (常用)
1、创建Maven模块
2、导入依赖
<parent>
<groupId>org.springframework.bootgroupId>
<artifactId>spring-boot-starter-parentartifactId>
<version>2.4.5version>
<relativePath/>
parent>
<dependencies>
<dependency>
<groupId>org.springframework.bootgroupId>
<artifactId>spring-boot-starter-webartifactId>
dependency>
dependencies>
<build>
<finalName>springboot_quickfinalName>
<plugins>
<plugin>
<groupId>org.springframework.bootgroupId>
<artifactId>spring-boot-maven-pluginartifactId>
plugin>
plugins>
build>
pom文件完整描述：
<project xmlns="http://maven.apache.org/POM/4.0.0"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
<modelVersion>4.0.0modelVersion>
<groupId>org.examplegroupId>
<artifactId>springboot_01_quickstartartifactId>
<version>1.0-SNAPSHOTversion>
<packaging>jarpackaging>
<description>Demo Project for Spring Bootdescription>
<properties>
<maven.compiler.source>8maven.compiler.source>
<maven.compiler.target>8maven.compiler.target>
properties>
<parent>
<groupId>org.springframework.bootgroupId>
<artifactId>spring-boot-starter-parentartifactId>
<version>2.4.5version>
<relativePath/>
parent>
<dependencies>
<dependency>
<groupId>org.springframework.bootgroupId>
<artifactId>spring-boot-starter-webartifactId>
dependency>
dependencies>
<build>
<finalName>springboot_quickfinalName>
<plugins>
<plugin>
<groupId>org.springframework.bootgroupId>
<artifactId>spring-boot-maven-pluginartifactId>
plugin>
plugins>
build>
project>
3、编写启动类（放在com.baidou包下）
package com.baidou;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
/**
* SpringBoot启动类(入口类)
*
* @author 白豆五
* @version 2022/12/25 20:05
* @since JDK8
*/
@SpringBootApplication // 表示当前类是SpringBoot启动类,这个注解内部活非常多
public class HelloApplication {
public static void main(String[] args) {
SpringApplication.run(HelloApplication.class, args);
}
}
4、编写控制器类（路由）
package com.baidou.controller;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;
/**
* 处理请求,将内容返回给页面
* @author 白豆五
* @version 2022/12/25 20:07
* @since JDK8
*/
@RestController // @RestController=@Controller+@ResponeBody
@RequestMapping("test")
public class HelloController {
@GetMapping("hello")
public String hello() {
System.out.println("收到了一个请求~");
return "Hello SpringBoot!!!";
}
}
5、运行启动类的main方法(启动springboot程序)
项目启动成功后是这个样子的：
6、测试访问：http:localhost:8080/test/hello
3. 其他方式创建SpringBoot项目
① 通过IDEA上的【spring initializr】脚手架构建。（了解）
1、首先点击 【spring initializr】，然后配置项目使用的jdk环境，最后点击【next】。
2、填写项目的配置信息。
3、选择依赖，勾选web支持，最后点【next】。
4、配置项目名称和路径。
5、编写一个HelloController。
package com.baidou.controller;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RestController;
/**
* 接收请求并将数据响应到页面
* @author 白豆五
* @version 2022/8/24 18:05
* @since JDK8
*/
@RestController
public class HelloController {
@GetMapping("/hello")
public String hello(){
return "Hello World!";
}
}
6、启动springboot项目，跟之前运行Java程序一样，快捷键：shift+f10。
7、测试访问：http://localhost:8080/hello。
到这里你已经学会SpringBoot项目的基本创建和运行流程啦
② 通过官网上的Spring Initializer构建。（了解）
通过网页来创建springboot项目并下载到本地，使用的时候用IDEA导入即可。
- Spring Initializer：https://start.springboot.io/ 、https://start.spring.io/
- 阿里提供的脚手架：https://start.aliyun.com
（扩展：搭建个人Spring Initializr服务器）
4. SpringBoot的三种启动方式
第一种方式：运行启动类的main方法启动SpringBoot项目。
第二种方式：在当前项目路径下使用maven命令去运行springboo项目。
mvn spring-boot:run
或者在IDEA右侧Maven面板上执行命名：
第三种方式：打包部署的方式运行SpringBoot项目。
1、将项目打包，命令如下：
mvn clean package
或者使用MavenHelper插件手动为项目打包：
2、运行项目jar包，命令如下：
java -jar xx.jar
三、 SpringBoo项目结构
1. 目录结构
pom.xml 文件
-
指定了一个父工程（parent）：指定当前项目为SpringBoot，帮助我们声明了starter依赖的版本（
spring-boot-starter-xxx）。 -
项目元数据：包名，项目名，版本号。
-
指定了properties信息：指定了java的编译版本为1.8。
-
导入依赖：
spring-boot-starter（所有场景启动器最底层的依赖，常规依赖自导入） -
打包插件：
spring-boot-maven-plugin。
.gitignore 文件
- 上传Git的时候忽略一些文件和目录。
src 目录
--src
--main
--java // Java源码文件目录
--包名
启动类.java // 我们编写的类,需要放在启动类的子包中或者同级包下
--resources // 资源目录
--static // 存放静态资源的
--templates // 存放模板页面的
application.properties // SpringBoot提供的唯一的配置文件
--test // 单元测试
完整项目结构
springboot_01_quickstart //工程根目录
|---target //工程编译打包输出目录
|---.gitignore //上传Git的时候忽略一些文件和目录
|---pom.xml //管理Maven依赖
+---src
+---main //项目主目录
| +---java //Java源码文件目录
| | \---com
| | \---baidou
| | |---controller
| | |---service
| | |---mapper
| | |---pojo
| | |---config
| | |---...
| | \---HelloApplication //SpringBoot主类
| |
| \---resources //资源文件目录
| |---static //放静态资源文件,如 js、css等
| |---templates //页面模板,如 Thymeleaf、FreeMarker等
| \---application.yml //SpringBoot核心配置文件
|
\---test //单元测试目录
+---java //单元测试Java源码文件目录
| \---com
| \---baidou
| |---controller
| |---service
| |---dao
| |---pojo
| |---config
| |---...
| \---SpringBootDemoApplicationTests //SpringBoot测试主类
\---resources //单元测试资源文件目录
- target目录：Maven打包后会将编译后的.class文件和依赖的jar包等资源文件放到这个目录里。
- pom.xml文件：用来管理项目和依赖jar包。
- src目录：存放Java源码程序、程序配置文件、资源文件等，是开发用到的主目录。
- .gitignore文件：用来配置一些不需要通过Git进行版本控制的文件或目录。
使用 tree 命名生成目录树（扩展）
-
生成目录结构：tree
-
生成目录结构（包括文件）：
tree /f
2. 父工程
父项工程做依赖管理(可以锁定依赖的版本，减少依赖冲突)，例如我们自己的项目继承了 spring-boot-starter-parent 父工程，就代表我们的项目也是SpringBoot项目：
<parent>
<groupId>org.springframework.bootgroupId>
<artifactId>spring-boot-starter-parentartifactId>
<version>2.4.5version>
<relativePath/>
parent>
然后spring-boot-starter-parent又继承了 spring-boot-dependencies父工程。
<parent>
<groupId>org.springframework.bootgroupId>
<artifactId>spring-boot-dependenciesartifactId>
<version>2.4.5version>
parent>
在spring-boot-dependencies中几乎声明了所有开发中常用的依赖版本。
dependencyManagement依赖管理：（springboot父工程里面管理了一些依赖版本，父工程不会直接导入这些依赖，而是留给子工程用，当然我们也可以导入没被SpringBoo管理的依赖）
我们项目继承父工程后，导入依赖无需关注版本号，如发生坐标错误再指定version（注意：要小心版本冲突）。
<dependencies>
<dependency>
<groupId>org.springframework.bootgroupId>
<artifactId>spring-boot-starter-webartifactId>
dependency>
<dependency>
<groupId>org.springframework.bootgroupId>
<artifactId>spring-boot-starter-testartifactId>
dependency>
dependencies>
3. 起步依赖/启动器（starter）
spring官网中，提供了大量功能的起步依赖：https://docs.spring.io/spring-boot/docs/2.4.13/reference/html/using-spring-boot.html#using-boot-starter
SpringBoot将所有的功能场景都抽取出来，做成一个个的starter （启动器），只需要在项目中引入这些starter即可，所有相关的依赖便会自动导进来，例如：
- spring-boot-starter-web，用于web开发。
- spring-boot-starter-test，用于单元测试。
- spring-boot-starter-mail，用于邮件服务。
- spring-boot-starter-redis，用于Redis。
- …
- 通用格式：
spring-boot-starter-xxx。
当引入起步依赖时不需要写版本号(直接写GAV中的GA，群组id和项目即可)，因为我们项目pom.xml中引入了springboot父工程（父工程做版本控制），但是如果导入的包没有在SpringBoot依赖中管理就需要手动配置版本了。
<parent>
<groupId>org.springframework.bootgroupId>
<artifactId>spring-boot-starter-parentartifactId>
<version>2.5.6version>
<relativePath/>
parent>
<dependencies>
<dependency>
<groupId>org.springframework.bootgroupId>
<artifactId>spring-boot-starter-webartifactId>
dependency>
<dependency>
<groupId>org.springframework.bootgroupId>
<artifactId>spring-boot-starter-testartifactId>
<scope>testscope>
dependency>
<dependency>
<groupId>cn.hutoolgroupId>
<artifactId>hutool-allartifactId>
<version>5.7.6version>
dependency>
dependencies>
总结：起步依赖starter整合了很多常用功能，可以减少大量重复性工作。
4. 辅助功能
-
例如：SpringBoot项目内置了tomcat服务器。（springboot默认使用tomcat）
-
如果不想用tomcat，可以切换成jetty，jetty比tomcat更轻量级，可扩展性更强（相较于Tomcat），谷歌应用引擎（GAE）已经全面切换为Jetty。
-
在【web起步依赖】中排除【tomcat起步依赖】，然后再单独导入【jetty起步依赖】即可。
<dependencies>
<dependency>
<groupId>org.springframework.bootgroupId>
<artifactId>spring-boot-starter-webartifactId>
<exclusions>
<exclusion>
<groupId>org.springframework.bootgroupId>
<artifactId>spring-boot-starter-tomcatartifactId>
exclusion>
exclusions>
dependency>
<dependency>
<groupId>org.springframework.bootgroupId>
<artifactId>spring-boot-starter-jettyartifactId>
dependency>
dependencies>
四、配置文件
1. 配置文件格式
SpringBoot提供了3种核心配置文件：
- application.yml
- application.properties
- application.yaml （yaml和yml是一个东东）
1.1 修改服务器端口
application.properties：
# 配置web服务器端口号
server.port=80
application.yml：
server:
port: 81
application.yaml：
server:
port: 82
1.2 解决SpringBoot配置文件没有提示问题
1.3 SpringBoot配置文件加载顺序
同级目录下：application.properties(优先级最高) > application.yml > application.yaml
注意事项：
-
SpringBoot核心配置文件名为：application。
-
SpringBoot内置属性过多，且所有属性集中在一起修改，在使用时，通过提示键+关键字修改属性。
-
springboot常用的属性：https://docs.spring.io/spring-boot/docs/2.1.9.RELEASE/reference/htmlsingle/#appendix
2. YAML
2.1 为什么要用YAML？
- SpringBoot使用
application.properties和application.yml这两个作为全局配置文件，properties是一种常见的配置文件格式； - 配置文件的作用就是来配置某些信息，修改某些默认值，在我们创建springboot项目时它会自动创建application.properties文件；
- properties它有一个缺点，就是结构不清晰，不能体现配置项的相关性和层次性。
- 这里引入一种新的配置文件的形式就是yaml配置文件(YAML Ain’t Markup Langua，一种数据序列化格式)，后缀名为yml，它以数据为中心(重数据轻格式)，比json和xml更高效；
- 而且yml配置文件格式方便查阅；
如下几种配置文件存储数据对比：
# xml格式
张三
21
男
# json
{
"name":"李四",
"age":18,
"sex":"女"
}
# properties
person.name=王五
person.age=29
person.sex=boy
# yaml
person:
name: aopmin
age: 18
sex: maleale
2.2 YAML基本语法
- 以键值对的方式存储数据，kv之间有空格；
- 大小写敏感；
- 使用空格缩进表示层级关系；
- 缩进不允许使用tab，只允许空格；
- 对缩进的空格数目没有要求，只要同级元素左侧对齐即可；
#表示注释；- 字符串无需加引号，如果要加的话双引号不会转义，单引号会转义。
2.3 YAML数据类型
1、字面量： 单个的、不可再分的值。如 date、boolean、string、number、null
k: v
示例：
port: 8080
name: aopmin
age: 18
2、对象（映射/字典）： 键值对的集合。如 map、hash、set、object
# 行内写法
k: {v1,v2,v3}
# 层级写法
k:
k1: v1 #k1表示k的属性
k2: v2
k3: v3
示例：
student:
name: 张三
age: 18
sex: 男
数组（列表）： 一组按次序排列的值。array、list、queue
# 行内写法
k: [v1,v2,v3]
#层级写法
k:
- v1
- v2
- v3
示例：
hobbies: [Java,PHP,Python]
hobbies:
- Java
- PHP
- Python
2.4获取主配置文件信息的三种方式
方式1、使用
@Value注解读取properties或者yml文件中的内容，属性名引用方式：${一级属性名.二级属性名……}。
yaml文件：
version: 1.0-SNAPSHOT # 字面量
student: # 对象
name: aopmin
age: 18
sex: 男
hobbies: # 数组
- Java
- PHP
- Python
使用@Value注解读取yml单个数据：
@RestController
public class HelloController {
//使用@Value读取单个数据
@Value("${version}")
private String version;
@Value("${student.age}")
private int age;
@Value("${student.hobbies[2]}")
private String hobbie3; // 获取数组中第3个元素
@GetMapping("hello")
public String hello() {
System.out.println(version);
System.out.println(age);
System.out.println(hobbie3);
return "helloworld";
}
}
方式2、将全部数据封装到Environment对象
yaml文件：
version: 1.0-SNAPSHOT # 字面量
student: # 对象
name: aopmin
age: 18
sex: 男
hobbies: # 数组
- Java
- PHP
- Python
将ymal全部数据封装到Environment对象，使用的时候注入即可，然后通过Environment对象的getProperty()方法获取指定属性值：
@RestController
public class HelloController {
// 依赖注入
@Autowired
private Environment env; //Spring提供的
@GetMapping("hello")
public String hello() {
System.out.println(env.getProperty("version"));
System.out.println(env.getProperty("student.name"));
System.out.println(env.getProperty("student.hobbies[0]"));
return "helloworld";
}
}
方式3、把指定数据封装到自定义类的对象中（常用）
如果在yml文件中需要编写大量的自定义配置，并且具有统一的前缀时，采用如下方式：
yaml文件：
version: 1.0-SNAPSHOT # 字面量
student: # 对象
name: aopmin
age: 18
sex: 男
hobbies: # 数组
- Java
- PHP
- Python
自定义类与配置文件绑定：
@Data //lombok注解
@Component // 把这个类添加到Spring容器中
@ConfigurationProperties(prefix = "student") //将这个类与配置文件前缀为student绑定,把yaml中student配置信息注入到当前类的Bean对象中
public class StudentProperties {
private String name;
private int age;
private String sex;
private List<String> hobbies;
}
controller：
@RestController
public class HelloController {
@Autowired
private StudentProperties student;
@GetMapping("hello")
public StudentProperties hello() {
return student;
}
}
解决自定义对象封装数据警告问题 （可选操作）
需要向pom.xml导入依赖（插件可选操作），然后重启项目更新元数据：
<dependency>
<groupId>org.springframework.bootgroupId>
<artifactId>spring-boot-configuration-processorartifactId>
<optional>trueoptional>
dependency>
<profiles>
<profile>
<id>dev_envid>
<properties>
<profile.active>devprofile.active>
properties>
<activation>
<activeByDefault>trueactiveByDefault>
activation>
profile>
<profile>
<id>pro_envid>
<properties>
<profile.active>proprofile.active>
properties>
profile>
<profile>
<id>test_envid>
<properties>
<profile.active>testprofile.active>
properties>
profile>
profiles>
2、导入属性加载过滤器插件：
<build>
<plugins>
<plugin>
<artifactId>maven-resources-pluginartifactId>
<configuration>
<encoding>utf-8encoding>
<useDefaultDelimiters>trueuseDefaultDelimiters>
configuration>
plugin>
plugins>
build>
3、在SpringBoot核心配置文件application.xml中引用Maven属性:
# 设置启动环境
spring:
profiles:
active: ${profile.active} # 引用maven上的多环境配置
---
# 开发
spring:
profiles: dev #开发环境id
server:
# 项目端口号
port: 8080
servlet:
# 项目路径
context-path: /
---
# 生产
spring:
profiles: pro #生产环境id
server:
# 项目端口号
port: 8081
servlet:
# 项目路径
context-path: /demo
---
# 测试
spring:
profiles: test #测试环境id
server:
# 项目端口号
port: 8082
servlet:
# 项目路径
context-path: /test
4、使用Maven命令打包并切换生产环境
mvn clear package -P pro_env
5、测试
ok已经成功用生产环境部署项目了。
3.4 配置文件分类
多级文件的作用：1级与2级留做系统打包后设置通用属性，3级与4级用于系统开发阶段设置通用属性。
配置文件可以出现在以下四种位置：
-
1级： file:config/application.yml 【优先级最高】
-
2级：
file:application.yml -
3级：classpath:config/application.yml
-
4级：
classpath:application.yml【优先级最低】
五、SpringBoot整合JUnit
1. 回顾Spring整合JUnit
1、导入依赖：
<dependency>
<groupId>junitgroupId>
<artifactId>junitartifactId>
<version>4.12version>
dependency>
<dependency>
<groupId>org.springframeworkgroupId>
<artifactId>spring-testartifactId>
<version>5.2.10.RELEASEversion>
dependency>
2、测试类：要配置Spring整合Junit专用的类加载器以及配置类所在的地方
// 使用Spring整合Junit专用的类加载器
@RunWith(SpringJUnit4ClassRunner.class)
// 加载配置文件或者配置类
@ContextConfiguration(classes = {SpringConfig.class}) //加载配置类
//@ContextConfiguration(locations={"classpath:applicationContext.xml"})//加载配置文件
public class AccountServiceTest {
//支持自动装配注入bean
@Autowired
private AccountService accountService;
@Test
public void testFindById(){
System.out.println(accountService.findById(1));
}
@Test
public void testFindAll(){
System.out.println(accountService.findAll());
}
}
2. SpringBoot整合JUnit
1、导入Junit起步依赖：
<dependency>
<groupId>org.springframework.bootgroupId>
<artifactId>spring-boot-starter-testartifactId>
dependency>
2、编写测试类 (注意：测试类必须放在和启动类相同的包下，或者放在启动类所在包的子包下)
@SpringBootTest
public class GoodMapperTest {
@Autowired
private GoodMapper goodMapper;
@Test
public void test0() {
System.out.println(goodMapper.selectById(536563d));
}
@Test
public void test1() {
Good good = new Good(12345d,"测试数据",1d,3d,3d,new Date(),"测试数据","测试数据");
boolean save = goodMapper.save(good);
System.out.println(save);
}
@Test
public void test2() {
Good good = new Good(12345d,"测试数据122",1222d,322d,322d,new Date(),"测试2数据","测试数据");
boolean save = goodMapper.updateById(good);
System.out.println(save);
}
@Test
public void test3() {
boolean b = goodMapper.deleteById(562379d);
System.out.println(b);
}
}
如果测试类无法注入Bean，在测试类上添加@ContextConfiguration(classes = 启动类.class)即可。
报错信息：非法状态异常，找不到@SpringBootConfiguration注解标注的SpringBoot配置类，需要使用@ContextConfiguration 或者 @SpringBootTest(classes=xxx)注解加载配置类。
六、SpringBoot整合SpringMVC
1. 设置拦截器
1、导入依赖web开发起步依赖：
<dependency>
<groupId>org.springframework.bootgroupId>
<artifactId>spring-boot-starter-webartifactId>
dependency>
2、编写Controller：
@RestController
@RequestMapping("books")
public class BookController {
@GetMapping("hello")
public String hello() {
System.out.println("接收了一个请求~~~");
return "helloworld";
}
}
3、在com.baidou.handler包下编写拦截器：（拦截器功能：登录认证、权限验证、记录日志、性能监控等等）
package com.baidou.handler;
import org.springframework.stereotype.Component;
import org.springframework.web.servlet.HandlerInterceptor;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
/**
* 拦截器
* 定义一个去实现HandlerInterceptor接口重写preHandle方法
* @author 白豆五
* @version 2022/12/27
* @since JDK8
*/
@Component
public class MyInterceptor implements HandlerInterceptor {
// 处理器执行前被调用
@Override
public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {
System.out.println("拦截器执行了~");
return true;
}
}
4、在com.baidou.config包下创建一个MvcConfig配置类：（注册拦截器）
-
方式1：继承
WebMvcConfigurationSupport，但是默认静态资源路径不好使，必须重新映射。 -
方式2：实现
WebMvcConfigurer接口，默认静态资源路径好使，还可以重新映射。
package com.baidou.config;
import com.baidou.handler.MyInterceptor;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.annotation.Configuration;
import org.springframework.web.servlet.config.annotation.*;
/**
* springmvc配置类
*
* @author 白豆五
* @version 2022/12/27
* @since JDK8
*/
@Configuration
public class MvcConfig implements WebMvcConfigurer {
// 注入拦截器bean
@Autowired
private MyInterceptor myInterceptor;
// 配置拦截器
@Override
public void addInterceptors(InterceptorRegistry registry) {
//拦截/books/hello请求
registry.addInterceptor(myInterceptor).addPathPatterns("/books/hello");
}
}
5、测试访问：
2. 静态资源访问
方式1：使用springboot默认提供的静态资源访问路径
查看org.springframework.boot.autoconfigure.web.WebProperties类的源码，静态资源可以放到如下几个类路径的下面：（推荐使用/static/，见名知意）
- /META-INF/resources/
- /resources/
- /static/
- /public/
方式2：通过mvc的配置类放行静态资源
package com.baidou.config;
import com.baidou.handler.MyInterceptor;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.annotation.Configuration;
import org.springframework.web.servlet.config.annotation.*;
/**
* springmvc配置类
*
* @author 白豆五
* @version 2022/12/27
* @since JDK8
*/
@Configuration
public class MvcConfig implements WebMvcConfigurer {
@Autowired
private MyInterceptor myInterceptor;
// 配置拦截器
@Override
public void addInterceptors(InterceptorRegistry registry) {
registry.addInterceptor(myInterceptor).addPathPatterns("/books/hello");
}
// 静态资源放行
@Override
public void addResourceHandlers(ResourceHandlerRegistry registry) {
registry.addResourceHandler("/ym/**").addResourceLocations("classpath:/ym/");
registry.addResourceHandler("/html/**").addResourceLocations("classpath:/html/");
}
// 页面跳转
@Override
public void addViewControllers(ViewControllerRegistry registry) {
registry.addViewController("/").setViewName("forward:books.html");
}
}
访问resources/ym目录下的b.html文件：
七、SpringBoot整合MyBatis
前期准备：数据库的sql脚本
-- 创建ssm_db数据库并设置字符编码
CREATE DATABASE IF NOT EXISTS ssm_db CHARACTER SET utf8;
-- 使用ssm_db数据库
USE ssm_db;
-- 创建tbl_book表
CREATE TABLE tbl_book(
id INT PRIMARY KEY AUTO_INCREMENT, -- 图书编号
TYPE VARCHAR(100), -- 图书类型
NAME VARCHAR(100), -- 图书名称
description VARCHAR(100) -- 图书描述
);
-- 初始化数据
INSERT INTO tbl_book VALUES(NULL,'计算机理论','Spring实战 第5版','Spring入门经典教材，深入理解Spring原理技术内幕');
INSERT INTO tbl_book VALUES(NULL,'计算机理论','Spring 5核心原理与30个类手写实战','十年沉淀之作,手写Spring精华思想');
INSERT INTO tbl_book VALUES(NULL,'计算机理论','Spring 5设计模式','深入Spring源码剖析,Spring源码蕴含的10大设计模式');
1. 回顾Spring整合MyBatis
1、导入依赖：
<dependencies>
<dependency>
<groupId>org.springframeworkgroupId>
<artifactId>spring-contextartifactId>
<version>5.2.10.RELEASEversion>
dependency>
<dependency>
<groupId>org.springframeworkgroupId>
<artifactId>spring-jdbcartifactId>
<version>5.2.10.RELEASEversion>
dependency>
<dependency>
<groupId>org.mybatisgroupId>
<artifactId>mybatisartifactId>
<version>3.5.6version>
dependency>
<dependency>
<groupId>org.mybatisgroupId>
<artifactId>mybatis-springartifactId>
<version>1.3.0version>
dependency>
<dependency>
<groupId>mysqlgroupId>
<artifactId>mysql-connector-javaartifactId>
<version>5.1.47version>
dependency>
<dependency>
<groupId>com.alibabagroupId>
<artifactId>druidartifactId>
<version>1.1.16version>
dependency>
dependencies>
2、创建SpringConfig配置类：(导入JdbcConfig、MyBatisConfig)
package com.baidou.config;
//Spring配置类
@ComponentScan({"com.baidou.service"}) //扫描组件(service包下的Bean)
@PropertySource("classpath:jdbc.properties") //加载类路径下的配置文件
@Import({JdbcConfig.class,MybatisConfig.class}) //导入配置类
@EnableTransactionManagement //开启spring事务管理注解
public class SpringConfig {
}
jdbc.properties:
jdbc.driver=com.mysql.jdbc.Driver
jdbc.url=jdbc:mysql://localhost:3306/ssm_db?useSSL=false
jdbc.username=root
jdbc.password=123456
3、创建JDBCConfig配置类（定义数据源、加载propertie中数据库连接信息）
package com.baidou.config;
/**
* JdbcConfig:加载数据库连接信息、定义数据源、Spring事务管理
*
* @author 白豆五
* @version 2022/12/27
* @since JDK8
*/
public class JdbcConfig {
@Value("${jdbc.driver}")
private String driver;
@Value("${jdbc.url}")
private String url;
@Value("${jdbc.username}")
private String username;
@Value("${jdbc.password}")
private String password;
// 配置数据库连接池
@Bean
public DataSource dataSource() {
DruidDataSource ds = new DruidDataSource();
// 初始化四个基本参数
ds.setDriverClassName(driver);
ds.setUrl(url);
ds.setUsername(username);
ds.setPassword(password);
return ds;
}
// Spring事务管理需要的平台事务管理器对象
@Bean
public PlatformTransactionManager platformTransactionManager(DataSource ds){
DataSourceTransactionManager dstm = new DataSourceTransactionManager();
dstm.setDataSource(ds);
return dstm;
}
}
4、创建MyBatisConfig配置类（定义SqlSessionFactoryBean、定义映射配置）
package com.baidou.config;
import org.mybatis.spring.SqlSessionFactoryBean;
import org.mybatis.spring.mapper.MapperScannerConfigurer;
import org.springframework.context.annotation.Bean;
import javax.sql.DataSource;
/**
*
* MyBatis配置类(SqlSessionFactoryBean、mapper扫描配置)
*
* @author 白豆五
* @version 2022/12/27
* @since JDK8
*/
public class MybatisConfig {
// 定义Bean，返回工厂对象SqlSessionFactoryBean
@Bean
public SqlSessionFactoryBean sqlSessionFactoryBean(DataSource ds) {
SqlSessionFactoryBean factoryBean = new SqlSessionFactoryBean();
factoryBean.setDataSource(ds);
return factoryBean;
}
// 定义Bean，返回MapperScannerConfigurer mapper扫描配置
@Bean
public MapperScannerConfigurer mapperScannerConfigurer() {
MapperScannerConfigurer msc = new MapperScannerConfigurer();
// 扫描dao包下的接口，并生成对应的代理对象，交给spring容器管理
msc.setBasePackage("com.baidou.dao");
return msc;
}
}
2. SpringBoot整合MyBatis
1、导入mybatis起步依赖和驱动
<dependency>
<groupId>org.mybatis.spring.bootgroupId>
<artifactId>mybatis-spring-boot-starterartifactId>
<version>2.1.0version>
dependency>
<dependency>
<groupId>mysqlgroupId>
<artifactId>mysql-connector-javaartifactId>
<version>5.1.47version>
dependency>
2、在application.yml中设置数据源参数
# 数据源配置
spring:
datasource:
driver-class-name: com.mysql.jdbc.Driver
url: jdbc:mysql://127.0.0.1:3306/ssm_db?useSSL=false&serverTimezone=UTC
username: root
password: 123456
# mybatis配置
mybatis:
configuration:
# 开启驼峰映射 关键字:camel
map-underscore-to-camel-case: true
# 标准sql输出 关键字:logimpl
log-impl: org.apache.ibatis.logging.stdout.StdOutImpl
注意：Mysql驱动8版本需要在url中配置时区。
3、定义实体类、数据层接口
package com.baidou.entity;
//实体类
@Data
public class Book {
private Integer id;
private String type;
private String name;
private String description;
}
在mapper接口上添加@Mapper注解，springboot底层会自动创建代理对象:
package com.baidou.mapper;
// 操作数据库的接口
@Mapper //将当前接口创建的代理对象放入spring容器中
public interface BookMapper {
@Insert("insert into tbl_book values (null,#{type},#{name},#{description})")
int save(Book book);
@Update("update tbl_book set type=#{type},name=#{name},description=#{description} where id=#{id}")
int update(Book book);
@Delete("delete from tbl_book where id=#{id}")
int deleteById(Integer id);
@Select("select * from tbl_book")
List<Book> selectAll();
@Select("select * from tbl_book where id=#{id}")
Book selectById(Integer id);
}
4、测试类中注入mapper接口，测试功能：
package com.baidou.test;
import com.baidou.entity.Book;
import com.baidou.mapper.BookMapper;
import org.junit.jupiter.api.Test;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;
import java.util.List;
@SpringBootTest
public class BookMapperTest {
@Autowired
private BookMapper bookMapper;
@Test
public void testSelectAll(){
List<Book> books = bookMapper.selectAll();
for (Book book : books) {
System.out.println(book);
}
}
}
3. 切换数据库连接池
常见的数据库连接池
-
C3P0，是一个开源的JDBC连接池，它实现了数据源和JNDI绑定，支持JDBC3规范和JDBC2的标准扩展。C3P0是异步操作的，缓慢的JDBC操作通过帮助进程完成。扩展这些操作可以有效的提升性能。目前使用它的开源项目有hibernate，spring等。C3P0有自动回收空闲连接功能。 -
DBCP（DataBase Connection Pool），是java数据库连接池的一种，由Apache开发，通过数据库连接池，可以让程序自动管理数据库连接的释放和断开。 -
Proxool，是sourceforge下的一个开源项目，这个项目提供一个健壮、易用的连接池，最为关键的是这个连接池提供监控的功能，方便易用，便于发现连接泄漏的情况。 -
Druid（德鲁伊），是阿里的一个开源项目，整个项目由数据库连接池、插件框架和SQL解析器组成。该项目主要是为了扩展JDBC的一些限制，可以让程序员实现一些特殊的需求，比如向密钥服务请求凭证、统计SQL信息、SQL性能收集、SQL注入检查、SQL翻译等，程序员可以通过定制来实现自己需要的功能。 -
Hikari（嘿咔蕊）， 是一个高性能的 JDBC 连接池组件，SpringBoot默认使用的连接池。（由小日子过得不错研发）
3.1 切换Druid连接池
1、导入druid依赖：
<dependency>
<groupId>com.alibabagroupId>
<artifactId>druidartifactId>
<version>1.1.16version>
dependency>
2、在application.yml配置文件中通过spring.datasource.type指定连接池的核心类DruidDataSource。
spring:
datasource:
type: com.alibaba.druid.pool.DruidDataSource # 切换数据源
url: jdbc:mysql:///ssm_db?useSSL=false&serverTimezone=UTC
driver-class-name: com.mysql.jdbc.Driver
username: root
password: 123456
3.2 通过starter整合Druid
默认配置—>约定优于配置—>起步依赖starter
1、导入druid起步依赖：
<dependency>
<groupId>com.alibabagroupId>
<artifactId>druid-spring-boot-starterartifactId>
<version>1.2.15version>
dependency>
2、在application.yml文件中配置druid：
# druid连接池配置起步依赖基础配置
spring:
datasource:
druid: # 可以不用写driver
url: jdbc:mysql://localhost:3306/ssm_db?useSSL=false
username: root
password: 123456
大佬整理的资料：https://blog.csdn.net/qq_41946216/article/details/127095367
八、彩蛋
1. 插件
1.1 JBLSpringBootAppGen 插件
1.2 Grep Console（对控制台的日志进行过滤且加上不同背景色）
1.3 .ignore （生成git过滤推送的文件，里面可以指定生成的模板）
1.4 CodeGlance Pro（代码地图）
ctrl+shift+g 取消显示
1.5 其他插件
2. IDEA设置
工欲善其事必先利其器
2.1 设置行号与方法分割符
2.2 高亮显示修改目录
当项目有改动时，对应的目录就会高亮，亮Light主题下会变成浅蓝色更直观。（需要集成git等版本控制工具后才能生效）
2.3 自动导包
2.4 设置Maven的Reload操作 （刷新maven坐标）
2.5 设置输入忽略大小写
配置成功后代码提示就忽略大小写了。
2.6 ctrl + 鼠标滚轮：调节字体大小
3. IDEA常用的快捷键
历史剪切板：Ctrl+Shift+V
查找/打开最近使用过的文件: Ctrl+E
全局查找/替换：Ctrl+Shift+F/R (F表示查找、R表示替换)
万能搜索：双击Shift
一键生成代码模板：Ctrl+Alt+T （try-catch、synchronized等等）
问题狙击手：F2 定位问题 、Alt+回车 解决问题
重命名：Shift+F6
抽取变量： Ctrl+Alt+V
抽取字段： Ctrl+Alt+F
抽取参数： Ctrl+Alt+P
抽取常量： Ctrl+Alt+C
抽取方法： Ctrl+Alt+M
未完待续…