SpringBoot框架

1.1 简介

1.2 特性

1.3 四大核心

2 springboot入门案例

2.1 SpringBoot 项目开发步骤

?2.2??创建一个 Spring MVC 的 Spring BootController?

2.3? 分析

2.4 核心配置文件格式

2.5??Spring Boot 前端使用 JSP

3 SpringBoot框架Web开发

?3.1??Spring Boot 集成 MyBatis?

?3.2?DAO 的其它开发方式

?3.3?Spring Boot 事务支持

3.4??Spring Boot 下的 Spring MVC（注解）

?3.5 SpringBoot实现RESTFUL

3.6??Spring Boot 集成 Redis?

1.1 简介

springboot是spring家族中的一个全新框架，用来简化spring程序的创建和开发过程。在以往我们通过SpringMVC+Spring+Mybatis框架进行开发的时候，我们需要配置web.xml，spring配置，mybatis配置，然后整合在一起，而springboot抛弃了繁琐的xml配置过程，采用大量默认的配置来简化我们的spring开发过程。

SpringBoot化繁为简，使开发变得更加的简单迅速。

1.2 特性

能够快速创建基于spring的程序
能够直接使用Java main方法启动内嵌的Tomcat服务器运行springboot程序，不需要部署war包
提供约定的starter POM来简化Maven配置，让Maven的配置变得简单
自动化配置，根据项目的Maven依赖配置，springboot自动配置spring、springmvc等
提供了程序的健康检查功能
基本可以完全不使用xml配合文件，采用注解配置

1.3 四大核心

自动配置、起步依赖、Actuator、命令行界面

2 springboot入门案例

2.1 SpringBoot 项目开发步骤

（1）创建一个 Module，选择类型为Spring Initializr 快速构建

（2）设置 GAV 坐标及 pom 配置信息

（3）选择 Spring Boot 版本及依赖

（4）设置模块名称、Content Root 路径及模块文件的目录，然后点击finish即可

（5）项目结构如下：

static：存放静态资源。如图片、CSS、JavaScript 等
templates：存放 Web 页面的模板文件
application.properties/application.yml 用于存放程序的各种依赖模块的配置信息，比如服务端口，数据库连接配置等
.gitignore：使用版本控制工具 git 的时候，设置一些忽略提交的内容
Application.java：SpringBoot 程序执行的入口，执行该程序中的 main 方法，启动当前SpringBoot项目。

（6）对pom.xml文件进行解释

 
 
 4.0.0 
  
  
     org.springframework.boot 
     spring-boot-starter-parent 
     2.2.1.RELEASE 
       
  
 
  
 com.bjpowernode.springboot 
 002-springboot-springmvc 
 1.0.0 
 
  
 002-springboot-springmvc 
  
 Demo project for Spring Boot 
 
  
  
     1.8 
  
 
 
  
  
      
         org.springframework.boot 
         spring-boot-starter-web 
      
 
  
      
         org.springframework.boot 
         spring-boot-starter-test 
         test 
          
              
                 org.junit.vintage 
                 junit-vintage-engine 
              
          
      
  
 
  
      
          
          
             org.springframework.boot 
             spring-boot-maven-plugin 
          
      
  
 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62

2.2创建一个 Spring MVC 的 Spring BootController

（1）创建SpringBootController 类

注意：新创建的类一定要位于 Application 同级目录或者下级目录，否则 SpringBoot 加
载不到。

package com.bjpowernode.springboot.web; 
 
import org.springframework.stereotype.Controller; 
import org.springframework.web.bind.annotation.RequestMapping; 
import org.springframework.web.bind.annotation.ResponseBody; 
 
@Controller 
public class SpringBootController { 
 
 @RequestMapping(value = "/springBoot/say") 
 public @ResponseBody String say() { 
     return "Hello,springBoot!"; 
 } 
} 
1
2
3
4
5
6
7
8
9
10
11
12
13
14

（2）启动Application类中的main方法

通过在控制台的输出，可以看到启动 SpringBoot 框架，会启动一个内嵌的 tomcat，端
口号为 8080，上下文根为空。

（3）在浏览器中输入 http://localhost:8080/springBoot/say进行访问

2.3 分析

