Spring的学习与实战
目录
一、Spring起步
- Spring早已经成为企业级开发的业界标准，尤其是Spring Boot 2.0、Spring 5发布后，Spring的生态系统引领了技术架构发展的潮流，对于Java开发人员，深入掌握Spring全家桶的各种框架应用及必要的底层原理知识，是一件非常重要的事情。
学习路线图
Spring的基础知识
什么是Spring
Spring的核心是提供了一个容器（container），通常称为Spring应用上下文（Spring application context），它们会创建和管理应用组件。这些组件也可以称为bean，会在Spring应用上下文中装配在一起，从而形成一个完整的应用程序。
将bean装配在一起的行为是通过一种基于依赖注入（dependency injection，DI）的模式实现的。此时，组件不会再去创建它所依赖的组件并管理它们的生命周期，使用依赖注入的应用依赖于单独的实体（容器）来创建和维护所有的组件，并将其注入到需要它们的bean中。通常，这是通过构造器参数和属性访问方法来实现的。
Spring框架核心模块
SpringBoot
在历史上，一般通过两种配置方式为Spring应用上下文提供Bean
- 使用一个或多个XML文件描述bean
- 使用@Configuration注解会告知Spring这是一个配置类
随着Spring Boot 2.x的引入，Spring自动配置的能力已经大大加强，Spring Boot能够基于类路径中的条目、环境变量和其他因素合理猜测需要配置的组件并将它们装配在一起。Java程序员尽可能多地使用Spring Boot，只有在必要的时候才使用显式配置。
第一个Spring应用DEMO
- 在IntelliJ IDEA中创建新项目
- 通过地址为//start.spring.io/初始化项目；
- 指定项目通用信息：
- 选择项目Starter：
- 生成的项目结构：
- maven规范
<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="//maven.apache.org/POM/4.0.0" xmlns:xsi="//www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="//maven.apache.org/POM/4.0.0 //maven.apache.org/xsd/maven-4.0.0.xsd">
<modelVersion>4.0.0</modelVersion>
<parent>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-parent</artifactId>
<version>2.3.1.RELEASE</version>
<relativePath/> <!-- lookup parent from repository -->
</parent>
<groupId>com.example</groupId>
<artifactId>demo</artifactId>
<version>0.0.1-SNAPSHOT</version>
<name>demo</name>
<description>Demo project for Spring Boot</description>
<properties>
<java.version>1.8</java.version>
</properties>
<dependencies>
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-web</artifactId>
</dependency>
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-test</artifactId>
<scope>test</scope>
<exclusions>
<exclusion>
<groupId>org.junit.vintage</groupId>
<artifactId>junit-vintage-engine</artifactId>
</exclusion>
</exclusions>
</dependency>
</dependencies>
<build>
<plugins>
<plugin>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-maven-plugin</artifactId>
</plugin>
</plugins>
</build>
</project>
可参见本人博客《Maven POM( Project Object Model，项目对象模型 )》及《一图说清maven常见要素》这两篇文章。
- 入口类
/**
* SpringBoot应用
*/
@SpringBootApplication
public class DemoApplication {
public static void main(String[] args) {
// 运行应用
SpringApplication.run(DemoApplication.class, args);
}
}
@SpringBootApplication是一个组合注解，它组合了3个其他的注解。
- @SpringBootConfiguration：将该类声明为配置类。尽管这个类目前还没有太多的配置，但是后续我们可以按需添加基于Java的Spring框架配置。这个注解实际上是@Configuration注解的特殊形式。
- @EnableAutoConfiguration：启用Spring Boot的自动配置。我们随后会介绍自动配置的更多功能。就现在来说，我们只需要知道这个注解会告诉SpringBoot自动配置它认为我们会用到的组件。
- @ComponentScan：启用组件扫描。这样我们能够通过@Component@Controller、@Service这样的注解声明其他类，Spring会自动发现它们并将它们注册为Spring应用上下文中的组件。
8. 测试类
// SpringBoot测试
@SpringBootTest
class DemoApplicationTests {
// 测试方法
@Test
void contextLoads() {
}
}
- 程序启动
编写自己的第一个SpringMVC例子
- 第一个Controller
index()是一个简单的控制器方法。它带有@GetMapping注解，表明如果针对“/”发送HTTP GET请求，那么这个方法将会处理请求。该方法所做的只是返回String类型的index值，该控制器方法中还通过Spring自动注入IndexService服务组件，及调用服务组件方法。
/**
* 第一个SpringMVC程序--Controller层
*
* @author zhuhuix
* @date 2020-07-02
*/
@Controller
public class IndexController {
// Spring注入服务组件
@Autowired
private IndexService indexService;
@GetMapping("/")
public String index(Model model) {
String index = indexService.getIndex();
model.addAttribute("index", index);
// 返回视图 即index.html
return "index";
}
}
- 第一个Service
getIndex()是一个简单的服务方法。该方法所做的只是返回String类型的index值，该服务组件供控制层调用。
/**
* 第一个SpringMVC程序--Service层
* * @author zhuhuix
* @date 2020-07-02
*/
@Service
public class IndexService {
public String getIndex() {
return "hello world!!!";
}
}
- 第一个View
— 使用Thymeleaf模板引擎
### application.properties
###ThymeLeaf配置
spring:
thymeleaf:
#模板的模式，支持 HTML, XML TEXT JAVASCRIPT
mode: HTML5
#编码 可不用配置
encoding: UTF-8
#内容类别,可不用配置
content-type: text/html
#开发配置为false,避免修改模板还要重启服务器
cache: false
#配置模板路径，默认是templates，可以不用配置
prefix: classpath:/templates
— 定义index.html视图层
<!DOCTYPE html>
<html xmlns:th="//www.thymeleaf.org" >
<head>
<meta charset="UTF-8"/>
<title>Title</title>
</head>
<body>
<p th:text="${index}" />
</body>
</html>
- 运行测试
尝试使用Spring Boot DevTools
•代码变更后应用会自动重启；
•当面向浏览器的资源（如模板、JavaScript、样式表）等发生变化时，会自动刷新浏览器
- pom.xml
<dependencies>
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-devtools</artifactId>
<optional>true</optional>
<scope>runtime</scope>
</dependency>
...
</dependencies>
<build>
<plugins>
<plugin>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-maven-plugin</artifactId>
<configuration>
<!--fork : devtools生效必须设置成true -->
<fork>true</fork>
</configuration>
</plugin>
</plugins>
</build>
- idea设置
— 需勾选Build project automaticallty
— ctrl+alt+shift+/ :Registry 中第一项必须打勾
Spring起步小结
- Spring核心框架：Spring核心框架是Spring领域中一切的基础。它提供了核心容器和依赖注入框架。
- Spring Boot：Spring Boot构建在Spring之上，通过简化依赖管理、自动配置和运行时洞察，使Spring更加易用；
- Spring MVC：我们通过SpringBoot初始化生成的框架上加入Controller,Service,View的分层，编写了第一个Spring MVC程序，并成功运行。
- 使用Idea开发环境，安装Spring Boot DevTools并进行配置，提高了开发效率。
二、基于SpringMVC开发web应用
. 在上一小节中创建了第一个DEMO，本章将继续基于SpringMVC框架构建我们的web应用，该应用需要实现用户登记，具体实现步骤如下：
- 创建用户的数据模型；
- 在服务层编写用户登记的业务逻辑；
- 生成为Web浏览器提供用户登记内容的控制器
- 在视图层运用模板引擎展示数据及校验表单输入
创建数据模型
- 创建一个用户类，定义用户id,用户名称，邮箱三个属性；
- 添加默认构造方法与全属性构造方法；
- 对用户属性添加对应getter,setter方法；
/**
* 基于SpringMVC框架开发web应用--用户类
*
* @author zhuhuix
* @date 2020-07-03
*/
public class User implements Serializable {
// 用户id
private Long id;
// 用户名
private String name;
// 邮箱
private String email;
User(){ }
public User(Long id, String name, String email) {
this.id = id;
this.name = name;
this.email = email;
}
public Long getId() {
return id;
}
public void setId(Long id) {
this.id = id;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public String getEmail() {
return email;
}
public void setEmail(String email) {
this.email = email;
}
}
创建业务逻辑
- 实现返回所有用户数据的列表
- 实现增加用户的功能
/**
* 基于SpringMVC框架开发web应用--用户服务类
*
* @author zhuhuix
* @date 2020-07-03
*/
@Service
public class UserService {
public static ArrayList<User> users = new ArrayList<>();
// mock数据
public UserService() {
users.add(new User(1L, "Mike", "[email protected]"));
users.add(new User(2L, "Jack", "[email protected]"));
users.add(new User(3L, "Kate", "[email protected]"));
users.add(new User(4L, "Mary", "[email protected]"));
users.add(new User(5L, "Rose", "[email protected]"));
}
// 返回所有的用户
public List<User> listUsers() {
return users;
}
// 增加用户
public User saveUser(User user) {
user.setId(users.size() + 1L);
users.add(user);
return user;
}
}
创建控制器
在Spring MVC框架中，控制器是重要的参与者。它们的主要职责是处理HTTP请求传递给视图以便于渲染HTML（浏览器展现）。
- SpirngMVC的请求注解
| 注解 | 描述 |
|---|---|
| @RequestMapping | 通用的请求 |
| @GetMapping | 处理HTTP GET请示 |
| @PostMapping | 处理HTTP POST请示 |
| @PutMapping | 处理HTTP PUT请示 |
| @DeleteMapping | 处理HTTP DELETE请示 |
- 用户控制器的处理内容
— 处理路径为“/user”的HTTP GET请求，向服务层调用返回所有用户数据列表的接口，获取数据后传递给对应的视图模板，并发送给发起请求的Web浏览器。
— 处理路径为“/user”的HTTP POST请求，向服务层调用增加用户的接口，处理成功后调用路径为“/user”的HTTP GET请求，并发送给发起请求的Web浏览器。
— 处理路径为“/user/form”的HTTP GET请求，产生一个新用户数据模型，并调用对应的视图模板，发送给发起请求的Web浏览器。
/**
* 基于SpringMVC框架开发web应用--用户控制器
*
* @author zhuhuix
* @date 2020-07-03
*/
@RestController
@RequestMapping("/user")
public class UserController {
@Autowired
private UserService userService;
// 保存用户并返回到用户列表页面
@PostMapping
public ModelAndView saveUser(User user) {
userService.saveUser(user);
return new ModelAndView("redirect:/user");//重定向到list页面
}
// 获取创建用户表单页面
@GetMapping("/form")
public ModelAndView createForm(Model model) {
model.addAttribute("user",new User());
return new ModelAndView("register","userModel",model);
}
// 获取用户列表页面
@GetMapping
public ModelAndView list(Model model) {
model.addAttribute("userList", userService.listUsers());
return new ModelAndView("userlist", "userModel", model);
}
}
设计视图模板
- 设计一个用户列表的视图模板
— Thymeleaf提供了一个属性“th:each”，它会迭代一个元素集合，为集合中的每个条目渲染HTML，我们可以利用这个属性，设计出用户的列表视图
<!DOCTYPE html>
<html xmlns:th="//www.thymeleaf.org"
xmlns:layout="//www.ultrag.net.nz/thymeleaf/layout"
>
<head>
<meta charset="UTF-8">
</head>
<body>
<h3>用户列表</h3>
<div>
<a th:href="@{/user/form}">创建用户</a>
</div>
<table border="1">
<thead>
<tr>
<td>ID</td>
<td>Email</td>
<td>Name</td>
</tr>
</thead>
<tbody>
<tr th:if="${userModel.userList.size()} eq 0">
<td colspan="3">没有用户信息！</td>
</tr>
<tr th:each="user:${userModel.userList}">
<td th:text="${user.id}"></td>
<td th:text="${user.email}"></td>
<td th:text="${user.name}"></td>
</tr>
</tbody>
</table>
</body>
</html>
- 设计一个提交新用户的视图模板
— 用户通过这个视图，录用名称与邮箱地址，提交新用户的信息。
<!DOCTYPE html>
<html xmlns:th="//www.thymeleaf.org"
xmlns:layout="//www.ultrag.net.nz/thymeleaf/layout"
>
<head>
<meta charset="UTF-8">
</head>
<body>
<h3>登记用户</h3>
<form action="/users" th:action="@{/user}" method="POST" th:object="${userModel.user}">
<input type="hidden" name="id" th:value="*{id}">
名称：<br>
<input type="text" name="name" th:value="*{name}">
<br>
邮箱：<br>
<input type="text" name="email" th:value="*{email}">
<input type="submit" value="提交" >
</form>
</body>
</html>
运行Web应用
- 到目前为止，我们已经开发了User用户模型、UserService用户服务类、UserController控制器、userlist用户列表视图模板、register用户登记视图模板，接下来我们可以尝试运行一下。打开浏览器并访问//localhost:8080/user。
- 点击页面上的创建用户，登记新用户，并提交
该web应用一切运行正常。
表单校验
虽然我们已经实现了用户列表与登记新用户，但视图层还存在漏洞，比如用户名称为空的时候不能保存，邮箱输入格式要符合规则，所以程序要对表单输入的内容进行校验。
- 引入Validation API与Hibernate的Validation API 依赖
<dependency>
<groupId>org.hibernate.validator</groupId>
<artifactId>hibernate-validator</artifactId>
<version>6.0.13.Final</version>
</dependency>
<dependency>
<groupId>javax.validation</groupId>
<artifactId>validation-api</artifactId>
<version>2.0.1.Final</version>
</dependency>
- 在要被校验的类上声明校验规则：即在User类上声明校验规则。
public class User implements Serializable {
// 用户id
@NotNull
private Long id;
// 用户名
@NotBlank(message = "用户名称不能为空")
private String name;
// 邮箱
@Pattern(message ="邮箱格式不符", regexp = "^[A-Za-z0-9\\u4e00-\\u9fa5]+@[a-zA-Z0-9_-]+(\\.[a-zA-Z0-9_-]+)+$")
private String email;
...
}
- 在控制器方法中声明要进行校验：即在UserController类的saveUser上增加用户数据的校验规则。
@RestController
@RequestMapping("/user")
public class UserController {
@Autowired
private UserService userService;
// 保存用户并返回到用户列表页面
@PostMapping
public ModelAndView saveUser(@Valid User user, Errors errors,Model model) {
if (errors.hasErrors()){
model.addAttribute("user",user);
if (errors.getFieldError("name")!=null) {
model.addAttribute("nameError", errors.getFieldError("name").getDefaultMessage());
}
if (errors.getFieldError("email")!=null) {
model.addAttribute("emailError", errors.getFieldError("email").getDefaultMessage());
}
return new ModelAndView("register","userModel",model);
}
userService.saveUser(user);
//重定向到list页面
return new ModelAndView("redirect:/user");
}
...
}
- 修改register表单视图以展现校验错误。
<!DOCTYPE html>
<html xmlns:th="//www.thymeleaf.org">
<head>
<meta charset="UTF-8">
</head>
<body>
<h3>登记用户</h3>
<form action="/users" th:action="@{/user}" method="POST" th:object="${userModel.user}">
<input type="hidden" name="id" th:value="*{id}">
名称：<br>
<input type="text" name="name" th:value="*{name}" >
<br>
邮箱：<br>
<input type="text" name="email" th:value="*{email}">
<br>
<input type="submit" value="提交" >
<div style="color:red" th:text="${nameError}"></div>
<div style="color:red" th:text="${emailError}"></div>
</form>
</body>
</html>
展现校验错误
基于SpringMVC开发web应用小结
- Spring提供了一个强大Spring MVC的Web框架。
- Spring MVC是基于注解的，通过像@RequestMapping、@GetMapping和@PostMapping这样的注解来启用请求处理方法的声明。
- 请求处理方法返回一个Thymeleaf模板，同时会带有模型数据。
- Spring MVC支持表单校验。
三、实现数据持久化
. 在上一小节中基于SpringMVC框架构建了我们的web应用，并在视图层运用模板引擎展示数据及校验表单输入，本章将使用JdbcTemplate及Spring Data实现数据持久化的操作。
数据库
- 一说到数据的持久化，首选方案就是关系型数据库，本文将使用互联网领域最常用mysql数据库。
MySQL 最流行的关系型数据库管理系统，MySQL所使用的 SQL 语言是用于访问数据库的最常用标准化语言，MySQL由于性能高、成本低、可靠性好，已经成为最流行的开源数据库，因此被广泛地应用在互联网领域中。
建立用户信息登记表
- 根据用户信息模型类，设计用户信息登录表
DROP DATABASE IF EXISTS user_info;
CREATE DATABASE user_info
DEFAULT CHARACTER SET utf8
DEFAULT COLLATE utf8_general_ci;
use user_info;
SET NAMES utf8mb4;
SET FOREIGN_KEY_CHECKS = 0;
-- ----------------------------
-- Table structure for user
-- ----------------------------
DROP TABLE IF EXISTS `user`;
CREATE TABLE `user` (
`id` bigint(20) NOT NULL AUTO_INCREMENT,
`name` varchar(255) CHARACTER SET utf8 COLLATE utf8_general_ci NULL DEFAULT NULL,
`email` varchar(255) 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;
SET FOREIGN_KEY_CHECKS = 1;
Web应用项目集成mysql
- 增加依赖
<!--Mysql依赖包-->
<dependency>
<groupId>mysql</groupId>
<artifactId>mysql-connector-java</artifactId>
<version>5.1.47</version>
<scope>runtime</scope>
</dependency>
<!-- 数据库连接池:druid数据源驱动 -->
<dependency>
<groupId>com.alibaba</groupId>
<artifactId>druid-spring-boot-starter</artifactId>
<version>1.1.10</version>
</dependency>
- Spring配置
#配置数据源
spring.datasource.type=com.alibaba.druid.pool.DruidDataSource
spring.datasource.username=root
spring.datasource.password=root
spring.datasource.url=jdbc:mysql://user_info?serverTimezone=Asia/Shanghai&characterEncoding=utf8&useSSL=false&allowPublicKeyRetrieval=true
使用JdbcTemplate实现数据持久化
Spring对JDBC的支持要归功于JdbcTemplate类。JdbcTemplate提供了一种特殊的方式，通过这种方式，开发人员在对关系型数据库执行SQL操作的时候能够避免使用JDBC时常见的繁文缛节和样板式代码。
- 增加依赖
<!-- JDBC -->
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-jdbc</artifactId>
</dependency>
- 修改UserService业务逻辑
/**
* 基于SpringMVC框架开发web应用--用户服务类
*
* @author zhuhuix
* @date 2020-07-03
* @date 2020-07-04 增加通过jdbcTemplate处理数据
*/
@Service
public class UserService {
@Autowired
private JdbcTemplate jdbcTemplate;
// 返回所有的用户
public List<User> listUsers() {
return jdbcTemplate.query("select id,name,email from user;",
new Object[]{}, new BeanPropertyRowMapper<>(User.class));
}
// 增加用户
public int saveUser(User user) {
return jdbcTemplate.update("insert into user(name,email) values(?,?);"
, user.getName(), user.getEmail());
}
}
再次运行Web应用
-
我们只修改了UserService用户服务类；控制器、视图模板都未做任何改变，接下来我们可以再次尝试运行一下。打开浏览器并访问//localhost:8080/user。
-
输入用户信息并提交
-
查看数据库用户信息表
实现数据持久化小结
相对于普通的JDBC，Spring的JdbcTemplate能够极大地简化关系型数据库的使用。但是，你会发现使用JPA会更加简单。接下来我们会继续通过Spring Data框架让数据持久化变得更简单。
四、使用Spring Data实现数据持久化
在上篇文章中，我们使用mysql数据库与JdbcTemplate简单实现了数据持久化操作，并对web程序进行了测试，本篇文章将继续通过Spring Data框架让数据持久化变得更简单。
Spring Data
- Spring Data是一个用于简化数据库访问，并支持云服务的开源框架。其主要目标是使得数据库的访问变得方便快捷，常用的子项目有：
Spring Data JDBC -数据访问组件对JDBC的支持。
Spring Data JPA：-基于关系型数据库进行JPA持久化。
Spring Data MongoDB – 持久化到Mongo文档数据库。
Spring Data Redis-持久化到Redis key-value内存数据库。
Spring Data REST：通过Spring Data数据访问组件导出为RESTful资源。
Spring Data Cassandra：持久化到Cassandra数据库。
四、使用Spring Data JPA持久化数据
- 本文会基于原JDBC的实现替换为使用SpringData JPA的repository
添加JPA starter依赖
<!--pom.xml-->
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-data-jpa</artifactId>
</dependency>
修改实体类，添加JPA映射注解
- 首先我们给原来的user表增加两个时间字段
ALTER TABLE user ADD COLUMN create_time DATETIME;
ALTER TABLE user ADD COLUMN update_time DATETIME;
- 修改user.class
— 给user类添加@Entity注解，声明为JPA实体
— 给id字段添加@Id注解将其指定为数据库中唯一标识该实体的属性
— 给id字段添加@GeneratedValue注解，依赖数据库自动生成ID值
— 给其它字段添加@Column注解，并声明对应user表中的字段名称
— 增加createTime成员,添加@CreationTimestamp注解，使用该注解可以让Hibernate在插入数据时对注解的属性对应的日期类型创建默认值
— 增加updateTime成员，添加@UpdateTimestamp注解，使用该注解可以让Hibernate在更新数据时对注解的属性对应的日期类型进行更新
/**
* 基于SpringMVC框架开发web应用--用户类
*
* @author zhuhuix
* @date 2020-07-03
* @date 2020-07-07 添加JPA映射注解
*/
@Entity
public class User implements Serializable {
// 用户id
@Id
@GeneratedValue(strategy = GenerationType.IDENTITY)
private Long id;
// 用户名
@NotBlank(message = "用户名称不能为空")
@Column(name="name")
private String name;
// 邮箱
@Column(name="email")
@Pattern(message ="邮箱格式不符", regexp = "^[A-Za-z0-9\\u4e00-\\u9fa5]+@[a-zA-Z0-9_-]+(\\.[a-zA-Z0-9_-]+)+$")
private String email;
// 创建时间
@Column(name = "create_time")
@CreationTimestamp
private Timestamp createTime;
// 更新时间
@Column(name = "update_time")
@UpdateTimestamp
private Timestamp updateTime;
public User(Long id, String name, String email) {
this.id = id;
this.name = name;
this.email = email;
}
public Long getId() {
return id;
}
public void setId(Long id) {
this.id = id;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public String getEmail() {
return email;
}
public void setEmail(String email) {
this.email = email;
}
}
声明JPA repository接口
- 借助Spring Data JPA，我们可以通过继承CrudRepository接口，快速定义应用的数据层。CrudRepository定义并实现了很多用于CRUD（创建、读取、更新、删除）操作的方法，我们根本就不用编写实现类！当应用启动的时候，Spring DataJPA会在运行期自动生成实现类。这意味着，我们现在就可以在服务层直接设用repository的增删改查操作了。
/**
* 基于SpringMVC框架开发web应用--数据操作层
*
* @author zhuhuix
* @date 2020-07-07
*/
public interface UserRepository extends CrudRepository<User,Long> {
}
服务层repository
- 接下来我们在UserService层直接调用UserRepository中由Spring Data JPA提供的各种方法，实现查询及增加用户信息。
/**
* 基于SpringMVC框架开发web应用--用户服务类
*
* @author zhuhuix
* @date 2020-07-03
* @date 2020-07-04 增加通过jdbcTemplate处理数据
* @date 2020-07-07 将jdbcTemplate处理数据程序改为Spring Data JPA的处理方式
*/
@Service
public class UserService {
@Autowired
private UserRepository userRepository;
// 返回所有的用户
public List<User> listUsers() {
return (List<User>) userRepository.findAll();
}
// 增加用户
public User saveUser(User user) {
return userRepository.save(user);
}
}
再次运行Web应用
-
我们增加了数据层并修改了UserService服务层；控制器、视图模板都未做任何改变，接下来我们可以再次尝试运行一下。打开浏览器并访问//localhost:8080/user。
-
输入用户信息并提交
-
查看数据库用户信息表
-
测试结论：通过将JdbcTemplate替换成Spring Data JPA,同样实现了用户信息的查询与增加，而且通过JPA CrudRepository接口，我们没有书写一行SQL语句，也实现了数据的增加与查询。
自定义JPA repository
- 除了CrudRepository提供的基本CRUD操作之外，还需要通过用户名称或邮箱地址查找用户信息，那我们需要添加如下的方法声明到UserRepository中:
public interface UserRepository extends CrudRepository<User,Long> {
// 自定义添加通过用户名称查找用户信息
List<User> findByName(String name);
}
按照Spring Data的规范的规定，查询方法以find | read | get开头（比如 find、findBy、read、readBy、get、getBy），涉及查询条件时，条件的属性用条件关键字连接，要注意的是：条件属性以首字母大写。框架在进行方法名解析时，会先把方法名多余的前缀截取掉，然后对剩下部分进行解析。
直接在接口中定义查询方法，如果是符合规范的，可以不用写实现，即不用写SQL。
服务层增加查找接口
@Service
public class UserService {
@Autowired
private UserRepository userRepository;
...
// 根据名称查找用户
public List<User> searchUser(String name){
return userRepository.findByName(name);
}
}
控制器增加用户查找功能
/**
* 基于SpringMVC框架开发web应用--用户控制器
*
* @author zhuhuix
* @date 2020-07-03
* @date 2020-07-07 增加用户查找
*/
@RestController
@RequestMapping("/user")
public class UserController {
@Autowired
private UserService userService;
...
// 查找输入页面
@GetMapping("/index")
public ModelAndView index(Model model) {
model.addAttribute("user", new User());
return new ModelAndView("index", "userModel", model);
}
// 查找提交并跳转用户列表
@PostMapping("/search")
public ModelAndView search(@ModelAttribute User user, Model model) {
model.addAttribute("userList", userService.searchUser(user.getName()));
return new ModelAndView("userlist", "userModel", model);
}
}
视图层增加用户查找页面
<!-- index.html-->
<!DOCTYPE html>
<html xmlns:th="//www.thymeleaf.org" >
<head>
<meta charset="UTF-8"/>
<title>Title</title>
</head>
<body>
<h3>查找用户</h3>
<form action="/users" th:action="@{/user/search}" method="POST" th:object="${userModel.user}">
名称：<br>
<input type="text" name="name" th:value="*{name}" >
<br>
<input type="submit" value="查询" >
</form>
</body>
</html>
查找功能测试
使用Spring Data实现数据持久化小结
- Spring Data JPA能够极大地简化JPA持久化，我们只需编写repository接口即可;
- Spirng Data 对于实体类可以通过各种注解进行数据的管理：比如@Id ,@Column,@CreationTimestamp等等
- 只需要符合JPA的接口命名规则，我们可以自定义JPA repository各种对于数据的操作方法：比如findBy… ,findAllBy…,findBy..And..等。
五、使用Spring Security安全框架保护web应用
- 在前四篇文章中已经实现了一个非常简单的用户邮箱登记的web应用，并将数据保存到mysql数据库中。但这个web应用涉及的数据展示、查询及操作都是开放的，如果部署在互联网上，可以访问应用的人员都可随意增加及查询数据，这显然是不符合安全要求的。
作为软件开发人员，我们必须采取措施来保护应用程序中的信息。
启用Spring Security
Spring Security是一个功能强大且高度可定制的身份验证和访问控制框架。它是用于保护基于Spring的应用程序的标准。
本文将通过Spring Security配置实现web应用的如下功能：
- 实现页面的WEB安全保护
- 实现管理员的帐户注册
- 实现登录验证的完整流程
Spring Security的基本登录认证
- 在pom.xml文件中添加依赖
<!-- Spring Security-->
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-security </artifactId>
</dependency>
通过将security starter添加到项目的构建文件中，我们得到了如下的安全特性：
- 所有的HTTP请求路径都需要认证；
- 不需要特定的角色和权限；
- 没有登录页面；
- 认证过程是通过HTTP basic认证对话框实现的；
- 系统只有一个用户，用户名为user。
我们试着启动一下应用，并访问用户列表页面，发现程序竟然跳转到了一个login登录页面，并要求输入用户和密码。
这是一个HTTP basic认证对话框，提示进行认证。要想通过这个认证，需要一个用户名和密码。用户名为user，而密码则是随机生成的，可以在日志监控界面上查到：
我们试着在登录界面上输入用户名user与图中的密码，进行认证登录：
程序顺利通过了密码认证，并进入到用户列表界面。但显然以上的方式是不符合需求的，我们需要的是：
- 通过自定义的登录页面来提示管理员用户进行认证；
- 提供一个注册页面，新管理员用户能够注册；
- 对不同的请求路径，执行不同的安全规则。比如注册页面不需要进行认证，其他页面需要进行认证。
使用Spring Security实现自定义用户认证
增加管理员实体类
-- ----------------------------
-- Table structure for admin
-- ----------------------------
DROP TABLE IF EXISTS `admin`;
CREATE TABLE `admin` (
`id` bigint(20) NOT NULL AUTO_INCREMENT,
`user_name` varchar(255) CHARACTER SET utf8 COLLATE utf8_general_ci NULL DEFAULT NULL,
`user_password` varchar(255) 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;
SET FOREIGN_KEY_CHECKS = 1;
/**
* 基于SpringMVC框架开发web应用--管理员用户类,用于登录认证
*
* @author zhuhuix
* @date 2020-07-08
*/
@Entity
public class Admin implements UserDetails {
// 管理员id
@Id
@GeneratedValue(strategy = GenerationType.IDENTITY)
private Long id;
@Column(name="user_name")
private String userName;
@Column(name="user_password")
private String userPassword;
@Override
public Collection<? extends GrantedAuthority> getAuthorities() {
return Arrays.asList(new SimpleGrantedAuthority("ROLE_USER"));
}
@Override
public String getPassword() {
return userPassword;
}
@Override
public String getUsername() {
return userName;
}
@Override
public boolean isAccountNonExpired() {
return true;
}
@Override
public boolean isAccountNonLocked() {
return true;
}
@Override
public boolean isCredentialsNonExpired() {
return true;
}
@Override
public boolean isEnabled() {
return true;
}
public Long getId() {
return id;
}
public void setId(Long id) {
this.id = id;
}
public void setUserName(String userName) {
this.userName = userName;
}
public void setUserPassword(String userPassword) {
this.userPassword = userPassword;
}
}
- 管理员类实现了Spring Security的UserDetails接口。通过实现UserDetails接口，我们能够提供更多信息给框架，比如用户都被授予了哪些权限以及用户的账号是否可用。
- getAuthorities()方法返回用户被授予权限的一个集合。各种is…Expired()方法要返回一个boolean值，表明用户的账号是否可用或过期。
使用Spring Data JPA定义管理员的持久化接口
/**
* 基于SpringMVC框架开发web应用--管理员数据操作层
*
* @author zhuhuix
* @date 2020-07-08
*/
public interface AdminRepository extends CrudRepository<Admin,Long> {
// 根据用户名查找管理员
Admin findByUserName(String username);
}
创建获取管理员详情信息的服务层
/**
* 基于SpringMVC框架开发web应用--管理员服务层
*
* @author zhuhuix
* @date 2020-07-08
*/
@Service
public class AdminService implements UserDetailsService {
private final Logger logger = LoggerFactory.getLogger(Logger.class);
@Autowired
private AdminRepository adminRepository;
@Override
public UserDetails loadUserByUsername(String s) throws UsernameNotFoundException {
Admin admin = adminRepository.findByUserName(s);
if (admin == null) {
logger.error("管理员" + s + "未找到");
throw new UsernameNotFoundException("User " + s + "not found");
}
return admin;
}
// 保存管理员
public Admin save(Admin admin){
return adminRepository.save(admin);
}
}
配置Spring Security
/**
* Spring Security配置类
*
* @author zhuhuix
* @date 2020-07-08
*/
@Configuration
@EnableWebSecurity
public class WebSecurityConfig extends WebSecurityConfigurerAdapter {
@Autowired
private AdminService adminService;
@Override
protected void configure(AuthenticationManagerBuilder authenticationManagerBuilder) throws Exception {
authenticationManagerBuilder
.userDetailsService(adminService)
.passwordEncoder(new BCryptPasswordEncoder());
}
}
测试自定义的登录验证方法
以上通过建立管理员信息表，及通过JPA定义数据处理层，编写获取管理员信息的服务实现，最后配置Spring Security Web安全类，实现了自定义的登录验证方法，下面具体来测试一下：
web应用程序已经实现了自定义的用户登录验证。
实现管理员的注册
- 以上虽然完成了管理员的登录验证，但没有涉及管理员的添加，以下需要完成管理员注册流程。
管理员注册控制器
/**
* 基于SpringMVC框架开发web应用--管理员注册控制器
*
* @author zhuhuix
* @date 2020-07-08
*/
@RestController
@RequestMapping("/admin")
public class AdminController {
@Autowired
private AdminService adminService;
// 管理注册页
@GetMapping
public ModelAndView registerForm(Model model) {
model.addAttribute("admin", new Admin());
return new ModelAndView("registration", "adminModel", model);
}
// 提交注册信息
@PostMapping("/register")
public ModelAndView save(Admin admin) {
BCryptPasswordEncoder bCryptPasswordEncoder =new BCryptPasswordEncoder();
admin.setUserPassword(bCryptPasswordEncoder.encode(admin.getPassword()));
if (adminService.save(admin) != null) {
return new ModelAndView("redirect:/login ");
} else {
return null;
}
}
}
管理员注册页面
<!DOCTYPE html>
<html xmlns:th="//www.thymeleaf.org">
<head>
<meta charset="UTF-8">
</head>
<body>
<h3>管理员注册</h3>
<form action="/admin" th:action="@{/admin/register}" method="POST" th:object="${adminModel.admin}">
名称：<br>
<input type="text" name="userName" th:value="*{userName}" >
<br>
输入密码：<br>
<input type="password" name="userPassword" th:value="*{userPassword}">
<br>
<input type="submit" value="注册" >
</form>
</body>
</html>
配置保护Web请求的安全性规则
- 以上完成了管理员注册的业务逻辑、控制层、与页面视图，但如果我们直接访问管理员注册页面的时候，web应用程序仍然会跳转到login页面，要求输入用户名和密码，这显然不符合需求，我们只需要对需要认证的页面进行登录验证保护，对于注册页面是开放的，所以我们需要配置保护web请求的安全性规则：
/**
* Spring Security配置类
*
* @author zhuhuix
* @date 2020-07-08
*/
@Configuration
@EnableWebSecurity
public class WebSecurityConfig extends WebSecurityConfigurerAdapter {
@Autowired
private AdminService adminService;
// 自定义用户验证
@Override
protected void configure(AuthenticationManagerBuilder authenticationManagerBuilder) throws Exception {
authenticationManagerBuilder
.userDetailsService(adminService)
.passwordEncoder(new BCryptPasswordEncoder());
}
// 保护web请求的安全性规则
@Override
protected void configure(HttpSecurity http) throws Exception{
http.authorizeRequests()
.antMatchers("/user/**").access("hasRole('ROLE_USER')")
.antMatchers("/admin/**").permitAll()
.and().formLogin().defaultSuccessUrl("/user")
.and().httpBasic();
}
}
完整测试
- 访问管理员注册页面进行注册
- 使用注册的管理员帐户进行登录验证
使用Spring Security安全框架保护web应用小结
- Spring Security的自动配置是实现基本安全性功能的好办法，但是大多数的应用都需要自定义安全规则，这样才能满足特定的安全需求。
- 认证用户详情信息可以通过自定义用户存储机制进行管理，它的后端可以是关系型数据库。
- 注意：以上实现功能有不完全处：如管理员注册时，需在页面进行密码的两次确认，服务层需判断帐户名是否存在等，请大家借鉴使用。
六、Spring的配置属性
- 本小节将了解Spring的配置属性及完成自定义的配置
Spring的环境抽象(Environment)
Spring的环境抽象是各种配置属性的一站式服务。它抽取了原始的属性，这样需要这些属性的bean就可以从Spring本身中获取了。Spring环境会拉取多个属性源，包括：
- JVM系统属性；
- 操作系统环境变量；
- 命令行参数；
- 应用属性配置文件。
通过应用属性配置文件完成Spring的环境配置
- 我们回顾下原web应用中的application.properties文件：
###数据源配置
spring.datasource.type=com.alibaba.druid.pool.DruidDataSource
spring.datasource.username=root
spring.datasource.password=root
spring.datasource.driver-class-name=net.sf.log4jdbc.sql.jdbcapi.DriverSpy
spring.datasource.url=jdbc:log4jdbc:mysql://localhost:3306/user_info?serverTimezone=Asia/Shanghai&characterEncoding=utf8&useSSL=false&allowPublicKeyRetrieval=true
#thymelea模板配置
spring.thymeleaf.prefix=classpath:/templates/
spring.thymeleaf.suffix=.html
spring.thymeleaf.mode=HTML5
spring.thymeleaf.encoding=UTF-8
spring.thymeleaf.content-type=text/html
spring.thymeleaf.cache=false
spring.resources.chain.strategy.content.enabled=true
spring.resources.chain.strategy.content.paths=/**
- Spring Boot引入了具有层次关系的yml格式的配置文件：
spring:
port:8080
显然具有层次关系的配置文件更易于理解与书写，接下来我们将使用application.yml取代application.properties完成各种属性配置。
配置数据源
###数据源配置
spring:
datasource:
type: com.alibaba.druid.pool.DruidDataSource
username: root
password: root
driver-class-name: net.sf.log4jdbc.sql.jdbcapi.DriverSpy
url: jdbc:log4jdbc:mysql://localhost:3306/user_info?serverTimezone=Asia/Shanghai&characterEncoding=utf8&useSSL=false&allowPublicKeyRetrieval=true
配置模板引擎
#thymelea模板配置
thymeleaf:
prefix: classpath:/templates/
suffix: .html
mode: HTML5
encoding: UTF-8
content-type: text/html
cache: false
配置日志
- 默认情况下，Spring Boot通过Logback配置日志，日志会以INFO级别写入到控制台中，我们希望重新配置显示日志的格式；
- 同时我们希望通过监控sql日志输出到控制台，并将输出的信息进行筛选打印；
- 首先需引入log4jdbc依赖
<dependency>
<groupId>org.bgee.log4jdbc-log4j2</groupId>
<artifactId>log4jdbc-log4j2-jdbc4.1</artifactId>
<version>1.16</version>
</dependency>
- 其次生成配置文件log4jdbc.log4j2.properties：
log4jdbc.spylogdelegator.name=net.sf.log4jdbc.log.slf4j.Slf4jSpyLogDelegator
log4jdbc.auto.load.popular.drivers=false
log4jdbc.drivers=com.mysql.cj.jdbc.Driver
- 最后创建一个logback.xml文件完成配置：
<?xml version="1.0" encoding="UTF-8"?>
<configuration scan="true" scanPeriod="30 seconds" debug="false">
<contextName>web demo</contextName>
<property name="log.charset" value="utf-8" />
<property name="log.pattern" value="%black(%contextName-) %red(%d{yyyy-MM-dd HH:mm:ss}) %green([%thread]) %highlight(%-5level) %boldMagenta(%logger{36}) - %gray(%msg%n)" />
<!--输出到控制台-->
<appender name="console" class="ch.qos.logback.core.ConsoleAppender">
<encoder>
<pattern>${log.pattern}</pattern>
<charset>${log.charset}</charset>
</encoder>
</appender>
<!--普通日志输出到控制台-->
<root level="info">
<appender-ref ref="console" />
</root>
<!--监控sql日志输出 -->
<logger name="jdbc.sqlonly" level="INFO" additivity="false">
<appender-ref ref="console" />
</logger>
<logger name="jdbc.resultset" level="ERROR" additivity="false">
<appender-ref ref="console" />
</logger>
<!-- 如想看到表格数据，将OFF改为INFO -->
<logger name="jdbc.resultsettable" level="OFF" additivity="false">
<appender-ref ref="console" />
</logger>
<logger name="jdbc.connection" level="OFF" additivity="false">
<appender-ref ref="console" />
</logger>
<logger name="jdbc.sqltiming" level="OFF" additivity="false">
<appender-ref ref="console" />
</logger>
<logger name="jdbc.audit" level="OFF" additivity="false">
<appender-ref ref="console" />
</logger>
</configuration>
- 输出格式如下：
创建自定义的配置属性
为了支持配置属性的注入，Spring Boot提供了@ConfigurationProperties注解。将它放到Spring 应用上下文的 bean之后，它就会为该bean中那些能够根据Spring环境注入值的属性赋值。
- 我们希望给管理员注册时，添加一个应用的默认密码，假设用户注册时，不输入密码，web应用就以这个默认密码进行注册，并写入数据库。
在application.yml中加入配置
#管理员默认密码
admin:
password: 123456
编写配置类
- 使用 @ConfigurationProperties 配置模块
- 过添加 @Component 注解让 Component Scan 扫描到
/**
* 基于SpringMVC框架开发web应用--管理员用户默认密钥
*
* @author zhuhuix
* @date 2020-07-09
*/
@Component
@ConfigurationProperties(prefix = "admin")
public class DefaultPasswordProperties {
private String password;
public String getPassword() {
return password;
}
public void setPassword(String password) {
this.password = password;
}
}
使用自定义的配置属性
/**
* 基于SpringMVC框架开发web应用--管理员注册控制器
* * @author zhuhuix
* @date 2020-07-08
* @date 2020-07-09 注册密码为空时使用自定义的默认密码属性
*/
@RestController
@RequestMapping("/admin")
public class AdminController {
@Autowired
private AdminService adminService;
@Autowired
private DefaultPasswordProperties defaultPasswordProperties;
// 管理注册页
@GetMapping
public ModelAndView registerForm(Model model) {
model.addAttribute("admin", new Admin());
return new ModelAndView("registration", "adminModel", model);
}
// 提交注册信息
@PostMapping("/register")
public ModelAndView save(Admin admin) {
// 如果注册密码为空，则赋值默认密码
if (StringUtils.isEmpty(admin.getPassword())) {
admin.setUserPassword(defaultPasswordProperties.getPassword());
}
BCryptPasswordEncoder bCryptPasswordEncoder = new BCryptPasswordEncoder();
admin.setUserPassword(bCryptPasswordEncoder.encode(admin.getPassword()));
if (adminService.save(admin) != null) {
return new ModelAndView("redirect:/login ");
} else {
return null;
}
}
}
属性配置测试
- 注册admin2管理员，密码保持为空，并提交
- 用admin2管理员，密码为123456进行登录
- 登录成功
Spring的配置属性小结
- Spring的配置属性可以通过命令行参数、环境变量、JVM系统属性、属性文件或YAML文件等方式进行设置。
- Spring的配置属性可以用来覆盖自动配置相关的设置，包括指定数据源URL和日志级别。
- Spring的配置属性可以添加@ConfigurationProperties注解，这样就能够从多个属性源中选取一个来注入它的值。
七、Spring集成REST API服务
本节将进入到新的单元：Spring与应用的集成，今天先实现集成REST API服务。
REST API服务
微服务架构，前后端分离目前已成为互联网项目开发的业界标准，其核心思想就是前端（APP、小程序、H5页面等）通过调用后端的API接口，提交及返回JSON数据进行交互。
- 移动设备、平板电脑、智能设备已经非常常见，许多应用程序采用了一种通用的设计，那就是将用户界面推到更接近客户端的地方，而让服务器公开API，通过这种API，各种客户端都能与后端功能进行交互。
- REST API（REpresentation State Transfer Application Programming Interface）：通过URL定位资源，用HTTP动词（GET，POST，DELETE，PUSH等）描述操作，与后端服务进行交互。
Spring集成REST API服务
-
在前几篇文章中我们用了模板引擎开发了多页应用（MultiPage Application，MPA），我们将在原有基础上按以下步骤实现集成API服务：
-
创建用户管理的Restful Api(UserRestfulApi.java)的接口，实现增加、删除、修改、查找用户信息的API交互服务；
-
集成Swagger2，对上述API接口进行测试。
用Spring MVC实现用户管理Restful Api
- Controller
/**
* 基于SpringMVC框架开发web应用--用户restful api
* 增加、删除、修改、查找用户信息的API交互服务
*
* @author zhuhuix
* @date 2020-07-10
*/
@RestController
@RequestMapping("/user/api")
public class UserRestfulApi {
@Autowired
private UserService userService;
// 增加用户信息
@PostMapping
public ResponseEntity<User> addUser(User user) {
return ResponseEntity.ok(userService.saveUser(user));
}
// 根据id删除用户
@DeleteMapping("/{id}")
public ResponseEntity deleteUser(@PathVariable Long id) {
userService.deleteUser(id);
return ResponseEntity.ok(HttpStatus.OK);
}
// 根据id修改用户
@PutMapping("/{id}")
public ResponseEntity<User> updateUser(@RequestBody User user) {
return ResponseEntity.ok(userService.saveUser(user));
}
// 根据id查找用户
@GetMapping("/{id}")
public ResponseEntity<User> findUser(@PathVariable Long id) {
return ResponseEntity.ok(userService.findUser(id));
}
}
- Service
/**
* 基于SpringMVC框架开发web应用--用户服务类
*
* @author zhuhuix
* @date 2020-07-03
* @date 2020-07-04 增加通过jdbcTemplate处理数据
* @date 2020-07-07 将jdbcTemplate处理数据程序改为Spring Data JPA的处理方式
* @date 2020-07-10 增加
*/
@Service
public class UserService {
@Autowired
private UserRepository userRepository;
// 返回所有的用户
public List<User> listUsers() {
return (List<User>) userRepository.findAll();
}
// 保存用户
public User saveUser(User user) {
return userRepository.save(user);
}
// 删除用户
public void deleteUser(Long id){
userRepository.deleteById(id);
}
// 查找用户
public User findUser(Long id){
return userRepository.findById(id).get();
}
// 根据名称查找用户
public List<User> searchUser(String name){
return userRepository.findByName(name);
}
}
- Repository
/**
* 基于SpringMVC框架开发web应用--数据操作层
*
* @author zhuhuix
* @date 2020-07-07
*/
public interface UserRepository extends CrudRepository<User,Long> {
// 自定义添加通过用户名称查找用户信息
List<User> findByName(String name);
}
Spring 集成Swagger2
Swagger2 作为一个规范和完整的框架，可以用于生成、描述、调用和可视化 RESTful 风格的 Web 服务：
1、 接口文档在线自动生成，文档随接口变动实时更新，节省维护成本
2、 支持在线接口测试，不依赖第三方工具
- 添加maven依赖
<!-- RESTful APIs swagger2 -->
<dependency>
<groupId>io.springfox</groupId>
<artifactId>springfox-swagger2</artifactId>
<version>2.9.2</version>
<exclusions>
<exclusion>
<groupId>io.swagger</groupId>
<artifactId>swagger-annotations</artifactId>
</exclusion>
<exclusion>
<groupId>io.swagger</groupId>
<artifactId>swagger-models</artifactId>
</exclusion>
</exclusions>
</dependency>
<dependency>
<groupId>io.springfox</groupId>
<artifactId>springfox-swagger-ui</artifactId>
<version>2.9.2</version>
</dependency>
<dependency>
<groupId>io.swagger</groupId>
<artifactId>swagger-annotations</artifactId>
<version>1.5.21</version>
</dependency>
<dependency>
<groupId>io.swagger</groupId>
<artifactId>swagger-models</artifactId>
<version>1.5.21</version>
</dependency>
- 创建 Swagger2配置类
/**
* Swagger2配置类
*
* @author zhuhuix
* @date 2020-07-10
*/
@Configuration
@EnableSwagger2
public class SwaggerConfig {
@Bean
@SuppressWarnings("all")
public Docket createRestApi() {
return new Docket(DocumentationType.SWAGGER_2)
.enable(true)
.apiInfo(apiInfo())
.select()
.paths(Predicates.not(PathSelectors.regex("/error.*")))
.build();
}
private ApiInfo apiInfo() {
return new ApiInfoBuilder()
.title("Restful Api接口测试")
.version("1.0")
.build();
}
}
API接口进行测试
- 在测试之前，为防止post、put、delete请求出现 403 Forbidden ,需要禁用跨域请求的安全验证
/**
* Spring Security配置类
*
* @author zhuhuix
* @date 2020-07-08
* @date 2020-07-10 禁用跨域请求的安全验证
*/
@Configuration
@EnableWebSecurity
public class WebSecurityConfig extends WebSecurityConfigurerAdapter {
@Autowired
private AdminService adminService;
// 自定义用户验证
@Override
protected void configure(AuthenticationManagerBuilder authenticationManagerBuilder) throws Exception {
authenticationManagerBuilder
.userDetailsService(adminService)
.passwordEncoder(new BCryptPasswordEncoder());
}
// 保护web请求的安全性规则
@Override
protected void configure(HttpSecurity http) throws Exception{
http.authorizeRequests()
.antMatchers("/user/**").access("hasRole('ROLE_USER')")
.antMatchers("/admin/**").permitAll()
.and().formLogin().defaultSuccessUrl("/user")
.and().httpBasic()
// 禁用 CSRF
.and().csrf().disable();
}
}
增加用户(HTTP POST请求)
查找用户(HTTP GET请求)
修改用户(HTTP PUT请求)
删除用户(HTTP DELETE请求)
Spring集成REST API服务小结
至此我们完成了Spring集成restful api服务，并通过集成Swagger2，简单直观地对http的各种请求进行了完整地测试，下面做个总结：
- Rest端点可以通过Spring MVC来创建，这里的控制器与面向浏览器的控制器遵循相同的编程模型。
- @RestController注解简化了REST控制器，使用它的话，处理器方法中就不需要添加@ResponseBody注解了。
- Restful Api一般会添加JWT认证机制进行安全验证，具体可参见《SpringBoot整合SpringSecurity实现JWT认证》。
