#### 1.5.2、页面样式无法加载的问题
页面样式bootstrap.min.css是一个CDN地址，需要通过科学上网的方式访问
否则你的登录页会加载很久，并且看到的页面是这样的（登录按钮没有样式文件渲染，但是不影响登录功能的执行）
### 1.6、Spring Security默认做了什么
- 保护应用程序URL，要求对应用程序的任何交互进行身份验证。
- 程序启动时生成一个默认用户“user”。
- 生成一个默认的随机密码，并将此密码记录在控制台上。
- 生成默认的登录表单和注销页面。
- 提供基于表单的登录和注销流程。
- 对于Web请求，重定向到登录页面；
- 对于服务请求，返回401未经授权。
- 处理跨站请求伪造（CSRF）攻击。
- 处理会话劫持攻击。
- 写入Strict-Transport-Security以确保HTTPS。
- 写入X-Content-Type-Options以处理嗅探攻击。
- 写入Cache Control头来保护经过身份验证的资源。
- 写入X-Frame-Options以处理点击劫持攻击。
## 2、Spring Security 的底层原理
**官方文档：**[Spring Security的底层原理](https://docs.spring.io/spring-security/reference/servlet/architecture.html)
Spring Security之所以默认帮助我们做了那么多事情，它的底层原理是传统的`Servlet过滤器`
### 2.1、Filter
下图展示了处理一个Http请求时，过滤器和Servlet的工作流程：
因此我们可以在过滤器中对请求进行修改或增强。
### 2.2、DelegatingFilterProxy
DelegatingFilterProxy 是 Spring Security 提供的一个 Filter 实现，可以在 Servlet 容器和 Spring 容器之间建立桥梁。通过使用 DelegatingFilterProxy，这样就可以将Servlet容器中的 Filter 实例放在 Spring 容器中管理。
### 2.3、FilterChainProxy
复杂的业务中不可能只有一个过滤器。因此FilterChainProxy是Spring Security提供的一个特殊的Filter，它允许通过SecurityFilterChain将过滤器的工作委托给多个Bean Filter实例。
### 2.4、SecurityFilterChain
SecurityFilterChain 被 FilterChainProxy 使用，负责查找当前的请求需要执行的Security Filter列表。
### 2.5、Multiple SecurityFilterChain
可以有多个SecurityFilterChain的配置，FilterChainProxy决定使用哪个SecurityFilterChain。如果请求的URL是/api/messages/，它首先匹配SecurityFilterChain0的模式/api/\*\*，因此只调用SecurityFilterChain 0。假设没有其他SecurityFilterChain实例匹配，那么将调用SecurityFilterChain n。
## 3、程序的启动和运行
### 3.1、DefaultSecurityFilterChain
SecurityFilterChain接口的实现，加载了默认的16个Filter
### 3.2、SecurityProperties
默认情况下Spring Security将初始的用户名和密码存在了SecurityProperties类中。这个类中有一个静态内部类User，配置了默认的用户名（name = "user"）和密码（password = uuid）
我们也可以将用户名、密码配置在SpringBoot的配置文件中：在application.properties中配置自定义用户名和密码
```properties
spring.security.user.name=user
spring.security.user.password=123
```
# 第二章 Spring Security自定义配置
## 1、基于内存的用户认证
### 1.1、创建自定义配置
实际开发的过程中，我们需要应用程序更加灵活，可以在SpringSecurity中创建自定义配置文件
**官方文档：**[Java自定义配置](https://docs.spring.io/spring-security/reference/servlet/configuration/java.html)
**UserDetailsService**用来管理用户信息，**InMemoryUserDetailsManager**是UserDetailsService的一个实现，用来管理基于内存的用户信息。
创建一个WebSecurityConfig文件：
定义一个@Bean，类型是UserDetailsService，实现是InMemoryUserDetailsManager
```java
@Configuration
@EnableWebSecurity//Spring项目总需要添加此注解，SpringBoot项目中不需要
public class WebSecurityConfig {
@Bean
public UserDetailsService userDetailsService() {
InMemoryUserDetailsManager manager = new InMemoryUserDetailsManager();
manager.createUser( //此行设置断点可以查看创建的user对象
User
.withDefaultPasswordEncoder()
.username("chen") //自定义用户名
.password("password") //自定义密码
.roles("USER") //自定义角色
.build()
);
return manager;
}
}
```
**测试：**使用用户名chen，密码password登录
### 1.2、基于内存的用户认证流程
- 程序启动时：
- 创建`InMemoryUserDetailsManager`对象
- 创建`User`对象，封装用户名密码
- 使用InMemoryUserDetailsManager`将User存入内存`
- 校验用户时：
- SpringSecurity自动使用`InMemoryUserDetailsManager`的`loadUserByUsername`方法从`内存中`获取User对象
- 在`UsernamePasswordAuthenticationFilter`过滤器中的`attemptAuthentication`方法中将用户输入的用户名密码和从内存中获取到的用户信息进行比较，进行用户认证
## 2、基于数据库的数据源
### 2.1、SQL
创建三个数据库表并插入测试数据
```sql
/*
Navicat Premium Dump SQL
Source Server : localhost
Source Server Type : MySQL
Source Server Version : 80030 (8.0.30)
Source Host : localhost:3306
Source Schema : security-demo
Target Server Type : MySQL
Target Server Version : 80030 (8.0.30)
File Encoding : 65001
Date: 15/09/2025 19:49:11
*/
SET NAMES utf8mb4;
SET FOREIGN_KEY_CHECKS = 0;
-- ----------------------------
-- Table structure for permission
-- ----------------------------
DROP TABLE IF EXISTS `permission`;
CREATE TABLE `permission` (
`permission_id` int NOT NULL AUTO_INCREMENT COMMENT '权限ID',
`permission_name` varchar(100) NOT NULL COMMENT '权限名称',
`description` varchar(255) DEFAULT NULL COMMENT '权限描述',
PRIMARY KEY (`permission_id`)
) ENGINE=InnoDB AUTO_INCREMENT=7 DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_0900_ai_ci;
-- ----------------------------
-- Records of permission
-- ----------------------------
BEGIN;
INSERT INTO `permission` (`permission_id`, `permission_name`, `description`) VALUES (1, 'USER_READ', '查看用户信息');
INSERT INTO `permission` (`permission_id`, `permission_name`, `description`) VALUES (2, 'USER_ADD', '新增用户信息');
INSERT INTO `permission` (`permission_id`, `permission_name`, `description`) VALUES (3, 'ROLE_MANAGE', '管理角色');
INSERT INTO `permission` (`permission_id`, `permission_name`, `description`) VALUES (4, 'PERMISSION_MANAGE', '管理权限');
INSERT INTO `permission` (`permission_id`, `permission_name`, `description`) VALUES (5, 'DATA_VIEW', '查看数据');
INSERT INTO `permission` (`permission_id`, `permission_name`, `description`) VALUES (6, 'DATA_EXPORT', '导出数据');
COMMIT;
-- ----------------------------
-- Table structure for role
-- ----------------------------
DROP TABLE IF EXISTS `role`;
CREATE TABLE `role` (
`role_id` int NOT NULL AUTO_INCREMENT COMMENT '角色ID',
`role_name` varchar(100) NOT NULL COMMENT '角色名称',
`description` varchar(255) DEFAULT NULL COMMENT '角色描述',
PRIMARY KEY (`role_id`)
) ENGINE=InnoDB AUTO_INCREMENT=4 DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_0900_ai_ci;
-- ----------------------------
-- Records of role
-- ----------------------------
BEGIN;
INSERT INTO `role` (`role_id`, `role_name`, `description`) VALUES (1, 'ADMIN', '管理员，拥有所有权限');
INSERT INTO `role` (`role_id`, `role_name`, `description`) VALUES (2, 'USER', '普通用户，拥有基本权限');
INSERT INTO `role` (`role_id`, `role_name`, `description`) VALUES (3, 'GUEST', '访客，只读权限');
COMMIT;
-- ----------------------------
-- Table structure for role_permission
-- ----------------------------
DROP TABLE IF EXISTS `role_permission`;
CREATE TABLE `role_permission` (
`role_permission_id` int NOT NULL AUTO_INCREMENT COMMENT '角色权限关联ID',
`role_id` int NOT NULL COMMENT '角色ID',
`permission_id` int NOT NULL COMMENT '权限ID',
PRIMARY KEY (`role_permission_id`),
KEY `fk_role_rp` (`role_id`),
KEY `fk_permission_rp` (`permission_id`),
CONSTRAINT `fk_permission_rp` FOREIGN KEY (`permission_id`) REFERENCES `permission` (`permission_id`) ON DELETE CASCADE ON UPDATE CASCADE,
CONSTRAINT `fk_role_rp` FOREIGN KEY (`role_id`) REFERENCES `role` (`role_id`) ON DELETE CASCADE ON UPDATE CASCADE
) ENGINE=InnoDB AUTO_INCREMENT=10 DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_0900_ai_ci;
-- ----------------------------
-- Records of role_permission
-- ----------------------------
BEGIN;
INSERT INTO `role_permission` (`role_permission_id`, `role_id`, `permission_id`) VALUES (1, 1, 1);
INSERT INTO `role_permission` (`role_permission_id`, `role_id`, `permission_id`) VALUES (2, 1, 2);
INSERT INTO `role_permission` (`role_permission_id`, `role_id`, `permission_id`) VALUES (3, 1, 3);
INSERT INTO `role_permission` (`role_permission_id`, `role_id`, `permission_id`) VALUES (4, 1, 4);
INSERT INTO `role_permission` (`role_permission_id`, `role_id`, `permission_id`) VALUES (5, 1, 5);
INSERT INTO `role_permission` (`role_permission_id`, `role_id`, `permission_id`) VALUES (6, 1, 6);
INSERT INTO `role_permission` (`role_permission_id`, `role_id`, `permission_id`) VALUES (7, 2, 5);
INSERT INTO `role_permission` (`role_permission_id`, `role_id`, `permission_id`) VALUES (8, 2, 6);
INSERT INTO `role_permission` (`role_permission_id`, `role_id`, `permission_id`) VALUES (9, 3, 5);
COMMIT;
-- ----------------------------
-- Table structure for user
-- ----------------------------
DROP TABLE IF EXISTS `user`;
CREATE TABLE `user` (
`user_id` int NOT NULL AUTO_INCREMENT,
`username` varchar(50) DEFAULT NULL,
`password` varchar(500) DEFAULT NULL,
`enabled` tinyint(1) NOT NULL,
PRIMARY KEY (`user_id`) USING BTREE,
UNIQUE KEY `user_username_uindex` (`username`)
) ENGINE=InnoDB AUTO_INCREMENT=9 DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_0900_ai_ci;
-- ----------------------------
-- Records of user
-- ----------------------------
BEGIN;
INSERT INTO `user` (`user_id`, `username`, `password`, `enabled`) VALUES (1, 'admin', '{bcrypt}$2a$10$GRLdNijSQMUvl/au9ofL.eDwmoohzzS7.rmNSJZ.0FxO/BTk76klW', 1);
INSERT INTO `user` (`user_id`, `username`, `password`, `enabled`) VALUES (2, 'Helen', '{bcrypt}$2a$10$GRLdNijSQMUvl/au9ofL.eDwmoohzzS7.rmNSJZ.0FxO/BTk76klW', 1);
INSERT INTO `user` (`user_id`, `username`, `password`, `enabled`) VALUES (3, 'Tom', '{bcrypt}$2a$10$GRLdNijSQMUvl/au9ofL.eDwmoohzzS7.rmNSJZ.0FxO/BTk76klW', 1);
INSERT INTO `user` (`user_id`, `username`, `password`, `enabled`) VALUES (5, 'chen', '{bcrypt}$2a$10$HAtUwigy.mHi1upDq.qPde0l67KHJUc.uePI7pAYNMvIba8FD79Uu', 1);
INSERT INTO `user` (`user_id`, `username`, `password`, `enabled`) VALUES (6, 'chen1', '{bcrypt}$2a$10$RB9owAey8yrUh5cFQ0bNauEk/1rogrIi6Tr9SabLP2OP5hRvtrJ3W', 1);
INSERT INTO `user` (`user_id`, `username`, `password`, `enabled`) VALUES (7, 'chen11', '{bcrypt}$2a$10$2/o7JRNM9.1axGv/js9Ei.6IrL3zLE.FOWlfz4zsooNyMv2a3CX.a', 1);
INSERT INTO `user` (`user_id`, `username`, `password`, `enabled`) VALUES (8, 'chen111', '{bcrypt}$2a$10$EPS0sdZfcMxugOxmhJFcy.QiUBesc5f5JaR6esEb98JSViXXswLGy', 1);
COMMIT;
-- ----------------------------
-- Table structure for user_role
-- ----------------------------
DROP TABLE IF EXISTS `user_role`;
CREATE TABLE `user_role` (
`user_role_id` int NOT NULL AUTO_INCREMENT COMMENT '用户角色关联ID',
`user_id` int NOT NULL COMMENT '用户ID',
`role_id` int NOT NULL COMMENT '角色ID',
PRIMARY KEY (`user_role_id`),
KEY `fk_user` (`user_id`),
KEY `fk_role` (`role_id`),
CONSTRAINT `fk_role` FOREIGN KEY (`role_id`) REFERENCES `role` (`role_id`) ON DELETE CASCADE ON UPDATE CASCADE,
CONSTRAINT `fk_user` FOREIGN KEY (`user_id`) REFERENCES `user` (`user_id`) ON DELETE CASCADE ON UPDATE CASCADE
) ENGINE=InnoDB AUTO_INCREMENT=4 DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_0900_ai_ci;
-- ----------------------------
-- Records of user_role
-- ----------------------------
BEGIN;
INSERT INTO `user_role` (`user_role_id`, `user_id`, `role_id`) VALUES (1, 1, 1);
INSERT INTO `user_role` (`user_role_id`, `user_id`, `role_id`) VALUES (2, 2, 2);
INSERT INTO `user_role` (`user_role_id`, `user_id`, `role_id`) VALUES (3, 3, 3);
COMMIT;
SET FOREIGN_KEY_CHECKS = 1;
```
### 2.2、引入依赖
```xml
## 5、添加用户功能
### 5.1、Controller
UserController中添加方法
```java
@PostMapping("/add")
public void add(@RequestBody User user){
userService.saveUserDetails(user);
}
```
### 5.2、Service
UserService接口中添加方法
```java
void saveUserDetails(User user);
```
UserServiceImpl实现中添加方法
```java
@Resource
private DBUserDetailsManager dbUserDetailsManager;
@Override
public void saveUserDetails(User user) {
UserDetails userDetails = org.springframework.security.core.userdetails.User
.withDefaultPasswordEncoder()
.username(user.getUsername()) //自定义用户名
.password(user.getPassword()) //自定义密码
.build();
dbUserDetailsManager.createUser(userDetails);
}
```
### 5.3、修改配置
DBUserDetailsManager中添加方法
```java
@Override
public void createUser(UserDetails userDetails) {
User user = new User();
user.setUsername(userDetails.getUsername());
user.setPassword(userDetails.getPassword());
user.setEnabled(true);
userMapper.insert(user);
}
```
### 5.4、使用Swagger测试
pom中添加配置用于测试
```xml
登录
错误的用户名和密码.
```
### 7.3、配置SecurityFilterChain
SecurityConfiguration：
```java
.formLogin( form -> {
form
.loginPage("/login").permitAll() //登录页面无需授权即可访问
.usernameParameter("username") // 前台传入的参数名如果不是这个, 就需要在这里设置,自定义表单用户名参数，默认是username
.passwordParameter("password") //自定义表单密码参数，默认是password
.failureUrl("/login?error") //登录失败的返回地址
;
}); //使用表单授权方式
```
# 第三章 前后端分离
## 1、用户认证流程
- 登录成功后调用：AuthenticationSuccessHandler
- 登录失败后调用：AuthenticationFailureHandler
## 2、引入fastjson
```xml
# 第五章 授权
授权管理的实现在SpringSecurity中非常灵活，可以帮助应用程序实现以下两种常见的授权需求：
- 用户-权限-资源：例如张三的权限是添加用户、查看用户列表，李四的权限是查看用户列表(资源指的是对应后端接口的地址)
- 用户-角色-权限-资源：例如 张三是角色是管理员、李四的角色是普通用户，管理员能做所有操作，普通用户只能查看信息
## 1、基于request的授权
### 1.1、用户-权限-资源
**需求：**
- 具有USER_LIST权限的用户可以访问/user/list接口
- 具有USER_ADD权限的用户可以访问/user/add接口
#### 配置权限
SecurityFilterChain
```java
//开启授权保护
http.authorizeRequests(
authorize -> authorize
//具有USER_LIST权限的用户可以访问/user/list
.requestMatchers("/user/list").hasAuthority("USER_LIST")
//具有USER_ADD权限的用户可以访问/user/add
.requestMatchers("/user/add").hasAuthority("USER_ADD")
//对所有请求开启授权保护
.anyRequest()
//已认证的请求会被自动授权
.authenticated()
);
```
#### 授予权限
DBUserDetailsManager中的loadUserByUsername方法：
```java
Collection
SecurityFilterChain (自定义)
```java
//错误处理
http.exceptionHandling(exception -> {
exception.authenticationEntryPoint(new MyAuthenticationEntryPoint());//请求未认证的接口
exception.accessDeniedHandler((request, response, e)->{ //请求未授权的接口
//创建结果对象
HashMap result = new HashMap();
result.put("code", -1);
result.put("message", "没有权限");
//转换成json字符串
String json = JSON.toJSONString(result);
//返回响应
response.setContentType("application/json;charset=UTF-8");
response.getWriter().println(json);
});
});
```
**更多的例子：**[Authorize HttpServletRequests :: Spring Security](https://docs.spring.io/spring-security/reference/servlet/authorization/authorize-http-requests.html)
### 1.2、用户-角色-资源
**需求：**角色为ADMIN的用户才可以访问/user/**路径下的资源
#### 配置角色
SecurityFilterChain
```java
//开启授权保护
http.authorizeRequests(
authorize -> authorize
//具有管理员角色的用户可以访问/user/**
.requestMatchers("/user/**").hasRole("ADMIN")
//对所有请求开启授权保护
.anyRequest()
//已认证的请求会被自动授权
.authenticated()
);
```
#### 授予角色
DBUserDetailsManager中的loadUserByUsername方法：
```java
return org.springframework.security.core.userdetails.User
.withUsername(user.getUsername())
.password(user.getPassword())
.roles("ADMIN")
.build();
```
### 1.3、用户-角色-权限-资源
RBAC（Role-Based Access Control，基于角色的访问控制）是一种常用的数据库设计方案，它将用户的权限分配和管理与角色相关联。以下是一个基本的RBAC数据库设计方案的示例：
1. 用户表（User table）：包含用户的基本信息，例如用户名、密码和其他身份验证信息。
| 列名 | 数据类型 | 描述 |
| :------- | -------- | -------- |
| user_id | int | 用户ID |
| username | varchar | 用户名 |
| enable | tinyint | 是否启用 |
| ... | ... | ... |
2. 角色表（Role table）：存储所有可能的角色及其描述。
| 列名 | 数据类型 | 描述 |
| ----------- | -------- | -------- |
| role_id | int | 角色ID |
| role_name | varchar | 角色名称 |
| description | varchar | 角色描述 |
| ... | ... | ... |
3. 权限表（Permission table）：定义系统中所有可能的权限。
| 列名 | 数据类型 | 描述 |
| --------------- | -------- | -------- |
| permission_id | int | 权限ID |
| permission_name | varchar | 权限名称 |
| description | varchar | 权限描述 |
| ... | ... | ... |
4. 用户角色关联表（User-Role table）：将用户与角色关联起来
| 列名 | 数据类型 | 描述 |
| ------------ | -------- | -------------- |
| user_role_id | int | 用户角色关联ID |
| user_id | int | 用户ID |
| role_id | int | 角色ID |
| ... | ... | ... |
5. 角色权限关联表（Role-Permission table）：将角色与权限关联起来。
| 列名 | 数据类型 | 描述 |
| ------------------ | -------- | -------------- |
| role_permission_id | int | 角色权限关联ID |
| role_id | int | 角色ID |
| permission_id | int | 权限ID |
| ... | ... | ... |
在这个设计方案中，用户可以被分配一个或多个角色，而每个角色又可以具有一个或多个权限。通过对用户角色关联和角色权限关联表进行操作，可以实现灵活的权限管理和访问控制。
当用户尝试访问系统资源时，系统可以根据用户的角色和权限决定是否允许访问。这样的设计方案使得权限管理更加简单和可维护，因为只需调整角色和权限的分配即可，而不需要针对每个用户进行单独的设置。
```xml
### 2.2、给用户授予角色和权限
DBUserDetailsManager中的loadUserByUsername方法：
```java
return org.springframework.security.core.userdetails.User
.withUsername(user.getUsername())
.password(user.getPassword())
.roles("ADMIN")
.authorities("USER_ADD", "USER_UPDATE") //会覆盖掉前面的.roles("ADMIN"), 所以只能选一个用
.build();
```
### 2.2、常用授权注解
```java
//用户必须有 ADMIN 角色 并且 用户名是 admin 才能访问此方法
@PreAuthorize("hasRole('ADMIN') and authentication.name == 'admim'")
@GetMapping("/list")
public List
User:
OAuth 2.0 Login with Spring Security
You are successfully logged in
via the OAuth 2.0 Client
User Attributes:
```
### 3.6、启动应用程序
- 启动程序并访问localhost:8080。浏览器将被重定向到默认的自动生成的登录页面，该页面显示了一个用于GitHub登录的链接。
- 点击GitHub链接，浏览器将被重定向到GitHub进行身份验证。
- 使用GitHub账户凭据进行身份验证后，用户会看到授权页面，询问用户是否允许或拒绝客户应用访问GitHub上的用户数据。点击允许以授权OAuth客户端访问用户的基本个人资料信息。
- 此时，OAuth客户端访问GitHub的获取用户信息的接口获取基本个人资料信息，并建立一个已认证的会话。
## 4、案例分析
### 4.1、登录流程
1. **A 网站让用户跳转到 GitHub，并携带参数ClientID 以及 Redirection URI。**
2. GitHub 要求用户登录，然后询问用户"A 网站要求获取用户信息的权限，你是否同意？"
3. 用户同意，GitHub 就会重定向回 A 网站，同时发回一个授权码。
4. **A 网站使用授权码，向 GitHub 请求令牌。**
5. GitHub 返回令牌.
6. **A 网站使用令牌，向 GitHub 请求用户数据。**
7. GitHub返回用户数据
8. **A 网站使用 GitHub用户数据登录**
### 4.2、CommonOAuth2Provider
CommonOAuth2Provider是一个预定义的通用OAuth2Provider，为一些知名资源服务API提供商（如Google、GitHub、Facebook）预定义了一组默认的属性。
例如，**授权URI、令牌URI和用户信息URI**通常不经常变化。因此，提供默认值以减少所需的配置。
因此，当我们配置GitHub客户端时，只需要提供client-id和client-secret属性。
```java
GITHUB {
public ClientRegistration.Builder getBuilder(String registrationId) {
ClientRegistration.Builder builder = this.getBuilder(
registrationId,
ClientAuthenticationMethod.CLIENT_SECRET_BASIC,
//授权回调地址(GitHub向客户应用发送回调请求，并携带授权码)
"{baseUrl}/{action}/oauth2/code/{registrationId}");
builder.scope(new String[]{"read:user"});
//授权页面
builder.authorizationUri("https://github.com/login/oauth/authorize");
//客户应用使用授权码，向 GitHub 请求令牌
builder.tokenUri("https://github.com/login/oauth/access_token");
//客户应用使用令牌向GitHub请求用户数据
builder.userInfoUri("https://api.github.com/user");
//username属性显示GitHub中获取的哪个属性的信息
builder.userNameAttributeName("id");
//登录页面超链接的文本
builder.clientName("GitHub");
return builder;
}
},
```- :