（1）spring-boot-starter-parent 是一个 Springboot 的父级依赖，开发 SpringBoot 程序都需
要继承该父级项目，它用来提供相关的 Maven 默认依赖，使用它之后，常用的 jar
包依赖可以省去 version 配置
（2）Spring Boot 提供了一些默认的jar 包的依赖，可查看该父级依赖的 pom 文件
（3）如果不想使用某个默认的依赖版本，可以通过 pom.xml 文件的属性配置覆盖各个
依赖项，比如覆盖 Spring 版本：

??
?    5.0.0.RELEASE?
 ?
1
2
3

（4）@SpringBootApplication 注解是 Spring Boot 项目的核心注解，主要作用是开启
Spring 自动配置，如果在 Application 类上去掉该注解，那么不会启动 SpringBoot程序
（5）main 方法是一个标准的 Java 程序的 main 方法，是boot项目启动运行的入口
（6）@Controller 及 @ResponseBody 依然是我们之前的 Spring MVC，因为 Spring Boot
的里面依然是使用我们的 Spring MVC + Spring + MyBatis 等框架

2.4 核心配置文件格式

（1）.properties 文件（默认采用该文件）

通过修改 application.properties 配置文件，修改默认 tomcat 端口号及项目上下文件根：

#设置内嵌 Tomcat 端口号 
server.port=9090 
 
#配置项目上下文根 
server.servlet.context-path=/003-springboot-port-context-path 
1
2
3
4
5

页面显示结果：

（2）.yml 文件：

项目名称：004-springboot-yml

yml 是一种 yaml 格式的配置文件，主要采用一定的空格、换行等格式排版进行配置。它能够直观的被计算机识别数据序列化格式，容易被人类阅读，yaml 类似于 xml，但是语法比 xml 简洁很多，值与前面的冒号配置项必须要有一个空格， yml 后缀也可以使用 yaml 后缀。

注意：当两种格式配置文件同时存在时，使用的是.properties 配置文件。

（3）多环境配置（.properties方式）

在实际开发的过程中，我们的项目会经历很多的阶段（开发->测试->上线），每个阶段
的配置也会不同，例如：端口、上下文根、数据库等，那么这个时候为了方便在不同的环境
之间切换，SpringBoot 提供了多环境配置，具体步骤如下：

项目名称：005-springboot-multi-environment

为每个环境创建一个配置文件，命名必须为application-环境标识.properties|yml

application-dev.properties

#开发环境

#设置内嵌 Tomcat 默认端口号 
server.port=8080 
 
#设置项目的上下文根 
server.servlet.context-path=/005-springboot-multi-environment-dev 
1
2
3
4
5
6
7

application-product.properties

#生产环境 
 
#配置内嵌 Tomcat 默认端口号 
server.port=80 
 
#配置项目上下文根 
server.servlet.context-path=/005-springboot-multi-environment-product 
1
2
3
4
5
6
7

application-test.properties

#测试环境 
 
#配置内嵌 Tomcat 端口号 
server.port=8081 
 
#配置项目的上下文根 
server.servlet.context-path=/005-springboot-multi-environment-test 
1
2
3
4
5
6
7

在总配置文件 application.properties 进行环境的激活

#SpringBoot 的总配置文件 
 
#激活开发环境 
#spring.profiles.active=dev 
 
#激活测试环境 
#spring.profiles.active=test 
 
#激活生产环境 
spring.profiles.active=product 
1
2
3
4
5
6
7
8
9
10

（4）多环境配置（.yml方式）

application-dev.yml

#设置开发环境配置 
 
server: 
 port: 8080 #设置 Tomcat 内嵌端口号 
 servlet: 
  context-path: /dev #设置上下文根 
1
2
3
4
5
6

application-product.yml

#设置生产环境配置 
 
server: 
 port: 80 
 servlet: 
  context-path: /product 
1
2
3
4
5
6

application-test.yml

#设置测试环境配置 
 
server: 
 port: 9090 
 servlet: 
  context-path: /test
1
2
3
4
5
6

在总配置文件 application.yml进行环境的激活

#springboot 总配置文件 
 
#激活开发环境 
#spring: 
# profiles: 
#  active: dev 
 
 
#激活测试环境 
#spring: 
# profiles: 
#  active: test 
 
#激活生产环境 
spring: 
 profiles: 
  active: product 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

（5）Spring Boot 自定义配置

在 SpringBoot 的核心配置文件中，除了使用内置的配置项之外，我们还可以在自定义配
置，然后采用如下注解去读取配置的属性值：

（A）@Value注解用于逐个读取application.properties中的配置

