0.简介
1. 介绍
springsecurity是安全框架，准确来说是安全管理框架。相比与另外一个安全框架Shiro，springsecurity提供了更丰富的功能，社区资源也比Shiro丰富
springsecurity框架用于Web应用的需要进行认证和授权
认证：验证当前访问系统的是不是本系统的用户，并且要确认具体是哪个用户
授权：经过认证后判断当前用户是否有权限进行某个操作。认证和授权也是SpringSecurity作为安全框架的核心功能
认证和授权也是SpringSecurity作为安全框架的核心功能
该笔记对标的视频是 BV1mm4y1X7Hc，拿着这个BV号在b站搜，就能搜到课程视频
1.快速入门
第一步 修改pom.xml文件为如下
<parent>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-parent</artifactId>
<version>2.5.0</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>第二步: 在idea修改maven的相关设置，然后刷新maven
第三步: 在 src/main/java 目录新建 com.huanf.SpringsecurityDome01Application类，作为项目的引导类，也叫启动类。在SpringsecurityDome01Application类写入如下
package com.huanf;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
@SpringBootApplication
public class SpringsecurityDome01Application {
public static void main(String[] args) {
SpringApplication.run(SpringsecurityDome01Application.class, args);
}
}
第四步: 在 src/main/java/com.huanf 目录新建controller.HelloController类，写入如下
package com.huanf.controller;
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;
/**
* @Author：豆浆
* @name :HelloController
* @Date：2024/4/16 11:15
*/
@RestController
public class HelloController {
@RequestMapping("/hello")
public String hello(){
return "hello";
}
}
第五步: 运行SpringsecurityDome01Application引导类，然后浏览器访问如下，测试SpringBoot工程有没有搭建成功
http://localhost:8080/hello
2. Boot整合Security
第一步: 在pom.xml添加如下
<!--SpringSecurity启动器-->
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-security</artifactId>
</dependency>
引入依赖后我们在尝试去访问之前的接口就会自动跳转到一个SpringSecurity的默认登录页面，默认用户名是user,密码会输出在控制台。必须登录之后才能对接口进行访问
第二步: 重新运行SpringsecurityDome01Application引导类，浏览器访问如下
访问时会自动被下面的链接拦截
第三步: 在idea控制台查看登录的密码，用户名是user
登录之后，就会自动跳到并访问下面的地址
第四步: 默认的退出登录接口如下
3.认证
springsecurity的权限管理，是先授权后认证，所以我们先学习认证这一部分
流程图如下，注意下图的jwt指的是 json web token，jwt是登录校验的时候用的技术，可以根据指定的算法进行信息的加密和解密
1. spring security原理
Spring Security的原理其实就是一个过滤器链，内部包含了提供各种功能的过滤器。例如快速入门案例里面使用到的三种过滤器，如下图
监听器 -> 过滤器链 -> dispatcherservlet(前置拦截器 -> mapperHandle -> 后置拦截器 -> 最终拦截器)
一、UsernamePasswordAuthenticationFilter: 负责处理我们在登陆页面填写了用户名密码后的登陆请求。入门案例的认证工作主要有它负责
二、ExceptionTranslationFilter：处理过滤器链中抛出的任何AccessDeniedException和AuthenticationException
三、FilterSecurityInterceptor：负责权限校验的过滤器
注意上图，橙色部分表示认证，黄色部分表示异常处理，红色部分表示授权
如何查看security提供的过滤器有哪几个，或者叫哪几种，如下
2. 认证流程
我们来详细学一下上面 '1. springsecurity原理' 的橙色部分，也就是认证那部分的知识
一、Authentication接口: 它的实现类，表示当前访问系统的用户，封装了用户相关信息
二、AuthenticationManager接口：定义了认证Authentication的方法
三、UserDetailsService接口：加载用户特定数据的核心接口。里面定义了一个根据用户名查询用户信息的方法
四、UserDetails接口：提供核心用户信息。通过UserDetailsService根据用户名获取处理的用户信息要封装成UserDetails对象返回。然后将这些信息封装到Authentication对象中
3. 自定义security的思路
在 '快速入门' 中，我们在Boot项目里面引入了Security依赖，实现了当我们访问某个业务接口时，会被Security的login接口拦截，但是如果我们不想使用Security默认的登录页面，那么怎么办呢，还有，springsecurity的校验，我们希望是根据数据库来做校验，那么怎么实现呢。我们需要实现如下
【登录-未实现】
①、自定义登录接口。用于调用ProviderManager的方法进行认证 如果认证通过生成jwt，然后把用户信息存入redis中
②、自定义UserDetailsService接口的实现类。在这个实现类中去查询数据库
【校验-未实现】
①、定义Jwt认证过滤器。用于获取token，然后解析token获取其中的userid，还需要从redis中获取用户信息，然后存入SecurityContextHolder
4. 自定义security的搭建
注意: 这次搭建的项目，会在下面所有的笔记中都学习，不管是 '认证' 还是 '授权'，反正下面谈到什么目录、什么类，说的都是这个项目
第四步: 打开idea，新建maven项目
第五步: 修改pom.xml文件为如下
<parent>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-parent</artifactId>
<version>2.5.0</version>
</parent>
<dependencies>
<!--还要引入这个，不然后面javax.servlet依赖找不到-->
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-web</artifactId>
</dependency>
<!--springboot整合springsecurity-->
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-security</artifactId>
</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>
<!--引入Lombok依赖，方便实体类开发-->
<dependency>
<groupId>org.projectlombok</groupId>
<artifactId>lombok</artifactId>
</dependency>
</dependencies>
第七步: 在 src/main/java 目录新建 com.huanf.TokenApplication 类，写入如下
package com.sangeng;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
/**
* @Author：豆浆
* @name :TokenApplication
* @Date：2024/4/16 12:12
*/
@SpringBootApplication
public class TokenApplication {
public static void main(String[] args) {
SpringApplication.run(TokenApplication.class,args);
}
}
第八步: 在 src/main/java/com.huanf 目录新建 controller.HelloController 类，写入如下
package com.sangeng.controller;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;
/**
* @Author：豆浆
* @name :HelloController
* @Date：2024/4/16 12:13
*/
@RestController
public class HelloController {
@RequestMapping("/hello")
public String hello(){
return "hello";
}
}
5. 自定义security的代码
第一步: 在 src/main/java/com.huanf 目录新建 utils.FastJsonRedisSerializer 类，写入如下
package com.huanf.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;
//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);
}
}
第二步: 在 src/main/java/com.huanf 目录新建 config.RedisConfig 类，写入如下
package com.sangeng.config;
import com.sangeng.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;
@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;
}
}
第三步: 在 src/main/java/com.huanf 目录新建 domain.ResponseResult 类，写入如下
package com.sangeng.domain;
import com.fasterxml.jackson.annotation.JsonInclude;
//响应类
@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;
}
}
第四步: 在 utile 目录新建 JwtUtil 类，写入如下
package com.sangeng.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;
//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();
}
}
第五步: 在 utile 目录新建 RedisCache 类，写入如下
package com.sangeng.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;
@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);
}
}
第六步: 在 utile 目录新建 WebUtils 类，写入如下
package com.sangeng.utils;
import javax.servlet.http.HttpServletResponse;
import java.io.IOException;
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;
}
}
第七步: 在 domain目录新建 User类，写入如下
package com.sangeng.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;
//用户表(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;
}上面的代码总体如下图所示
6. 自定义security的数据库
第一步: 数据库校验用户。从之前的分析我们可以知道，我们自定义了一个UserDetailsService，让SpringSecurity使用我们的UserDetailsService。我们自己的UserDetailsService可以从数据库中查询用户名和密码。我们先创建一个用户表， 建表语句如下：
注意: 要想让用户的密码是明文存储，需要在密码前加{noop}，作用是例如等下在浏览器登陆的时候就可以用huanf作为用户名，112233作为密码来登陆了
create database if not exists huanf_security;
use huanf_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','豆浆','{noop}112233','0',DEFAULT,DEFAULT,DEFAULT,DEFAULT,'1',DEFAULT,DEFAULT,DEFAULT,DEFAULT,DEFAULT);
第二步: 在pom.xml添加如下
<!--引入MybatisPuls依赖-->
<dependency>
<groupId>com.baomidou</groupId>
<artifactId>mybatis-plus-boot-starter</artifactId>
<version>3.4.3</version>
</dependency>
<!--引入mysql驱动的依赖-->
<dependency>
<groupId>mysql</groupId>
<artifactId>mysql-connector-java</artifactId>
</dependency>
第三步: 在 src/main/resources 目录新建File，文件名为application.yml，写入如下
spring:
datasource:
url: jdbc:mysql://localhost:3306/huanf_security?characterEncoding=utf-8&serverTimezone=UTC
username: root
password: 228675
driver-class-name: com.mysql.cj.jdbc.Driver
第四步: 在 src/main/java/com.huanf 目录新建 mapper.UserMapper 接口，写入如下
package com.huanf.mapper;
import com.baomidou.mybatisplus.core.mapper.BaseMapper;
import com.huanf.domain.User;
@Service
public interface UserMapper extends BaseMapper<User> {
}
第五步: 在TokenApplication引导类添加如下
@MapperScan("com.huanf.mapper")
第六步: 在pom.xml添加如下
<!--引入Junit，用于测试-->
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-test</artifactId>
</dependency>
第七步: 在 src/test/java 目录新建 com.huanf.MapperTest类，写入如下。作用是测试mybatis-plus是否正常
package com.sangeng;
import com.sangeng.domain.User;
import com.sangeng.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;
/**
* @Author：豆浆
* @name :MapperTest
* @Date：2024/4/23 15:59
*/
@SpringBootTest
public class MapperTest {
@Autowired
private UserMapper userMapper;
@Test
public void testUserMapper(){
//查询所有用户
List<User> users = userMapper.selectList(null);
System.out.println(users);
}
}
第八步: 运行MapperTest类的testUserMapper方法，看是否能查到数据库的所有用户。到此，可以确定数据库是没问题的，环境到此就准备好了
7. 自定义security的认证实现
上面我们已经把准备工作做好了，包括搭建、代码、数据库。接下来我们会实现让security在认证的时候，根据我们数据库的用户和密码进行认证，也就是被security拦截业务接口，出现登录页面之后，我们需要通过输入数据库里的用户和密码来登录，而不是使用security默认的用户和密码进行登录
思路: 只需要新建一个实现类，在这个实现类里面实现Security官方的UserDetailsService接口，然后重写里面的loadUserByUsername方法
注意: 重写好loadUserByUsername方法之后，我们需要把拿到 '数据库与用户输入的数据' 进行比对的结果，也就是user对象这个结果封装成能被 'Security官方的UserDetailsService接口' 接收的类型，例如可以封装成我们下面写的LoginUser类型。然后才能伪装好数据，给Security官方的认证机制去对比user对象与数据库的结果是否匹配。Security官方的认证机制会拿LoginUser类的方法数据(数据库拿，不再用默认的)，跟我们封装过去的user对象进行匹配，要使匹配一致，就证明认证通过，也就是用户在浏览器页面输入的用户名和密码能被Security认证通过，就不再拦截该用户去访问我们的业务接口
第一步: 在domain目录新建LoginUser类，作为UserDetails接口(Security官方提供的接口)的实现类
package com.huanf.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 //get和set方法
@NoArgsConstructor //无参构造
@AllArgsConstructor //带参构造
//实现UserDetails接口之后，要重写UserDetails接口里面的7个方法
public class LoginUser implements UserDetails {
private User xxuser;
@Override
//用于返回权限信息。现在我们正在学'认证'，'权限'后面才学。所以返回null即可
public Collection<? extends GrantedAuthority> getAuthorities() {
return null;
}
@Override
//用于获取用户密码。由于使用的实体类是User，所以获取的是数据库的用户密码
public String getPassword() {
return xxuser.getPassword();
}
@Override
//用于获取用户名。由于使用的实体类是User，所以获取的是数据库的用户名
public String getUsername() {
return xxuser.getUserName();
}
@Override
//判断登录状态是否过期。把这个改成true，表示永不过期
public boolean isAccountNonExpired() {
return true;
}
@Override
//判断账号是否被锁定。把这个改成true，表示未锁定，不然登录的时候，不让你登录
public boolean isAccountNonLocked() {
return true;
}
@Override
//判断登录凭证是否过期。把这个改成true，表示永不过期
public boolean isCredentialsNonExpired() {
return true;
}
@Override
//判断用户是否可用。把这个改成true，表示可用状态
public boolean isEnabled() {
return true;
}
}
第二步: 在 src/main/java/com.huanf 目录新建 service.impl.MyUserDetailServiceImpl 类，写入如下
package com.huanf.service.impl;
import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.huanf.domain.LoginUser;
import com.huanf.domain.User;
import com.huanf.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 java.util.Objects;
@Service
public class MyUserDetailServiceImpl implements UserDetailsService {
@Autowired
private UserMapper userMapper;
@Override
//UserDetails是Security官方提供的接口
public UserDetails loadUserByUsername(String xxusername) throws UsernameNotFoundException {
//查询用户信息。我们写的userMapper接口里面是空的，所以调用的是mybatis-plus提供的方法
LambdaQueryWrapper<User> queryWrapper = new LambdaQueryWrapper<>();
//eq方法表示等值匹配，第一个参数是数据库的用户名，第二个参数是我们传进来的用户名，这两个参数进行比较是否相等
queryWrapper.eq(User::getUserName,xxusername);
User user = userMapper.selectOne(queryWrapper);
//如果用户传进来的用户名，但是数据库没有这个用户名，就会导致我们是查不到的情况，那么就进行下面的判断。避免程序安全问题
if(Objects.isNull(user)){//判断user对象是否为空。当在数据库没有查到数据时，user就会为空，也就会进入这个判断
throw new RuntimeException("用户名或者密码错误");
}
//把查询到的user结果，封装成UserDetails类型，然后返回。
//但是由于UserDetails是个接口，所以我们先需要在domino目录新建LoginUser类，作为UserDetails的实现类，再写下面那行
return new LoginUser(user);
}
}第三步: 测试。运行TokenApplication引导类，浏览器输入如下，然后我们输入一下登录的用户名和密码，看是不是根据数据库来进行认证
http://localhost:8080/hello
8. 密码加密校验问题
上面我们实现了自定义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 类，写入如下。作用是根据原文，生成一个密文
package com.sangeng.config;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.security.config.annotation.web.configuration.WebSecurityConfigurerAdapter;
import org.springframework.security.crypto.bcrypt.BCryptPasswordEncoder;
import org.springframework.security.crypto.password.PasswordEncoder;
/**
* @Author：豆浆
* @name :SecurityConfig
* @Date：2024/4/23 16:50
*/
@Configuration
//实现Security提供的WebSecurityConfigurerAdapter类，就可以改变密码校验的规则了
public class SecurityConfig extends WebSecurityConfigurerAdapter {
@Bean
//把BCryptPasswordEncoder对象注入Spring容器中，SpringSecurity就会使用该PasswordEncoder来进行密码校验
//注意也可以注入PasswordEncoder，效果是一样的，因为PasswordEncoder是BCry..的父类
public PasswordEncoder passwordEncoder(){
return new BCryptPasswordEncoder();
}
}
第二步: 测试。在MapperTest类，添加如下，然后运行 xxTestBCryptPasswordEncoder 方法
@Test
public void xxTestBCryptPasswordEncoder(){
//如果不想在下面那行new的话，那么就在该类注入PasswordEncoder，例如如下
/**
* @Autowired
* private PasswordEncoder passwordEncoder;
*/
BCryptPasswordEncoder passwordEncoder = new BCryptPasswordEncoder();
//模拟用户输入的密码
String encode1 = passwordEncoder.encode("1234");
//再模拟一次用户输入的密码
String encode2 = passwordEncoder.encode("1234");
//虽然这两次的密码都是一样的，但是加密后是不一样的。每次运行，对同一原文都会有不同的加密结果
//原因:会添加随机的盐，加密结果=盐+原文+加密。达到每次加密后的密文都不相同的效果
System.out.println(encode1);
System.out.println(encode2);
}
【然后是 '校验'，如何实现，如下】
第一步(已做可跳过): 在config目录新建 SecurityConfig 类，写入如下。作用是根据原文，生成一个密文
package com.sangeng.config;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.security.config.annotation.web.configuration.WebSecurityConfigurerAdapter;
import org.springframework.security.crypto.bcrypt.BCryptPasswordEncoder;
import org.springframework.security.crypto.password.PasswordEncoder;
/**
* @Author：豆浆
* @name :SecurityConfig
* @Date：2024/4/23 16:50
*/
@Configuration
//实现Security提供的WebSecurityConfigurerAdapter类，就可以改变密码校验的规则了
public class SecurityConfig extends WebSecurityConfigurerAdapter {
@Bean
//把BCryptPasswordEncoder对象注入Spring容器中，SpringSecurity就会使用该PasswordEncoder来进行密码校验
//注意也可以注入PasswordEncoder，效果是一样的，因为PasswordEncoder是BCry..的父类
public PasswordEncoder passwordEncoder(){
return new BCryptPasswordEncoder();
}
}
第二步: 测试。在MapperTest类，添加如下，然后运行 yyTestBCryptPasswordEncoder 方法
@Test
public void yyTestBCryptPasswordEncoder(){
BCryptPasswordEncoder passwordEncoder = new BCryptPasswordEncoder();
//模拟用户输入了1234(第一个参数)，然后我们去跟数据库的密文进行比较(第二个参数)
boolean result = passwordEncoder.matches("1234", "$2a$10$zOitKu6UNk.b/iPFTtIj2u80sH/dfJI9vFr57qhDGteuXj/Wl8uSy");
//看一下比对结果
System.out.println(result);
}
9. jwt工具类实现加密校验
刚刚我们在测试类学习了密码的加密和校验，我们下面会先学如何使用jwt工具类实现密码的加密解密
首先是在pom.xml添加如下(已做可跳过)
<!--jwt依赖-->
<dependency>
<groupId>io.jsonwebtoken</groupId>
<artifactId>jjwt</artifactId>
<version>0.9.0</version>
</dependency>然后我们在上面的 '认证' 的 '5. 自定义security的代码' 已经创建了大量的类，写了大量的代码，但是还没有使用到，例如jwt的工具类，我们在utils目录创建的JwtUtil类还没有使用过，下面就来使用。如下
【加密】
第一步: 把JwtUtil类的main方法修改为如下，作用是使用createJWT方法生成指定字符串的密文J
public static void main(String[] args) throws Exception {
//加密指定字符串，xxjwt是123456加密后的密文
String xxjwt = createJWT("123456");
System.out.println(xxjwt);
}第二步: 运行JwtUtil类的main方法
【校验】
第一步: 把JwtUtil类的main方法修改为如下，作用是使用createJWT方法生成指定字符串的密文
public static void main(String[] args) throws Exception {
Claims xxclaims = parseJWT("eyJhbGciOiJIUzI1NiJ9.eyJqdGkiOiIyYWMxODhlZjJmMDE0YTU5YjU1YzM4MWNmMjMzNjA1MiIsInN1YiI6IjEyMzQ1NiIsImlzcyI6InNnIiwiaWF0IjoxNjg5MTMwMTE3LCJleHAiOjE2ODkxMzM3MTd9.RxI0dlCrDhYspi4VoIlblk7J9tvOO8Sd5p8bbFrd0mg");
//把上面那行的密文解密(校验)为原文
String yysubject = xxclaims.getSubject();
//输出解密后的原文
System.out.println(yysubject);
}第二步: 运行JwtUtil类的main方法
10. 登录接口的分析
在上面学习的 '认证' 的 '3. 自定义security的思路' 当中，我们有一个功能需求是自定义登录接口，这个功能还没有实现，我们需要实现这个功能，但是，实现这个功能需要使用到jwt，我们刚刚也学习了使用jwt来实现加密校验，那么下面就正式学习如何实现这个登录接口，首先是分析，如下
①我们需要自定义登陆接口，也就是在controller目录新建LoginController类，在controller方法里面去调用service接口，在service接口实现AuthenticationManager去进行用户的认证，注意，我们定义的controller方法要让SpringSecurity对这个接口放行(如果不放行的话，会被SpringSecurity拦截)，让用户访问这个接口的时候不用登录也能访问。
②在service接口中我们通过AuthenticationManager的authenticate方法来进行用户认证,所以需要在SecurityConfig中配置把AuthenticationManager注入容器
③认证成功的话要生成一个jwt，放入响应中返回。并且为了让用户下回请求时能通过jwt识别出具体的是哪个用户，我们需要把用户信息存入redis，可以把用户id作为key。
11. redis下载安装启动
Redis是一款key-value存储结构的内存级NoSQL数据库，也就是运行在内存上的数据库
●支持多种数据存储格式
●支持持久化
●支持集群
Redis下载(windows版-Redis-x64-5.0.14.msi)
https://github.com/tporadowski/redis/releases为方便学习，可拿我在用的redis，如下网盘有软件包
安装完成之后，打开安装目录
redis的服务端启动命令
redis-server.exe redis.windows.conf
redis的客户端启动命令
redis-cli.exe
具体启动步骤如下。注意: 如果你的redis启动后控制台没蜂窝图案，那么请认真按照下面第二张图的步骤，数字表示命令的先后顺序
12. 登录接口的实现
第一步: 修改数据库的huanf用户的密码，把112233明文修改为对应的密文。密文可以用jwt工具类加密112233看一下，或者直接复制我给出的
UPDATE sys_user SET password = '$2a$10$YPnG.IYUk0mMechaxSibBuKmNeTzvuHdcxkqvoxizsll6WCQG9CHG' WHERE id = 2;
第二步: 在 SecurityConfig 类添加如下
@Bean
@Override
public AuthenticationManager authenticationManagerBean() throws Exception {
return super.authenticationManagerBean();
}
@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();
}
第三步: 在service目录新建 LoginService 接口，写入如下
package com.huanf.service;
import com.huanf.domain.ResponseResult;
import com.huanf.domain.User;
import org.springframework.stereotype.Service;
@Service
public interface LoginService {
ResponseResult login(User user);
}
第四步: 在service目录新建 impl.LoginServiceImpl 类，写入如下
package com.huanf.service.impl;
import com.huanf.domain.LoginUser;
import com.huanf.domain.ResponseResult;
import com.huanf.domain.User;
import com.huanf.service.LoginService;
import com.huanf.utils.JwtUtil;
import com.huanf.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 java.util.HashMap;
import java.util.Map;
import java.util.Objects;
@Service
//写登录的核心代码
public class LoginServiceImpl implements LoginService {
@Autowired
//先在SecurityConfig，使用@Bean注解重写官方的authenticationManagerBean类，然后这里才能注入成功
private AuthenticationManager authenticationManager;
@Autowired
//RedisCache是我们在utils目录写好的类
private RedisCache redisCache;
@Override
//ResponseResult和user是我们在domain目录写好的类
public ResponseResult login(User user) {
//用户在登录页面输入的用户名和密码
UsernamePasswordAuthenticationToken authenticationToken = new UsernamePasswordAuthenticationToken(user.getUserName(),user.getPassword());
//获取AuthenticationManager的authenticate方法来进行用户认证
Authentication authenticate = authenticationManager.authenticate(authenticationToken);
//判断上面那行的authenticate是否为null，如果是则认证没通过，就抛出异常
if(Objects.isNull(authenticate)){
throw new RuntimeException("登录失败");
}
//如果认证通过，就使用userid生成一个jwt，然后把jwt存入ResponseResult后返回
LoginUser loginUser = (LoginUser) authenticate.getPrincipal();
String userid = loginUser.getXxuser().getId().toString();
String jwt = JwtUtil.createJWT(userid);
//把完整的用户信息存入redis，其中userid作为key，注意存入redis的时候加了前缀 login:
Map<String, String> map = new HashMap<>();
map.put("token",jwt);
redisCache.setCacheObject("login:"+userid,loginUser);
return new ResponseResult(200,"登录成功",map);
}
}
第五步: 在controller目录新建 LoginController 类，写入如下
package com.huanf.controller;
import com.huanf.domain.ResponseResult;
import com.huanf.domain.User;
import com.huanf.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;
@RestController
public class LoginController {
@Autowired
//LoginService是我们在service目录写好的接口
private LoginService loginService;
@PostMapping("/user/login")
//ResponseResult和user是我们在domain目录写好的类
public ResponseResult xxlogin(@RequestBody User user){
//登录
return loginService.login(user);
}
}
第六步: 在application.yml添加如下，作用是添加redis的连接信息
redis:
host: 127.0.0.1
port: 6379
第七步: 本地打开你的redis
d:
cd /redis
redis-server.exe redis.windows.conf
第八步: 运行TokenApplication引导类
第九步: 测试。打开你的postman，发送下面的POST请求
localhost:8080/user/login
注意还要带上如下JSON类型的Body数据
{
"userName":"huanf",
"password":"112233"
}
13. 认证过滤器
在上面学习的 '认证' 的 '3. 自定义security的思路' 当中，我们有一个功能需求是定义Jwt认证过滤器，这个功能还没有实现，下面就正式学习如何实现这个功能。要实现Jwt认证过滤器，我们需要获取token，然后解析token获取其中的userid，还需要从redis中获取用户信息，然后存入SecurityContextHolder
为什么要有redis参与: 是为了防止过了很久之后，浏览器没有关闭，拿着token也能访问，这样不安全
认证过滤器的作用是什么: 上面我们实现登录接口的时，当某个用户登录之后，该用户就会有一个token值，我们可以通过认证过滤器，由于有token值，并且token值认证通过，也就是证明是这个用户的token值，那么该用户访问我们的业务接口时，就不会被Security拦截。简单理解作用就是登录过的用户可以访问我们的业务接口，拿到对应的资源
第一步: 定义过滤器。在 src/main/java/com.huanf 目录新建 filter.JwtAuthenticationTokenFilter 类，写入如下
package com.huanf.filter;
import com.huanf.domain.LoginUser;
import com.huanf.utils.JwtUtil;
import com.huanf.utils.RedisCache;
import io.jsonwebtoken.Claims;
import org.springframework.beans.factory.annotation.Autowired;
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.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 {
@Autowired
private RedisCache redisCache;
@Override
protected void doFilterInternal(HttpServletRequest request, HttpServletResponse response, FilterChain filterChain) throws ServletException, IOException {
//获取token，指定你要获取的请求头叫什么
String xxtoken = request.getHeader("token");
//判空，不一定所有的请求都有请求头，所以上面那行的xxtoken可能为空
//!StringUtils.hasText()方法用于检查给定的字符串是否为空或仅包含空格字符
if (!StringUtils.hasText(xxtoken)) {
//如果请求没有携带token，那么就不需要解析token，不需要获取用户信息，直接放行就可以
filterChain.doFilter(request, response);
//return之后，就不会走下面那些代码
return;
}
//解析token
String userid; //把userid定义在外面，才能同时用于下面的46行和52行
try {
Claims claims = JwtUtil.parseJWT(xxtoken);
userid = claims.getSubject();
} catch (Exception e) {
e.printStackTrace();
throw new RuntimeException("token非法");
}
//从redis中获取用户信息
String redisKey = "login:" + userid;
//LoginUser是我们在domain目录写的实体类
LoginUser loginUser = redisCache.getCacheObject(redisKey);
//判断获取到的用户信息是否为空，因为redis里面可能并不存在这个用户信息，例如缓存过期了
if(Objects.isNull(loginUser)){
//抛出一个异常
throw new RuntimeException("用户未登录");
}
//把最终的LoginUser用户信息，通过setAuthentication方法，存入SecurityContextHolder
//TODO 获取权限信息封装到Authentication中
UsernamePasswordAuthenticationToken authenticationToken =
//第一个参数是LoginUser用户信息，第二个参数是凭证(null)，第三个参数是权限信息(null)
new UsernamePasswordAuthenticationToken(loginUser,null,null);
SecurityContextHolder.getContext().setAuthentication(authenticationToken);
//全部做完之后，就放行
filterChain.doFilter(request, response);
}
}
第二步: 修改SecurityConfig类为如下，其实也就是在configure方法加了一点代码、并且注入了JwtAuthenticationTokenFilter类
package com.huanf.config;
import com.huanf.filter.JwtAuthenticationTokenFilter;
import org.springframework.beans.factory.annotation.Autowired;
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.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;
@Configuration
//实现Security提供的WebSecurityConfigurerAdapter类，就可以改变密码校验的规则了
public class SecurityConfig extends WebSecurityConfigurerAdapter {
@Bean
//把BCryptPasswordEncoder对象注入Spring容器中，SpringSecurity就会使用该PasswordEncoder来进行密码校验
//注意也可以注入PasswordEncoder，效果是一样的，因为PasswordEncoder是BCry..的父类
public PasswordEncoder passwordEncoder(){
return new BCryptPasswordEncoder();
}
//---------------------------认证过滤器的实现----------------------------------
@Autowired
//注入我们在filter目录写好的类
private JwtAuthenticationTokenFilter jwtAuthenticationTokenFilter;
//---------------------------登录接口的实现----------------------------------
@Bean
@Override
public AuthenticationManager authenticationManagerBean() throws Exception {
return super.authenticationManagerBean();
}
@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
redis-server.exe redis.windows.conf
第四步: 运行TokenApplication引导类
第五步: 测试。打开你的postman，发送如下的POST请求，作用是先登录一个用户，这样就能生成这个用户对应的token值
localhost:8080/user/login
注意还要带上如下JSON类型的Body数据
{
"userName":"huanf",
"password":"112233"
}
第六步: 测试。继续在你的postman，发送如下GET请求，作用是拿着刚刚的token值，去访问我们的业务接口，看会不会被Security拦截，如果不会拦截，那么就说明认证过滤器生效了，使用场景就是简单理解就是登录过的用户可以访问我们的业务接口，拿到对应的资源
注意，由于token值我们是存在redis，所以是有默认过期时间的。注意在请求头那里，key要写token，value要写你复制的token值，然后点击发送请求。这个token值实际上就是使用jwt工具类把112233密码加密后的密文，不信你翻一下前面笔记看当时112233的密文，长得是不是跟现在的token值格式一样
14. 退出登录
上面我们既测试了登录认证，又实现了基于密文的token认证，到此就完整地实现了我们在 '认证' 的 '3. 自定义security的思路' 里面的【登录】和【校验】的功能
那么，我们怎么退出登录呢，也就是让某个用户的登录状态消失，也就是让token失效 ?
实现起来也比较简单，只需要定义一个登陆接口，然后获取SecurityContextHolder中的认证信息，删除redis中对应的数据即可
注意: 我们的token其实就是用户密码的密文，token是存在redis里面
第一步: 把LoginService接口修改为如下，注意只是稍微增加了一点代码，我用虚线隔开了，增加的代码是在虚线的下方
package com.huanf.service;
import com.huanf.domain.ResponseResult;
import com.huanf.domain.User;
import org.springframework.stereotype.Service;
@Service
public interface LoginService {
ResponseResult login(User user);
//-----------------------------------退出登录--------------------------------
ResponseResult yylogout();
}
第二步: 把LoginServiceImpl实现类修改为如下，注意只是稍微增加了一点代码，我用虚线隔开了，增加的代码是在虚线的下方
package com.huanf.service.impl;
import com.huanf.domain.LoginUser;
import com.huanf.domain.ResponseResult;
import com.huanf.domain.User;
import com.huanf.service.LoginService;
import com.huanf.utils.JwtUtil;
import com.huanf.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 java.util.HashMap;
import java.util.Map;
import java.util.Objects;
@Service
//写登录的核心代码
public class LoginServiceImpl implements LoginService {
@Autowired
//先在SecurityConfig，使用@Bean注解重写官方的authenticationManagerBean类，然后这里才能注入成功
private AuthenticationManager authenticationManager;
@Autowired
//RedisCache是我们在utils目录写好的类
private RedisCache redisCache;
@Override
//ResponseResult和user是我们在domain目录写好的类
public ResponseResult login(User user) {
//用户在登录页面输入的用户名和密码
UsernamePasswordAuthenticationToken authenticationToken = new UsernamePasswordAuthenticationToken(user.getUserName(),user.getPassword());
//获取AuthenticationManager的authenticate方法来进行用户认证
Authentication authenticate = authenticationManager.authenticate(authenticationToken);
//判断上面那行的authenticate是否为null，如果是则认证没通过，就抛出异常
if(Objects.isNull(authenticate)){
throw new RuntimeException("登录失败");
}
//如果认证通过，就使用userid生成一个jwt，然后把jwt存入ResponseResult后返回
LoginUser loginUser = (LoginUser) authenticate.getPrincipal();
String userid = loginUser.getXxuser().getId().toString();
String jwt = JwtUtil.createJWT(userid);
//把完整的用户信息存入redis，其中userid作为key，注意存入redis的时候加了前缀 login:
Map<String, String> map = new HashMap<>();
map.put("token",jwt);
redisCache.setCacheObject("login:"+userid,loginUser);
return new ResponseResult(200,"登录成功",map);
}
//-----------------------------------退出登录的具体代码--------------------------------
@Override
public ResponseResult yylogout() {
//获取我们在JwtAuthenticationTokenFilter类写的SecurityContextHolder对象中的用户id
UsernamePasswordAuthenticationToken authentication = (UsernamePasswordAuthenticationToken) SecurityContextHolder.getContext().getAuthentication();
//loginUser是我们在domain目录写好的实体类
LoginUser loginUser = (LoginUser) authentication.getPrincipal();
//获取用户id
Long userid = loginUser.getXxuser().getId();
//根据用户id，删除redis中的token值，注意我们的key是被 login: 拼接过的，所以下面写完整key的时候要带上 longin:
redisCache.deleteObject("login:"+userid);
return new ResponseResult(200,"注销成功");
}
}
第三步: 把LoginController类修改为如下，注意只是稍微增加了一点代码，我用虚线隔开了，增加的代码是在虚线的下方
package com.huanf.controller;
import com.huanf.domain.ResponseResult;
import com.huanf.domain.User;
import com.huanf.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;
@RestController
public class LoginController {
@Autowired
//LoginService是我们在service目录写好的接口
private LoginService loginService;
@PostMapping("/user/login")
//ResponseResult和user是我们在domain目录写好的类
public ResponseResult xxlogin(@RequestBody User user){
//登录
return loginService.login(user);
}
//-----------------------------------退出登录--------------------------------
@RequestMapping("/user/logout")
//ResponseResult是我们在domain目录写好的实体类
public ResponseResult xxlogout(){
return loginService.yylogout();
}
}
第四步: 本地打开你的redis
redis-server.exe redis.windows.conf
第五步: 运行TokenApplication引导类
第六步: 测试。打开你的postman，发送如下的POST请求，作用是先登录一个用户，这样就能生成这个用户对应的token值
localhost:8080/user/login
注意还要带上如下JSON类型的Body数据
{
"userName":"huanf",
"password":"112233"
}
第七步: 测试。继续在你的postman，发送如下GET请求，作用是拿着刚刚的token值，去访问我们的业务接口，看在有登录状态的情况下，能不能访问
http://localhost:8080/hello
注意还要带上你刚刚复制的token值，粘贴到消息头的Value输入框
第八步: 测试。继续在你的postman，发送如下GET请求，作用是退出登录，然后去访问我们的业务接口，看在没有登录状态的情况下，能不能访问
这个用户对应的token值
localhost:8080/user/logout注意还要带上你刚刚复制的token值，粘贴到消息头的Value输入框
授权
1. 权限系统的作用
为什么要设计权限系统 ?
例如要设计一个图书管理系统，普通学生账号的权限不能使用书籍编辑、删除的功能，普通学生能使用的功能仅仅是浏览页面，但是，如果是图书管理员用户，那么就能使用所有权限。简单理解就是我们需要不同的用户使用不同的功能，这就是权限系统要实现的效果
虽然前端也可以去判断用户的权限来选择是否显示某些功能的页面或组件，但是不安全，因为如果有人知道了对应功能的接口地址就可以不通过前端，直接去发送请求来实现相关功能操作，所以我们还需要在后端进行用户权限的判断，判断当前用户是否有相应的权限，必须具有所需权限才能进行相应的操作
前端防君子，后端防小人
2. 授权的基本流程
在SpringSecurity中，会使用默认的FilterSecurityInterceptor来进行权限校验。在FilterSecurityInterceptor中会从SecurityContextHolder获取其中的Authentication，然后获取其中的权限信息。当前用户是否拥有访问当前资源所需的权限
所以我们在项目中只需要把当前登录用户的权限信息也存入Authentication，然后设置我们的资源所需要的权限即可
3. 自定义访问路径的权限
SpringSecurity为我们提供了基于注解的权限控制方案，这也是我们项目中主要采用的方式。我们可以使用注解去指定访问对应的资源所需的权限
第一步: 在SecurityConfig配置类添加如下，作用是开启相关配置
@EnableGlobalMethodSecurity(prePostEnabled = true)
第二步: 开启了相关配置之后，就能使用@PreAuthorize等注解了。在HelloController类的hello方法，添加如下注解，其中test表示自定义权限的名字
@PreAuthorize("hasAuthority('test')")
4. 带权限访问的实现
权限信息: 有特殊含义的字符串
我们前面在登录时，会调用到MyUserDetailServiceImpl类的loadUserByUsername方法，当时我们写loadUserByUsername方法时，只写了查询用户数据信息的代码，还差查询用户权限信息的代码。在登录完之后，因为携带了token，所以需要在JwtAuthenticationTokenFilter类添加 '获取权限信息封装到Authentication中' 的代码，添加到UsernamePasswordAuthenticationToken的第三个参数里面，我们当时第三个参数传的是null。
第一步: 在上面的'3. 自定义访问路径的权限'，我们给HelloController类的 /hello 路径添加了权限限制，只有用户具有叫test的权限，才能访问这个路径
第二步: 把MyUserDetailServiceImpl类修改为如下，主要是增加了查询用户权限信息的代码，我会把增加的代码用红框框起来
package com.huanf.service.impl;
import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.huanf.domain.LoginUser;
import com.huanf.domain.User;
import com.huanf.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 java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
import java.util.Objects;
@Service
public class MyUserDetailServiceImpl implements UserDetailsService {
@Autowired
private UserMapper userMapper;
@Override
//UserDetails是Security官方提供的接口
public UserDetails loadUserByUsername(String xxusername) throws UsernameNotFoundException {
//查询用户信息。我们写的userMapper接口里面是空的，所以调用的是mybatis-plus提供的方法
LambdaQueryWrapper<User> queryWrapper = new LambdaQueryWrapper<>();
//eq方法表示等值匹配，第一个参数是数据库的用户名，第二个参数是我们传进来的用户名，这两个参数进行比较是否相等
queryWrapper.eq(User::getUserName,xxusername);
User user = userMapper.selectOne(queryWrapper);
//如果用户传进来的用户名，但是数据库没有这个用户名，就会导致我们是查不到的情况，那么就进行下面的判断。避免程序安全问题
if(Objects.isNull(user)){//判断user对象是否为空。当在数据库没有查到数据时，user就会为空，也就会进入这个判断
throw new RuntimeException("用户名或者密码错误");
}
//--------------------------------查询用户权限信息---------------------------------
//由于我们自定义了3个权限，所以用List集合存储。注意权限实际就是'有特殊含义的字符串'，所以下面的三个字符串就是自定义的
//下面那行就是我们的权限集合，等下还要在LoginUser类做权限集合的转换
List<String> list = new ArrayList<>(Arrays.asList("test","adminAuth","huanfAuth"));
//------------------------------------------------------------------------------
//把查询到的user结果，封装成UserDetails类型，然后返回。
//但是由于UserDetails是个接口，所以我们先需要在domino目录新建LoginUser类，作为UserDetails的实现类，再写下面那行
return new LoginUser(user,list); //这里传了第二个参数，表示的是权限信息
}
}
第三步: 封装权限信息。把LoginUser类修改为如下，主要是增加了把用户权限字符串的集合，转换封装在authorities变量里面
package com.huanf.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.Collection;
import java.util.List;
import java.util.stream.Collectors;
@Data //get和set方法
@NoArgsConstructor //无参构造
//@AllArgsConstructor //在下面封装权限信息时，由于我们自己写有参构造，所以这个注解需要注释掉
//实现UserDetails接口之后，要重写UserDetails接口里面的7个方法
public class LoginUser implements UserDetails {
//查询用户的用户名和密码等数据信息
private User xxuser;
//查询用户权限信息
private List<String> xxpermissions;
public LoginUser(User xxuser, List<String> permissions) {
this.xxuser = xxuser;
this.xxpermissions = permissions;
}
//我们把这个List写到外面这里了，注意成员变量名一定要是authorities，不然会出现奇奇怪怪的问题
@JSONField(serialize = false) //这个注解的作用是不让下面那行的成员变量序列化存入redis，避免redis不支持而报异常
private List<SimpleGrantedAuthority> authorities;
@Override
//用于返回权限信息。现在我们正在学'认证'，'权限'后面才学。所以返回null即可
//当要查询用户信息的时候，我们不能单纯返回null，要重写这个方法，作用是封装权限信息
public Collection<? extends GrantedAuthority> getAuthorities() { //重写GrantedAuthority接口的getAuthorities方法
/* 第一种权限集合的转换写法如下，传统的方式
//把xxpermissions中的String类型的权限信息(也就是"test","adminAuth","huanfAuth")封装成SimpleGrantedAuthority对象
//List<GrantedAuthority> authorities = new ArrayList<>(); //简化这行如下一行，我们把authorities成员变量写到外面了
authorities = new ArrayList<>();
for (String yypermission : xxpermissions) {
SimpleGrantedAuthority yyauthority = new SimpleGrantedAuthority(yypermission);
authorities.add(yyauthority);
}
*/
/* 第二种权限集合的转换写法如下，函数式编程 + stream流 的方式，双引号表示方法引用 */
//当authorities集合为空，就说明是第一次，就需要转换，当不为空就说明不是第一次，就不需要转换直接返回
if(authorities != null){ //严谨来说这个if判断是避免整个调用链中security本地线程变量在获取用户时的重复解析，和redis存取无关
return authorities;
}
//为空的话就会执行下面的转换代码
//List<SimpleGrantedAuthority> authorities = xxpermissions //简化这行如下一行，我们把authorities成员变量写到外面了
authorities = xxpermissions
.stream()
.map(SimpleGrantedAuthority::new)
.collect(Collectors.toList());
//最终返回转换结果
return authorities;
}
@Override
//用于获取用户密码。由于使用的实体类是User，所以获取的是数据库的用户密码
public String getPassword() {
return xxuser.getPassword();
}
@Override
//用于获取用户名。由于使用的实体类是User，所以获取的是数据库的用户名
public String getUsername() {
return xxuser.getUserName();
}
@Override
//判断登录状态是否过期。把这个改成true，表示永不过期
public boolean isAccountNonExpired() {
return true;
}
@Override
//判断账号是否被锁定。把这个改成true，表示未锁定
public boolean isAccountNonLocked() {
return true;
}
@Override
//判断登录凭证是否过期。把这个改成true，表示永不过期
public boolean isCredentialsNonExpired() {
return true;
}
@Override
//判断用户是否可用。把这个改成true，表示可用状态
public boolean isEnabled() {
return true;
}
}
第四步: 把JwtAuthenticationTokenFilter类修改为如下，主要是补充了前面没写的第三个参数，写成第三步封装好的权限信息
package com.huanf.filter;
import com.huanf.domain.LoginUser;
import com.huanf.utils.JwtUtil;
import com.huanf.utils.RedisCache;
import io.jsonwebtoken.Claims;
import org.springframework.beans.factory.annotation.Autowired;
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.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 {
@Autowired
private RedisCache redisCache;
@Override
protected void doFilterInternal(HttpServletRequest request, HttpServletResponse response, FilterChain filterChain) throws ServletException, IOException {
//获取token，指定你要获取的请求头叫什么
String xxtoken = request.getHeader("token");
//判空，不一定所有的请求都有请求头，所以上面那行的xxtoken可能为空
//!StringUtils.hasText()方法用于检查给定的字符串是否为空或仅包含空格字符
if (!StringUtils.hasText(xxtoken)) {
//如果请求没有携带token，那么就不需要解析token，不需要获取用户信息，直接放行就可以
filterChain.doFilter(request, response);
//return之后，就不会走下面那些代码
return;
}
//解析token
String userid; //把userid定义在外面，才能同时用于下面的46行和52行
try {
Claims claims = JwtUtil.parseJWT(xxtoken);
userid = claims.getSubject();
} catch (Exception e) {
e.printStackTrace();
throw new RuntimeException("token非法");
}
//从redis中获取用户信息
String redisKey = "login:" + userid;
//LoginUser是我们在domain目录写的实体类
LoginUser loginUser = redisCache.getCacheObject(redisKey);
//判断获取到的用户信息是否为空，因为redis里面可能并不存在这个用户信息，例如缓存过期了
if(Objects.isNull(loginUser)){
//抛出一个异常
throw new RuntimeException("用户未登录");
}
//把最终的LoginUser用户信息，通过setAuthentication方法，存入SecurityContextHolder
UsernamePasswordAuthenticationToken authenticationToken =
//第一个参数是LoginUser用户信息，第二个参数是凭证(null)，第三个参数是权限信息(null)
//在学习封装权限信息时，就要把下面的第三个参数补充完整，getAuthorities是我们在loginUser写的方法
new UsernamePasswordAuthenticationToken(loginUser,null,loginUser.getAuthorities());
SecurityContextHolder.getContext().setAuthentication(authenticationToken);
//全部做完之后，就放行
filterChain.doFilter(request, response);
}
}
第五步: 本地打开你的redis
redis-server.exe redis.windows.conf
第六步: 运行TokenApplication引导类
第七步: 测试。打开你的postman，发送如下的POST请求，作用是先登录一个用户，这样就能生成这个用户对应的token值
localhost:8080/user/login
注意还要带上如下JSON类型的Body数据
{
"userName":"huanf",
"password":"112233"
}
第八步: 测试。继续在你的postman，发送如下GET请求，作用是拿着刚刚的token值，去访问我们的业务接口，看在有登录状态的情况下，能不能访问
http://localhost:8080/hello
注意还要带上你刚刚复制的token值，粘贴到消息头的Value输入框
第九步: 测试。修改HelloController类的@PreAuthorize注解的权限字符串，我们把test改为xxtest。然后重新运行Application引导类
第十步: 测试。把第八步的测试再做一遍，看还能访问吗
授权-RBAC权限模型
1. 介绍
刚刚我们实现了只有当用户具备某种权限，才能访问我们的某个业务接口。但是存在一个问题，我们在给用户设置权限的时候，是写死的，在真正的开发中，我们是需要从数据库查询权限信息，下面就来学习如何从数据库查询权限信息，然后封装给用户。这个功能需要先准备好数据库和java代码，所以，下面的 '授权-RBAC权限模型' 都是在围绕这个功能进行学习，直到实现这个功能
RBAC权限模型 (Role-Based Access Control) ，是权限系统用到的经典模型，基于角色的权限控制。该模型由以下五个主要组成部分构成:
一、用户: 在系统中代表具体个体的实体，可以是人员、程序或其他实体。用户需要访问系统资源
二、角色: 角色是权限的集合，用于定义一组相似权限的集合。角色可以被赋予给用户，从而授予用户相应的权限
三、权限: 权限表示系统中具体的操作或功能，例如读取、写入、执行等。每个权限定义了对系统资源的访问规则
四、用户-角色映射: 用户-角色映射用于表示用户与角色之间的关系。通过为用户分配适当的角色，用户可以获得与角色相关联的权限
五、角色-权限映射: 角色-权限映射表示角色与权限之间的关系。每个角色都被分配了一组权限，这些权限决定了角色可执行的操作
截止目前，我们数据库只有1张表，在上面 '认证' 的 '6. 自定义security的数据库' 里面创建的 sys_user 用户表，下面我们会新增4张表，分别是权限表(每条数据是单个'粒度细的权限')、角色表(每条数据是多个'粒度细的权限')、角色表与权限表的中间表、用户表与角色表的中间表。总共5张表，组成了RBAC模型，中间表的作用是维护两张表的多对多关系
2.数据库表的创建
第一步: 在你数据库的huanf_security 库，新建 sys_menu权限表、sys_role角色表、sys_role_menu中间表、sys_user_role中间表，并插入数据
create database if not exists huanf_security;
use huanf_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)注意: 没有huanf_security数据库 和 sys_user用户表 的话，请去上面笔记的 '认证' 的 '6. 自定义security的数据库' 里面进行创建。或者我给你写出来了，如下
create database if not exists huanf_security;
use huanf_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靑惷','$2a$10$YPnG.IYUk0mMechaxSibBuKmNeTzvuHdcxkqvoxizsll6WCQG9CHG','0',DEFAULT,DEFAULT,DEFAULT,DEFAULT,'1',DEFAULT,DEFAULT,DEFAULT,DEFAULT,DEFAULT);
第二步: 测试SQL语句，也就是确认一下你的建表、插入数据是否达到要求
# 通过用户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
注意: 可以查到两条数据，这两条数据就是等下数据库返回给我们的权限字符串
3. 查询数据库的权限信息
第一步: 在 domain 目录新建 Menu 实体类，写入如下
package com.huanf.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") //指定表名，避免等下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 接口。作用是定义mapper，其中提供一个方法可以根据userid查询权限信息
package com.huanf.mapper;
import com.baomidou.mybatisplus.core.mapper.BaseMapper;
import com.huanf.domain.Menu;
import java.util.List;
import org.springframework.stereotype.Service;
@Service
//BaseMapper是mybatisplus官方提供的接口，里面提供了很多单表查询的方法
public interface MenuMapper extends BaseMapper<Menu> {
//由于是多表联查，mybatisplus的BaseMapper接口没有提供，我们需要自定义方法，所以需要创建对应的mapper文件，定义对应的sql语句
List<String> selectPermsByUserId(Long id);
}
第三步: 在 resources 目录新建 mapper目录，接着在这个mapper目录新建File，名字叫 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.huanf.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 = #{userid}
AND r.`status` = 0
AND m.`status` = 0
</select>
</mapper>
第四步: 把application.yml修改为如下，作用是告诉mybatisplus，刚刚写的MenuMapper.xml文件是在哪个地方
mybatis-plus:
# 配置MenuMapper.xml文件的路径
# 也可以不写，因为默认就是在类加载路径(resouces)下的mapper目录的任意层级的后缀为xml的文件，都会被扫描到
mapper-locations: classpath*:/mapper/**/*.xml
第五步: 测试。这里只是检查mybatismlus能不能拿到数据库的权限字符串。在MapperTest类添加如下
@Autowired
private MenuMapper menuMapper;
@Test
public void testSelectPermsByUserId(){
//L表示Long类型
List<String> list = menuMapper.selectPermsByUserId(2L);
System.out.println(list);
}
4. RBAC权限模型的实现
不要把RBAC模型想得很难，其实难的话只是数据库表的设计和SQL语句的编写，需要5张表。数据库设计好之后就很简单了，使用mybatis-plus去查询数据库表的权限字符串(例如我们的权限字符串是放在sys_menu表)，然后把你查到的数据去替换死数据就好了。我们只剩最后一步，就是替换死数据，如下
第一步: 把MyUserDetailServiceImpl类修改为如下，我们只是增加了查询来自数据库的权限信息的代码
package com.huanf.service.impl;
import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.huanf.domain.LoginUser;
import com.huanf.domain.User;
import com.huanf.mapper.MenuMapper;
import com.huanf.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 java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
import java.util.Objects;
@Service
public class MyUserDetailServiceImpl implements UserDetailsService {
@Autowired
private UserMapper userMapper;
@Autowired
//MenuMapper是我们在mapper目录写好的接口，作用是查询来自数据库的权限信息
private MenuMapper menuMapper;
@Override
//UserDetails是Security官方提供的接口
public UserDetails loadUserByUsername(String xxusername) throws UsernameNotFoundException {
//查询用户信息。我们写的userMapper接口里面是空的，所以调用的是mybatis-plus提供的方法
LambdaQueryWrapper<User> queryWrapper = new LambdaQueryWrapper<>();
//eq方法表示等值匹配，第一个参数是数据库的用户名，第二个参数是我们传进来的用户名，这两个参数进行比较是否相等
queryWrapper.eq(User::getUserName,xxusername);
User user = userMapper.selectOne(queryWrapper);
//如果用户传进来的用户名，但是数据库没有这个用户名，就会导致我们是查不到的情况，那么就进行下面的判断。避免程序安全问题
if(Objects.isNull(user)){//判断user对象是否为空。当在数据库没有查到数据时，user就会为空，也就会进入这个判断
throw new RuntimeException("用户名或者密码错误");
}
//--------------------------------查询用户权限信息----------------------------------
//由于我们自定义了3个权限，所以用List集合存储。注意权限实际就是'有特殊含义的字符串'，所以下面的三个字符串就是自定义的
//下面那行就是我们的权限集合，等下还要在LoginUser类做权限集合的转换
//List<String> list = new ArrayList<>(Arrays.asList("test","adminAuth","huanfAuth"));
//上面那行的list就不用死数据啦，我们用下面那行的list，是数据库获取到的权限字符串信息的数据
//-------------------------------查询来自数据库的权限信息--------------------------------
List<String> list = menuMapper.selectPermsByUserId(user.getId());
//-------------------------------------------------------------------------------
//把查询到的user结果，封装成UserDetails类型，然后返回。
//但是由于UserDetails是个接口，所以我们先需要在domino目录新建LoginUser类，作为UserDetails的实现类，再写下面那行
return new LoginUser(user,list); //这里传了第二个参数，表示的是权限信息
}
}
第二步: 测试。由于我们知道数据库传过来的权限字符串是 system:dept:list 和 system:test:list，所以我们要把HelloController类的权限字符串修改为如下
system:test:list
或
system:dept:list
第三步: 本地打开你的redis
redis-server.exe redis.windows.conf
第四步: 运行TokenApplication引导类
第五步: 测试。打开你的postman，发送如下的POST请求，作用是先登录一个用户，这样就能生成这个用户对应的token值
localhost:8080/user/login
注意还要带上如下JSON类型的Body数据
{
"userName":"huanf",
"password":"112233"
}
第六步: 测试。继续在你的postman，发送如下GET请求，作用是拿着刚刚的token值，去访问我们的业务接口，看在有登录状态的情况下，能不能访问
http://localhost:8080/hello
注意还要带上你刚刚复制的token值，粘贴到消息头的Value输入框
第七步: 测试。修改HelloController类的@PreAuthorize注解的权限字符串，我们改为 xxxsystem:test:list。然后重新运行Application引导类
第八步: 测试。把第八步的测试再做一遍，看还能访问吗
自定义异常处理
上面的我们学习了 '认证' 和 '授权'，实现了基本的权限管理，然后也学习了从数据库获取授权的 '授权-RBAC权限模型'，实现了从数据库获取用户具备的权限字符串。到此，我们完整地实现了权限管理的功能，但是，当认证或授权出现报错时，我们希望响应回来的json数据有实体类的code、msg、data这三个字段，怎么实现呢
我们需要学习Spring Security的异常处理机制，就可以在认证失败或者是授权失败的情况下也能和我们的接口一样返回相同结构的json，这样可以让前端能对响应进行统一的处理
在SpringSecurity中，如果我们在认证或者授权的过程中出现了异常会被ExceptionTranslationFilter捕获到，如上图。在ExceptionTranslationFilter中会去判断是认证失败还是授权失败出现的异常，其中有如下两种情况
一、如果是认证过程中出现的异常会被封装成AuthenticationException然后调用AuthenticationEntryPoint对象的方法去进行异常处理。
二、如果是授权过程中出现的异常会被封装成AccessDeniedException然后调用AccessDeniedHandler对象的方法去进行异常处理。
总结: 如果我们需要自定义异常处理，我们只需要创建AuthenticationEntryPoint和AccessDeniedHandler的实现类对象，然后配置给SpringSecurity即可
第一步: 在 src/main/java/com.huanf 目录新建 handler.AuthenticationEntryPointImpl类，写入如下，作用是自定义认证的实现类
package com.huanf.handler;
import com.alibaba.fastjson.JSON;
import com.huanf.domain.ResponseResult;
import com.huanf.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;
@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);
//WebUtils是我们在utils目录写好的类
WebUtils.renderString(response,json);
}
}
第二步: 在handler目录新建 AccessDeniedHandlerImpl 类，写入如下，作用是自定义授权的实现类
package com.huanf.handler;
import com.alibaba.fastjson.JSON;
import com.huanf.domain.ResponseResult;
import com.huanf.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;
@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里面
package com.huanf.config;
import com.huanf.filter.JwtAuthenticationTokenFilter;
import org.springframework.beans.factory.annotation.Autowired;
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.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.AuthenticationEntryPoint;
import org.springframework.security.web.access.AccessDeniedHandler;
import org.springframework.security.web.authentication.UsernamePasswordAuthenticationFilter;
@Configuration
@EnableGlobalMethodSecurity(prePostEnabled = true)
//实现Security提供的WebSecurityConfigurerAdapter类，就可以改变密码校验的规则了
public class SecurityConfig extends WebSecurityConfigurerAdapter {
@Bean
//把BCryptPasswordEncoder对象注入Spring容器中，SpringSecurity就会使用该PasswordEncoder来进行密码校验
//注意也可以注入PasswordEncoder，效果是一样的，因为PasswordEncoder是BCry..的父类
public PasswordEncoder passwordEncoder(){
return new BCryptPasswordEncoder();
}
//---------------------------认证过滤器的实现----------------------------------
@Autowired
//注入我们在filter目录写好的类
private JwtAuthenticationTokenFilter jwtAuthenticationTokenFilter;
//---------------------------登录接口的实现----------------------------------
@Bean
@Override
public AuthenticationManager authenticationManagerBean() throws Exception {
return super.authenticationManagerBean();
}
@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);
}
@Autowired
//注入Security提供的认证失败的处理器，这个处理器里面的AuthenticationEntryPointImpl实现类，用的不是官方的了，
//而是用的是我们在handler目录写好的AuthenticationEntryPointImpl实现类，因为我们也是添加到容器把官方的这个实现类覆盖了
private AuthenticationEntryPoint authenticationEntryPoint;
@Autowired
//注入Security提供的授权失败的处理器，这个处理器里面的AccessDeniedHandlerImpl实现类，用的不是官方的了，
//而是用的是我们在handler目录写好的AccessDeniedHandlerImpl实现类，因为我们也是添加到容器把官方的这个实现类覆盖了
private AccessDeniedHandler accessDeniedHandler;
//--------------------------------------------------------------------------
}
第四步: 本地打开你的redis
第五步: 运行TokenApplication引导类
第六步: 测试认证异常。打开你的postman，发送如下的POST请求，作用是登录一个不存在的用户，模拟认证异常
localhost:8080/user/login
注意还要带上如下JSON类型的Body数据
{
"userName":"xxhuanf",
"password":"112233"
}
第七步: 测试授权异常。先在HelloController类修改PreAuthorize注解的权限字符串，修改成huanf用户不存在的权限字符串，接着重新运行TokenApplication引导类，然后去正常登录一个用户并访问 /hello 业务接口，必然会报权限异常，然后我们看一下响应回来的数据格式，是不是我们定义的json格式
跨域
我这里跟教程视频的不一致，教程视频大概想讲的是只有同时配置springboot和security的跨域，那么外界用户才能访问我们的接口，但是我实际操作的却不一致，不清楚是不是版本的问题，总之都学一下吧，我的操作证明出来的是security的跨域写了跟没写都无效，只要是boot配置了跨域，那么跨域问题就解决了
1. 跨域的后端解决
由于我们的SpringSecurity负责所有请求和资源的管理，当请求经过SpringSecurity时，如果SpringSecurity不允许跨域，那么也是会被拦截，所以下面我们将学习并解决跨域问题。前面我们在测试时，是在postman测试，因此没有出现跨域问题的情况，postman只是负责发请求跟浏览器没关系
浏览器出于安全的考虑，使用 XMLHttpRequest 对象发起HTTP请求时必须遵守同源策略，否则就是跨域的HTTP请求，默认情况下是被禁止的。 同源策略要求源相同才能正常进行通信，即协议、域名、端口号都完全一致。 前后端分离项目，前端项目和后端项目一般都不是同源的，所以肯定会存在跨域请求的问题
我们要实现如下两个需求 (我实际做出的效果跟教程视频不一致，第二个需求其实没必要存在，boot解决了跨域就都解决了):
1、开启SpringBoot的允许跨域访问
2、开启SpringSecurity的允许跨域访问
第一步: 开启SpringBoot的允许跨域访问。在 config 目录新建 CorsConfig 类，写入如下
package com.huanf.config;
import org.springframework.context.annotation.Configuration;
import org.springframework.web.servlet.config.annotation.CorsRegistry;
import org.springframework.web.servlet.config.annotation.WebMvcConfigurer;
@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);
}
}
第二步: 开启SpringSecurity的允许跨域访问。在把 SecurityConfig 修改为如下。增加了一点代码，我会用红框框出来
package com.huanf.config;
import com.huanf.filter.JwtAuthenticationTokenFilter;
import org.springframework.beans.factory.annotation.Autowired;
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.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.AuthenticationEntryPoint;
import org.springframework.security.web.access.AccessDeniedHandler;
import org.springframework.security.web.authentication.UsernamePasswordAuthenticationFilter;
@Configuration
@EnableGlobalMethodSecurity(prePostEnabled = true)
//实现Security提供的WebSecurityConfigurerAdapter类，就可以改变密码校验的规则了
public class SecurityConfig extends WebSecurityConfigurerAdapter {
@Bean
//把BCryptPasswordEncoder对象注入Spring容器中，SpringSecurity就会使用该PasswordEncoder来进行密码校验
//注意也可以注入PasswordEncoder，效果是一样的，因为PasswordEncoder是BCry..的父类
public PasswordEncoder passwordEncoder(){
return new BCryptPasswordEncoder();
}
//---------------------------认证过滤器的实现----------------------------------
@Autowired
//注入我们在filter目录写好的类
private JwtAuthenticationTokenFilter jwtAuthenticationTokenFilter;
//---------------------------登录接口的实现------------------------------------
@Bean
@Override
public AuthenticationManager authenticationManagerBean() throws Exception {
return super.authenticationManagerBean();
}
@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);
//---------------------------👇 设置security运行跨域访问 👇------------------
http.cors();
//---------------------------👆 设置security运行跨域访问 👆------------------
}
//---------------------------👇 异常处理的相关配置 👇-----------------------------
@Autowired
//注入Security提供的认证失败的处理器，这个处理器里面的AuthenticationEntryPointImpl实现类，用的不是官方的了，
//而是用的是我们在handler目录写好的AuthenticationEntryPointImpl实现类，因为我们也是添加到容器把官方的这个实现类覆盖了
private AuthenticationEntryPoint authenticationEntryPoint;
@Autowired
//注入Security提供的授权失败的处理器，这个处理器里面的AccessDeniedHandlerImpl实现类，用的不是官方的了，
//而是用的是我们在handler目录写好的AccessDeniedHandlerImpl实现类，因为我们也是添加到容器把官方的这个实现类覆盖了
private AccessDeniedHandler accessDeniedHandler;
//---------------------------👆 异常处理的相关配置 👆----------------------------
}
第三步: 由于没有前端项目，所以我们下面会跑一个前端项目，然后测试后端的跨域功能
2. 前端项目的搭建
第一步: 下载项目源码，下载下来是 sg_security_demo.zip 文件，在D盘新建 security_cors_webproject 目录，把下载的zip文件解压到这个目录
https://cowtransfer.com/s/1e227864a65b41
第二步: 运行前端项目。请确保你电脑有安装node.js，然后以管理员身份打开命令行窗口，输入如下
d:
cd /security_cors_webproject/sg_security_demo
npm install
npm run serve
第三步: 如果你第二步执行不了，那么原因只能是nodejs版本问题，最简单的解决方法就是打开 '控制面板'，点击 '程序和功能'，下拉找到 'Node.js'，右键卸载，并且把你之前nodejs的安装目录删掉。最后下载稳定版14.几的nodejs，为方便下载，我把我的nodejs下载链接放下面，直接下载安装即可
nodejs的14.21.3-x64版本下载: https://cowtransfer.com/s/d76a70e4b02c4f
第四步: 访问前端的项目
http://localhost:8080/#/login
3. 后端解决跨域的演示
第一步: 由于这个前端项目的要求后端服务的端口是8888，所以我们要修改一下idea的application.yml文件，把默认的8080端口改为8888端口
server:
# 指定后端的启动端口
port: 8888
第二步: 为了等下直观的看出跨域的问题，我们把后端的 boot与security的跨域代码注释掉。然后运行TokenApplication引导类
第三步: 本地打开你的redis，这个是给后端用的。如果你想拿到用户登录后生成的token，就打开，如果只是测试跨域的话，不打开也没事
d:
cd /redis
redis-server.exe redis.windows.conf
第四步: 测试。访问前端项目，登录一个数据库的真实用户(用户名huanf，密码112233)，假的也行，主要是看请求会不会出现跨域问题
第五步: 把后端的 boot与security的跨域代码注释解开。然后重新运行TokenApplication引导类。然后浏览器再次重复第三步的测试
第六步: 我后来呢，把security的跨域单独注释了，然后重新运行引导类，想验证是不是只要security不允许跨域，那么即使boot允许跨域，那最终也是不允许跨域的，原因是资源必然要经过security。但是实验结果却是security注释了之后，仅靠boot的跨域放行，前端竟然也能正常访问后端接口
第七步: 然后我又在想，仅靠boot就能解决跨域，那么仅靠security能不能解决跨域呢，于是我把boot的跨域代码注释掉了，把security的跨域代码解开了，重新运行了引导类，然后却发现security解决不了跨域，那这里不是白学了吗，boot的跨域解决谁没学过，咱主要就是好奇security的跨域解决。但是也不能说明，我们在security里面写的跨域代码是无效的，可能是版本问题或者官方问题，况且万一以后用上了还能赌一赌 doge
授权-权限校验的方法
学的是HelloController类的 @PreAuthorize注解 的三个方法
我们前面都是使用@PreAuthorize注解，然后在在其中使用的是hasAuthority方法进行校验。SpringSecurity还为我们提供了其它方法例如: hasAnyAuthority，hasRole，hasAnyRole等
1. hasAuthority方法
我们最早使用@PreAuthorize注解是在前面笔记的 '授权' 的 '3. 自定义访问路径的权限'。可以回去看看，当时并没有详细学习@PreAuthorize注解的hasAuthority方法，只是直接使用，我们下面就来学习一下hasAuthority方法的原理，然后再学习hasAnyAuthority、hasRole、hasAnyRole方法就容易理解了
hasAuthority方法: 执行到了SecurityExpressionRoot的hasAuthority，内部其实是调用authentication的getAuthorities方法获取用户的权限列表。然后判断我们存入的方法参数数据在权限列表中。hasAnyAuthority方法可以传入多个权限，只有用户有其中任意一个权限都可以访问对应资源
hasAuthority方法的执行流程如下图，图比较多，请从上往下查看
2. hasAnyAuthority方法
hasAnyAuthority方法的执行流程跟上面的hasAuthority方法是一样的，只是传参不同。所以重点演示传参，执行流程是真的一模一样，把上面的hasAuthority方法的执行流程认真看一次就行了。hasAuthority方法只能传入一个参数，也就是一个权限字符串。hasAnyAuthority方法可以传入多个参数，也就是多个权限字符串，只要用户具有其中任意一个权限就能访问指定业务接口
第一步: 为方便演示hasAnyAuthority方法能够传入多个参数并看到最终效果，我们把HelloController类的@RequestMapping注解修改为如下
@PreAuthorize("hasAnyAuthority('zidingyi','huanf','system:dept:list')"); //传入3个自定义权限
第二步: 本地打开你的redis
redis-server.exe redis.windows.conf
第三步: 运行TokenApplication引导类，打开postman软件，发送登录请求，然后发送访问/hello接口的请求
3. hasRole方法
首先是执行流程，如下几张图，从上往下看，很精华没有尿点
下图是打断点后的测试图
然后是测试的操作，如下
第一步: 为方便演示hasAnyAuthority方法能够传入多个参数并看到最终效果，我们把HelloController类的@RequestMapping注解修改为如下
@PreAuthorize("hasRole('system:dept:list')") //只能传一个权限字符串，多传会报红线
第二步: 本地打开你的redis
第三步: 运行TokenApplication引导类，打开postman软件，发送登录请求，然后发送访问/hello接口的请求
4. hasAnyRole方法
执行流程跟刚刚的hasRole方法是一模一样的，只是传参不同。把上面的hasRole方法的执行流程认真看一次就行了。hasRole方法只能传入一个参数，也就是一个权限字符串。hasAnyRole方法可以传入多个参数，也就是多个权限字符串，只要用户具有其中任意一个权限就能访问指定业务接口
第一步: 为方便演示hasAnyAuthority方法能够传入多个参数并看到最终效果，我们把HelloController类的@RequestMapping注解修改为如下
@PreAuthorize("hasAnyRole('zidingyi','huanf','system:dept:list')")
第二步: 本地打开你的redis
第三步: 运行TokenApplication引导类，打开postman软件，发送登录请求，然后发送访问/hello接口的请求
5. 自定义权限校验的方法
在上面的源码中，我们知道security校验权限的PreAuthorize注解，其实就是获取用户权限，然后跟业务接口的权限进行比较，最后返回一个布尔类型。自定义一个权限校验方法的话，就需要新建一个类，在类里面定义一个方法，按照前面学习的三种方法的定义格式，然后返回值是布尔类型。如下
第一步: 在 src/main/java/com.huanf目录新建 expression.HuanfExpressionRoot 类，写入如下
package com.huanf.expression;
import com.huanf.domain.LoginUser;
import org.springframework.security.core.Authentication;
import org.springframework.security.core.context.SecurityContextHolder;
import org.springframework.stereotype.Component;
import java.util.List;
@Component("huanfEX")
//自定义权限校验的方法
public class HuanfExpressionRoot {
//自定义权限校验的方法
public boolean huanfHasAuthority(String authority){
//获取用户具有的权限字符串，有可能用户具有多个权限字符串，所以获取后是一个集合
Authentication authentication = SecurityContextHolder.getContext().getAuthentication();
//LoginUser是我们在domain目录写好的实体类
LoginUser loginUser = (LoginUser) authentication.getPrincipal();
List<String> xxpermissions = loginUser.getXxpermissions();
//判断用户权限集合中，是否存在跟业务接口(业务接口的权限字符串会作为authority形参传进来)一样的权限
return xxpermissions.contains(authority);
}
}
第二步: 刚刚在第一步自定义了huanfHasAuthority方法，用于权限校验，那么如何让 @PreAuthorize 注解去使用huanfHasAuthority方法，只需要在SPEL表达式来获取容器中bean的名字。修改HelloController类为如下
package com.huanf.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")
//官方提供的4个权限校验的方法
//@PreAuthorize("hasAuthority('system:dept:list')")
//@PreAuthorize("hasAnyAuthority('zidingyi','huanf','system:dept:list')")
//@PreAuthorize("hasRole('system:dept:list')")
//@PreAuthorize("hasAnyRole('zidingyi','huanf','system:dept:list')")
//自定义权限校验的方法，huanfHasAuthority
@PreAuthorize("@huanfEX.huanfHasAuthority('system:dept:list')")
public String hello(){
return "欢迎，开始你新的学习旅程吧";
}
}
第三步: 本地打开你的redis
第四步: 运行TokenApplication引导类，打开postman软件，发送登录请求，然后发送访问/hello接口的请求
6.基于配置的权限控制
前面学习的权限控制是基于@PreAuthorize注解来完成的，如何使用配置的方式，也就是在配置类当中，来实现权限控制，如下
第一步: 在HelloController类添加如下，作用是新增一个接口
//基于配置的权限控制
@RequestMapping("/configAuth")
public ResponseResult xx(){
return new ResponseResult(200,"访问成功");
}
第二步: 把SecurityConfig类修改为如下，主要就是添加权限控制相关的配置
package com.huanf.config;
import com.huanf.filter.JwtAuthenticationTokenFilter;
import org.springframework.beans.factory.annotation.Autowired;
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.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.AuthenticationEntryPoint;
import org.springframework.security.web.access.AccessDeniedHandler;
import org.springframework.security.web.authentication.UsernamePasswordAuthenticationFilter;
@Configuration
@EnableGlobalMethodSecurity(prePostEnabled = true)
//实现Security提供的WebSecurityConfigurerAdapter类，就可以改变密码校验的规则了
public class SecurityConfig extends WebSecurityConfigurerAdapter {
@Bean
//把BCryptPasswordEncoder对象注入Spring容器中，SpringSecurity就会使用该PasswordEncoder来进行密码校验
//注意也可以注入PasswordEncoder，效果是一样的，因为PasswordEncoder是BCry..的父类
public PasswordEncoder passwordEncoder(){
return new BCryptPasswordEncoder();
}
//---------------------------认证过滤器的实现----------------------------------
@Autowired
//注入我们在filter目录写好的类
private JwtAuthenticationTokenFilter jwtAuthenticationTokenFilter;
//---------------------------登录接口的实现------------------------------------
@Bean
@Override
public AuthenticationManager authenticationManagerBean() throws Exception {
return super.authenticationManagerBean();
}
@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()
//基于配置的的权限控制。指定接口的地址，为HelloController类里面的/configAuth接口，指定权限为system:dept:list
.antMatchers("/configAuth").hasAuthority("system:dept:list")
//上一行的hasAuthority方法就是security官方提供的4种权限控制的方法之一
// 除上面外的所有请求全部需要鉴权认证
.anyRequest().authenticated();
//---------------------------认证过滤器的实现-------------------------------
//把token校验过滤器添加到过滤器链中
//第一个参数是上面注入的我们在filter目录写好的类，第二个参数表示你想添加到哪个过滤器之前
http.addFilterBefore(jwtAuthenticationTokenFilter, UsernamePasswordAuthenticationFilter.class);
//---------------------------👇 异常处理的相关配置 👇------------------------
http.exceptionHandling()
//配置认证失败的处理器
.authenticationEntryPoint(authenticationEntryPoint)
//配置授权失败的处理器
.accessDeniedHandler(accessDeniedHandler);
//---------------------------👇 设置security运行跨域访问 👇------------------
http.cors();
//---------------------------👆 设置security运行跨域访问 👆------------------
}
//---------------------------👇 异常处理的相关配置 👇-----------------------------
@Autowired
//注入Security提供的认证失败的处理器，这个处理器里面的AuthenticationEntryPointImpl实现类，用的不是官方的了，
//而是用的是我们在handler目录写好的AuthenticationEntryPointImpl实现类，因为我们也是添加到容器把官方的这个实现类覆盖了
private AuthenticationEntryPoint authenticationEntryPoint;
@Autowired
//注入Security提供的授权失败的处理器，这个处理器里面的AccessDeniedHandlerImpl实现类，用的不是官方的了，
//而是用的是我们在handler目录写好的AccessDeniedHandlerImpl实现类，因为我们也是添加到容器把官方的这个实现类覆盖了
private AccessDeniedHandler accessDeniedHandler;
//---------------------------👆 异常处理的相关配置 👆----------------------------
}
第三步: 本地打开你的redis
第四步: 运行TokenApplication引导类，打开postman软件，发送登录请求，然后发送访问/configAuth接口的请求
防护CSRF攻击
在SecurityConfig类里面的configure方法里面，有一个配置如下，我们上面都没有去学习，下面就来了解一下
http..csrf().disable(); //关闭csrf，可防护csrf攻击。如果不关闭的话
CSRF是指跨站请求伪造（Cross-site request forgery），是web常见的攻击之一，如图
详细看这篇博客: https://blog.youkuaiyun.com/freeking101/article/details/86537087防护: SpringSecurity去防止CSRF攻击的方式就是通过csrf_token。后端会生成一个csrf_token，前端发起请求的时候需要携带这个csrf_token,后端会有过滤器进行校验，如果没有携带或者是伪造的就不允许访问
我们可以发现CSRF攻击依靠的是cookie中所携带的认证信息。但是在前后端分离的项目中我们的认证信息其实是token，而token并不是存储中cookie中，并且需要前端代码去把token设置到请求头中才可以，所以CSRF攻击也就不用担心了，前后端分离的项目，在配置类关闭csrf就能防范csrf攻击
认证-自定义处理器
上面我们已经完整学习了认证和授权的完成流程，如果自己待的公司不是用上面学习的那一套认证和授权的流程，那么就是使用的自定义处理器，下面是认证的3个自定义处理器，学完之后就会发现自定义处理器的操作其实都是大同小异
1. 自定义successHandler
successHandler表示 '登录认证成功的处理器'
实际上在UsernamePasswordAuthenticationFilter进行登录认证的时候，如果登录成功了是会调用AuthenticationSuccessHandler的方法进行认证成功后的处理的。AuthenticationSuccessHandler就是登录成功处理器。我们也可以自己去自定义成功处理器进行成功后的相应处理
如何才能自定义 '登录成功的处理器' 呢，分析如下:
我们目前有两个项目工程，一个是最开始的SecurityQuickStart项目工程，另一个是现在的TokenDemo项目工程。由于TokenDemo项目工程被我们配置了很多东西，内部其实已经没有UsernamePasswordAuthenticationFilter这个过滤器了，所以我们只能在SecurityQuickStart项目工程进行操作演示
为什么在TokenDemo项目工程不能进行操作: 因为TokenDemo项目工程把security默认提供的浏览器登录页面去掉了，我们当时在笔记的 '认证' 的 '12. 登录接口的实现' 那里，把默认的登录接口改掉了，可前去翻笔记，直到现在都没有使用过security默认提供的浏览器登录页面，一直用的postman发请求。而自定义successHandler，要求必须要使用到security默认提供的浏览器登录页面(严谨说是登录表单，如下图)，所以就只能回到最初的项目
具体操作如下
第一步: 在idea软件打开 '快速入门' 里面创建的 'SecurityQuickStart'项目工程
第二步: 在 src/main/java/com.huanf 目录新建 handler.MySuccessHandler 类，然后实现security官方提供的AuthenticationSuccessHandler接口，注意这个接口需要我们去重写2个方法，需要重写哪个呢，如下图，然后写入如下
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;
@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^");
}
}
第三步: 把刚刚创建的MySuccessHandler实现类，配置给security。在 src/main/java/com.huanf 目录新建 config.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;
@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();
}
}
第四步: 本地打开你的redis
第五步: 运行SecurityApplication引导类，浏览器访问如下，作用是发送登录请求，只登录就行，因为我们是测试自定义'登录认证成功的处理器'
http://localhost:8080/logout # 先退出登录，避免对测试造成影响
http://localhost:8080/hello # 访问这个路径后会自动跳到8080/login路径，我们就在跳之后的页面测试。登录的用户名是security默认的use，密码在控制台
由于这个项目是我们在'快速入门'里面写的，所以登录认证的方式是在浏览器发请求并且输入表单的方式，还没有'授权'相关的代码。认证的用户名和密码也都是security官方默认提供的，这个先说明一下，不然可能对这个用户名和密码感到困惑，不知道是哪里来的
2. 自定义failureHandler
failureHandler表示 '登录认证失败的处理器'
在UsernamePasswordAuthenticationFilter进行认证登录的时候，除了有刚刚学过的 '登录成功的处理器'也就是调用AuthenticationSuccessHandler。还有 '登录失败的处理器'了，也就是调用AuthenticationFailureHandler，如何自定义 '登录认证失败的处理器'，分析如下
具体操作如下
第一步: 在 handler 目录新建 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;
@Component
//官方提供的AuthenticationFailureHandler接口的实现类，用于自定义'登录失败的处理器'
public class MyFailureHandler implements AuthenticationFailureHandler {
@Override
public void onAuthenticationFailure(HttpServletRequest request, HttpServletResponse response, AuthenticationException exception) throws IOException, ServletException {
//我们只验证认证成功之后被调用到下面那行代码就行，如果是要自定义'登录成功的处理器'，那么就在下面写具体代码即可
System.out.println("登录认证失败了*_*，请检查用户名或密码");
}
}
第二步: 把刚刚创建的MyFailureHandler实现类，配置给security。把 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;
@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();
}
}
第三步: 本地打开你的redis
第四步: 运行SecurityApplication引导类，浏览器访问如下，作用是发送登录请求，注意要故意登录失败，因为我们是测试自定义'登录认证失败的处理器'
http://localhost:8080/logout # 先退出登录，避免对测试造成影响
http://localhost:8080/hello # 访问这个路径后会自动跳到8080/login路径，我们就在跳之后的页面测试。登录的用户名是security默认的use，密码在控制台
3. 自定义LogoutSuccessHandler
LogoutSuccessHandlerr '登出成功的处理器'
有个过滤器叫DefaultLogoutPageGeneratingFilter，是登出操作的过滤器，可以指定登出(也就是退出登录的意思)成功后的处理。有个接口叫LogoutSuccessHandler接口，我们需要新建一个类，然后实现这个接口，重新接口里面的方法，就能实现自定义LogoutSuccessHandler
具体操作如下
第一步: 在 handler 目录新建 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;
@Component
//官方提供的LogoutSuccessHandler接口的实现类，用于自定义'登出成功的处理器'
public class MyLogoutSuccessHandler implements LogoutSuccessHandler {
@Override
public void onLogoutSuccess(HttpServletRequest request, HttpServletResponse response, Authentication authentication) throws IOException, ServletException {
//我们只验证登出成功之后被调用到下面那行代码就行，如果是要自定义'登出成功的处理器'，那么就在下面写具体代码即可
System.out.println("退出登录成功");
}
}
第二步: 把刚刚创建的MyLogoutSuccessHandler实现类，配置给security。把 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;
@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();
}
}
第三步: 本地打开你的redis
第四步: 运行SecurityApplication引导类，浏览器访问如下，作用是发送退出登录的请求，因为我们是验证自定义'登出成功的处理器'
http://localhost:8080/logout # 退出登录，避免对测试造成影响
完结撒花
扫一扫
1134
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
