Spring Security 指南
一、概述
Spring Security 是 Spring 家族中的一个安全管理框架。相比另外一个安全框架 Shiro，它提供了更丰富的功能，社区资源也比 Shiro 丰富。
Spring Security 是一个功能强大且高度可定制的身份验证和访问控制框架。它是用于保护基于 Spring 的应用程序的实际标准。
Spring Security 是一个框架，致力于为 Java 应用程序提供身份验证和授权。与所有 Spring 项目一样，Spring Security 的真正强大之处在于可以轻松扩展以满足自定义要求。
在 Java 生态中，目前有 Spring Security 和 Apache Shiro 两个安全框架，可以完成认证和授权的功能。
一般来说，中大型的项目都是使用 SpringSecurity 来做安全框架。小项目有 Shiro 的比较多，因为相比与 SpringSecurity，Shiro 的上手更加的简单。
一般 Web 应用的需要进行认证和授权：
- 认证：验证当前访问系统的是不是本系统的用户，并且要确认具体是哪个用户
- 授权：经过认证后判断当前用户是否有权限进行某个操作
而认证和授权也是 SpringSecurity 作为安全框架的核心功能。
1. 快速入门
1.1 准备工作
我们先要搭建一个简单的 SpringBoot 工程。
① 设置父工程 添加依赖
<parent>
<artifactId>spring-boot-starter-parent</artifactId>
<groupId>org.springframework.boot</groupId>
<version>3.0.4</version>
</parent>
<dependencies>
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-web</artifactId>
</dependency>
<dependency>
<groupId>org.projectlombok</groupId>
<artifactId>lombok</artifactId>
<optional>true</optional>
</dependency>
</dependencies>
② 创建启动类
@SpringBootApplication
public class SecurityApplication {
public static void main(String[] args) {
SpringApplication.run(SecurityApplication.class, args);
}
}
③ 创建 Controller
@RestController
@RequestMapping("/demo")
public class HelloController {
@GetMapping("/good")
public String hello(){
return "hello";
}
}
1.2 引入 SpringSecurity
在 SpringBoot 项目中使用 SpringSecurity 我们只需要引入依赖即可实现入门案例。
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-security</artifactId>
</dependency>
引入依赖后我们在尝试去访问之前的接口就会自动跳转到一个 SpringSecurity 的默认登陆页面，默认用户名是 user，密码会输出在控制台。必须登陆之后才能对接口进行访问。
2. 认证
2.1 登陆校验流程
2.2 原理初探
想要知道如何实现自己的登陆流程就必须要先知道入门案例中 SpringSecurity 的流程。
2.2.1 SpringSecurity 完整流程
SpringSecurity 的原理其实就是一个16层的过滤器链，内部包含了提供各种功能的过滤器。
核心过滤器：
- UsernamePasswordAuthenticationFilter：负责处理我们在登陆页面填写了用户名密码后的登陆请求
- ExceptionTranslationFilter：处理过滤器链中抛出的任何 AccessDeniedException 和 AuthenticationException
- FilterSecurityInterceptor：负责权限校验的过滤器
我们可以通过 Debug 查看当前系统中 SpringSecurity 过滤器链中有哪些过滤器及它们的顺序。
2.3 实现
2.3.1 前置准备：配置、依赖、工具类、数据库（sys_user）
① 设置父工程 添加依赖
<dependencies>
<!-- Spring Security -->
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-security</artifactId>
</dependency>
<!-- fastjson 依赖 -->
<dependency>
<groupId>com.alibaba</groupId>
<artifactId>fastjson</artifactId>
<version>1.2.83</version>
</dependency>
<!-- jwt 依赖 -->
<dependency>
<groupId>io.jsonwebtoken</groupId>
<artifactId>jjwt</artifactId>
<version>0.9.1</version>
</dependency>
<!-- JDK 11+ 需要添加这些依赖 -->
<dependency>
<groupId>javax.xml.bind</groupId>
<artifactId>jaxb-api</artifactId>
<version>2.3.1</version>
</dependency>
<dependency>
<groupId>com.sun.xml.bind</groupId>
<artifactId>jaxb-impl</artifactId>
<version>2.3.1</version>
</dependency>
<dependency>
<groupId>com.sun.xml.bind</groupId>
<artifactId>jaxb-core</artifactId>
<version>2.3.0</version>
</dependency>
<!--web依赖-->
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-web</artifactId>
</dependency>
<!--单元测试坐标-->
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-test</artifactId>
<scope>test</scope>
</dependency>
<!--mybatisPlus-->
<dependency>
<groupId>com.baomidou</groupId>
<artifactId>mybatis-plus-spring-boot3-starter</artifactId>
<version>3.5.6</version>
</dependency>
<!--mysql-->
<dependency>
<groupId>com.mysql</groupId>
<artifactId>mysql-connector-j</artifactId>
</dependency>
<!--druid-->
<dependency>
<groupId>com.alibaba</groupId>
<artifactId>druid-spring-boot-starter</artifactId>
<version>1.2.8</version>
</dependency>
<!--lombok-->
<dependency>
<groupId>org.projectlombok</groupId>
<artifactId>lombok</artifactId>
</dependency>
<!--validation依赖-->
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-validation</artifactId>
</dependency>
<!--redis-->
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-data-redis</artifactId>
</dependency>
</dependencies>
②配置类
spring:
application:
name: springSecurity
datasource:
url: jdbc:mysql://localhost:3306/your_databases?characterEncoding=utf-8&serverTimezone=UTC
username: your_username
password: your_password
driver-class-name: com.mysql.cj.jdbc.Driver
# redis目前到这里还没有用到大家可以不需要填写
# data:
# redis:
# database: 0
# host: 127.0.0.1
# port: 6379
# timeout: 5000
# lettuce:
# pool:
# max-active: 32
# max-wait: -1
# max-idle: 16
# min-idle: 8
server:
port: 8080
mybatis-plus:
configuration:
log-impl: org.apache.ibatis.logging.stdout.StdOutImpl
③启动类、控制层（这里就正常即可不做演示【注意：这里可以使用mybatisPlus后续会方便一些】）
④JWT工具类
package com.chyb.springsecurity.until;
import io.jsonwebtoken.Claims;
import io.jsonwebtoken.JwtBuilder;
import io.jsonwebtoken.Jwts;
import io.jsonwebtoken.SignatureAlgorithm;
import javax.crypto.SecretKey;
import javax.crypto.spec.SecretKeySpec;
import java.util.Base64;
import java.util.Date;
import java.util.UUID;
/**
* JWT工具类
*/
public class JwtUtil {
//有效期为
public static final Long JWT_TTL = 60 * 60 * 1000L;// 60 * 60 *1000 一个小时
//设置秘钥明文
public static final String JWT_KEY = "zndl";
public static String getUUID(){
String token = UUID.randomUUID().toString().replaceAll("-", "");
return token;
}
/**
* 生成加密后的秘钥 secretKey
* @return
*/
public static SecretKey generalKey() {
byte[] encodedKey = Base64.getDecoder().decode(JwtUtil.JWT_KEY);
SecretKey key = new SecretKeySpec(encodedKey, 0, encodedKey.length, "AES");
return key;
}
/**
* 生成jtw
* @param subject token中要存放的数据（json格式）
* @return
*/
public static String createJWT(String subject) {
JwtBuilder builder = getJwtBuilder(subject, null, getUUID());// 设置过期时间
return builder.compact();
}
/**
* 生成jtw
* @param subject token中要存放的数据（json格式）
* @param ttlMillis token超时时间
* @return
*/
public static String createJWT(String subject, Long ttlMillis) {
JwtBuilder builder = getJwtBuilder(subject, ttlMillis, getUUID()); // 设置过期时间
return builder.compact();
}
/**
* 创建token
* @param id 唯一的ID
* @param subject token中要存放的数据（json格式）
* @param ttlMillis token超时时间
* @return
*/
public static String createJWT(String id, String subject, Long ttlMillis) {
JwtBuilder builder = getJwtBuilder(subject, ttlMillis, id); // 设置过期时间
return builder.compact();
}
private static JwtBuilder getJwtBuilder(String subject, Long ttlMillis, String uuid) {
SignatureAlgorithm signatureAlgorithm = SignatureAlgorithm.HS256;
SecretKey secretKey = generalKey();
long nowMillis = System.currentTimeMillis();
Date now = new Date(nowMillis);
if(ttlMillis==null){
ttlMillis=JwtUtil.JWT_TTL;
}
long expMillis = nowMillis + ttlMillis;
Date expDate = new Date(expMillis);
return Jwts.builder()
.setId(uuid) // 唯一的ID
.setSubject(subject) // 主题 可以是JSON数据
.setIssuer("admin") // 签发者
.setIssuedAt(now) // 签发时间
.signWith(signatureAlgorithm, secretKey) //使用HS256对称加密算法签名, 第二个参数为秘钥
.setExpiration(expDate);
}
/**
* 解析
*
* @param jwt
* @return
* @throws Exception
*/
public static Claims parseJWT(String jwt) throws Exception {
SecretKey secretKey = generalKey();
return Jwts.parser()
.setSigningKey(secretKey)
.parseClaimsJws(jwt)
.getBody();
}
}
⑤RedisCache工具类
package com.chyb.springsecurity.until;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.redis.core.BoundSetOperations;
import org.springframework.data.redis.core.HashOperations;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.data.redis.core.ValueOperations;
import org.springframework.stereotype.Component;
import java.util.*;
import java.util.concurrent.TimeUnit;
@SuppressWarnings(value = { "unchecked", "rawtypes" })
@Component
public class RedisCache
{
@Autowired
public RedisTemplate redisTemplate;
/**
* 缓存基本的对象，Integer、String、实体类等
*
* @param key 缓存的键值
* @param value 缓存的值
*/
public <T> void setCacheObject(final String key, final T value)
{
redisTemplate.opsForValue().set(key, value);
}
/**
* 缓存基本的对象，Integer、String、实体类等
*
* @param key 缓存的键值
* @param value 缓存的值
* @param timeout 时间
* @param timeUnit 时间颗粒度
*/
public <T> void setCacheObject(final String key, final T value, final Long timeout, final TimeUnit timeUnit)
{
redisTemplate.opsForValue().set(key, value, timeout, timeUnit);
}
/**
* 设置有效时间
*
* @param key Redis键
* @param timeout 超时时间
* @return true=设置成功；false=设置失败
*/
public boolean expire(final String key, final long timeout)
{
return expire(key, timeout, TimeUnit.SECONDS);
}
/**
* 设置有效时间
*
* @param key Redis键
* @param timeout 超时时间
* @param unit 时间单位
* @return true=设置成功；false=设置失败
*/
public boolean expire(final String key, final long timeout, final TimeUnit unit)
{
return redisTemplate.expire(key, timeout, unit);
}
/**
* 获得缓存的基本对象。
*
* @param key 缓存键值
* @return 缓存键值对应的数据
*/
public <T> T getCacheObject(final String key)
{
ValueOperations<String, T> operation = redisTemplate.opsForValue();
return operation.get(key);
}
/**
* 删除单个对象
*
* @param key
*/
public boolean deleteObject(final String key)
{
return redisTemplate.delete(key);
}
/**
* 删除集合对象
*
* @param collection 多个对象
* @return
*/
public long deleteObject(final Collection collection)
{
return redisTemplate.delete(collection);
}
/**
* 缓存List数据
*
* @param key 缓存的键值
* @param dataList 待缓存的List数据
* @return 缓存的对象
*/
public <T> long setCacheList(final String key, final List<T> dataList)
{
Long count = redisTemplate.opsForList().rightPushAll(key, dataList);
return count == null ? 0 : count;
}
/**
* 获得缓存的list对象
*
* @param key 缓存的键值
* @return 缓存键值对应的数据
*/
public <T> List<T> getCacheList(final String key)
{
return redisTemplate.opsForList().range(key, 0, -1);
}
/**
* 缓存Set
*
* @param key 缓存键值
* @param dataSet 缓存的数据
* @return 缓存数据的对象
*/
public <T> BoundSetOperations<String, T> setCacheSet(final String key, final Set<T> dataSet)
{
BoundSetOperations<String, T> setOperation = redisTemplate.boundSetOps(key);
Iterator<T> it = dataSet.iterator();
while (it.hasNext())
{
setOperation.add(it.next());
}
return setOperation;
}
/**
* 获得缓存的set
*
* @param key
* @return
*/
public <T> Set<T> getCacheSet(final String key)
{
return redisTemplate.opsForSet().members(key);
}
/**
* 缓存Map
*
* @param key
* @param dataMap
*/
public <T> void setCacheMap(final String key, final Map<String, T> dataMap)
{
if (dataMap != null) {
redisTemplate.opsForHash().putAll(key, dataMap);
}
}
/**
* 获得缓存的Map
*
* @param key
* @return
*/
public <T> Map<String, T> getCacheMap(final String key)
{
return redisTemplate.opsForHash().entries(key);
}
/**
* 往Hash中存入数据
*
* @param key Redis键
* @param hKey Hash键
* @param value 值
*/
public <T> void setCacheMapValue(final String key, final String hKey, final T value)
{
redisTemplate.opsForHash().put(key, hKey, value);
}
/**
* 获取Hash中的数据
*
* @param key Redis键
* @param hKey Hash键
* @return Hash中的对象
*/
public <T> T getCacheMapValue(final String key, final String hKey)
{
HashOperations<String, String, T> opsForHash = redisTemplate.opsForHash();
return opsForHash.get(key, hKey);
}
/**
* 删除Hash中的数据
*
* @param key
* @param hkey
*/
public void delCacheMapValue(final String key, final String hkey)
{
HashOperations hashOperations = redisTemplate.opsForHash();
hashOperations.delete(key, hkey);
}
/**
* 获取多个Hash中的数据
*
* @param key Redis键
* @param hKeys Hash键集合
* @return Hash对象集合
*/
public <T> List<T> getMultiCacheMapValue(final String key, final Collection<Object> hKeys)
{
return redisTemplate.opsForHash().multiGet(key, hKeys);
}
/**
* 获得缓存的基本对象列表
*
* @param pattern 字符串前缀
* @return 对象列表
*/
public Collection<String> keys(final String pattern)
{
return redisTemplate.keys(pattern);
}
}
⑥数据库
SET NAMES utf8mb4;
SET FOREIGN_KEY_CHECKS = 0;
-- ----------------------------
-- 菜单表
-- ----------------------------
DROP TABLE IF EXISTS `sys_menu`;
CREATE TABLE `sys_menu` (
`id` bigint NOT NULL AUTO_INCREMENT,
`menu_name` varchar(64) CHARACTER SET utf8mb4 COLLATE utf8mb4_0900_ai_ci NOT NULL DEFAULT 'NULL' COMMENT '菜单名',
`path` varchar(200) CHARACTER SET utf8mb4 COLLATE utf8mb4_0900_ai_ci NULL DEFAULT NULL COMMENT '路由地址',
`component` varchar(255) CHARACTER SET utf8mb4 COLLATE utf8mb4_0900_ai_ci NULL DEFAULT NULL COMMENT '组件路径',
`visible` char(1) CHARACTER SET utf8mb4 COLLATE utf8mb4_0900_ai_ci NULL DEFAULT '0' COMMENT '菜单状态（0显示 1隐藏）',
`status` char(1) CHARACTER SET utf8mb4 COLLATE utf8mb4_0900_ai_ci NULL DEFAULT '0' COMMENT '菜单状态（0正常 1停用）',
`perms` varchar(100) CHARACTER SET utf8mb4 COLLATE utf8mb4_0900_ai_ci NULL DEFAULT NULL COMMENT '权限标识',
`icon` varchar(100) CHARACTER SET utf8mb4 COLLATE utf8mb4_0900_ai_ci NULL DEFAULT '#' COMMENT '菜单图标',
`create_by` bigint NULL DEFAULT NULL,
`create_time` datetime NULL DEFAULT NULL,
`update_by` bigint NULL DEFAULT NULL,
`update_time` datetime NULL DEFAULT NULL,
`del_flag` int NULL DEFAULT 0 COMMENT '是否删除（0未删除 1已删除）',
`remark` varchar(500) CHARACTER SET utf8mb4 COLLATE utf8mb4_0900_ai_ci NULL DEFAULT NULL COMMENT '备注',
PRIMARY KEY (`id`) USING BTREE
) ENGINE = InnoDB AUTO_INCREMENT = 3 CHARACTER SET = utf8mb4 COLLATE = utf8mb4_0900_ai_ci COMMENT = '菜单表' ROW_FORMAT = Dynamic;
-- ----------------------------
-- 查润几条数据后期测试使用
-- ----------------------------
INSERT INTO `sys_menu` VALUES (1, '部门管理', 'dept', 'system/dept/index', '0', '0', 'sys:user', '#', NULL, NULL, NULL, NULL, 0, NULL);
INSERT INTO `sys_menu` VALUES (2, '用户', 'test', 'system/test/index', '0', '0', 'sys:user', '#', NULL, NULL, NULL, NULL, 0, NULL);
-- ----------------------------
-- 角色表
-- ----------------------------
DROP TABLE IF EXISTS `sys_role`;
CREATE TABLE `sys_role` (
`id` bigint NOT NULL AUTO_INCREMENT,
`name` varchar(128) CHARACTER SET utf8mb4 COLLATE utf8mb4_0900_ai_ci NULL DEFAULT NULL,
`role_key` varchar(100) CHARACTER SET utf8mb4 COLLATE utf8mb4_0900_ai_ci NULL DEFAULT NULL COMMENT '角色权限字符串',
`status` char(1) CHARACTER SET utf8mb4 COLLATE utf8mb4_0900_ai_ci NULL DEFAULT '0' COMMENT '角色状态（0正常 1停用）',
`del_flag` int NULL DEFAULT 0 COMMENT 'del_flag',
`create_by` bigint NULL DEFAULT NULL,
`create_time` datetime NULL DEFAULT NULL,
`update_by` bigint NULL DEFAULT NULL,
`update_time` datetime NULL DEFAULT NULL,
`remark` varchar(500) CHARACTER SET utf8mb4 COLLATE utf8mb4_0900_ai_ci NULL DEFAULT NULL COMMENT '备注',
PRIMARY KEY (`id`) USING BTREE
) ENGINE = InnoDB AUTO_INCREMENT = 3 CHARACTER SET = utf8mb4 COLLATE = utf8mb4_0900_ai_ci COMMENT = '角色表' ROW_FORMAT = Dynamic;
-- ----------------------------
-- 测试数据
-- ----------------------------
INSERT INTO `sys_role` VALUES (1, 'ADMIN', 'admin', '0', 0, NULL, NULL, NULL, NULL, NULL);
-- ----------------------------
-- 角色和菜单关联表
-- ----------------------------
DROP TABLE IF EXISTS `sys_role_menu`;
CREATE TABLE `sys_role_menu` (
`role_id` bigint NOT NULL AUTO_INCREMENT COMMENT '角色ID',
`menu_id` bigint NOT NULL DEFAULT 0 COMMENT '菜单id',
PRIMARY KEY (`role_id`, `menu_id`) USING BTREE
) ENGINE = InnoDB AUTO_INCREMENT = 2 CHARACTER SET = utf8mb4 COLLATE = utf8mb4_0900_ai_ci ROW_FORMAT = Dynamic;
-- ----------------------------
-- 测试数据
-- ----------------------------
INSERT INTO `sys_role_menu` VALUES (1, 1);
INSERT INTO `sys_role_menu` VALUES (1, 2);
-- ----------------------------
-- 用户表
-- ----------------------------
DROP TABLE IF EXISTS `sys_user`;
CREATE TABLE `sys_user` (
`id` bigint NOT NULL AUTO_INCREMENT COMMENT '主键',
`user_name` varchar(64) CHARACTER SET utf8mb4 COLLATE utf8mb4_0900_ai_ci NOT NULL DEFAULT 'NULL' COMMENT '用户名',
`nick_name` varchar(64) CHARACTER SET utf8mb4 COLLATE utf8mb4_0900_ai_ci NOT NULL DEFAULT 'NULL' COMMENT '昵称',
`password` varchar(64) CHARACTER SET utf8mb4 COLLATE utf8mb4_0900_ai_ci NOT NULL DEFAULT 'NULL' COMMENT '密码',
`status` char(1) CHARACTER SET utf8mb4 COLLATE utf8mb4_0900_ai_ci NULL DEFAULT '0' COMMENT '账号状态（0正常 1停用）',
`email` varchar(64) CHARACTER SET utf8mb4 COLLATE utf8mb4_0900_ai_ci NULL DEFAULT NULL COMMENT '邮箱',
`phonenumber` varchar(32) CHARACTER SET utf8mb4 COLLATE utf8mb4_0900_ai_ci NULL DEFAULT NULL COMMENT '手机号',
`sex` char(1) CHARACTER SET utf8mb4 COLLATE utf8mb4_0900_ai_ci NULL DEFAULT NULL COMMENT '用户性别（0男，1女，2未知）',
`avatar` varchar(128) CHARACTER SET utf8mb4 COLLATE utf8mb4_0900_ai_ci NULL DEFAULT NULL COMMENT '头像',
`user_type` char(1) CHARACTER SET utf8mb4 COLLATE utf8mb4_0900_ai_ci NOT NULL DEFAULT '1' COMMENT '用户类型（0管理员，1普通用户）',
`create_by` bigint NULL DEFAULT NULL COMMENT '创建人的用户id',
`create_time` datetime NULL DEFAULT NULL COMMENT '创建时间',
`update_by` bigint NULL DEFAULT NULL COMMENT '更新人',
`update_time` datetime NULL DEFAULT NULL COMMENT '更新时间',
`del_flag` int NULL DEFAULT 0 COMMENT '删除标志（0代表未删除，1代表已删除）',
PRIMARY KEY (`id`) USING BTREE,
UNIQUE INDEX `unique_user_name`(`user_name` ASC) USING BTREE
) ENGINE = InnoDB AUTO_INCREMENT = 5 CHARACTER SET = utf8mb4 COLLATE = utf8mb4_0900_ai_ci COMMENT = '用户表' ROW_FORMAT = Dynamic;
-- ----------------------------
-- 测试数据
-- ----------------------------
INSERT INTO `sys_user` VALUES (2, 'admin', 'chyb', '{noop}123', '0', NULL, NULL, NULL, NULL, '1', NULL, NULL, NULL, NULL, 0);
-- ----------------------------
-- 角色与用户关联表
-- ----------------------------
DROP TABLE IF EXISTS `sys_user_role`;
CREATE TABLE `sys_user_role` (
`user_id` bigint NOT NULL AUTO_INCREMENT COMMENT '用户id',
`role_id` bigint NOT NULL DEFAULT 0 COMMENT '角色id',
PRIMARY KEY (`user_id`, `role_id`) USING BTREE
) ENGINE = InnoDB AUTO_INCREMENT = 3 CHARACTER SET = utf8mb4 COLLATE = utf8mb4_0900_ai_ci ROW_FORMAT = Dynamic;
-- ----------------------------
-- 测试数据
-- ----------------------------
INSERT INTO `sys_user_role` VALUES (2, 1);
SET FOREIGN_KEY_CHECKS = 1;
⑦redis配置
package com.chyb.springsecurity.config;
import com.chyb.springsecurity.until.FastJsonRedisSerializer;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.data.redis.connection.RedisConnectionFactory;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.data.redis.serializer.StringRedisSerializer;
@Configuration
public class RedisConfig {
@Bean
@SuppressWarnings(value = { "unchecked", "rawtypes" })
public RedisTemplate<Object, Object> redisTemplate(RedisConnectionFactory connectionFactory)
{
RedisTemplate<Object, Object> template = new RedisTemplate<>();
template.setConnectionFactory(connectionFactory);
FastJsonRedisSerializer serializer = new FastJsonRedisSerializer(Object.class);
// 使用StringRedisSerializer来序列化和反序列化redis的key值
template.setKeySerializer(new StringRedisSerializer());
template.setValueSerializer(serializer);
// Hash的key也采用StringRedisSerializer的序列化方式
template.setHashKeySerializer(new StringRedisSerializer());
template.setHashValueSerializer(serializer);
template.afterPropertiesSet();
return template;
}
}
⑧redis序列化工具
package com.chyb.springsecurity.until;
import com.alibaba.fastjson.JSON;
import com.alibaba.fastjson.parser.ParserConfig;
import com.alibaba.fastjson.serializer.SerializerFeature;
import com.fasterxml.jackson.databind.JavaType;
import com.fasterxml.jackson.databind.type.TypeFactory;
import org.springframework.data.redis.serializer.RedisSerializer;
import org.springframework.data.redis.serializer.SerializationException;
import java.nio.charset.Charset;
/**
* Redis使用FastJson序列化
*/
public class FastJsonRedisSerializer<T> implements RedisSerializer<T>
{
public static final Charset DEFAULT_CHARSET = Charset.forName("UTF-8");
private Class<T> clazz;
static
{
ParserConfig.getGlobalInstance().setAutoTypeSupport(true);
}
public FastJsonRedisSerializer(Class<T> clazz)
{
super();
this.clazz = clazz;
}
@Override
public byte[] serialize(T t) throws SerializationException
{
if (t == null)
{
return new byte[0];
}
return JSON.toJSONString(t, SerializerFeature.WriteClassName).getBytes(DEFAULT_CHARSET);
}
@Override
public T deserialize(byte[] bytes) throws SerializationException
{
if (bytes == null || bytes.length <= 0)
{
return null;
}
String str = new String(bytes, DEFAULT_CHARSET);
return JSON.parseObject(str, clazz);
}
protected JavaType getJavaType(Class<?> clazz)
{
return TypeFactory.defaultInstance().constructType(clazz);
}
}
⑨实体类
Menu(菜单)
package com.chyb.springsecurity.domain;
import com.baomidou.mybatisplus.annotation.TableId;
import com.baomidou.mybatisplus.annotation.TableName;
import com.fasterxml.jackson.annotation.JsonInclude;
import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;
import java.io.Serializable;
import java.util.Date;
@TableName(value="sys_menu")
@Data
@AllArgsConstructor
@NoArgsConstructor
@JsonInclude(JsonInclude.Include.NON_NULL)
public class Menu implements Serializable {
private static final long serialVersionUID = -54979041104113736L;
@TableId
private Long id;
/**
* 菜单名
*/
private String menuName;
/**
* 路由地址
*/
private String path;
/**
* 组件路径
*/
private String component;
/**
* 菜单状态（0显示 1隐藏）
*/
private String visible;
/**
* 菜单状态（0正常 1停用）
*/
private String status;
/**
* 权限标识
*/
private String perms;
/**
* 菜单图标
*/
private String icon;
private Long createBy;
private Date createTime;
private Long updateBy;
private Date updateTime;
/**
* 是否删除（0未删除 1已删除）
*/
private Integer delFlag;
/**
* 备注
*/
private String remark;
}
User(用户)
package com.chyb.springsecurity.domain;
import com.alibaba.fastjson.annotation.JSONField;
import com.baomidou.mybatisplus.annotation.TableId;
import com.baomidou.mybatisplus.annotation.TableName;
import com.fasterxml.jackson.annotation.JsonIgnore;
import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;
import java.io.Serializable;
import java.util.Date;
@Data
@AllArgsConstructor
@NoArgsConstructor
@TableName(value = "sys_user")
public class User implements Serializable {
private static final long serialVersionUID = -40356785423868312L;
/**
* 主键
*/
@TableId
private Long id;
/**
* 用户名
*/
private String userName;
/**
* 昵称
*/
private String nickName;
/**
* 密码
*/
private String password;
/**
* 账号状态（0正常 1停用）
*/
private String status;
/**
* 邮箱
*/
private String email;
/**
* 手机号
*/
private String phonenumber;
/**
* 用户性别（0男，1女，2未知）
*/
private String sex;
/**
* 头像
*/
private String avatar;
/**
* 用户类型（0管理员，1普通用户）
*/
private String userType;
/**
* 创建人的用户id
*/
private Long createBy;
/**
* 创建时间
*/
private Date createTime;
/**
* 更新人
*/
private Long updateBy;
/**
* 更新时间
*/
private Date updateTime;
/**
* 删除标志（0代表未删除，1代表已删除）
*/
private Integer delFlag;
}
2.3.2 配置使用数据库中的账号密码
前言：这里说的步骤参考下图：
代码实现
- 封装UserDetails对象
使用security中自带的类将用户的基本信息和权限等封装起来，后续需要使用
@Data
@NoArgsConstructor
public class LoginUser implements UserDetails {
/*User:实体类*/
private User user;
public LoginUser(User user) {
this.user = user;
}
/*获取权限信息*/
@Override
public Collection<? extends GrantedAuthority> getAuthorities() {
return null;
}
/*获取密码*/
@Override
public String getPassword() {
return user.getPassword();
}
/*获取用户名*/
@Override
public String getUsername() {
return user.getUserName();
}
/*判断是否 未 过期*/
@Override
public boolean isAccountNonExpired() {
return true;
}
/*判断是否 未 锁定*/
@Override
public boolean isAccountNonLocked() {
return true;
}
/*判断是否 未 超时*/
@Override
public boolean isCredentialsNonExpired() {
return true;
}
/*此账号是否可用*/
@Override
public boolean isEnabled() {
return true;
}
}
- 主要实现逻辑
这里其实就是对应着上面 认证流程图 中的 5.调用loadUserByUsername方法查询用户
@Service
public class UserDetailService implements UserDetailsService {
@Autowired
private UserMapper userMapper;
/*重写loadUserByUsername方法调用数据库判断是否账号密码是否正确*/
@Override
public UserDetails loadUserByUsername(String username) throws UsernameNotFoundException {
/*1.调用数据看查询username是否存在*/
User user = userMapper.selectOne(new LambdaUpdateWrapper<User>()
.eq(User::getUserName, username));
/*这里Objects.isNull()和==null实际是等价的，唯一不同点就是isNull的可读性高一些更加的现代化一些，但是性能略微稍逊一点==null，可忽略不计*/
if (Objects.isNull(user)) {
throw new RuntimeException("此用户不存在");
}
/*2.授权*/
//TODO
/*3.正确的话将创建UserDetail返回*/
return new LoginUser(user);
}
}
- 在使用数据库中的数据添加一个记录用来测试
INSERT INTO `sys_user` VALUES (2, 'admin', 'chyb', '{noop}123', '0', NULL, NULL, NULL, NULL, '1', NULL, NULL, NULL, NULL, 0);
注意点:为什么密码这里需要使用{noop}your_password
这里可以在官网中找到其源由，如下图：
不过这里其实大家可以做了解即可，后面创建springSecurity封装的Bean对象即可，无需在前面添加{...}
- 大家自行访问api即可，若可以与数据库中的信息对应便成功了
2.3.3 配置加密方式（同时解决密码需要使用前缀{~}问题）
- 创建配置类：
这里就是使用 BCrypt 方式加密，也是security所推荐的一种方式，这里可以参考上面官网图展示的加密方式
@Configuration
/*security的核心配置注解功能如下：
1. 启用 Spring Security 的 Web 安全支持
2. 激活 Spring Security 的默认安全配置
3. 启用 Web 安全相关的功能
4. 自动配置安全过滤器链*/
@EnableWebSecurity
public class SecurityConfig {
/*配置加密方式*/
@Bean
public PasswordEncoder passwordEncoder() {
return new BCryptPasswordEncoder();
}
}
- 在测试类中调用加密方法
@SpringBootTest
class SpringSecurityApplicationTests {
@Autowired
private PasswordEncoder passwordEncoder;
@Test
void contextLoads() {
String encode = passwordEncoder.encode("123");
System.out.println(encode);//$2a$10$kLYQh/6MpDbw3mx38hqzb.RftepuSQGhvB2eRzOV27sU5XcF9Gjqu
System.out.println(passwordEncoder.matches("123", "$2a$10$kLYQh/6MpDbw3mx38hqzb.RftepuSQGhvB2eRzOV27sU5XcF9Gjqu"));//true
}
}
- 修改密码
将用户的密码修改为加密后的密码
2.3.4 自定义登录接口，并集成jwt
- 配置security，放行自定义的登录接口
@Configuration
/*security的核心配置注解功能如下：
1. 启用 Spring Security 的 Web 安全支持
2. 激活 Spring Security 的默认安全配置
3. 启用 Web 安全相关的功能
4. 自动配置安全过滤器链*/
@EnableWebSecurity
public class SecurityConfig {
@Bean
/*配置加密方式*/
public PasswordEncoder passwordEncoder() {
return new BCryptPasswordEncoder();
}
@Bean
/*注入authenticationManager对象*/
public AuthenticationManager authenticationManager(AuthenticationConfiguration config) throws Exception {
return config.getAuthenticationManager();
}
@Bean
public SecurityFilterChain filterChain(HttpSecurity http) throws Exception {
http
.authorizeHttpRequests(authz -> authz
.requestMatchers("/user/login").permitAll() // 放行自定义登录页面
// 除上面外的所有请求全部需要鉴权认证
.anyRequest().authenticated()
)
/*这里先关闭csrf，否则会将不会放行post的登录请求*/
.csrf(AbstractHttpConfigurer::disable);
return http.build();
}
}
- 编写服务层并调用，返回jwt
@Service
public class LoginServiceImpl extends ServiceImpl<UserMapper, User> implements LoginService {
@Autowired
private AuthenticationManager authenticationManager;
@Override
public String login(User user) {
/*2.封装Authentication对象*/
UsernamePasswordAuthenticationToken authentication =
new UsernamePasswordAuthenticationToken(user.getUserName(),user.getPassword());
/*3.调用authentication()方法进行认证*/
Authentication authenticate = authenticationManager.authenticate(authentication);
if (authenticate == null) {throw new RuntimeException("登录异常");}
// 4. 将对象序列化为Json字符串并返回，
LoginUser principal = (LoginUser) authenticate.getPrincipal();
String jsonString = JSON.toJSONString(principal);
return JwtUtil.createJWT(jsonString);
}
}
注意点：
- 第3步
authenticationManager.authenticate(authentication)这里是security中 认证流程的核心
- ↓ 内部发生以下步骤：
- a. 调用 UserDetailService.loadUserByUsername(username)
- b. 从数据库加载用户信息（包含加密后的密码）
- c. 使用 PasswordEncoder 比较用户输入密码和数据库密码
- d. 如果匹配，返回认证成功的 Authentication 对象(并检查用户状态、加载用户权限信息)
- 第4步这里大家也可以只将用户的userName返回， 无需将整个用户对象作为jwt令牌返回，这个只是为了在后续操作的过程判断是那个用户， 所以一般返回用户id即可
2.3.5 创建过滤器验校验JWT是否合法
上面我们已经写了登录返回jwt的功能，那接下来就是校验JWT，这里只展示如何集成security去做校验，
并不会展示如何校验，而是直接调用上面的JWT工具类中的parseJWT(String jwt)方法
- 创建过滤器
@Component
/*OncePerRequestFilter:每个请求只过滤一次*/
public class JwtAuthenticationTokenFilter extends OncePerRequestFilter {
@Override
protected void doFilterInternal(HttpServletRequest request, HttpServletResponse response, FilterChain filterChain) throws ServletException, IOException {
/*放行登录接口*/
String requestURI = request.getRequestURI();
if (requestURI.equals("/user/login")) {
filterChain.doFilter(request,response);
return;
}
/*判断token是否为空*/
String token = request.getHeader("Token");
if (token == null) throw new RuntimeException("登录异常");
/*验证token*/
try {
Claims claims = JwtUtil.parseJWT(token);
String subject = claims.getSubject();
LoginUser loginUser = JSON.parseObject(subject, LoginUser.class);
UsernamePasswordAuthenticationToken authentication =
new UsernamePasswordAuthenticationToken(loginUser, null, null);
SecurityContextHolder.getContext().setAuthentication(authentication);
filterChain.doFilter(request, response);
} catch (Exception e) {
throw new RuntimeException("token错误");
}
}
}
注意点：
if (requestURI.equals("/user/login")) { filterChain.doFilter(request,response); return; }这里需要先放行之后才可以return，否则会中断过滤器，将会到达不到后续的过滤器和controller
- 配置到security中
在security配置中添加
@EnableWebSecurity
@Configuration
public class SecurityConfig {
// ...原代码不变
// 注入刚刚创建的过滤器
@Resource
private JwtAuthenticationTokenFilter jwtAuthenticationTokenFilter;
@Bean
public SecurityFilterChain filterChain(HttpSecurity http) throws Exception {
http
// ...原代码不变
/*在UsernamePasswordAuthenticationFilter前面添加自定义的过滤器*/
.addFilterBefore(jwtAuthenticationTokenFilter, UsernamePasswordAuthenticationFilter.class);
}
}
- 测试
后续在请求除登录请求外的其他请求都会去验证jwt是否合法，若不合法将会请求失败
2.3.6 集成redis实现用户退出功能
实现原理：
- 将登录用户的唯一标识(id)，作为jwt
- 将id设为键值，用户信息作为对象，存储到redis中，并以jwt的过期时间设置为redis的过期时间
- 在自定义的JWT身份验证过滤器(
JwtAuthenticationTokenFilter)中,利用验证token解析出的id值在redistribution中取出用户信息- 将取出的用户信息设置为security的上下文
为什么要使用redis?
当你开发的项目是单体项目时，其实用处并不需要使用，强制使用有可能会适得其反，使得性能下降 但是
在特殊场景下却特别合适：
- 需要主动让令牌失效
- 在分布式系统，需要共享会话
代码如下：
- 修改
LoginServiceImpl
@Service
public class LoginServiceImpl extends ServiceImpl<UserMapper, User> implements LoginService {
@Autowired
private AuthenticationManager authenticationManager;
@Resource
private RedisCache redisCache;
@Override
public String login(User user) {
/*2.封装Authentication对象*/
UsernamePasswordAuthenticationToken authentication =
new UsernamePasswordAuthenticationToken(user.getUserName(),user.getPassword());
/*3.调用authentication()方法进行认证*/
Authentication authenticate = authenticationManager.authenticate(authentication);
// ↓ 内部发生以下步骤：
// a. 调用您的 UserDetailService.loadUserByUsername(username)
// b. 从数据库加载用户信息（包含加密后的密码）
// c. 使用 PasswordEncoder 比较用户输入密码和数据库密码
// d. 如果匹配，返回认证成功的 Authentication 对象(并检查用户状态、加载用户权限信息)
if (authenticate == null) {throw new RuntimeException("登录异常");}
// 4. 将对象序列化为Json字符串并返回，
LoginUser principal = (LoginUser) authenticate.getPrincipal();
// String jsonString = JSON.toJSONString(principal);
//4.将id作为jwt返回，并将用户信息对象存入到redis，并以id为key值，后续可以查询到用户信息
String jsonString = JSON.toJSONString(principal.getUser().getId());
/*5. 创建jwt令牌返回*/
String jwt = JwtUtil.createJWT(jsonString);
/*6.将用户信息存入到redis中*/
String key= "login:" + principal.getUser().getId();
redisCache.setCacheObject(key, principal, JwtUtil.JWT_TTL / 1000L, TimeUnit.SECONDS);
return jwt;
}
}
- 修改
JwtAuthenticationTokenFilter
@Component
/*每个请求只过滤一次*/
public class JwtAuthenticationTokenFilter extends OncePerRequestFilter {
@Autowired
private RedisCache redisCache;
@Override
protected void doFilterInternal(HttpServletRequest request, HttpServletResponse response, FilterChain filterChain) throws ServletException, IOException {
/*放行登录接口*/
String requestURI = request.getRequestURI();
if (requestURI.equals("/user/login")) {
/*注意这里需要先放行之后才可以return，否则会中断过滤器，将会到达不到后续的过滤器和controller*/
filterChain.doFilter(request,response);
return;
}
/*判断token是否为空*/
String token = request.getHeader("token");
if (token == null) throw new RuntimeException("登录异常");
/*验证token*/
try {
Claims claims = JwtUtil.parseJWT(token);
String subject = claims.getSubject();
String id = JSON.parseObject(subject, String.class);
/*获取用户信息存到security的上下文中*/
LoginUser loginUser = (LoginUser) redisCache.getCacheObject("login:" + id);
/*若是为空则说明redis中的用户信息已经过期，或者被删除*/
if (loginUser != null) {
/*设置上下文*/
UsernamePasswordAuthenticationToken authentication =
new UsernamePasswordAuthenticationToken(loginUser, null, null);
SecurityContextHolder.getContext().setAuthentication(authentication);
}
} catch (Exception e) {
throw new RuntimeException("token错误");
}
filterChain.doFilter(request, response);
}
}
- 创建
loginOut退出登录api接口
/*退出登录*/
@GetMapping("/loginOut")
public R loginOut(HttpServletRequest req, HttpServletResponse res) {
String token = req.getHeader("token");
if (ObjectUtils.isEmpty(token)){
token = req.getParameter("token");
}
/*获取security上下文中的用户信息；或者说获取当前线程的登录的用户信息，返回的对象是Authentication*/
Authentication authentication = SecurityContextHolder.getContext().getAuthentication();
/*这里*/
if (authentication != null) {
/*清除上下文*/
new SecurityContextLogoutHandler().logout(req, res, authentication);
/*清除redis*/
LoginUser principal = (LoginUser) authentication.getPrincipal();
String key = "login:" + principal.getUser().getId();
redisCache.deleteObject(key);
}
return ok(null, "退出成功");
}
- 测试
- 登录之后，使用返回的jwt访问其他的的api接口查看是否可以访问，在将redis中的用户信息删掉再去访问查看是否可以访问。
- 使用
loginOut接口退出登录查看是否生效
3. 授权
3.0 权限系统的作用
权限系统用于控制不同用户对系统功能的访问权限。例如一个学校图书馆的管理系统，普通学生登录只能看到借书还书相关的功能，而图书馆管理员登录则能看到并使用添加书籍信息、删除书籍信息等功能。
3.1 授权基本流程
在 SpringSecurity 中，会使用默认的 FilterSecurityInterceptor 来进行权限校验。在 FilterSecurityInterceptor 中会从 SecurityContextHolder 获取其中的 Authentication，然后获取其中的权限信息，判断当前用户是否拥有访问当前资源所需的权限。
3.2 授权实现
3.2.1 限制访问资源所需权限
SpringSecurity 为我们提供了基于注解的权限控制方案。
开启注解支持：
Spring Security 6：
@Configuration
@EnableMethodSecurity(prePostEnabled = true)
public class SecurityConfig {
// ...
}
在对使用注解：
import org.springframework.web.bind.annotation.RequestMapping;
@RequestMapping("/demo")
@RestController
public class HelloController {
@GetMapping("/good")
@PreAuthorize(hasAuthority('sys:admin'))
public String test1() {
return "phone 17 plus max";
}
@GetMapping("/hello")
@PreAuthorize(hasAuthority('sys:user'))
public String test1() {
return "phone 17 plus max";
}
}
3.2.2 更新LoginUser中的获取信息的方法（getAuthorities()）
package com.chyb.springsecurity.domain.vo;
import com.alibaba.fastjson.annotation.JSONField;
import lombok.Data;
import lombok.NoArgsConstructor;
import org.springframework.security.core.GrantedAuthority;
import com.chyb.springsecurity.domain.User;
import org.springframework.security.core.authority.SimpleGrantedAuthority;
import org.springframework.security.core.userdetails.UserDetails;
import java.util.Collection;
import java.util.List;
import java.util.stream.Collectors;
@Data
@NoArgsConstructor
public class LoginUser implements UserDetails {
/*User:实体类*/
private User user;
// 存储权限信息
private List<String> permissions;
// 存储SpringSecurity所需要的权限信息的集合
@JSONField(serialize = false)
private List<GrantedAuthority> authorities;
public LoginUser(User user) {
this.user = user;
}
public LoginUser(User user,List<String> permissions) {
this.user = user;
this.permissions = permissions;
}
/*获取权限信息*/
@Override
public Collection<? extends GrantedAuthority> getAuthorities() {
if(authorities!=null){
return authorities;
}
// 把permissions中字符串类型的权限信息转换成GrantedAuthority对象存入authorities中
authorities = permissions.stream().
map(SimpleGrantedAuthority::new)
.collect(Collectors.toList());
return authorities;
}
// .....
}
3.2.3 从数据库查询权限信息
3.2.3.1 RBAC 权限模型
RBAC 权限模型（Role-Based Access Control）即：基于角色的权限控制。这是目前最常被开发者使用也是相对易用、通用权限模型。
数据库关联图：
3.2.3.2 创建mapper根据userId获取权限信息
这里因为只需要获取权限信息所以只需要创建Menu(菜单的)Mapper即可
MenuMapper
package com.chyb.springsecurity.mapper;
import com.baomidou.mybatisplus.core.mapper.BaseMapper;
import com.chyb.springsecurity.domain.Menu;
import org.apache.ibatis.annotations.Mapper;
import org.apache.ibatis.annotations.Select;
import java.util.List;
@Mapper
public interface MenuMapper extends BaseMapper<Menu> {
List<String> selectPermsByUserId(Long id);
}
MenuMapper.xml
<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN" "http://mybatis.org/dtd/mybatis-3-mapper.dtd" >
<mapper namespace="com.chyb.springsecurity.mapper.MenuMapper">
<select id="selectPermsByUserId" resultType="java.lang.String">
SELECT
DISTINCT m.`perms`
FROM
sys_user_role ur
LEFT JOIN `sys_role` r ON ur.`role_id` = r.`id`
LEFT JOIN `sys_role_menu` rm ON ur.`role_id` = rm.`role_id`
LEFT JOIN `sys_menu` m ON m.`id` = rm.`menu_id`
WHERE
user_id = #{id}
AND r.`status` = 0
AND m.`status` = 0
</select>
</mapper>
3.2.4 更新UserDetailsService，将授权信息赋值给LonginUser
package com.chyb.springsecurity.service.Impl;
import com.baomidou.mybatisplus.core.conditions.update.LambdaUpdateWrapper;
import com.chyb.springsecurity.domain.Menu;
import com.chyb.springsecurity.domain.User;
import com.chyb.springsecurity.domain.vo.LoginUser;
import com.chyb.springsecurity.mapper.MenuMapper;
import com.chyb.springsecurity.mapper.UserMapper;
import jakarta.annotation.Resource;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.security.core.GrantedAuthority;
import org.springframework.security.core.userdetails.UserDetails;
import org.springframework.security.core.userdetails.UserDetailsService;
import org.springframework.security.core.userdetails.UsernameNotFoundException;
import org.springframework.stereotype.Service;
import java.util.ArrayList;
import java.util.List;
import java.util.Objects;
@Service
public class UserDetailService implements UserDetailsService {
@Resource
private UserMapper userMapper;
/*获取权限*/
@Resource
private MenuMapper menuMapper;
/*登录接口*/
@Override
public UserDetails loadUserByUsername(String username) throws UsernameNotFoundException {
/*1.调用数据看查询username是否存在*/
User user = userMapper.selectOne(new LambdaUpdateWrapper<User>()
.eq(User::getUserName, username));
/*这里Objects.isNull()和==null实际是等价的，唯一不同点就是isNull的可读性高一些更加的现代化一些，但是性能略微稍逊一点==null，可忽略不计*/
if (Objects.isNull(user)) {
throw new RuntimeException("此用户不存在");
}
/*2.授权操作*/
List<String> authorities = menuMapper.selectPermsByUserId(user.getId());
/*3.正确的话将创建UserDetail返回*/
return new LoginUser(user, authorities);
}
}
3.2.5 测试
若是按照上面的数据库来去访问api的话，登录admin用户只可以访问
/demo/good(也就是权限标识符sys:admin的信息)若不是的话，大家可以测试数据库执行查询权限的sql，将user_id设置为对应的id，查看返回的值是否与在注解上标识的符号相同
4. 自定义失败处理
在 SpringSecurity 中，如果我们在认证或者授权的过程中出现了异常会被 ExceptionTranslationFilter 捕获到。
- 如果是认证过程中出现的异常会被封装成 AuthenticationException 然后调用 AuthenticationEntryPoint 对象的方法去进行异常处理
- 如果是授权过程中出现的异常会被封装成 AccessDeniedException 然后调用 AccessDeniedHandler 对象的方法去进行异常处理
① 权限未授予处理器
package com.chyb.springsecurity.handle;
import com.alibaba.fastjson.JSON;
import com.chyb.springsecurity.domain.R;
import jakarta.servlet.ServletException;
import jakarta.servlet.ServletOutputStream;
import jakarta.servlet.http.HttpServletRequest;
import jakarta.servlet.http.HttpServletResponse;
import org.springframework.http.HttpStatus;
import org.springframework.security.access.AccessDeniedException;
import org.springframework.security.web.access.AccessDeniedHandler;
import org.springframework.stereotype.Component;
import java.io.IOException;
import java.nio.charset.StandardCharsets;
import static com.chyb.springsecurity.domain.R.fail;
@Component
public class AccessDeniedHandlerImpl implements AccessDeniedHandler {
@Override
public void handle(HttpServletRequest request, HttpServletResponse response, AccessDeniedException accessDeniedException) throws IOException, ServletException {
R<Object> fail = fail(403, "权限不足");
String json = JSON.toJSONString(fail);
ServletOutputStream outputStream = response.getOutputStream();
outputStream.write(json.getBytes(StandardCharsets.UTF_8));
outputStream.flush();
outputStream.close();
}
}
② 请求未认证的结果处理器
package com.chyb.springsecurity.handle;
import com.alibaba.fastjson.JSON;
import com.chyb.springsecurity.domain.R;
import jakarta.servlet.ServletException;
import jakarta.servlet.ServletOutputStream;
import jakarta.servlet.http.HttpServletRequest;
import jakarta.servlet.http.HttpServletResponse;
import org.springframework.security.core.AuthenticationException;
import org.springframework.security.web.AuthenticationEntryPoint;
import org.springframework.stereotype.Component;
import java.io.IOException;
import java.nio.charset.StandardCharsets;
import static com.chyb.springsecurity.domain.R.fail;
/**
* 认证失败处理类
*/
@Component
public class AuthenticationEntryPointImpl implements AuthenticationEntryPoint {
@Override
public void commence(HttpServletRequest request, HttpServletResponse response, AuthenticationException authException) throws IOException, ServletException {
R<Object> fail = fail(401, "认证失败请重新登录");
String json = JSON.toJSONString(fail);
ServletOutputStream outputStream = response.getOutputStream();
outputStream.write(json.getBytes(StandardCharsets.UTF_8));
outputStream.flush();
outputStream.close();
}
}
配置异常处理器：
@Configuration
/*security的核心配置注解功能如下：
1. 启用 Spring Security 的 Web 安全支持
2. 激活 Spring Security 的默认安全配置
3. 启用 Web 安全相关的功能
4. 自动配置安全过滤器链*/
@EnableWebSecurity
@EnableMethodSecurity(prePostEnabled = true)
public class SecurityConfig {
// ...
@Bean
public SecurityFilterChain filterChain(HttpSecurity http) throws Exception {
http
// ...
/*在UsernamePasswordAuthenticationFilter前面添加自定义的过滤器*/
.addFilterBefore(jwtAuthenticationTokenFilter, UsernamePasswordAuthenticationFilter.class)
/*添加自定义没有权限处理器*/
.exceptionHandling(configurer -> configurer.accessDeniedHandler(accessDeniedHandler)
.authenticationEntryPoint(authenticationEntryPoint));
return http.build();
}
}
参考文档： spring Security笔记
扫一扫
700
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