案例演示：

**（1）**在核心配置文件 applicatin.properties 中，添加两个自定义配置项 school.name 和
website。在 IDEA 中可以看到这两个属性不能被 SpringBoot 识别，背景是桔色的：

.properties方式

.yml方式

#设置端口号及上下文根 
server: 
 port: 9090 
 servlet: 
  context-path: / 
 
school: 
 name: ssm 
websit: http://www.baidu.com 
1
2
3
4
5
6
7
8
9

（2）在 SpringBootController 中定义属性，并使用@Value 注解或者自定义配置值，并对其方法进行测试

@Controller 
public class SpringBootController { 
 
 @Value("${school.name}") 
 private String schoolName; 
 
 @Value("${websit}") 
 private String websit; 
 
 @RequestMapping(value = "/springBoot/config") 
 public @ResponseBody String say() { 
 return schoolName + "------" + websit; 
 } 
} 
1
2
3
4
5
6
7
8
9
10
11
12
13
14

（3）重新运行 Application，在浏览器中进行测试

（B）@ConfigurationProperties

**作用：**将整个文件映射成一个对象，用于自定义配置项比较多的情况。

案例演示：

**（1）**在 com.abc.springboot.config 包下创建 ConfigInfo 类，并为该类加上 Component 和
ConfigurationProperties 注解，并在 ConfigurationProperties 注解中添加属性 prefix，可以区分同名配置。

@Data
@Component 
@ConfigurationProperties(prefix = "school") 
public class ConfigInfo { 
 
 private String name; 
 
 private String websit; 
} 
1
2
3
4
5
6
7
8
9

（2）application.properties 配置文件

#设置内嵌 Tomcat 端口号 
server.port=9090 
 
#设置上下文根 
server.servlet.context-path=/config 
 
school.name=ssm 
school.websit=http://www.baidu.com 
1
2
3
4
5
6
7
8

（3）在 SpringBootController 中注入 ConfigInfo 配置类

@Autowired 
private ConfigInfo configInfo; 
1
2

（4）修改 SpringBootController 类中的测试方法

@RequestMapping(value = "/springBoot/config") 
public @ResponseBody String say() { 
 return configInfo.getName() + "=======" + configInfo.getWebsit(); 
} 
1
2
3
4

（5）重新运行 Application，在浏览器中进行测试

（C）警告解决

在 ConfigInfo 类中使用了 ConfigurationProperties 注解后，IDEA 会出现一个警告，不影响程序的执行。

点击 open documentnation 跳转到网页，在网页中提示需要加一个依赖，我们将这
个依赖拷贝，粘贴到 pom.xml 文件中即可。

 
 
  org.springframework.boot 
  spring-boot-configuration-processor 
  true 
 
1
2
3
4
5
6

（D）中文乱码

如果在 SpringBoot 核心配置文件中有中文信息，会出现乱码：

一般在配置文件中，不建议出现中文（注释除外）
如果出现中文，可以先转化为 ASCII 码

2.5Spring Boot 前端使用 JSP

（1）在 pom.xml 文件中配置以下依赖项

 
 
 
 org.apache.tomcat.embed 
 tomcat-embed-jasper 
 
 
 
 
 
 javax.servlet 
 javax.servlet-api 
 
 
 javax.servlet.jsp 
 javax.servlet.jsp-api 
 2.3.1 
 
 
 
 
 
 javax.servlet 
 jstl 
 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25

