SpringSecurity
一、快速入门
1.创建maven模块SpringSecurityQuickStart
所需依赖如下：
查看代码
<dependencies>
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-security</artifactId>
</dependency>
<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>
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-test</artifactId>
<scope>test</scope>
</dependency>
<dependency>
<groupId>org.springframework.security</groupId>
<artifactId>spring-security-test</artifactId>
<scope>test</scope>
</dependency>
</dependencies>
2.创建控制层方法controller.HelloController
HelloController
package com.tzc.springsecurityquickstart.controller;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;
@RestController
public class HelloController {
@RequestMapping("/hello")
public String hello(){
return "hello";
}
}
3.启动项目，浏览器访问localhost:8080/hello
访问时会自动被下面的链接拦截：http://localhost:8080/login
这是SpringSecurity默认的登陆页面，输入默认用户名user和自动生成的密码，即可完成登录访问hello页面；
还可以通过以下链接登出账号：http://localhost:8080/logout
二、SpringSecurity原理
SpringSecurity的原理其实就是一个过滤器链，内部包含了提供各种功能的过滤器。例如快速入门案例里面使用到的三种过滤器，如下图
监听器 -> 过滤器链 -> dispatcherservlet(前置拦截器 -> mapperHandle -> 后置拦截器 -> 最终拦截器)
一、UsernamePasswordAuthenticationFilter: 负责处理我们在登陆页面填写了用户名密码后的登陆请求。入门案例的认证工作主要有它负责
二、ExceptionTranslationFilter：处理过滤器链中抛出的任何AccessDeniedException和AuthenticationException
三、FilterSecurityInterceptor：负责权限校验的过滤器
注意上图，橙色部分表示认证，黄色部分表示异常处理，红色部分表示授权
如何查看security提供的过滤器有哪几个，或者叫哪几种，如下：
1.认证原理
springsecurity的权限管理，是先授权后认证，所以我们先学习认证这一部分
流程图如下，注意下图的jwt指的是 json web token，jwt是登录校验的时候用的技术，可以根据指定的算法进行信息的加密和解密
2.认证流程
我们来详细学一下上面 '1. springsecurity原理' 的橙色部分，也就是认证那部分的知识
一、Authentication接口: 它的实现类，表示当前访问系统的用户，封装了用户相关信息
二、AuthenticationManager接口：定义了认证Authentication的方法
三、UserDetailsService接口：加载用户特定数据的核心接口。里面定义了一个根据用户名查询用户信息的方法
四、UserDetails接口：提供核心用户信息。通过UserDetailsService根据用户名获取处理的用户信息要封装成UserDetails对象返回。然后将这些信息封装到Authentication对象中
三、自定义SpringSecurity登录认证流程
1.思路
在 '快速入门' 中，我们在Boot项目里面引入了Security依赖，实现了当我们访问某个业务接口时，会被Security的login接口拦截，但是如果我们不想使用Security默认的登录页面，那么怎么办呢，还有，springsecurity的校验，我们希望是根据数据库来做校验，那么怎么实现呢。我们需要实现如下
【登录-未实现】
①、自定义登录接口。用于调用ProviderManager的方法进行认证 如果认证通过生成jwt，然后把用户信息存入redis中
②、自定义UserDetailsService接口的实现类。在这个实现类中去查询数据库
【校验-未实现】
①、定义Jwt认证过滤器。用于获取token，然后解析token获取其中的userid，还需要从redis中获取用户信息，然后存入SecurityContextHolder
2.准备工作
①新建maven模块TokenDemo
所需依赖如下：
查看代码
<dependencies>
<!--引入MybatisPuls依赖-->
<dependency>
<groupId>com.baomidou</groupId>
<artifactId>mybatis-plus-boot-starter</artifactId>
<version>3.4.3</version>
</dependency>
<!--引入mysql驱动的依赖-->
<dependency>
<groupId>com.mysql</groupId>
<artifactId>mysql-connector-j</artifactId>
<scope>runtime</scope>
</dependency>
<!--redis依赖-->
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-data-redis</artifactId>
</dependency>
<!--fastjson依赖-->
<dependency>
<groupId>com.alibaba</groupId>
<artifactId>fastjson</artifactId>
<version>1.2.33</version>
</dependency>
<!--jwt依赖-->
<dependency>
<groupId>io.jsonwebtoken</groupId>
<artifactId>jjwt</artifactId>
<version>0.9.0</version>
</dependency>
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-security</artifactId>
</dependency>
<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>
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-test</artifactId>
<scope>test</scope>
</dependency>
<dependency>
<groupId>org.springframework.security</groupId>
<artifactId>spring-security-test</artifactId>
<scope>test</scope>
</dependency>
</dependencies>
②创建控制层controller.HelloController
查看代码
package com.tzc.tokendemo.controller;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;
@RestController
public class HelloController {
@RequestMapping("/hello")
public String hello(){
return "hello";
}
}
③新建工具类包utils，并添加下列工具类
1. Redis使用FastJson序列化的工具类——FastJsonRedisSerializer
package com.tzc.tokendemo.utils;
import com.alibaba.fastjson.JSON;
import com.alibaba.fastjson.serializer.SerializerFeature;
import com.fasterxml.jackson.databind.JavaType;
import com.fasterxml.jackson.databind.ObjectMapper;
import com.fasterxml.jackson.databind.type.TypeFactory;
import org.springframework.data.redis.serializer.RedisSerializer;
import org.springframework.data.redis.serializer.SerializationException;
import com.alibaba.fastjson.parser.ParserConfig;
import org.springframework.util.Assert;
import java.nio.charset.Charset;
/**
* @author 35238
* @date 2023/7/11 0011 15:37
*/
//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);
}
}
2. JWT工具类——JwtUtil
package com.tzc.tokendemo.utils;
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;
/**
* @author 35238
* @date 2023/7/11 0011 15:46
*/
//JWT工具类
public class JwtUtil {
//有效期为
public static final Long JWT_TTL = 60 * 60 *1000L;// 60 * 60 *1000 一个小时
//设置秘钥明文, 注意长度必须大于等于6位
public static final String JWT_KEY = "huanfqc";
public static String getUUID(){
String token = UUID.randomUUID().toString().replaceAll("-", "");
return token;
}
/**
* 生成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();
}
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("huanf") // 签发者
.setIssuedAt(now) // 签发时间
.signWith(signatureAlgorithm, secretKey) //使用HS256对称加密算法签名, 第二个参数为秘钥
.setExpiration(expDate);
}
/**
* 创建token
* @param id
* @param subject
* @param ttlMillis
* @return
*/
public static String createJWT(String id, String subject, Long ttlMillis) {
JwtBuilder builder = getJwtBuilder(subject, ttlMillis, id);// 设置过期时间
return builder.compact();
}
public static void main(String[] args) throws Exception {
String token = "eyJhbGciOiJIUzI1NiJ9.eyJqdGkiOiJjYWM2ZDVhZi1mNjVlLTQ0MDAtYjcxMi0zYWEwOGIyOTIwYjQiLCJzdWIiOiJzZyIsImlzcyI6InNnIiwiaWF0IjoxNjM4MTA2NzEyLCJleHAiOjE2MzgxMTAzMTJ9.JVsSbkP94wuczb4QryQbAke3ysBDIL5ou8fWsbt_ebg";
Claims claims = parseJWT(token);
System.out.println(claims);
}
/**
* 生成加密后的秘钥 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;
}
/**
* 解析
*
* @param jwt
* @return
* @throws Exception
*/
public static Claims parseJWT(String jwt) throws Exception {
SecretKey secretKey = generalKey();
return Jwts.parser()
.setSigningKey(secretKey)
.parseClaimsJws(jwt)
.getBody();
}
}
3. redis工具类——RedisCache
package com.tzc.tokendemo.utils;
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;
/**
* @author 35238
* @date 2023/7/11 0011 15:50
*/
@SuppressWarnings(value = { "unchecked", "rawtypes" })
@Component
//redis工具类
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 Integer 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);
}
}
4. 将字符串渲染到客户端的工具类——WebUtils
package com.tzc.tokendemo.utils;
import javax.servlet.http.HttpServletResponse;
import java.io.IOException;
/**
* @author 35238
* @date 2023/7/11 0011 15:53
*/
public class WebUtils {
/**
* 将字符串渲染到客户端
*
* @param response 渲染对象
* @param string 待渲染的字符串
* @return null
*/
public static String renderString(HttpServletResponse response, String string) {
try
{
response.setStatus(200);
response.setContentType("application/json");
response.setCharacterEncoding("utf-8");
response.getWriter().print(string);
}
catch (IOException e)
{
e.printStackTrace();
}
return null;
}
}
④新建配置类包config，并添加下列配置类
redis配置类——RedisConfig
package com.tzc.tokendemo.config;
import com.tzc.tokendemo.utils.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;
/**
* @author 35238
* @date 2023/7/11 0011 15:40
*/
@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;
}
}
⑤新建实体类包domain，并添加下列实体类
响应类——ResponseResult
package com.tzc.tokendemo.domain;
import com.fasterxml.jackson.annotation.JsonInclude;
/**
* @author 35238
* @date 2023/7/11 0011 15:43
*/
//响应类
@JsonInclude(JsonInclude.Include.NON_NULL)
public class ResponseResult<T> {
/**
* 状态码
*/
private Integer code;
/**
* 提示信息，如果有错误时，前端可以获取该字段进行提示
*/
private String msg;
/**
* 查询到的结果数据，
*/
private T data;
public ResponseResult(Integer code, String msg) {
this.code = code;
this.msg = msg;
}
public ResponseResult(Integer code, T data) {
this.code = code;
this.data = data;
}
public Integer getCode() {
return code;
}
public void setCode(Integer code) {
this.code = code;
}
public String getMsg() {
return msg;
}
public void setMsg(String msg) {
this.msg = msg;
}
public T getData() {
return data;
}
public void setData(T data) {
this.data = data;
}
public ResponseResult(Integer code, String msg, T data) {
this.code = code;
this.msg = msg;
this.data = data;
}
}
用户表(User)实体类——User
package com.tzc.tokendemo.domain;
import com.baomidou.mybatisplus.annotation.TableId;
import com.baomidou.mybatisplus.annotation.TableName;
import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;
import java.io.Serializable;
import java.util.Date;
/**
* @author 35238
* @date 2023/7/11 0011 16:00
*/
//用户表(User)实体类
@Data
@AllArgsConstructor
@NoArgsConstructor
@TableName("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;
}
3.数据库准备
①创建数据库tzc_security与表sys_user，并插入两条数据
查看代码
create database if not exists tzc_security;
use tzc_security;
CREATE TABLE `sys_user` (
`id` BIGINT(20) NOT NULL AUTO_INCREMENT COMMENT '主键',
`user_name` VARCHAR(64) NOT NULL DEFAULT 'NULL' COMMENT '用户名',
`nick_name` VARCHAR(64) NOT NULL DEFAULT 'NULL' COMMENT '昵称',
`password` VARCHAR(64) NOT NULL DEFAULT 'NULL' COMMENT '密码',
`status` CHAR(1) DEFAULT '0' COMMENT '账号状态（0正常 1停用）',
`email` VARCHAR(64) DEFAULT NULL COMMENT '邮箱',
`phonenumber` VARCHAR(32) DEFAULT NULL COMMENT '手机号',
`sex` CHAR(1) DEFAULT NULL COMMENT '用户性别（0男，1女，2未知）',
`avatar` VARCHAR(128) DEFAULT NULL COMMENT '头像',
`user_type` CHAR(1) NOT NULL DEFAULT '1' COMMENT '用户类型（0管理员，1普通用户）',
`create_by` BIGINT(20) DEFAULT NULL COMMENT '创建人的用户id',
`create_time` DATETIME DEFAULT NULL COMMENT '创建时间',
`update_by` BIGINT(20) DEFAULT NULL COMMENT '更新人',
`update_time` DATETIME DEFAULT NULL COMMENT '更新时间',
`del_flag` INT(11) DEFAULT '0' COMMENT '删除标志（0代表未删除，1代表已删除）',
PRIMARY KEY (`id`)
) ENGINE=INNODB AUTO_INCREMENT=2 DEFAULT CHARSET=utf8mb4 COMMENT='用户表';
insert into sys_user values (1,'admin','管理员','{noop}123456','0',DEFAULT,DEFAULT,DEFAULT,DEFAULT,'0',DEFAULT,DEFAULT,DEFAULT,DEFAULT,DEFAULT);
insert into sys_user values (2,'huanf','涣沷a靑惷','{noop}112233','0',DEFAULT,DEFAULT,DEFAULT,DEFAULT,'1',DEFAULT,DEFAULT,DEFAULT,DEFAULT,DEFAULT);注意: 要想让用户的密码是明文存储，需要在密码前加{noop}，作用是例如等下在浏览器登陆的时候就可以用huanf作为用户名，112233作为密码来登陆了
②添加数据库相关配置
查看代码
spring:
datasource:
url: jdbc:mysql://localhost:3306/tzc_security?serverTimezone=UTC
username: root
password: abc123
driver-class-name: com.mysql.cj.jdbc.Driver
③新建 mapper.UserMapper 接口
查看代码
package com.tzc.tokendemo.mapper;
import com.baomidou.mybatisplus.core.mapper.BaseMapper;
import com.tzc.tokendemo.domain.User;
import org.springframework.stereotype.Component;
@Component
public interface UserMapper extends BaseMapper<User> {
}
④在TokenApplication引导类添加如下
@MapperScan("com.tzc.tokendemo.mapper")
⑤新建测试类MapperTest，测试数据库能否正常连通
查看代码
package com.tzc.tokendemo;
import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.tzc.tokendemo.domain.User;
import com.tzc.tokendemo.mapper.UserMapper;
import org.junit.jupiter.api.Test;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;
import java.util.List;
@SpringBootTest
public class MapperTest {
@Autowired
private UserMapper userMapper;
@Test
public void testUserMapper(){
// List<User> users = userMapper.selectList(null);
// System.out.println(users);\
LambdaQueryWrapper<User> queryWrapper = new LambdaQueryWrapper<>();
queryWrapper.eq(User::getUserName, "admin");
User user = userMapper.selectOne(queryWrapper);
System.out.println(user);
}
}
4.改变查询用户信息的方式——由默认从内存中查找改为从数据库中查询
——实现方式：实现UserDetails接口与UserDetailsService接口
①在domain包下新建LoginUser类，作为UserDetails接口(Security官方提供的接口)的实现类
查看代码
package com.tzc.tokendemo.domain;
import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;
import org.springframework.security.core.GrantedAuthority;
import org.springframework.security.core.userdetails.UserDetails;
import java.util.Collection;
@Data
@AllArgsConstructor
@NoArgsConstructor
public class loginUser implements UserDetails {
private 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;
}
}
②新建service.Impl包，并在其下新建实现类UserDetailsServiceImpl，对UserDetailsService接口进行实现，替代默认的实现类
查看代码
package com.tzc.tokendemo.service.Impl;
import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.tzc.tokendemo.domain.User;
import com.tzc.tokendemo.domain.loginUser;
import com.tzc.tokendemo.mapper.UserMapper;
import org.springframework.beans.factory.annotation.Autowired;
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 javax.annotation.Resource;
import java.util.Objects;
@Service
public class UserDetailsServiceImpl implements UserDetailsService {
@Resource
private UserMapper userMapper;
@Override
public UserDetails loadUserByUsername(String username) throws UsernameNotFoundException {
//查询用户信息
LambdaQueryWrapper<User> queryWrapper = new LambdaQueryWrapper<>();
queryWrapper.eq(User::getUserName, username);
User user = userMapper.selectOne(queryWrapper);
//如果没有查询到用户就抛出异常
if(Objects.isNull(user)){
throw new RuntimeException("用户名或密码错误");
}
//TODO查询对应的权限信息
return new loginUser(user);
}
}
③启动项目，浏览器访问localhost:8080/hello
此时就可以使用数据库中自定义的用户名和密码进行登录了
5.改变密码加密&校验方式——实现方式：添加配置类SecurityConfig
上面我们实现了自定义Security的认证机制，让Security根据数据库的数据，来认证用户输入的数据是否正确。但是当时存在一个问题，就是我们在数据库存入用户表的时候，插入的huanf用户的密码是 {noop}112233，为什么用112233不行呢
原因: SpringSecurity默认使用的PasswordEncoder要求数据库中的密码格式为：{加密方式}密码。对应的就是{noop}112233，实际表示的是112233
但是我们在数据库直接暴露112233为密码，会造成安全问题，所以我们需要把加密后的1234的密文当作密码，此时用户在浏览器登录时输入1234，我们如何确保用户能够登录进去呢，答案是SpringSecurity默认的密码校验，替换为SpringSecurity为我们提供的BCryptPasswordEncoder
我们只需要使用把BCryptPasswordEncoder对象注入Spring容器中，SpringSecurity就会使用该PasswordEncoder来进行密码校验。我们可以定义一个SpringSecurity的配置类，SpringSecurity要求这个配置类要继承WebSecurityConfigurerAdapter。
①在config包下添加配置类SecurityConfig，继承WebSecurityConfigurerAdapter，并在其中添加passwordEncoder()方法
查看代码
package com.tzc.tokendemo.config;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.security.config.annotation.web.configuration.WebSecurityConfiguration;
import org.springframework.security.config.annotation.web.configuration.WebSecurityConfigurerAdapter;
import org.springframework.security.crypto.bcrypt.BCryptPasswordEncoder;
import org.springframework.security.crypto.password.PasswordEncoder;
@Configuration
//实现Security提供的WebSecurityConfigurerAdapter类，就可以改变密码校验的规则了
public class SecurityConfig extends WebSecurityConfigurerAdapter {
@Bean
//把BCryptPasswordEncoder对象注入Spring容器中，SpringSecurity就会使用该PasswordEncoder来进行密码校验
//注意也可以注入PasswordEncoder，效果是一样的，因为PasswordEncoder是BCry..的父类
public PasswordEncoder passwordEncoder(){
return new BCryptPasswordEncoder();
}
}
②测试BCryptPasswordEncoder的作用（非必须，主要用于展示此类的加密与校验方法）
在MapperTest中注入PasswordEncoder，并添加测试方法xxTestBCryptPasswordEncoder()
package com.tzc.tokendemo;
import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.tzc.tokendemo.domain.User;
import com.tzc.tokendemo.mapper.UserMapper;
import org.junit.jupiter.api.Test;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.security.crypto.bcrypt.BCryptPasswordEncoder;
import org.springframework.security.crypto.password.PasswordEncoder;
import java.util.List;
@SpringBootTest
public class MapperTest {
@Autowired
private UserMapper userMapper;
@Autowired
private PasswordEncoder passwordEncoder;
@Test
public void xxTestBCryptPasswordEncoder(){
//模拟用户输入的密码
String encode1 = passwordEncoder.encode("1234");
//再模拟一次用户输入的密码
String encode2 = passwordEncoder.encode("1234");
//虽然这两次的密码都是一样的，但是加密后是不一样的。每次运行，对同一原文都会有不同的加密结果
//原因:会添加随机的盐，加密结果=盐+原文+加密。达到每次加密后的密文都不相同的效果
System.out.println(encode1);//$2a$10$NQg9JGjxoJtLnWQk3X/dBOr.EO9i0VURnn1sFEv2o5KBlwFQs9NKK
System.out.println(encode2);//$2a$10$UaeCxmpK0ZHgobEdxW6.HuY7foFMepzDp4uW7h8Xh.7LMcF4CVN8K
//
//true
System.out.println(passwordEncoder.matches("1234", "$2a$10$NQg9JGjxoJtLnWQk3X/dBOr.EO9i0VURnn1sFEv2o5KBlwFQs9NKK"));
}
@Test
public void testUserMapper(){
// List<User> users = userMapper.selectList(null);
// System.out.println(users);\
LambdaQueryWrapper<User> queryWrapper = new LambdaQueryWrapper<>();
queryWrapper.eq(User::getUserName, "admin");
User user = userMapper.selectOne(queryWrapper);
System.out.println(user);
}
}
③将数据库中的密码改为加密后的密文(正常流程这一步应该是在注册时完成)，启动项目并使用账号和密文对应的密码登录，登陆成功
6.自定义登录接口，认证成功时根据userId生成JWT并放入响应中返回，再将用户完整信息存入redis中
①用一个测试方法展示JWT的基本加密、解析方法
查看代码
@Test
public void TestJwt() throws Exception {
//createJWT()方法生成JWT
String token = JwtUtil.createJWT("1234");
//eyJhbGciOiJIUzI1NiJ9.eyJqdGkiOiI2ODAxZGFhMjE5NWM0ODQ3YjQ4YjQ3Mjg4M2RjOTU2MyIsInN1YiI6IjEyMzQiLCJpc3MiOiJodWFuZiIsImlhdCI6MTY5MzU1NDQxMywiZXhwIjoxNjkzNTU4MDEzfQ.FmbIG6gTPoNffkSkGNYcA-6faok3QmcZT0DNa2oKWGo
System.out.println(token);
//parseJWT()方法解析JWT
Claims claims = JwtUtil.parseJWT("eyJhbGciOiJIUzI1NiJ9.eyJqdGkiOiI2ODAxZGFhMjE5NWM0ODQ3YjQ4YjQ3Mjg4M2RjOTU2MyIsInN1YiI6IjEyMzQiLCJpc3MiOiJodWFuZiIsImlhdCI6MTY5MzU1NDQxMywiZXhwIjoxNjkzNTU4MDEzfQ.FmbIG6gTPoNffkSkGNYcA-6faok3QmcZT0DNa2oKWGo");
String subject = claims.getSubject();
System.out.println(subject);//1234
}
②实现思路
①我们需要自定义登陆接口，也就是在controller目录新建LoginController类，在controller方法里面去调用service接口，在service接口实现AuthenticationManager去进行用户的认证，注意，我们定义的controller方法要让SpringSecurity对这个接口放行(如果不放行的话，会被SpringSecurity拦截)，让用户访问这个接口的时候不用登录也能访问。
②在service接口中我们通过AuthenticationManager的authenticate方法来进行用户认证,所以需要在SecurityConfig中配置把AuthenticationManager注入容器
③认证成功的话要生成一个jwt，放入响应中返回。并且为了让用户下回请求时能通过jwt识别出具体的是哪个用户，我们需要把用户信息存入redis，可以把用户id作为key。
③在配置类SecurityConfig中添加下列两个方法
authenticationManagerBean()：在配置类SecurityConfig中将authenticationManagerBean()注入容器之后，就可以直接从容器中取出AuthenticationManager对象了；
configure()：关闭csrf、允许"/user/login"请求匿名访问、其余请求必须先通过认证；
查看代码
package com.tzc.tokendemo.config;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.security.authentication.AuthenticationManager;
import org.springframework.security.config.annotation.web.builders.HttpSecurity;
import org.springframework.security.config.annotation.web.configuration.WebSecurityConfiguration;
import org.springframework.security.config.annotation.web.configuration.WebSecurityConfigurerAdapter;
import org.springframework.security.config.http.SessionCreationPolicy;
import org.springframework.security.crypto.bcrypt.BCryptPasswordEncoder;
import org.springframework.security.crypto.password.PasswordEncoder;
@Configuration
//实现Security提供的WebSecurityConfigurerAdapter类，就可以改变密码校验的规则了
public class SecurityConfig extends WebSecurityConfigurerAdapter {
@Bean
//把BCryptPasswordEncoder对象注入Spring容器中，SpringSecurity就会使用该PasswordEncoder来进行密码校验
//注意也可以注入PasswordEncoder，效果是一样的，因为PasswordEncoder是BCry..的父类
public PasswordEncoder passwordEncoder(){
return new BCryptPasswordEncoder();
}
//在配置类SecurityConfig中将authenticationManagerBean()注入容器之后，就可以直接从容器中取出AuthenticationManager对象了
@Bean
@Override
public AuthenticationManager authenticationManagerBean() throws Exception {
return super.authenticationManagerBean();
}
//关闭csrf、允许"/user/login"请求匿名访问、其余请求必须先通过认证
@Override
protected void configure(HttpSecurity http) throws Exception {
http
//由于是前后端分离项目，所以要关闭csrf
.csrf().disable()
//由于是前后端分离项目，所以session是失效的，我们就不通过Session获取SecurityContext
.sessionManagement().sessionCreationPolicy(SessionCreationPolicy.STATELESS)
.and()
//指定让spring security放行登录接口的规则
.authorizeRequests()
// 对于登录接口 anonymous表示允许匿名访问
.antMatchers("/user/login").anonymous()
// 除上面外的所有请求全部需要鉴权认证
.anyRequest().authenticated();
}
}
④添加控制层类LoginController及其中的login()方法
查看代码
package com.tzc.tokendemo.controller;
import com.tzc.tokendemo.domain.ResponseResult;
import com.tzc.tokendemo.domain.User;
import com.tzc.tokendemo.service.LoginService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.RequestBody;
import org.springframework.web.bind.annotation.RestController;
import javax.annotation.Resource;
@RestController
public class LoginController {
@Resource
private LoginService loginService;
@PostMapping("/user/login")
public ResponseResult login(@RequestBody User user){
//登录
return loginService.login(user);
}
}
⑤添加service层接口LoginService及其实现类
LoginService
package com.tzc.tokendemo.service;
import com.tzc.tokendemo.domain.ResponseResult;
import com.tzc.tokendemo.domain.User;
public interface LoginService {
ResponseResult login(User user);
}
authenticate对象的内部结构
LoginServiceImpl
package com.tzc.tokendemo.service.Impl;
import com.tzc.tokendemo.domain.LoginUser;
import com.tzc.tokendemo.domain.ResponseResult;
import com.tzc.tokendemo.domain.User;
import com.tzc.tokendemo.service.LoginService;
import com.tzc.tokendemo.utils.JwtUtil;
import com.tzc.tokendemo.utils.RedisCache;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.security.authentication.AuthenticationManager;
import org.springframework.security.authentication.UsernamePasswordAuthenticationToken;
import org.springframework.security.core.Authentication;
import org.springframework.stereotype.Service;
import javax.annotation.Resource;
import java.util.HashMap;
import java.util.Map;
import java.util.Objects;
@Service
public class LoginServiceImpl implements LoginService {
@Resource
private AuthenticationManager authenticationManager;
@Resource
private RedisCache redisCache;
@Override
public ResponseResult login(User user) {
//调用AuthenticationManager的authenticate()方法进行用户认证，
//authenticate()方法会继续调用UserDetailService中的loadUserByUsername()方法查询用户信息
UsernamePasswordAuthenticationToken authenticationToken = new UsernamePasswordAuthenticationToken(user.getUserName(), user.getPassword());
Authentication authenticate = authenticationManager.authenticate(authenticationToken);
//如果认证未通过，抛出异常
if(Objects.isNull(authenticate)){
throw new RuntimeException("登录失败");
}
//如果认证通过，则使用userid生成JWT并存入ResponseResult返回
LoginUser loginUser = (LoginUser) authenticate.getPrincipal();
String userId = loginUser.getUser().getId().toString();
String jwt = JwtUtil.createJWT(userId);
Map<String, String> map = new HashMap<>();
map.put("token", jwt);
//将完整的用户信息存入redis中，以userid作为key
redisCache.setCacheObject("login" + userId, loginUser);
return new ResponseResult(200, "登录成功", map);
}
}
⑥启动本机Redis服务，启动项目，使用postman发出登录请求（可选）
成功登录
⑦启动Redis服务器，修改SpringBoot的配置，启动项目，使用postman发出登录请求（可选）
启动虚拟机上的Redis服务器
查看代码
cd /usr/local/bin
redis-server /myredis/redis7.conf
#-a密码，-p端口
redis-cli -a 111111 -p 6379
#测试Redis服务能否正常使用，输入命令ping，若返回PONG说明可正常使用
ping
修改配置application.yml
application.yml
spring:
datasource:
url: jdbc:mysql://localhost:3306/tzc_security?serverTimezone=UTC
username: root
password: abc123
driver-class-name: com.mysql.cj.jdbc.Driver
redis:
host: 192.168.189.129
port: 6379
password: 111111
lettuce:
pool:
max-active: 8
max-wait: -1ms
max-idle: 8
min-idle: 0
启动项目，使用postman发出登录请求
可以在Redis服务器端查看存入数据的key-value
7.添加token认证过滤器——作用是在登录成功后访问页面时对请求中携带的token进行校验并查询Redis判断权限
①认证过滤器的作用
前面我们已经完成了对登录接口的设计，登录成功会生成JWT响应给前端，并将完整用户信息以userId为key存入Redis，
接下来登陆成功后访问页面时就需要在请求头中携带token，而认证过滤器的作用就是对请求头中携带的token进行解析校验，
具体来说就是先解析JWT获得userId，再根据userId去Redis中查询用户完整信息，根据其中的权限信息判断此用户是否允许访问，若允许则放行，不允许则抛出异常；
②新建认证过滤器filter.JwtAuthenticationTokenFilter（此处还未添加权限信息）
JwtAuthenticationTokenFilter
package com.tzc.tokendemo.filter;
import com.tzc.tokendemo.domain.LoginUser;
import com.tzc.tokendemo.utils.JwtUtil;
import com.tzc.tokendemo.utils.RedisCache;
import io.jsonwebtoken.Claims;
import org.springframework.security.authentication.UsernamePasswordAuthenticationToken;
import org.springframework.security.core.context.SecurityContextHolder;
import org.springframework.stereotype.Component;
import org.springframework.util.StringUtils;
import org.springframework.web.filter.OncePerRequestFilter;
import javax.annotation.Resource;
import javax.servlet.FilterChain;
import javax.servlet.ServletException;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.io.IOException;
import java.util.Objects;
@Component
public class JwtAuthenticationTokenFilter extends OncePerRequestFilter {
@Resource
private RedisCache redisCache;
@Override
protected void doFilterInternal(HttpServletRequest request, HttpServletResponse response, FilterChain filterChain) throws ServletException, IOException {
//获取token
String token = request.getHeader("token");
if(!StringUtils.hasText(token)){
//放行
filterChain.doFilter(request, response);
return;
}
//解析token
String userId;
try {
Claims claims = JwtUtil.parseJWT(token);
userId = claims.getSubject();
} catch (Exception e) {
e.printStackTrace();
throw new RuntimeException("token非法");
}
//从redis中获取用户信息
String redisKey = "login" + userId;
LoginUser loginUser = redisCache.getCacheObject(redisKey);
if(Objects.isNull(loginUser)){
throw new RuntimeException("用户未登录");
}
//存入SecurityContextHolder
//TODO 获取权限信息封装到Authentication中
UsernamePasswordAuthenticationToken authenticationToken =
//第一个参数是LoginUser用户信息，第二个参数是凭证(null)，第三个参数是权限信息(null)
new UsernamePasswordAuthenticationToken(loginUser,null,null);
SecurityContextHolder.getContext().setAuthentication(authenticationToken);
//全部做完之后，就放行
filterChain.doFilter(request, response);
}
}
③修改SecurityConfig，将认证过滤器配置到UsernamePasswordAuthenticationFilter之前
@Resource
private JwtAuthenticationTokenFilter jwtAuthenticationTokenFilter;
//把token校验过滤器添加到过滤器链中
//第一个参数是上面注入的我们在filter目录写好的类，第二个参数表示你想添加到哪个过滤器之前
http.addFilterBefore(jwtAuthenticationTokenFilter, UsernamePasswordAuthenticationFilter.class);SecurityConfig
package com.tzc.tokendemo.config;
import com.tzc.tokendemo.filter.JwtAuthenticationTokenFilter;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.security.authentication.AuthenticationManager;
import org.springframework.security.config.annotation.web.builders.HttpSecurity;
import org.springframework.security.config.annotation.web.configuration.WebSecurityConfiguration;
import org.springframework.security.config.annotation.web.configuration.WebSecurityConfigurerAdapter;
import org.springframework.security.config.http.SessionCreationPolicy;
import org.springframework.security.crypto.bcrypt.BCryptPasswordEncoder;
import org.springframework.security.crypto.password.PasswordEncoder;
import org.springframework.security.web.authentication.UsernamePasswordAuthenticationFilter;
import javax.annotation.Resource;
@Configuration
//实现Security提供的WebSecurityConfigurerAdapter类，就可以改变密码校验的规则了
public class SecurityConfig extends WebSecurityConfigurerAdapter {
@Resource
private JwtAuthenticationTokenFilter jwtAuthenticationTokenFilter;
@Bean
//把BCryptPasswordEncoder对象注入Spring容器中，SpringSecurity就会使用该PasswordEncoder来进行密码校验
//注意也可以注入PasswordEncoder，效果是一样的，因为PasswordEncoder是BCry..的父类
public PasswordEncoder passwordEncoder(){
return new BCryptPasswordEncoder();
}
//在配置类SecurityConfig中将authenticationManagerBean()注入容器之后，就可以直接从容器中取出AuthenticationManager对象了
@Bean
@Override
public AuthenticationManager authenticationManagerBean() throws Exception {
return super.authenticationManagerBean();
}
//关闭csrf、允许"/user/login"请求匿名访问、其余请求必须先通过认证
@Override
protected void configure(HttpSecurity http) throws Exception {
http
//由于是前后端分离项目，所以要关闭csrf
.csrf().disable()
//由于是前后端分离项目，所以session是失效的，我们就不通过Session获取SecurityContext
.sessionManagement().sessionCreationPolicy(SessionCreationPolicy.STATELESS)
.and()
//指定让spring security放行登录接口的规则
.authorizeRequests()
// 对于登录接口 anonymous表示允许匿名访问
.antMatchers("/user/login").anonymous()
// 除上面外的所有请求全部需要鉴权认证
.anyRequest().authenticated();
//把token校验过滤器添加到过滤器链中
//第一个参数是上面注入的我们在filter目录写好的类，第二个参数表示你想添加到哪个过滤器之前
http.addFilterBefore(jwtAuthenticationTokenFilter, UsernamePasswordAuthenticationFilter.class);
}
}
④调试过滤器功能是否可用
启动项目，启动Redis服务器，使用postman先发出登录请求，项目向前端返回了生成的token
在过滤器的获取token代码处打断点，再次使用postman发出请求访问hello页面（在请求头中添加刚才生成的token），
一步步断点调试，可以看到过滤器对token进行解析获得userId，再查询Redis服务器获取用户完整信息，最后将请求放行，成功访问页面hello
8.自定义注销登录接口
①思路
从SecurityContextHolder中获取认证信息得到userId，再去Redis服务器中删除掉该用户的数据即可；
②在控制层中添加logout()方法
LoginController
package com.tzc.tokendemo.controller;
import com.tzc.tokendemo.domain.ResponseResult;
import com.tzc.tokendemo.domain.User;
import com.tzc.tokendemo.service.LoginService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.RequestBody;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;
import javax.annotation.Resource;
@RestController
public class LoginController {
@Resource
private LoginService loginService;
@PostMapping("/user/login")
public ResponseResult login(@RequestBody User user){
//登录
return loginService.login(user);
}
@RequestMapping("/user/logout")
public ResponseResult logout(){
//退出账号
return loginService.logout();
}
}
③在业务层接口及其实现类中添加logout()方法
LoginService
package com.tzc.tokendemo.service;
import com.tzc.tokendemo.domain.ResponseResult;
import com.tzc.tokendemo.domain.User;
public interface LoginService {
ResponseResult login(User user);
ResponseResult logout();
}
LoginServiceImpl
package com.tzc.tokendemo.service.Impl;
import com.tzc.tokendemo.domain.LoginUser;
import com.tzc.tokendemo.domain.ResponseResult;
import com.tzc.tokendemo.domain.User;
import com.tzc.tokendemo.service.LoginService;
import com.tzc.tokendemo.utils.JwtUtil;
import com.tzc.tokendemo.utils.RedisCache;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.security.authentication.AuthenticationManager;
import org.springframework.security.authentication.UsernamePasswordAuthenticationToken;
import org.springframework.security.core.Authentication;
import org.springframework.security.core.context.SecurityContextHolder;
import org.springframework.stereotype.Service;
import javax.annotation.Resource;
import java.util.HashMap;
import java.util.Map;
import java.util.Objects;
@Service
public class LoginServiceImpl implements LoginService {
@Resource
private AuthenticationManager authenticationManager;
@Resource
private RedisCache redisCache;
@Override
public ResponseResult login(User user) {
//调用AuthenticationManager的authenticate()方法进行用户认证，
//authenticate()方法会继续调用UserDetailService中的loadUserByUsername()方法查询用户信息
UsernamePasswordAuthenticationToken authenticationToken = new UsernamePasswordAuthenticationToken(user.getUserName(), user.getPassword());
Authentication authenticate = authenticationManager.authenticate(authenticationToken);
//如果认证未通过，抛出异常
if(Objects.isNull(authenticate)){
throw new RuntimeException("登录失败");
}
//如果认证通过，则使用userid生成JWT并封装进ResponseResult返回
LoginUser loginUser = (LoginUser) authenticate.getPrincipal();
String userId = loginUser.getUser().getId().toString();
String jwt = JwtUtil.createJWT(userId);
Map<String, String> map = new HashMap<>();
map.put("token", jwt);
//将完整的用户信息存入redis中，以userid作为key
redisCache.setCacheObject("login" + userId, loginUser);
return new ResponseResult(200, "登录成功", map);
}
@Override
public ResponseResult logout() {
//获取我们在JwtAuthenticationTokenFilter类写的SecurityContextHolder对象中的用户id
UsernamePasswordAuthenticationToken authentication = (UsernamePasswordAuthenticationToken) SecurityContextHolder.getContext().getAuthentication();
//loginUser是我们在domain目录写好的实体类
LoginUser loginUser = (LoginUser) authentication.getPrincipal();
//获取用户id
Long userid = loginUser.getUser().getId();
//根据用户id，删除redis中的token值，注意我们的key是被 login: 拼接过的，所以下面写完整key的时候要带上 longin:
redisCache.deleteObject("login"+userid);
return new ResponseResult(200,"注销成功");
}
}
④测试注销登录接口
启动项目和Redis服务器，使用postman发出注销登录请求（请求头中也要携带需要注销登录的用户的token），注销成功
再次使用postman携带原token发出请求访问hello页面，此时因未登录已无法访问
四、自定义SpringSecurity授权模块——权限管理
1. 权限系统的作用
为什么要设计权限系统 ?
例如要设计一个图书管理系统，普通学生账号的权限不能使用书籍编辑、删除的功能，普通学生能使用的功能仅仅是浏览页面，但是，如果是图书管理员用户，那么就能使用所有权限。简单理解就是我们需要不同的用户使用不同的功能，这就是权限系统要实现的效果
虽然前端也可以去判断用户的权限来选择是否显示某些功能的页面或组件，但是不安全，因为如果有人知道了对应功能的接口地址就可以不通过前端，直接去发送请求来实现相关功能操作，所以我们还需要在后端进行用户权限的判断，判断当前用户是否有相应的权限，必须具有所需权限才能进行相应的操作
前端防君子，后端防小人
2. 授权的基本流程及自定义思路
在SpringSecurity中，会使用默认的FilterSecurityInterceptor来进行权限校验。
在FilterSecurityInterceptor中会从SecurityContextHolder获取其中的Authentication，然后获取其中的权限信息。当前用户是否拥有访问当前资源所需的权限
自定义授权思路：
①为各接口设置访问需要的权限；
②在登录时查询当前用户的权限信息，并将其连同其它用户信息一起封装进loginUser中，最终存入Redis中；
③在登陆成功后，客户端发出其它请求需要认证时，从Redis服务器查询用户权限信息并封装进SecurityContextHolder中；
3.自定义授权实现
①为各接口设置访问需要的权限
在SecurityConfig配置类添加如下，作用是开启相关配置
@EnableGlobalMethodSecurity(prePostEnabled = true)SecurityConfig
package com.tzc.tokendemo.config;
import com.tzc.tokendemo.filter.JwtAuthenticationTokenFilter;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.security.authentication.AuthenticationManager;
import org.springframework.security.config.annotation.method.configuration.EnableGlobalMethodSecurity;
import org.springframework.security.config.annotation.web.builders.HttpSecurity;
import org.springframework.security.config.annotation.web.configuration.WebSecurityConfiguration;
import org.springframework.security.config.annotation.web.configuration.WebSecurityConfigurerAdapter;
import org.springframework.security.config.http.SessionCreationPolicy;
import org.springframework.security.crypto.bcrypt.BCryptPasswordEncoder;
import org.springframework.security.crypto.password.PasswordEncoder;
import org.springframework.security.web.authentication.UsernamePasswordAuthenticationFilter;
import javax.annotation.Resource;
@Configuration
@EnableGlobalMethodSecurity(prePostEnabled = true)
//实现Security提供的WebSecurityConfigurerAdapter类，就可以改变密码校验的规则了
public class SecurityConfig extends WebSecurityConfigurerAdapter {
@Resource
private JwtAuthenticationTokenFilter jwtAuthenticationTokenFilter;
@Bean
//把BCryptPasswordEncoder对象注入Spring容器中，SpringSecurity就会使用该PasswordEncoder来进行密码校验
//注意也可以注入PasswordEncoder，效果是一样的，因为PasswordEncoder是BCry..的父类
public PasswordEncoder passwordEncoder(){
return new BCryptPasswordEncoder();
}
//在配置类SecurityConfig中将authenticationManagerBean()注入容器之后，就可以直接从容器中取出AuthenticationManager对象了
@Bean
@Override
public AuthenticationManager authenticationManagerBean() throws Exception {
return super.authenticationManagerBean();
}
//关闭csrf、允许"/user/login"请求匿名访问、其余请求必须先通过认证
@Override
protected void configure(HttpSecurity http) throws Exception {
http
//由于是前后端分离项目，所以要关闭csrf
.csrf().disable()
//由于是前后端分离项目，所以session是失效的，我们就不通过Session获取SecurityContext
.sessionManagement().sessionCreationPolicy(SessionCreationPolicy.STATELESS)
.and()
//指定让spring security放行登录接口的规则
.authorizeRequests()
// 对于登录接口 anonymous表示允许匿名访问
.antMatchers("/user/login").anonymous()
// 除上面外的所有请求全部需要鉴权认证
.anyRequest().authenticated();
//把token校验过滤器添加到过滤器链中
//第一个参数是上面注入的我们在filter目录写好的类，第二个参数表示你想添加到哪个过滤器之前
http.addFilterBefore(jwtAuthenticationTokenFilter, UsernamePasswordAuthenticationFilter.class);
}
}
在HelloController类的hello方法，添加如下注解，其中test表示自定义权限的名字
@PreAuthorize("hasAuthority('test')")HelloController
package com.tzc.tokendemo.controller;
import org.springframework.security.access.prepost.PreAuthorize;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;
@RestController
public class HelloController {
@RequestMapping("/hello")
@PreAuthorize("hasAuthority('test')")
public String hello(){
return "hello";
}
}
②在登录时查询当前用户的权限信息，并将其连同其它用户信息一起封装进loginUser中
修改loadUserByUsername()方法，增加查询用户的权限信息（这里未从数据库中查询而是直接设置了），并将权限信息封装进loginUser中返回的步骤
//TODO 查询对应的权限信息
List<String> list = new ArrayList<>(Arrays.asList("test", "admin"));
return new LoginUser(user, list);UserDetailsServiceImpl
package com.tzc.tokendemo.service.Impl;
import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.tzc.tokendemo.domain.User;
import com.tzc.tokendemo.domain.LoginUser;
import com.tzc.tokendemo.mapper.UserMapper;
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 javax.annotation.Resource;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
import java.util.Objects;
@Service
public class UserDetailsServiceImpl implements UserDetailsService {
@Resource
private UserMapper userMapper;
@Override
public UserDetails loadUserByUsername(String username) throws UsernameNotFoundException {
//查询用户信息
LambdaQueryWrapper<User> queryWrapper = new LambdaQueryWrapper<>();
queryWrapper.eq(User::getUserName, username);
User user = userMapper.selectOne(queryWrapper);
//如果没有查询到用户就抛出异常
if(Objects.isNull(user)){
throw new RuntimeException("用户名或密码错误");
}
//TODO 查询对应的权限信息
List<String> list = new ArrayList<>(Arrays.asList("test", "admin"));
return new LoginUser(user, list);
}
}
为实体类LoginUser添加权限属性permissions及对应的构造器，同时重写getAuthorities()方法
private List<String> permissions;
public LoginUser(User user, List<String> permissions) {
this.user = user;
this.permissions = permissions;
}
@JSONField(serialize = false) //这个注解的作用是不让下面那行的成员变量序列化存入redis，避免redis不支持而报异常
private List<SimpleGrantedAuthority> authorities;
@Override
public Collection<? extends GrantedAuthority> getAuthorities() {
if(authorities != null){
return authorities;
}
//将permissions中String类型的权限信息封装成SimpleGrantedAuthority对象：
//方法一
// authorities = new ArrayList<>();
// for (String permission : permissions) {
// SimpleGrantedAuthority authority = new SimpleGrantedAuthority(permission);
// authorities.add(authority);
// }
//方法二
authorities = permissions.stream()
.map(SimpleGrantedAuthority::new)
.collect(Collectors.toList());
return authorities;
}LoginUser
package com.tzc.tokendemo.domain;
import com.alibaba.fastjson.annotation.JSONField;
import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;
import org.springframework.security.core.GrantedAuthority;
import org.springframework.security.core.authority.SimpleGrantedAuthority;
import org.springframework.security.core.userdetails.UserDetails;
import java.util.ArrayList;
import java.util.Collection;
import java.util.List;
import java.util.stream.Collectors;
@Data
@NoArgsConstructor
public class LoginUser implements UserDetails {
private User user;
private List<String> permissions;
public LoginUser(User user, List<String> permissions) {
this.user = user;
this.permissions = permissions;
}
@JSONField(serialize = false) //这个注解的作用是不让下面那行的成员变量序列化存入redis，避免redis不支持而报异常
private List<SimpleGrantedAuthority> authorities;
@Override
public Collection<? extends GrantedAuthority> getAuthorities() {
if(authorities != null){
return authorities;
}
//将permissions中String类型的权限信息封装成SimpleGrantedAuthority对象：
//方法一
// authorities = new ArrayList<>();
// for (String permission : permissions) {
// SimpleGrantedAuthority authority = new SimpleGrantedAuthority(permission);
// authorities.add(authority);
// }
//方法二
authorities = permissions.stream()
.map(SimpleGrantedAuthority::new)
.collect(Collectors.toList());
return authorities;
}
@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;
}
}
③在登陆成功后，客户端发出其它请求需要认证时，从Redis服务器查询用户权限信息并封装进SecurityContextHolder中
在认证过滤器JwtAuthenticationTokenFilter中添加将从Redis查询到的loginUser中的权限信息一同封装进SecurityContextHolder的步骤
//TODO 获取权限信息封装到Authentication中
UsernamePasswordAuthenticationToken authenticationToken =
//第一个参数是LoginUser用户信息，第二个参数是凭证(null)，第三个参数是权限信息
new UsernamePasswordAuthenticationToken(loginUser, null, loginUser.getAuthorities());JwtAuthenticationTokenFilter
package com.tzc.tokendemo.filter;
import com.tzc.tokendemo.domain.LoginUser;
import com.tzc.tokendemo.utils.JwtUtil;
import com.tzc.tokendemo.utils.RedisCache;
import io.jsonwebtoken.Claims;
import org.springframework.security.authentication.UsernamePasswordAuthenticationToken;
import org.springframework.security.core.context.SecurityContextHolder;
import org.springframework.stereotype.Component;
import org.springframework.util.StringUtils;
import org.springframework.web.filter.OncePerRequestFilter;
import javax.annotation.Resource;
import javax.servlet.FilterChain;
import javax.servlet.ServletException;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.io.IOException;
import java.util.Objects;
@Component
public class JwtAuthenticationTokenFilter extends OncePerRequestFilter {
@Resource
private RedisCache redisCache;
@Override
protected void doFilterInternal(HttpServletRequest request, HttpServletResponse response, FilterChain filterChain) throws ServletException, IOException {
//获取token
String token = request.getHeader("token");
if(!StringUtils.hasText(token)){
//放行
filterChain.doFilter(request, response);
return;
}
//解析token
String userId;
try {
Claims claims = JwtUtil.parseJWT(token);
userId = claims.getSubject();
} catch (Exception e) {
e.printStackTrace();
throw new RuntimeException("token非法");
}
//从redis中获取用户信息
String redisKey = "login" + userId;
LoginUser loginUser = redisCache.getCacheObject(redisKey);
if(Objects.isNull(loginUser)){
throw new RuntimeException("用户未登录");
}
//存入SecurityContextHolder
//TODO 获取权限信息封装到Authentication中
UsernamePasswordAuthenticationToken authenticationToken =
//第一个参数是LoginUser用户信息，第二个参数是凭证(null)，第三个参数是权限信息(null)
new UsernamePasswordAuthenticationToken(loginUser, null, loginUser.getAuthorities());
SecurityContextHolder.getContext().setAuthentication(authenticationToken);
//全部做完之后，就放行
filterChain.doFilter(request, response);
}
}
④测试授权功能
启动项目、Redis服务器，使用Postman重新登陆获得token
使用postman在请求头中携带token访问hello页面，访问成功
设置断点重新访问，可以看到此时的loginUser的permissions属性已经包括了权限信息
4.从数据库查询权限信息
①思路
上面我们已经实现了在登录时存入用户的权限信息、在认证时校验用户的权限，但在登录时存入用户的权限信息是手动确定的，而不是从数据库中查询，
因此这一步主要就是将业务层UserDetailsServiceImpl的loadUserByUsername()方法中的查询对应权限信息步骤，由手动确定改为从实际控制人查询；
②RBAC权限模型
RBAC权限模型 (Role-Based Access Control) ，是权限系统用到的经典模型，基于角色的权限控制。该模型由以下五个主要组成部分构成:
一、用户: 在系统中代表具体个体的实体，可以是人员、程序或其他实体。用户需要访问系统资源
二、角色: 角色是权限的集合，用于定义一组相似权限的集合。角色可以被赋予给用户，从而授予用户相应的权限
三、权限: 权限表示系统中具体的操作或功能，例如读取、写入、执行等。每个权限定义了对系统资源的访问规则
四、用户-角色映射: 用户-角色映射用于表示用户与角色之间的关系。通过为用户分配适当的角色，用户可以获得与角色相关联的权限
五、角色-权限映射: 角色-权限映射表示角色与权限之间的关系。每个角色都被分配了一组权限，这些权限决定了角色可执行的操作
截止目前，我们数据库只有1张表，在上面 '认证' 的 '6. 自定义security的数据库' 里面创建的 sys_user 用户表，下面我们会新增4张表，分别是权限表(每条数据是单个'粒度细的权限')、角色表(每条数据是多个'粒度细的权限')、角色表与权限表的中间表、用户表与角色表的中间表。总共5张表，组成了RBAC模型，中间表的作用是维护两张表的多对多关系
③准备工作——创建数据库表
创建表sys_menu、sys_role、sys_role_menu、sys_user_role
查看代码
create database if not exists tzc_security;
use tzc_security;
CREATE TABLE `sys_menu` (
`id` bigint(20) NOT NULL AUTO_INCREMENT,
`menu_name` varchar(64) NOT NULL DEFAULT 'NULL' COMMENT '菜单名',
`path` varchar(200) DEFAULT NULL COMMENT '路由地址',
`component` varchar(255) DEFAULT NULL COMMENT '组件路径',
`visible` char(1) DEFAULT '0' COMMENT '菜单状态（0显示 1隐藏）',
`status` char(1) DEFAULT '0' COMMENT '菜单状态（0正常 1停用）',
`perms` varchar(100) DEFAULT NULL COMMENT '权限标识',
`icon` varchar(100) DEFAULT '#' COMMENT '菜单图标',
`create_by` bigint(20) DEFAULT NULL,
`create_time` datetime DEFAULT NULL,
`update_by` bigint(20) DEFAULT NULL,
`update_time` datetime DEFAULT NULL,
`del_flag` int(11) DEFAULT '0' COMMENT '是否删除（0未删除 1已删除）',
`remark` varchar(500) DEFAULT NULL COMMENT '备注',
PRIMARY KEY (`id`)
) ENGINE=InnoDB AUTO_INCREMENT=2 DEFAULT CHARSET=utf8mb4 COMMENT='权限表';
CREATE TABLE `sys_role` (
`id` bigint(20) NOT NULL AUTO_INCREMENT,
`name` varchar(128) DEFAULT NULL,
`role_key` varchar(100) DEFAULT NULL COMMENT '角色权限字符串',
`status` char(1) DEFAULT '0' COMMENT '角色状态（0正常 1停用）',
`del_flag` int(1) DEFAULT '0' COMMENT 'del_flag',
`create_by` bigint(200) DEFAULT NULL,
`create_time` datetime DEFAULT NULL,
`update_by` bigint(200) DEFAULT NULL,
`update_time` datetime DEFAULT NULL,
`remark` varchar(500) DEFAULT NULL COMMENT '备注',
PRIMARY KEY (`id`)
) ENGINE=InnoDB AUTO_INCREMENT=3 DEFAULT CHARSET=utf8mb4 COMMENT='角色表';
CREATE TABLE `sys_role_menu` (
`role_id` bigint(200) NOT NULL AUTO_INCREMENT COMMENT '角色ID',
`menu_id` bigint(200) NOT NULL DEFAULT '0' COMMENT '菜单id',
PRIMARY KEY (`role_id`,`menu_id`)
) ENGINE=InnoDB AUTO_INCREMENT=2 DEFAULT CHARSET=utf8mb4;
CREATE TABLE `sys_user_role` (
`user_id` bigint(200) NOT NULL AUTO_INCREMENT COMMENT '用户id',
`role_id` bigint(200) NOT NULL DEFAULT '0' COMMENT '角色id',
PRIMARY KEY (`user_id`,`role_id`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4;
insert into sys_user_role values (2,1);
insert into sys_role values
(1,'经理','ceo',0,0,default,default,default,default,default),
(2,'程序员','coder',0,0,default,default,default,default,default);
insert into sys_role_menu values (1,1),(1,2);
insert into sys_menu values
(1,'部门管理','dept','system/dept/index',0,0,'system:dept:list','#',default,default,default,default,default,default),
(2,'测试','test','system/test/index',0,0,'system:test:list','#',default,default,default,default,default,default)
在数据库中测试根据userid多表查询得到权限信息perms的查询语句
查看代码
# 通过用户id去查询这个用户具有的权限列表。也就是根据userid查询perms，并且限制条件为role和menu都必须正常状态么也就是等于0
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 = 2
AND r.`status` = 0
AND m.`status` = 0
④从数据库中查询权限信息
在domain包下新建实体类Menu
Menu
package com.tzc.tokendemo.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;
/**
* @author 35238
* @date 2023/7/13 0013 21:25
*/
//权限表(也叫菜单表)的实体类
@TableName(value="sys_menu") //指定表名，避免等下mybatisplus的影响
@Data
@AllArgsConstructor
@NoArgsConstructor
@JsonInclude(JsonInclude.Include.NON_NULL)
//Serializable是官方提供的，作用是将对象转化为字节序列
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;
}
新建mapper层接口MenuMapper
查看代码
package com.tzc.tokendemo.mapper;
import com.baomidou.mybatisplus.core.mapper.BaseMapper;
import com.tzc.tokendemo.domain.Menu;
import org.springframework.stereotype.Service;
import java.util.List;
@Service
public interface MenuMapper extends BaseMapper<Menu> {
//由于是多表联查，mybatisplus的BaseMapper接口没有提供，我们需要自定义方法，所以需要创建对应的mapper文件，定义对应的sql语句
List<String> selectPermsByUserId(Long userid);
}
在Resources目录下新建mapper包，在包下新建对应的xml文件
MenuMapper.xml
<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE mapper
PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
"https://mybatis.org/dtd/mybatis-3-mapper.dtd">
<!--mapper接口和映射文件要保证两个一致：-->
<!--1.mapper接口的全类名和映射文件的命名空间（namespace）保持一致-->
<!--这里填入mapper接口的全类名，如UserMapper接口的全类名为com.atguigu.mybatis.mapper.UserMapper-->
<mapper namespace="com.tzc.tokendemo.mapper.MenuMapper">
<!-- int insertUser(); -->
<!--2.mapper接口中方法的方法名和映射文件中编写SQL的标签的id属性保持一致-->
<!-- <insert id="insertUser">-->
<!-- insert into t_user values(2,'makabaka','114514',25,'男','777.com')-->
<!-- </insert>-->
<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 = #{userid}
AND r.`status` = 0
AND m.`status` = 0
</select>
</mapper>
在配置文件application.yml文件中添加扫描xml文件的配置（非必须）
application.yml
spring:
datasource:
url: jdbc:mysql://localhost:3306/tzc_security?serverTimezone=UTC
username: root
password: abc123
driver-class-name: com.mysql.cj.jdbc.Driver
redis:
host: 192.168.189.129
port: 6379
password: 111111
lettuce:
pool:
max-active: 8
max-wait: -1ms
max-idle: 8
min-idle: 0
# 配置MenuMapper.xml文件的路径
# 也可以不写，因为默认就是在类加载路径(resouces)下的mapper目录的任意层级的后缀为xml的文件，都会被扫描到
mybatis-plus:
mapper-locations: classpath*:/mapper/**/*.xml
在MapperTest中新建测试方法，测试查询语句能否正常运行
testSelectPermsByUserId()
@Autowired
private MenuMapper menuMapper;
@Test
public void testSelectPermsByUserId(){
//L表示Long类型
List<String> list = menuMapper.selectPermsByUserId(2L);
System.out.println(list);//[system:dept:list, system:test:list]
}
⑤替换业务层UserDetailsServiceImpl的loadUserByUsername()方法中的查询对应权限信息步骤
@Resource
private MenuMapper menuMapper;
//查询对应的权限信息
// List<String> list = new ArrayList<>(Arrays.asList("test", "admin"));
List<String> list = menuMapper.selectPermsByUserId(user.getId());UserDetailsServiceImpl
package com.tzc.tokendemo.service.Impl;
import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.tzc.tokendemo.domain.User;
import com.tzc.tokendemo.domain.LoginUser;
import com.tzc.tokendemo.mapper.MenuMapper;
import com.tzc.tokendemo.mapper.UserMapper;
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 javax.annotation.Resource;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
import java.util.Objects;
@Service
public class UserDetailsServiceImpl implements UserDetailsService {
@Resource
private UserMapper userMapper;
@Resource
private MenuMapper menuMapper;
@Override
public UserDetails loadUserByUsername(String username) throws UsernameNotFoundException {
//查询用户信息
LambdaQueryWrapper<User> queryWrapper = new LambdaQueryWrapper<>();
queryWrapper.eq(User::getUserName, username);
User user = userMapper.selectOne(queryWrapper);
//如果没有查询到用户就抛出异常
if(Objects.isNull(user)){
throw new RuntimeException("用户名或密码错误");
}
//查询对应的权限信息
// List<String> list = new ArrayList<>(Arrays.asList("test", "admin"));
List<String> list = menuMapper.selectPermsByUserId(user.getId());
return new LoginUser(user, list);
}
}
同时将控制层HelloController中hello页面的访问权限更换为system:dept:list
@PreAuthorize("hasAuthority('system:dept:list')")HelloController
package com.tzc.tokendemo.controller;
import org.springframework.security.access.prepost.PreAuthorize;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;
@RestController
public class HelloController {
@RequestMapping("/hello")
@PreAuthorize("hasAuthority('system:dept:list')")
public String hello(){
return "hello";
}
}
⑥测试权限管理功能能否正常运行
启动项目、Redis服务器，使用postman重新登录，再携带token发出访问hello页面的请求，成功访问
此时在过滤器中打断点，使用postman重新发出请求，可以看到此时的loginUser中的permissions变成了system:dept:list、system:test:list
5.自定义异常处理——统一以ResponseResult格式作为响应，方便前端进行进一步处理
①原理及自定义思路
在SpringSecurity中，如果我们在认证或者授权的过程中出现了异常会被ExceptionTranslationFilter捕获到，如上图。在ExceptionTranslationFilter中会去判断是认证失败还是授权失败出现的异常，其中有如下两种情况
一、如果是认证过程中出现的异常会被封装成AuthenticationException然后调用AuthenticationEntryPoint对象的方法去进行异常处理。
二、如果是授权过程中出现的异常会被封装成AccessDeniedException然后调用AccessDeniedHandler对象的方法去进行异常处理。
总结: 如果我们需要自定义异常处理，我们只需要创建AuthenticationEntryPoint和AccessDeniedHandler的实现类对象，然后配置给SpringSecurity即可
②新增handler包，并在其下添加两个异常处理类
AuthenticationEntryPointImpl
package com.tzc.tokendemo.handler;
import com.alibaba.fastjson.JSON;
import com.tzc.tokendemo.domain.ResponseResult;
import com.tzc.tokendemo.utils.WebUtils;
import org.springframework.http.HttpStatus;
import org.springframework.security.core.AuthenticationException;
import org.springframework.security.web.AuthenticationEntryPoint;
import org.springframework.stereotype.Component;
import javax.servlet.ServletException;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.io.IOException;
/**
* @author 35238
* @date 2023/7/14 0014 15:51
*/
@Component
//这个类只处理认证异常，不处理授权异常
public class AuthenticationEntryPointImpl implements AuthenticationEntryPoint {
@Override
//第一个参数是请求对象，第二个参数是响应对象，第三个参数是异常对象。把异常封装成授权的对象，然后封装到handle方法
public void commence(HttpServletRequest request, HttpServletResponse response, AuthenticationException authException) throws IOException, ServletException {
//ResponseResult是我们在domain目录写好的实体类。HttpStatus是spring提供的枚举类，UNAUTHORIZED表示401状态码
ResponseResult result = new ResponseResult(HttpStatus.UNAUTHORIZED.value(), "用户认证失败，请重新登录");
//把上面那行拿到的result对象转换为JSON字符串
String json = JSON.toJSONString(result);
//将该json字符串注入到响应报文中
WebUtils.renderString(response,json);
}
}
AccessDeniedHandlerImpl
package com.tzc.tokendemo.handler;
import com.alibaba.fastjson.JSON;
import com.tzc.tokendemo.domain.ResponseResult;
import com.tzc.tokendemo.utils.WebUtils;
import org.springframework.http.HttpStatus;
import org.springframework.security.access.AccessDeniedException;
import org.springframework.security.web.access.AccessDeniedHandler;
import org.springframework.stereotype.Component;
import javax.servlet.ServletException;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.io.IOException;
/**
* @author 35238
* @date 2023/7/14 0014 14:42
*/
@Component
//这个类只处理授权异常，不处理认证异常
public class AccessDeniedHandlerImpl implements AccessDeniedHandler {
@Override
//第一个参数是请求对象，第二个参数是响应对象，第三个参数是异常对象。把异常封装成认证的对象，然后封装到handle方法
public void handle(HttpServletRequest request, HttpServletResponse response, AccessDeniedException accessDeniedException) throws IOException, ServletException {
//ResponseResult是我们在domain目录写好的实体类。HttpStatus是spring提供的枚举类，FORBIDDEN表示403状态码
ResponseResult result = new ResponseResult(HttpStatus.FORBIDDEN.value(), "您没有权限进行访问");
//把上面那行拿到的result对象转换为JSON字符串
String json = JSON.toJSONString(result);
//WebUtils是我们在utils目录写好的类
WebUtils.renderString(response,json);
}
}
③在配置类SecurityConfig中将上面的两个异常处理类配置到Spring Security中
@Resource
private AccessDeniedHandlerImpl accessDeniedHandler;
@Resource
private AuthenticationEntryPointImpl authenticationEntryPoint;
//异常处理的相关配置
http.exceptionHandling()
//配置认证失败的处理器
.authenticationEntryPoint(authenticationEntryPoint)
//配置授权失败的处理器
.accessDeniedHandler(accessDeniedHandler);
SecurityConfig
package com.tzc.tokendemo.config;
import com.tzc.tokendemo.filter.JwtAuthenticationTokenFilter;
import com.tzc.tokendemo.handler.AccessDeniedHandlerImpl;
import com.tzc.tokendemo.handler.AuthenticationEntryPointImpl;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.security.authentication.AuthenticationManager;
import org.springframework.security.config.annotation.method.configuration.EnableGlobalMethodSecurity;
import org.springframework.security.config.annotation.web.builders.HttpSecurity;
import org.springframework.security.config.annotation.web.configuration.WebSecurityConfiguration;
import org.springframework.security.config.annotation.web.configuration.WebSecurityConfigurerAdapter;
import org.springframework.security.config.http.SessionCreationPolicy;
import org.springframework.security.crypto.bcrypt.BCryptPasswordEncoder;
import org.springframework.security.crypto.password.PasswordEncoder;
import org.springframework.security.web.authentication.UsernamePasswordAuthenticationFilter;
import javax.annotation.Resource;
@Configuration
@EnableGlobalMethodSecurity(prePostEnabled = true)
//实现Security提供的WebSecurityConfigurerAdapter类，就可以改变密码校验的规则了
public class SecurityConfig extends WebSecurityConfigurerAdapter {
@Resource
private JwtAuthenticationTokenFilter jwtAuthenticationTokenFilter;
@Resource
private AccessDeniedHandlerImpl accessDeniedHandler;
@Resource
private AuthenticationEntryPointImpl authenticationEntryPoint;
@Bean
//把BCryptPasswordEncoder对象注入Spring容器中，SpringSecurity就会使用该PasswordEncoder来进行密码校验
//注意也可以注入PasswordEncoder，效果是一样的，因为PasswordEncoder是BCry..的父类
public PasswordEncoder passwordEncoder(){
return new BCryptPasswordEncoder();
}
//在配置类SecurityConfig中将authenticationManagerBean()注入容器之后，就可以直接从容器中取出AuthenticationManager对象了
@Bean
@Override
public AuthenticationManager authenticationManagerBean() throws Exception {
return super.authenticationManagerBean();
}
//关闭csrf、允许"/user/login"请求匿名访问、其余请求必须先通过认证
@Override
protected void configure(HttpSecurity http) throws Exception {
http
//由于是前后端分离项目，所以要关闭csrf
.csrf().disable()
//由于是前后端分离项目，所以session是失效的，我们就不通过Session获取SecurityContext
.sessionManagement().sessionCreationPolicy(SessionCreationPolicy.STATELESS)
.and()
//指定让spring security放行登录接口的规则
.authorizeRequests()
// 对于登录接口 anonymous表示允许匿名访问
.antMatchers("/user/login").anonymous()
// 除上面外的所有请求全部需要鉴权认证
.anyRequest().authenticated();
//把token校验过滤器添加到过滤器链中
//第一个参数是上面注入的我们在filter目录写好的类，第二个参数表示你想添加到哪个过滤器之前
http.addFilterBefore(jwtAuthenticationTokenFilter, UsernamePasswordAuthenticationFilter.class);
//异常处理的相关配置
http.exceptionHandling()
//配置认证失败的处理器
.authenticationEntryPoint(authenticationEntryPoint)
//配置授权失败的处理器
.accessDeniedHandler(accessDeniedHandler);
}
}
④测试异常处理效果
启动项目、Redis服务器，使用postman用错误的用户名密码发送登录请求，响应如下：
修改控制层HelloController中访问hello页面所需的权限，模拟用户没有权限的情况，重新启动项目，使用Postman登录后访问hello页面
@PreAuthorize("hasAuthority('system:dept:list111')")响应如下：
6.跨域问题解决
①什么是跨域问题及其解决思路
由于我们的SpringSecurity负责所有请求和资源的管理，当请求经过SpringSecurity时，如果SpringSecurity不允许跨域，那么也是会被拦截，所以下面我们将学习并解决跨域问题。前面我们在测试时，是在postman测试，因此没有出现跨域问题的情况，postman只是负责发请求跟浏览器没关系
浏览器出于安全的考虑，使用 XMLHttpRequest 对象发起HTTP请求时必须遵守同源策略，否则就是跨域的HTTP请求，默认情况下是被禁止的。 同源策略要求源相同才能正常进行通信，即协议、域名、端口号都完全一致。 前后端分离项目，前端项目和后端项目一般都不是同源的，所以肯定会存在跨域请求的问题。
我们可以通过实现如下两个需求来解决跨域问题：
1、开启SpringBoot的允许跨域访问
2、开启SpringSecurity的允许跨域访问
②具体实现
在config包下新增配置类CorsConfig
查看代码
package com.tzc.tokendemo.config;
import org.springframework.context.annotation.Configuration;
import org.springframework.web.servlet.config.annotation.CorsRegistry;
import org.springframework.web.servlet.config.annotation.WebMvcConfigurer;
/**
* @author 35238
* @date 2023/7/14 0014 20:17
*/
@Configuration
public class CorsConfig implements WebMvcConfigurer {
@Override
//重写spring提供的WebMvcConfigurer接口的addCorsMappings方法
public void addCorsMappings(CorsRegistry registry) {
// 设置允许跨域的路径
registry.addMapping("/**")
// 设置允许跨域请求的域名
.allowedOriginPatterns("*")
// 是否允许cookie
.allowCredentials(true)
// 设置允许的请求方式
.allowedMethods("GET", "POST", "DELETE", "PUT")
// 设置允许的header属性
.allowedHeaders("*")
// 跨域允许时间
.maxAge(3600);
}
}
在SecurityConfig中添加允许跨域的配置——后面经测试这一步注释掉似乎也不会出现跨域问题，可能是浏览器不同的缘故？
//允许跨域
http.cors();SecurityConfig
package com.tzc.tokendemo.config;
import com.tzc.tokendemo.filter.JwtAuthenticationTokenFilter;
import com.tzc.tokendemo.handler.AccessDeniedHandlerImpl;
import com.tzc.tokendemo.handler.AuthenticationEntryPointImpl;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.security.authentication.AuthenticationManager;
import org.springframework.security.config.annotation.method.configuration.EnableGlobalMethodSecurity;
import org.springframework.security.config.annotation.web.builders.HttpSecurity;
import org.springframework.security.config.annotation.web.configuration.WebSecurityConfiguration;
import org.springframework.security.config.annotation.web.configuration.WebSecurityConfigurerAdapter;
import org.springframework.security.config.http.SessionCreationPolicy;
import org.springframework.security.crypto.bcrypt.BCryptPasswordEncoder;
import org.springframework.security.crypto.password.PasswordEncoder;
import org.springframework.security.web.authentication.UsernamePasswordAuthenticationFilter;
import javax.annotation.Resource;
@Configuration
@EnableGlobalMethodSecurity(prePostEnabled = true)
//实现Security提供的WebSecurityConfigurerAdapter类，就可以改变密码校验的规则了
public class SecurityConfig extends WebSecurityConfigurerAdapter {
@Resource
private JwtAuthenticationTokenFilter jwtAuthenticationTokenFilter;
@Resource
private AccessDeniedHandlerImpl accessDeniedHandler;
@Resource
private AuthenticationEntryPointImpl authenticationEntryPoint;
@Bean
//把BCryptPasswordEncoder对象注入Spring容器中，SpringSecurity就会使用该PasswordEncoder来进行密码校验
//注意也可以注入PasswordEncoder，效果是一样的，因为PasswordEncoder是BCry..的父类
public PasswordEncoder passwordEncoder(){
return new BCryptPasswordEncoder();
}
//在配置类SecurityConfig中将authenticationManagerBean()注入容器之后，就可以直接从容器中取出AuthenticationManager对象了
@Bean
@Override
public AuthenticationManager authenticationManagerBean() throws Exception {
return super.authenticationManagerBean();
}
//关闭csrf、允许"/user/login"请求匿名访问、其余请求必须先通过认证
@Override
protected void configure(HttpSecurity http) throws Exception {
http
//由于是前后端分离项目，所以要关闭csrf
.csrf().disable()
//由于是前后端分离项目，所以session是失效的，我们就不通过Session获取SecurityContext
.sessionManagement().sessionCreationPolicy(SessionCreationPolicy.STATELESS)
.and()
//指定让spring security放行登录接口的规则
.authorizeRequests()
// 对于登录接口 anonymous表示允许匿名访问
.antMatchers("/user/login").anonymous()
// 除上面外的所有请求全部需要鉴权认证
.anyRequest().authenticated();
//把token校验过滤器添加到过滤器链中
//第一个参数是上面注入的我们在filter目录写好的类，第二个参数表示你想添加到哪个过滤器之前
http.addFilterBefore(jwtAuthenticationTokenFilter, UsernamePasswordAuthenticationFilter.class);
//异常处理的相关配置
http.exceptionHandling()
//配置认证失败的处理器
.authenticationEntryPoint(authenticationEntryPoint)
//配置授权失败的处理器
.accessDeniedHandler(accessDeniedHandler);
//允许跨域
http.cors();
}
}
为了配合前端项目的访问，这里添加配置将端口号改为8888
server:
port: 8888application.yml
spring:
datasource:
url: jdbc:mysql://localhost:3306/tzc_security?serverTimezone=UTC
username: root
password: abc123
driver-class-name: com.mysql.cj.jdbc.Driver
redis:
host: 192.168.189.129
port: 6379
password: 111111
lettuce:
pool:
max-active: 8
max-wait: -1ms
max-idle: 8
min-idle: 0
# 配置MenuMapper.xml文件的路径
# 也可以不写，因为默认就是在类加载路径(resouces)下的mapper目录的任意层级的后缀为xml的文件，都会被扫描到
mybatis-plus:
mapper-locations: classpath*:/mapper/**/*.xml
server:
port: 8888
③前端测试跨域问题是否解决
下载测试用前端项目
https://cowtransfer.com/s/1e227864a65b41
启动前端项目
//查看node.js是否已经安装
node -v
npm -v
//为前端项目安装npm并启动前端项目
npm install
npm run serve
访问前端项目的登陆页面
填入账号tzc密码1234，点击登录按钮，可以看到成功登录并传回了生成的token
五、源码分析及原理解析
1.权限校验方法
①控制层HelloController中hello()方法上的@PreAuthorize注解中的hasAuthority()方法源码解析
@PreAuthorize("hasAuthority('system:dept:list')")
//查看hasAuthority()方法，内部调用了hasAnyAuthority()方法
public final boolean hasAuthority(String authority) {
return this.hasAnyAuthority(authority);
}
//查看hasAnyAuthority()，内部调用了hasAnyAuthorityName()方法，并传入null作为前缀
public final boolean hasAnyAuthority(String... authorities) {
return this.hasAnyAuthorityName((String)null, authorities);
}
//查看hasAnyAuthorityName()方法，依次遍历字符串数组roles，判断roleSet是否包含其中的任意字符串(加上前缀后)
//若包含则返回true，反之返回false
private boolean hasAnyAuthorityName(String prefix, String... roles) {
Set<String> roleSet = this.getAuthoritySet();
String[] var4 = roles;
int var5 = roles.length;
for(int var6 = 0; var6 < var5; ++var6) {
String role = var4[var6];
String defaultedRole = getRoleWithDefaultPrefix(prefix, role);
if (roleSet.contains(defaultedRole)) {
return true;
}
}
return false;
}
//查看getAuthoritySet()方法，这里的getAuthorities()方法即为我们在loginUser中重写的getAuthorities()方法，
//getAuthorities()方法的作用是将permissions中String类型的权限信息封装成SimpleGrantedAuthority对象
private Set<String> getAuthoritySet() {
if (this.roles == null) {
Collection<? extends GrantedAuthority> userAuthorities = this.authentication.getAuthorities();
if (this.roleHierarchy != null) {
userAuthorities = this.roleHierarchy.getReachableGrantedAuthorities(userAuthorities);
}
//最后将得到的List转换为Set再返回
this.roles = AuthorityUtils.authorityListToSet(userAuthorities);
}
return this.roles;
}
@Override
public Collection<? extends GrantedAuthority> getAuthorities() {
if(authorities != null){
return authorities;
}
//将permissions中String类型的权限信息封装成SimpleGrantedAuthority对象：
//方法一
// authorities = new ArrayList<>();
// for (String permission : permissions) {
// SimpleGrantedAuthority authority = new SimpleGrantedAuthority(permission);
// authorities.add(authority);
// }
//方法二
authorities = permissions.stream()
.map(SimpleGrantedAuthority::new)
.collect(Collectors.toList());
return authorities;
}
总结：
hasAuthority()方法的实现思路就是，根据SecurityContextHolder获取当前用户所拥有的权限集合，再判断hasAuthority()传入的权限参数是否包含在此集合中，
若包含则返回true，权限校验通过，反之返回false校验失败；
②SpringSecurity提供的其它权限校验方法介绍——这些都不太常用，了解即可
hasAnyAuthority方法：可以传入多个权限作为参数，作用是校验用户是否具有其中的任一权限，若具有则返回true
@PreAuthorize("hasAnyAuthority('zidingyi','huanf','system:dept:list')"); //传入3个自定义权限
hasRole方法：传入单个权限作为参数，作用是给权限加上"ROLE_"作为前缀，再判断用户是否具有该权限，若具有则返回true
@PreAuthorize("hasRole('system:dept:list')") //只能传一个权限字符串，多传会报红线
hasAnyRole方法：可以传入多个权限作为参数，作用是给所有权限参数加上"ROLE_"作为前缀，再判断用户是否具有其中的任一权限，若具有则返回true
@PreAuthorize("hasAnyRole('zidingyi','huanf','system:dept:list')")
总结：这些方法底层其实和hasAuthority方法一样都是调用hasAnyAuthorityName(String prefix, String... roles)方法，区别只是传入权限参数的多少和是否加前缀而已；
③自定义权限校验方法
新建包expression，在此包下新建权限校验类MyExpressionRoot
MyExpressionRoot
package com.tzc.tokendemo.expression;
import com.tzc.tokendemo.domain.LoginUser;
import org.springframework.security.core.Authentication;
import org.springframework.security.core.context.SecurityContextHolder;
import org.springframework.stereotype.Component;
import java.util.List;
/**
* @author 35238
* @date 2023/7/16 0016 14:21
*/
@Component("ex")
//自定义权限校验的方法
public class MyExpressionRoot {
//自定义权限校验的方法
public boolean myHasAuthority(String authority){
//获取用户具有的权限字符串，有可能用户具有多个权限字符串，所以获取后是一个集合
Authentication authentication = SecurityContextHolder.getContext().getAuthentication();
//LoginUser是我们在domain目录写好的实体类
LoginUser loginUser = (LoginUser) authentication.getPrincipal();
List<String> permissions = loginUser.getPermissions();
//判断用户权限集合中，是否存在跟业务接口(业务接口的权限字符串会作为authority形参传进来)一样的权限
return permissions.contains(authority);
}
}
将控制层HelloController的hello方法的注解更换为下列——注意此时在注解内的双引号内也要加@符号：
@PreAuthorize("@ex.myHasAuthority('system:dept:list')")HelloController
package com.tzc.tokendemo.controller;
import org.springframework.security.access.prepost.PreAuthorize;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;
@RestController
public class HelloController {
@RequestMapping("/hello")
// @PreAuthorize("hasAuthority('system:dept:list')")
@PreAuthorize("@ex.myHasAuthority('system:dept:list')")
public String hello(){
return "hello";
}
}
测试自定义权限校验方法是否有效：
启动项目、Redis服务器，使用postman发出登录请求（注意此前项目的端口号已经改为了8888，postman发送请求的url也要改端口号）
使用生成的token请求访问hello页面，成功访问
④基于配置的权限控制——之前的都是基于@PreAuthorize注解
除了可以使用@PreAuthorize注解来规定权限控制方法外，还可以直接在SecurityConfig中进行配置（两种方法任意采取其中一种即可）
//基于配置的的权限控制。指定接口的地址，为HelloController类里面的/hello接口，指定权限为system:dept:list
.antMatchers("/hello").hasAuthority("system:dept:list")
2.CSRF是什么，为什么要在配置类中关闭CSRF
在SecurityConfig类里面的configure方法里面，有一个配置如下，我们上面都没有去学习，下面就来了解一下
http..csrf().disable(); //关闭csrf，可防护csrf攻击。如果不关闭的话
CSRF是指跨站请求伪造（Cross-site request forgery），是web常见的攻击之一，如图
详细看这篇博客: https://blog.csdn.net/freeking101/article/details/86537087
防护: SpringSecurity去防止CSRF攻击的方式就是通过csrf_token。后端会生成一个csrf_token，前端发起请求的时候需要携带这个csrf_token,后端会有过滤器进行校验，如果没有携带或者是伪造的就不允许访问
我们可以发现CSRF攻击依靠的是cookie中所携带的认证信息。但是在前后端分离的项目中我们的认证信息其实是token，而token并不是存储中cookie中，并且需要前端代码去把token设置到请求头中才可以，所以CSRF攻击
就不用担心了。
因此，前后端分离的项目天然可以防范csrf攻击，无需再携带和验证csrf_token，故在配置类关闭csrf；
3.自定义认证成功、认证失败、注销成功处理器
①什么是认证成功、认证失败、注销成功处理器
在SpringSecurity原始的认证流程中，在通过UsernamePasswordAuthenticationFilter进行登录认证后，若认证成功则会接着调用认证成功处理器AuthenticationSuccessHandler，
若认证失败则会调用认证失败处理器AuthenticationFailureHandler，在执行登出操作后会调用注销成功处理器LogoutSuccessHandler，
我们可以对这些处理器接口进行具体实现，添加自己想要进行的操作；
（为什么在TokenDemo项目工程不能进行操作: 因为TokenDemo项目工程把security默认提供的浏览器登录页面去掉了，我们当时在笔记中“登录接口的实现”那里，把默认的登录接口改掉了，可前去翻笔记，直到现在都没有
使用过security默认提供的浏览器登录页面，一直用的postman发请求。而自定义successHandler，要求必须要使用到security默认提供的浏览器登录页面(严谨说是登录表单，如下图)，所以就只能回到最初的项目）
②自定义认证成功处理器
添加认证成功处理器
MySuccessHandler
package com.huanf.handler;
import org.springframework.security.core.Authentication;
import org.springframework.security.web.authentication.AuthenticationSuccessHandler;
import org.springframework.stereotype.Component;
import javax.servlet.ServletException;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.io.IOException;
/**
* @author 35238
* @date 2023/7/16 0016 21:13
*/
@Component
//官方提供的AuthenticationSuccessHandler接口的实现类，用于自定义'登录成功的处理器'
public class MySuccessHandler implements AuthenticationSuccessHandler {
@Override
//实现security官方提供的AuthenticationSuccessHandler接口的下面这个抽象方法
public void onAuthenticationSuccess(HttpServletRequest request, HttpServletResponse response, Authentication authentication) throws IOException, ServletException {
//response是认证登录的请求响应对象，authentication是认证之后的对象
//我们只验证认证成功之后被调用到下面那行代码就行，如果是要自定义'登录成功的处理器'，那么就在下面写具体代码即可
System.out.println("登录认证成功了^V^");
}
}
在SecurityConfig中将认证成功处理器配置进去
http.formLogin().successHandler(xxsuccessHandler);SecurityConfig
package com.huanf.config;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.annotation.Configuration;
import org.springframework.security.config.annotation.web.builders.HttpSecurity;
import org.springframework.security.config.annotation.web.configuration.WebSecurityConfigurerAdapter;
import org.springframework.security.web.authentication.AuthenticationSuccessHandler;
/**
* @author 35238
* @date 2023/7/16 0016 21:36
*/
@Configuration
//SpringSecurity的配置类
public class SecurityConfig extends WebSecurityConfigurerAdapter {
@Autowired
//注入security官方提供的AuthenticationSuccessHandler接口
private AuthenticationSuccessHandler xxsuccessHandler;
@Override
protected void configure(HttpSecurity http) throws Exception {
//super.configure(http); //默认写的就这一行
//上面注入的接口作为successHandler方法的参数写进来。注意最重要的是'formLogin登录表单'，不然链式编程写不下去
//这样就相当于把刚刚在MySuccessHandler类里面的"自定义'登录成功的处理器'"，配置给security了
http.formLogin().successHandler(xxsuccessHandler);
//其它默认的认证接口，例如业务接口的认证限制，要配，因为你重写自定义了之后，原有的配置都被覆盖，不写的话业务接口就没有security认证拦截的功能了
//我的截图里面没有下面这一行的代码，希望你们不要漏写
http.authorizeRequests().anyRequest().authenticated();
}
}
③自定义认证失败处理器
添加认证失败处理器
MyFailureHandler
package com.huanf.handler;
import org.springframework.security.core.AuthenticationException;
import org.springframework.security.web.authentication.AuthenticationFailureHandler;
import org.springframework.stereotype.Component;
import javax.servlet.ServletException;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.io.IOException;
/**
* @author 35238
* @date 2023/7/17 0017 13:57
*/
@Component
//官方提供的AuthenticationFailureHandler接口的实现类，用于自定义'登录失败的处理器'
public class MyFailureHandler implements AuthenticationFailureHandler {
@Override
public void onAuthenticationFailure(HttpServletRequest request, HttpServletResponse response, AuthenticationException exception) throws IOException, ServletException {
//我们只验证认证成功之后被调用到下面那行代码就行，如果是要自定义'登录成功的处理器'，那么就在下面写具体代码即可
System.out.println("登录认证失败了*_*，请检查用户名或密码");
}
}
在SecurityConfig中将认证失败处理器配置进去
http.formLogin()
//登录认证成功的处理器
.successHandler(xxsuccessHandler)
//登录认证失败的处理器
.failureHandler(xxfailureHandler);SecurityConfig
package com.huanf.config;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.annotation.Configuration;
import org.springframework.security.config.annotation.web.builders.HttpSecurity;
import org.springframework.security.config.annotation.web.configuration.WebSecurityConfigurerAdapter;
import org.springframework.security.web.authentication.AuthenticationFailureHandler;
import org.springframework.security.web.authentication.AuthenticationSuccessHandler;
/**
* @author 35238
* @date 2023/7/16 0016 21:36
*/
@Configuration
//SpringSecurity的配置类
public class SecurityConfig extends WebSecurityConfigurerAdapter {
@Autowired
//注入security官方提供的AuthenticationSuccessHandler接口
private AuthenticationSuccessHandler xxsuccessHandler;
@Autowired
//注入security官方提供的AuthenticationSuccessHandler接口
private AuthenticationFailureHandler xxfailureHandler;
@Override
protected void configure(HttpSecurity http) throws Exception {
//super.configure(http); //默认写的就这一行
//上面注入的接口作为successHandler方法的参数写进来。注意最重要的是'formLogin登录表单'，不然链式编程写不下去
//这样就相当于把刚刚在MySuccessHandler类里面的"自定义'登录成功的处理器'"，配置给security了
http.formLogin()
//登录认证成功的处理器
.successHandler(xxsuccessHandler)
//登录认证失败的处理器
.failureHandler(xxfailureHandler);
//其它默认的认证接口，例如业务接口的认证限制，要配，因为你重写自定义了之后，原有的配置都被覆盖，不写的话业务接口就没有security认证拦截的功能了
//我的截图里面没有下面这一行的代码，希望你们不要漏写
http.authorizeRequests().anyRequest().authenticated();
}
}
④自定义注销成功处理器
添加注销成功处理器
MyLogoutSuccessHandler
package com.huanf.handler;
import org.springframework.security.core.Authentication;
import org.springframework.security.web.authentication.logout.LogoutSuccessHandler;
import org.springframework.stereotype.Component;
import javax.servlet.ServletException;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.io.IOException;
/**
* @author 35238
* @date 2023/7/17 0017 14:57
*/
@Component
//官方提供的LogoutSuccessHandler接口的实现类，用于自定义'登出成功的处理器'
public class MyLogoutSuccessHandler implements LogoutSuccessHandler {
@Override
public void onLogoutSuccess(HttpServletRequest request, HttpServletResponse response, Authentication authentication) throws IOException, ServletException {
//我们只验证登出成功之后被调用到下面那行代码就行，如果是要自定义'登出成功的处理器'，那么就在下面写具体代码即可
System.out.println("退出登录成功");
}
}
在SecurityConfig中将注销成功处理器配置进去
//登出成功的处理器的配置
http.logout()
//登出成功的处理器
.logoutSuccessHandler(xxlogoutSuccessHandler);SecurityConfig
package com.huanf.config;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.annotation.Configuration;
import org.springframework.security.config.annotation.web.builders.HttpSecurity;
import org.springframework.security.config.annotation.web.configuration.WebSecurityConfigurerAdapter;
import org.springframework.security.web.authentication.AuthenticationFailureHandler;
import org.springframework.security.web.authentication.AuthenticationSuccessHandler;
import org.springframework.security.web.authentication.logout.LogoutSuccessHandler;
/**
* @author 35238
* @date 2023/7/16 0016 21:36
*/
@Configuration
//SpringSecurity的配置类
public class SecurityConfig extends WebSecurityConfigurerAdapter {
@Autowired
//注入security官方提供的AuthenticationSuccessHandler接口
private AuthenticationSuccessHandler xxsuccessHandler;
@Autowired
//注入security官方提供的AuthenticationSuccessHandler接口
private AuthenticationFailureHandler xxfailureHandler;
@Autowired
//注入security官方提供的LogoutSuccessHandler接口
private LogoutSuccessHandler xxlogoutSuccessHandler;
@Override
protected void configure(HttpSecurity http) throws Exception {
//super.configure(http); //默认写的就这一行
//上面注入的接口作为successHandler方法的参数写进来。注意最重要的是'formLogin登录表单'，不然链式编程写不下去
//这样就相当于把刚刚在MySuccessHandler类里面的"自定义'登录成功的处理器'"，配置给security了
http.formLogin()
//登录认证成功的处理器
.successHandler(xxsuccessHandler)
//登录认证失败的处理器
.failureHandler(xxfailureHandler);
//登出成功的处理器的配置
http.logout()
//登出成功的处理器
.logoutSuccessHandler(xxlogoutSuccessHandler);
//其它默认的认证接口，例如业务接口的认证限制，要配，因为你重写自定义了之后，原有的配置都被覆盖，不写的话业务接口就没有security认证拦截的功能了
//我的截图里面没有下面这一行的代码，希望你们不要漏写
http.authorizeRequests().anyRequest().authenticated();
}
}