（2）在 pom.xml 的 build 标签中要配置以下信息
SpringBoot 要求 jsp 文件必须编译到指定的 META-INF/resources 目录下才能访问，否则
访问不到。其实官方已经更建议使用模板技术。

 
 
  
      
     src/main/webapp 
      
     META-INF/resources 
      
      
         **/*.* 
      
  
 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

（3）在 application.properties 文件配置 Spring MVC 的视图展示为jsp，这里相当于 Spring MVC 的配置。

#SpringBoot 核心配置文件 
#指定内嵌 Tomcat 端口号 
server.port=8090 
 
#配置 SpringMVC 视图解析器 
#其中：/ 表示目录为 src/main/webapp 
spring.mvc.view.prefix=/ 
spring.mvc.view.suffix=.jsp 
1
2
3
4
5
6
7
8

（4）在 com.abc.springboot.controller 包下创建 JspController 类

@Controller 
public class SpringBootController { 
 
 @RequestMapping(value = "/springBoot/jsp") 
 public String jsp(Model model) { 
 
     model.addAttribute("data","SpringBoot 前端使用 JSP 页面！"); 
 
 return "index"; 
 } 
} 
1
2
3
4
5
6
7
8
9
10
11

（5）在 src/main 下创建一个 webapp 目录，然后在该目录下新建index.jsp 页面

注意：如果在webapp目录下右键，没有创建jsp的选项，可以在Project Structure中指定webapp为 Web Resource Directory 。

（6）在 index.jsp 中获取 Controller 传递过来的数据

（7）重新运行 Application，通过浏览器访问测试

3 SpringBoot框架Web开发

通过实际代码案例进行梳理：

3.1Spring Boot 集成 MyBatis

通过 SpringBoot +MyBatis 实现对数据库学生表的查询操作的实现步骤：

（1）创建新的数据库springboot并向表中插入数据

（2）创建一个新的 SpringBoot 的 Module

创建项目的过程省略

（3）在 pom.xml 中添加相关 jar 依赖

 
 
 org.mybatis.spring.boot 
 mybatis-spring-boot-starter 
 2.0.0 
 

 
 
 mysql 
 mysql-connector-java 
 
1
2
3
4
5
6
7
8
9
10
11
12

（4）在 Springboot 的核心配置文件 application.properties 中配置数据源

#配置内嵌 Tomcat 端口号 
server.port=9090 
 
#配置项目上下文根 
server.servlet.context-path=/010-springboot-web-mybatis 
 
#配置数据库的连接信息 
#注意这里的驱动类有变化 
spring.datasource.driver-class-name=com.mysql.cj.jdbc.Driver 
spring.datasource.url=jdbc:mysql://localhost:3306/springboot?useUnicode=true&characterEncoding=UTF-8&useJDBCCompliantTimezoneShift=true&useLegacyDatetimeCode=false&serverTimezone=GMT%2B8 
 
spring.datasource.username=root 
spring.datasource.password=root
1
2
3
4
5
6
7
8
9
10
11
12
13

（5）开发代码（代码生成器）

使用 Mybatis 反向工程生成接口、映射文件以及实体 bean，具体步骤参见附录 1

（A）在 web 包下创建 StudentController 并编写代码

@Controller 
public class StudentController { 
 
 @Autowired 
 private StudentService studentService; 
 
 @RequestMapping(value = "/springBoot/student") 
 public @ResponseBody Object student() { 
 
 Student student = studentService.queryStudentById(1); 
 
 return student; 
 } 
} 
1
2
3
4
5
6
7
8
9
10
11
12
13
14

（B）在 service 包下创建 service 接口并编写代码

public interface StudentService { 
 
 /** 
 * 根据学生标识获取学生详情 
 * @param id 
 * @return 
 */ 
 Student queryStudentById(Integer id); 
}
1
2
3
4
5
6
7
8
9

（C）在 service.impl 包下创建 service 接口并编写代码

@Service 
public class StudentServiceImpl implements StudentService { 
 

 @Autowired 
 private StudentMapper studentMapper; 
 
 @Override 
 public Student queryStudentById(Integer id) { 
 return studentMapper.selectByPrimaryKey(id); 
 } 
} 
1
2
3
4
5
6
7
8
9
10
11
12

（D）如果在 web 中导入 service 存在报错，可以尝试进行如下配置解决

（E）在 Mybatis 反向工程生成的 StudentMapper 接口上加一个 Mapper 注解
@Mapper 作用：mybatis 自动扫描数据持久层的映射文件及 DAO 接口的关系

@Mapper 
public interface StudentMapper { 
}
1
2
3

（F）默认情况下，Mybatis 的 xml 映射文件不会编译到 target 的 class 目录下，所
以我们需要在 pom.xml 文件中配置 resource 。

 
  
 src/main/java 
  
     **/*.xml 
  
  

1
2
3
4
5
6
7
8

（G）启动 Application 应用，浏览器访问测试运行

3.2DAO 的其它开发方式

方式一：

（A）注释掉 StudentMapper 接口上的@Mapper 注解

（B）在运行的主类上添加注解包扫描MapperScan(“com.abc.springboot.mapper”)

@SpringBootApplication 
@MapperScan("com.abc.springboot.mapper") 
public class Application { 
1
2
3

或

@SpringBootApplication 
//Mybatis 提供的注解：扫描数据持久层的 mapper 映谢配置文件,DAO 接口上就不用加@Mapper 
//basePackages 通常指定到数据持久层包即可 
@MapperScan(basePackages = "com.abc.springboot.mapper") 
public class Application { 
1
2
3
4
5

方式二：

因为 SpringBoot 不能自动编译接口映射的 xml 文件，还需要手动在 pom 文件中指定，
所以有的公司直接将映射文件直接放到 resources 目录下，在 resources 目录下新建目录 mapper 存放映射文件，将 StudentMapper.xml 文件移到resources/mapper 目录下：

在 application.properties 配置文件中指定映射文件的位置，这个配置只有接口和映
射文件不在同一个包的情况下，才需要指定：

# 指定 Mybatis 映射文件的路径 
mybatis.mapper-locations=classpath:mapper/*.xml 
1
2

3.3Spring Boot 事务支持

springboot事务底层依然采用的是 Spring 本身提供的事务管理。

在入口类中使用注解@EnableTransactionManagement开启事务支持
在访问数据库的service方法上添加注解@Transactional即可

在上述案例的基础上，通过 SpringBoot +MyBatis 实现对数据库学生表的更新操作，在 service 层的方法中构建异常，查看事务是否生效：

（1）在 StudentController 中添加更新学生的方法

@RequestMapping(value = "/springboot/modify") 
public @ResponseBody Object modifyStudent() { 
 
 int count = 0; 
 try { 
 Student student = new Student(); 
 student.setId(1); 
 student.setName("Jack"); 
 student.setAge(33); 
 count = studentService.modifyStudentById(student); 
 } catch (Exception e) { 
 e.printStackTrace(); 
 return "fail"; 
 } 
 
 return count; 
} 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

（2）在 StudentService 接口中添加更新学生方法

int modifyStudentById(Student student); 
1

（3）在 StudentServiceImpl 接口实现类中对更新学生方法进行实现，并构建一个异常，同时在该方法上加@Transactional 注解。

@Override 
@Transactional //添加此注解说明该方法添加的事务管理 
public int update(Student student) { 
 
 int updateCount = studentMapper.updateByPrimaryKeySelective(student); 
 
 System.out.println("更新结果：" + updateCount); 
 
 //在此构造一个除数为 0 的异常，测试事务是否起作用 
 int a = 10/0; 
 
 return updateCount; 
} 
1
2
3
4
5
6
7
8
9
10
11
12
13

（4）在Application类上加@EnableTransactionManagement开启事务支持。

@EnableTransactionManagement 可选，但是业务方法上必须添加@Transactional 事务才生效

@SpringBootApplication 
@MapperScan(basePackages = "com.abc.springboot.mapper") 
@EnableTransactionManagement //开启事务支持(可选项，但@Transactional 必须添加) 
public class Application { 
1
2
3
4

3.4Spring Boot 下的 Spring MVC（注解）

springboot下的springMVC主要有以下注解：

（1）@Controller：Spring MVC 的注解，处理 http 请求

（2）@RestController ：@Controller 与@ResponseBody 的组合注解

如果一个 Controller 类添加了@RestController，那么该 Controller 类下的所有方法都相当
于添加了@ResponseBody 注解，用于返回字符串或json数据。

创建 MyRestController 类，演示@RestController 替代@Controller + @ResponseBody

@RestController 
public class MyRestController { 
 @Autowired 
 private StudentService studentService; 
 
 @RequestMapping("/boot/stu") 
 public Object stu(){ 
 return studentService.getStudentById(1); 
 } 
} 
1
2
3
4
5
6
7
8
9
10

（3）@RequestMapping：支持 Get 请求，也支持 Post 请求。
（4）@GetMapping ：只支持 Get 请求，主要用于查询操作。

（5）@PostMapping：只支持Post请求，主要用于新增数据。

（6）@PutMapping：只支持put请求，主要用于修改数据

（7）@DeleteMapping：只支持delete请求，通常用与删除数据

（8）综合案例：

（A）创建一个 MVCController，里面使用上面介绍的各种注解接收不同的请求

//RestController 注解相当于加了给方法加了@ResponseBody 注解，所以是不能跳转页面的，只能返回字符串或者 json 数据 
@RestController 
public class MVCController { 
 
 @GetMapping(value = "/query") 
 public String get() { 
 return "@GetMapping 注解,通常查询时使用"; 
 } 
 
 
 @PostMapping(value = "/add") 
 public String add() { 
 return "@PostMapping 注解，通常新增时使用"; 
 } 
 
 @PutMapping(value = "/modify") 
 public String modify() { 
 return "@PutMapping 注解，通常更新数据时使用"; 
 } 
 
 @DeleteMapping(value = "/remove") 
 public String remove() { 
 return "@DeleteMapping 注解，通常删除数据时使用"; 
 } 
} 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25

（B）启动应用，在浏览器中输入不同的请求进行测试

（C）结合POSTMan工具测试其他请求类型

3.5 SpringBoot实现RESTFUL

（1）简介

它是一种互联网软件设计的风格，它只是提出了一组客户端和服务器交互时的架构理念和设计原则，基于这种理念和原则设计的接口可以更简洁，更有层次。

比如我们要访问一个 http 接口：http://localhost:8080/boot/orderid=1021&status=1
采用 RESTFul 风格则 http 地址为：http://localhost:8080/boot/order/1021/1

（2）开发RESTFUL，主要用到以下注解：

@PathVariable ：获取 url 中的数据，该注解是实现 RESTFul 最主要的一个注解
@PostMapping ：接收和处理post方式的请求
@DeleteMapping：接收delete方式的请求，可以用GetMapping代替
@PutMapping ：接收put方式的请求，可以用 PostMapping 代替
@GetMapping ：接收get方式请求

（3）案例：使用 RESTful 风格模拟实现对学生的增删改查操作

该项目集成了 MyBatis、spring、SpringMVC，通过模拟实现对学生的增删改查操作

pom.xml文件

 
  
  
     org.springframework.boot 
     spring-boot-starter-web 
  
 
  
  
     org.mybatis.spring.boot 
     mybatis-spring-boot-starter 
     2.0.1 
  
  
  
     mysql 
     mysql-connector-java 
  
 
 
 
  
  
      
         src/main/java 
          
             **/*.xml 
          
      
  
 
  
      
      
         org.mybatis.generator 
         mybatis-generator-maven-plugin 
         1.3.6 
          
              
             GeneratorMapper.xml 
             true 
             true 
          
      
 
      
         org.springframework.boot 
         spring-boot-maven-plugin 
      
  
 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51

application.properties核心配置文件

#配置内嵌 Tomcat 端口号 
server.port=8090 
 
#配置项目上下文根 
server.servlet.context-path=/
 
#配置数据库的连接信息 
#注意这里的驱动类有变化 
spring.datasource.driver-class-name=com.mysql.cj.jdbc.Driver 
spring.datasource.url=jdbc:mysql://localhost:3306/springboot?useUnicode=true&characterEncoding=UTF-8&useJDBCCompliantTimezoneShift=true&useLegacyDatetimeCode=false&serverTimezone=GMT%2B8 
 
spring.datasource.username=root 
spring.datasource.password=root
1
2
3
4
5
6
7
8
9
10
11
12
13

通过逆向工程生成 DAO

创建 RESTfulController

@RestController 
public class RESTfulController { 
 
 /** 
 * 添加学生 
 * 请求地址：
http://localhost:9090/014-springboot-restful/springBoot/student/wangpeng/23 
 * 请求方式：POST 
 * @param name 
 * @param age 
 * @return 
 */ 
 @PostMapping(value = "/springBoot/student/{name}/{age}") 
 public Object addStudent(@PathVariable("name") String name, @PathVariable("age") Integer age) { 
 
 Map retMap = new HashMap(); 
 retMap.put("name",name); 
 retMap.put("age",age); 
 
 
 return retMap; 
 } 
 
 /** 
 * 删除学生 
 * 请求地址：
http://localhost:9090/014-springboot-restful/springBoot/student/1 
 * 请求方式：Delete 
 * @param id 
 * @return 
 */ 
 @DeleteMapping(value = "/springBoot/student/{id}") 
 public Object removeStudent(@PathVariable("id") Integer id) { 
 
 return "删除的学生 id 为：" + id; 
 } 
 
 /** 
 * 修改学生信息 
 * 请求地址：
http://localhost:9090/014-springboot-restful/springBoot/student/2 
 * 请求方式：Put 
 * @param id 
 * @return 
 */ 
 @PutMapping(value = "/springBoot/student/{id}") 
 public Object modifyStudent(@PathVariable("id") Integer id) { 
 
 return "修改学生的 id 为" + id; 
 } 
 
 @GetMapping(value = "/springBoot/student/{id}") 
 public Object queryStudent(@PathVariable("id") Integer id) { 
 
 return "查询学生的 id 为" + id; 
 } 
} 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57

使用 Postman 模拟发送请求，进行测试：

（4）请求冲突的问题

解决方案：<1>修改路径 <2>修改请求方式

创建 RESTfulController 类，结合 Postman 进行测试说明：

@RestController 
public class RESTfulController { 
 
 /** 
 * id:订单标识 
 * status：订单状态 
 * 请求路径：
http://localhost:9090/015-springboot-restful-url-conflict/springBoot/orde
r/1/1001 
 * @param id 
 * @param status 
 * @return 
 */ 
 @GetMapping(value = "/springBoot/order/{id}/{status}") 
 public Object queryOrder(@PathVariable("id") Integer id, @PathVariable("status") Integer status) { 
 
 Map map = new HashMap(); 
 
 map.put("id",id); 
 map.put("status",status); 
 
 return map; 
 } 
 
 /** 
 * id:订单标识 
 * status：订单状态 
 * 请求路径：
http://localhost:9090/015-springboot-restful-url-conflict/springBoot/1/or
der/1001 
 * @param id 
 * @param status 
 
 * @return 
 */ 
 @GetMapping(value = "/springBoot/{id}/order/{status}") 
 public Object queryOrder1(@PathVariable("id") Integer id, @PathVariable("status") Integer status) { 
 Map map = new HashMap(); 
 
 map.put("id",id); 
 map.put("status",status); 
 
 return map; 
 } 
 
 /** 
 * id:订单标识 
 * status：订单状态 
 * 请求路径：
http://localhost:9090/015-springboot-restful-url-conflict/springBoot/1001
/order/1 
 * @param id 
 * @param status 
 * @return 
 */ 
 @GetMapping(value = "/springBoot/{status}/order/{id}") 
 public Object queryOrder2(@PathVariable("id") Integer id, 
 @PathVariable("status") Integer status) { 
 Map map = new HashMap(); 
 
 map.put("id",id); 
 map.put("status",status); 
 
 return map; 
 } 
 
 /** 
 * id:订单标识 
 * status：订单状态 
 * 请求路径：
http://localhost:9090/015-springboot-restful-url-conflict/springBoot/1001
/order/1 
 * @param id 
 * @param status 
 * @return 
 */ 
 

 @PostMapping(value = "/springBoot/{status}/order/{id}") 
 public Object queryOrder3(@PathVariable("id") Integer id,  @PathVariable("status") Integer status) { 
 Map map = new HashMap(); 
 
 map.put("id",id); 
 map.put("status",status); 
 
 return map; 
 } 
 
 
 
 
 /** 
 * query1 和 query2 两个请求路径会发生请求路径冲突问题 
 * query3 与 query1 和 query2 发生请求冲突 
 * 注意：虽然两个路径写法改变了，但是由于传递的两个参数都是 int 值，所以不知道该交给
哪个请求进行处理 
 * 就会出现匹配模糊不清的异常，所以要想解决冲突，有两种方式： 
 * 1.修改请求路径 
 * 2.修改请求方式 
 */ 
} 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101

（5）RESTful 原则

增 post 请求、删 delete 请求、改 put 请求、查 get 请求
请求路径不要出现动词：

分页、排序等操作，不需要使用斜杠传参数

3.6Spring Boot 集成 Redis

完善根据学生 id 查询学生的功能：先从 redis 缓存中查找，如果找不到，再从数据库中
查找，然后放到 redis 缓存中。

具体实现步骤：

（A）首先通过 MyBatis 逆向工程生成实体 bean 和数据持久层：

（B）在 pom.xml 文件中添加 redis 依赖

 
 
 org.springframework.boot 
 spring-boot-starter-data-redis 
 
1
2
3
4
5

（C）Spring Boot 核心配置文件application.properties 如下：

#配置内嵌 Tomcat 端口号 
server.port=9090 
 
#配置项目上下文根 
server.servlet.context-path=/016-springboot-redis 
 
#配置连接 MySQL 数据库信息 
spring.datasource.url=jdbc:mysql://127.0.0.1:3306/springboot？useUnicode=true&characterEncoding=UTF8&useJDBCCompliantTimezoneShift=true&useLegacyDa
tetimeCode=false&serverTimezone=GMT%2B8 
spring.datasource.driver-class-name=com.mysql.cj.jdbc.Driver 
spring.datasource.username=root 
spring.datasource.password=root
 
#配置 redis 连接信息 
spring.redis.host=127.0.0.1 
spring.redis.port=6379 
#spring.redis.password=root
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

（D）启动redis服务

（E）RedisController类

@RestController 
public class RedisController { 
 
 @Autowired 
 private StudentService studentService; 
 
 /** 
 * 请求地址：
http://localhost:9090/016-springboot-redis//springboot/allStudentCount 
 * @param request 
 * @return 
 */ 
 @GetMapping(value = "/springboot/allStudentCount") 
 public Object allStudentCount(HttpServletRequest request) { 
 
 Long allStudentCount = studentService.queryAllStudentCount(); 
 
 return "学生总人数：" + allStudentCount; 
 } 
} 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20

（F）StudentService 接口

public interface StudentService { 
 
 /** 
 * 获取学生总人数 
 * @return 
 */ 
 Long queryAllStudentCount(); 
} 
1
2
3
4
5
6
7
8

（G）在 StudentServiceImpl 中注入 RedisTemplate，并编写根据 id获取学生的方法

配置了上面的步骤，Spring Boot 将自动配置 RedisTemplate，在需要操作 redis 的类中注入 redisTemplate 即可。
注意：Spring Boot 帮我们注入 RedisTemplate 类，泛型里面只能写、或者什么都不写。

@Service 
public class StudentServiceImpl implements StudentService { 
 
 @Autowired 
 private StudentMapper studentMapper; 
 
 @Autowired 
 private RedisTemplate redisTemplate; 
 
 @Override 
 public Long queryAllStudentCount() { 
 
 //设置 redisTemplate 对象 key 的序列化方式 
 redisTemplate.setKeySerializer(new StringRedisSerializer()); 
 
 //从 redis 缓存中获取总人数 
 Long allStudentCount = (Long) redisTemplate.opsForValue().get("allStudentCount"); 
 //判断是否为空 
 if ( allStudentCount==null) { 
 //去数据库查询，并存放到 redis 缓存中 
 
 allStudentCount = studentMapper.selectAllStudentCount(); 
 
redisTemplate.opsForValue().set("allStudentCount",allStudentCount,15,TimeUnit.SECONDS); 
 } 
 return allStudentCount; 
 } 
} 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28

（H）StudentMapper 接口

@Mapper
public interface StudentMapper {
 /** 
 * 获取学生总人数 
 * @return 
 */ 
 Long selectAllStudentCount(); 
}
1
2
3
4
5
6
7
8

（I）StudentMapper 映射文件

（J）启动类 Application

在 SpringBoot 启动类上添加扫描数据持久层的注解并指定扫描包：

@SpringBootApplication 
@MapperScan(basePackages = "com.abc.springboot.mapper")//扫描数据持久层 
public class Application { 
 
 public static void main(String[] args) { 
 SpringApplication.run(Application.class, args); 
 } 
 
} 
1
2
3
4
5
6
7
8
9

（K）让 Student 类实现序列化接口（可选）

在类名上 Alt + 回车，如果没有提示生成序列化 id，那么需要做如下的配置：

（L）启动 SpringBoot 应用，访问测试

先自我介绍一下，小编13年上师交大毕业，曾经在小公司待过，去过华为OPPO等大厂，18年进入阿里，直到现在。深知大多数初中级java工程师，想要升技能，往往是需要自己摸索成长或是报班学习，但对于培训机构动则近万元的学费，着实压力不小。自己不成体系的自学效率很低又漫长，而且容易碰到天花板技术停止不前。因此我收集了一份《java开发全套学习资料》送给大家，初衷也很简单，就是希望帮助到想自学又不知道该从何学起的朋友，同时减轻大家的负担。添加下方名片，即可获取全套学习资料哦

相关阅读:
2022 9.8 模拟
 git 介绍，入门举例
 TikTok本周动态，TikTok Shop新加坡首场大促将于本月举行
 基于SSM的药品管理系统的设计与实现
 数学建模笔记-第九讲-分类模型-逻辑回归
 OA问题的解决方法
 一文带您快速了解工业交换机
 2013年108计网
 鸿蒙harmony天气预报Demo
Iceberg源码学习：flink读iceberg流程二
原文地址：https://blog.csdn.net/m0_67403076/article/details/126115103