明空Minempty
【Spring】Spring Security 入门原理及实战
本文最后更新于2023年10月19日。如果文章内容或图片资源失效，请留言反馈，我会及时处理，谢谢！
为了有更好的阅读体验，阿尔法色色之屋为长篇文章提供了目录树，若没有正常显示，则需要手动缩小页面比例。
1. 基础概述
Spring Security 是 Spring 项目之中的一个安全模块，可以非常方便与spring项目无缝集成。在 Spring Boot 项目中 Spring Security 的集成也十分方便。本文主要介绍 Spring Security，以及其在 Web 应用中的使用。
2. 快速入门
2.1 创建项目
现在我们创建一个基本的 SpringBoot 的 Web 应用项目，首先引入依赖：
<dependencies>
<!-- SpringBoot 启动类 -->
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-web</artifactId>
</dependency>
<!-- SpringBoot 测试 -->
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-test</artifactId>
</dependency>
<!-- Lombok -->
<dependency>
<groupId>org.projectlombok</groupId>
<artifactId>lombok</artifactId>
<optional>true</optional>
</dependency>
</dependencies>然后创建启动类 SpringSecurityApplication：
@SpringBootApplication
public class SpringSecurityApplication {
public static void main(String[] args) {
SpringApplication.run(SpringSecurityApplication.class, args);
}
}然后在项目目录中新建包Controller用于表示控制层，在里面新建类AppController并编写代码:
@RestController
public class AppController {
@RequestMapping("/hello")
String home() {
return "Hello,Spring Security!";
}
}这时候我们启动项目，并访问http://localohost:8080/hello在页面中看到：
Hello,Spring Security!
2.2 加入依赖
这个时候我们给 SpringBoot 项目添加 SpringScurity 依赖，在pom.xml的<dependencies>标签中添加如下依赖：
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-security</artifactId>
</dependency>
<dependency>
<groupId>org.springframework.security</groupId>
<artifactId>spring-security-test</artifactId>
<scope>test</scope>
</dependency>此时我们再一次访问http://localhost:8080/hello就会跳转到 Spring Security 的登录界面：
说明 Spring Security 已经起作用了，但我们需要登陆才能继续访问。我们可以查看下这个页面的源代码，是这样：
<div class="container">
<form class="form-signin" method="post" action="/login">
<h2 class="form-signin-heading">Please sign in</h2>
<p>
<label for="username" class="sr-only">Username</label>
<input type="text" id="username" name="username" class="form-control" placeholder="Username" required="" autofocus="">
</p>
<p>
<label for="password" class="sr-only">Password</label>
<input type="password" id="password" name="password" class="form-control" placeholder="Password" required="">
</p>
<input name="_csrf" type="hidden" value="aebb7b60-a30f-4804-91b2-bba4ff372733">
<button class="btn btn-lg btn-primary btn-block" type="submit">Sign in</button>
</form>
</div>上面的div容器中包含了一个form，表单提交了三个数据：username【用户名】、 password【密码】、_csrf【CSRF安全防护相关】。Spring Security 默认的用户名是user，而默认密码则会在添加了 Spring Security 依赖后的项目启动时会随机生成。我们可以去控制台看下日志，会看到如下信息：
在输入用户名和密码后成功登录，并能访问http://localhost:8080/hello的内容。
2.2 自定义配置
上面演示了默认情况下登录 Spring Security 的系统。如果我们想用自己的定义的账号密码，则需要改配置。我们新建包Config并在其中创建类MySecurityConfiguration，并添加如下代码：
@Configuration
@EnableWebSecurity
public class MySecurityConfiguration extends WebSecurityConfigurerAdapter {
@Override
protected void configure(HttpSecurity http) throws Exception {
http
.authorizeRequests()
.anyRequest().authenticated()
.and()
.formLogin().and()
.httpBasic();
}
@Override
protected void configure(AuthenticationManagerBuilder auth) throws Exception {
auth.
inMemoryAuthentication()
.withUser("spring")
.password("{noop}123456").roles("USER");
}
}上面的配置其实和默认情况的配置几乎一样，只是这里定义了一个用户spring，密码123456 。
密码前面的{noop}表示的是指定的PasswordEncoder
此时我们启动项目，便可以使用spring这个用户及密码123456登录了。
2.3 访问控制
通常情况下，我们需要实现【特定资源只能由特定角色访问】的功能。
假设我们的系统有如下两个角色：ADMIN、USER。其中 ADMIN 可以访问所有资源，USER 只能访问特定资源。那么现在我们就要给系统添加如下内容：
新建控制层ProductController和请求地址映射/product/info代表商品信息方面的资源，代码如下。
@RestController
@RequestMapping("/product")
public class ProductController {
@RequestMapping("/info")
public String Info(){
return "This is Product Info Page.";
}
}新建控制层AdminController和请求地址映射/admin/home代表管理员方面的资源，代码如下。
@RestController
@RequestMapping("/admin")
public class AdminController {
@RequestMapping("/home")
public String Home(){
return "This is Admin Manage Home Page.";
}
}现在我们希望实现：管理员可以访问所有页面，而普通用户只能访问/product的相关页面。回到MySecurityConfiguration配置类，添加如下代码：
@Configuration
@EnableWebSecurity
public class MySecurityConfiguration extends WebSecurityConfigurerAdapter {
@Override
protected void configure(HttpSecurity http) throws Exception {
http
.authorizeRequests()
.antMatchers("/product/**").hasRole("USER")
.antMatchers("/admin/**").hasRole("ADMIN")
.anyRequest().authenticated()
.and()
.formLogin().and()
.httpBasic();
}
@Override
protected void configure(AuthenticationManagerBuilder auth) throws Exception {
auth
.inMemoryAuthentication()
.withUser("admin").password("{noop}admin").roles("ADMIN", "USER")
.and()
.withUser("spring").password("{noop}123456").roles("USER");
}
}这里我们增加了管理员 admin以及普通用户 spring，密码分别是 admin 和 123456。
同时，我们增加了链接对应的角色配置。通过上面的配置，我们可以知道：
使用USER角色的用户登录，只能访问/product相关的资源。使用ADMIN角色的用户登录，可以访问所有资源
下面来验证一下普通用户登录，重启项目，访问http://localhost:8080/admin/home，进入登录页面，输入用户名和密码，结果服务器响应的结果如下：
此时我们把请求地址修改成http://localhost:8080/product/info，可以看到访问成功并显示如下信息：
This is Product Info Page.
说明当前登录的USER角色只能访问/product/**的相关资源，与我们预期一致。
再来验证一下管理员用户登录，重启项目，访问http://localhost:8080/admin/home。在登录页面中输入管理员的用户名密码后，可以看到如下信息：
This is Admin Manage Home Page.
说明访问管理员资源了。我们试试http://localhost:8080/product/info是否也能访问，访问后也能看到如下信息：
This is Product Info Page.
说明ADMIN角色的用户可以访问所有资源，这个也和我们的预期一致。
2.4 获取信息
上面我们实现了不同角色访问控制，效果和我们预期的一致，但是并不直观，我们不妨尝试在控制器中获取当前用户角色的信息，直接输出，看看效果。以http://localhost:8080/product/info请求映射为例，我们修改其代码，如下：
@RequestMapping("/info")
@ResponseBody
public String productInfo(){
String currentUser = "";
Object principl = SecurityContextHolder.getContext().getAuthentication().getPrincipal();
if(principl instanceof UserDetails) {
currentUser = ((UserDetails)principl).getUsername();
}else {
currentUser = principl.toString();
}
return "CurrentUser: "+currentUser+" || This is Product Info Page.";
}此时访问``，登录ADMIN角色，可以访问成功并得到如下信息：
CurrentUser: admin || This is Product Info Page.
3. 原理初探
在常规的 Web 项目中，客户端与服务端之间进行请求响应时都会设计大量的过滤器来实现请求拦截或放行，可以通过如下图片来描述 Web 阶段的前后端认证流程：
而在 Spring 阶段，Spring Security 充当了这样的角色，也就是拦截请求并做响应处理，换句话说，Spring Security 就是一个多个过滤器组成的过滤链。
那么结合我们在第一节的快速入门程序中，来描述一下 Spring Security 在入门程序中都使用了哪些基本过滤器：
图中展示的核心过滤器的作用：
- UsernamePasswordAuthenticationFilter : 负责处理我们在登陆页面填写了用户名密码后的登陆请求。入门案例的认证工作主由它负责。
- ExceptionTranslationFilter : 处理过滤器链中抛出的任何异常例如 AccessDeniedException 和 AuthenticationException 。
- FilterSecurityInterceptor : 负责权限校验的过滤器。
这里只是列出了部分过滤器，Spring Security 的过滤器远不止这些。
结合上述过程，我们可以得出相对完整的 Spring Security 认证流程:
概念速查:
- Authentication 接口 : 它的实现类，表示当前访问系统的用户，封装了用户相关信息。
- AuthenticationManager 接口 : 定义了认证 Authentication 的方法。
- UserDetailsService 接口 : 加载用户特定数据的核心接口。里面定义了一个根据用户名查询用户信息的方法。
- UserDetails 接口 : 提供核心用户信息。通过 UserDetailsService 根据用户名获取处理的用户信息要封装成 UserDetails 对象返回。然后将这些信息封装到 Authentication 对象中。
4. 核心组件
在了解了 Spring Security 的认证流程后，我们来着重阐述一下这个安全框架里面的核心组件作用，为我们后续自定义认证流程做准备。
4.1 SecurityContext
安全上下文，用户通过 Spring Security 的校验之后，验证信息存储在SecurityContext中，SecurityContext的接口定义如下：
public interface SecurityContext extends Serializable {
/**
* Obtains the currently authenticated principal, or an authentication request token.
*
* @return the <code>Authentication</code> or <code>null</code> if no authentication
* information is available
*/
Authentication getAuthentication();
/**
* Changes the currently authenticated principal, or removes the authentication
* information.
*
* @param authentication the new <code>Authentication</code> token, or
* <code>null</code> if no further authentication information should be stored
*/
void setAuthentication(Authentication authentication);
}
可以看到SecurityContext接口只定义了两个方法，实际上其主要作用就是获取Authentication对象。
4.2 SecurityContextHolder
在典型的 Web 应用程序中，用户登录一次后会使用会话进行ID标识，然后利用这段缓存在服务器中的主体信息执行进一步请求操作。
在 Spring Security 中，SecurityContextHolder就是用于存储用户会话的。SecurityContextHolder默认使用ThreadLocal策略来存储认证信息，意味着这是一种与线程绑定的策略。在Web场景下的使用Spring Security，在用户登录时自动绑定认证信息到当前线程，在用户退出时，自动清除当前线程的认证信息。默认情况下，该上下文将上下文存储为 HTTP 请求之间的 HttpSession 属性。它会为每个请求恢复上下文，并且最重要的是，在请求完成时清除上下文。
SecurityContextHolder可以设置指定JVM策略（SecurityContext的存储策略），这个策略有三种：
- MODE_THREADLOCAL：SecurityContext 存储在线程中。
- MODE_INHERITABLETHREADLOCAL：SecurityContext 存储在线程中，但子线程可以获取到父线程中的 SecurityContext。
- MODE_GLOBAL：SecurityContext 在所有线程中都相同。
SecurityContextHolder 默认使用MODE_THREADLOCAL模式，即存储在当前线程中。在 Spring Security 应用中，我们通常能看到类似如下的代码：
SecurityContextHolder.getContext().setAuthentication(token);其作用就是存储当前认证信息。
4.3 Authentication
Authentication 直译过来是认证的意思，在 Spring Security 中 Authentication 用来表示当前用户是谁。可以理解为 Authentication 就是一组用户名密码信息。Authentication 也是一个接口，其定义如下：
public interface Authentication extends Principal, Serializable {
// 获取用户权限，一般情况下获取到的是用户的角色信息
Collection<? extends GrantedAuthority> getAuthorities();
// 获取证明用户认证的信息，通常情况下获取到的是密码等信息
Object getCredentials();
// 获取用户的额外信息（这部分信息可以是我们的用户表中的信息）
Object getDetails();
// 获取用户身份信息，在未认证的情况下获取到的是用户名，在已认证的情况下获取到的是 UserDetails 类
Object getPrincipal();
// 获取当前 Authentication 是否已认证
boolean isAuthenticated();
// 设置当前 Authentication 是否已认证
void setAuthenticated(boolean isAuthenticated) throws IllegalArgumentException;
}4.4 UserDetails
UserDetails，看名知义，是用户信息的意思。其存储的就是用户信息，其定义如下：
public interface UserDetails extends Serializable {
// 获取用户权限，本质上是用户的角色信息
Collection<? extends GrantedAuthority> getAuthorities();
// 获取密码
String getPassword();
// 获取用户名
String getUsername();
// 账户是否过期
boolean isAccountNonExpired();
// 账户是否被锁定
boolean isAccountNonLocked();
// 密码是否过期
boolean isCredentialsNonExpired();
// 账户是否可用
boolean isEnabled();
}4.5 UserDetailsService
提到了 UserDetails 就必须得提到 UserDetailsService, UserDetailsService 也是一个接口，且只有一个方法：loadUserByUsername，他可以用来获取 UserDetails。
通常在 Spring Security 应用中，我们会自定义一个 CustomUserDetailsService 来实现 UserDetailsService 接口，并实现其方法：
public UserDetails loadUserByUsername(final String login);我们在实现loadUserByUsername方法的时候，就可以通过查询数据库（或者是缓存、或者是其他的存储形式）来获取用户信息，然后组装成一个 UserDetails,(通常是一个org.springframework.security.core.userdetails.User，它继承自UserDetails)并返回。
在实现loadUserByUsername方法的时候，如果我们通过查库没有查到相关记录，需要抛出一个异常来告诉 Spring Security 来“善后”。这个异常是org.springframework.security.core.userdetails.UsernameNotFoundException。
4.6 AuthenticationManager
AuthenticationManager 是一个接口，它只有一个方法，接收参数为Authentication，其定义如下：
public interface AuthenticationManager {
Authentication authenticate(Authentication authentication)
throws AuthenticationException;
}AuthenticationManager 的作用就是校验Authentication,如果验证失败会抛出 AuthenticationException 异常。AuthenticationException 是一个抽象类，因此代码逻辑并不能实例化一个 AuthenticationException 异常并抛出，实际上抛出的异常通常是其实现类，如 DisabledException,LockedException,BadCredentialsException 等。BadCredentialsException 可能会比较常见，即密码错误的时候。
5. Sercurity 实战之 认证
5.1 思路分析
现在我们掌握了快速入门、认证流程分析、核心组件概述，接下来我们就可以通过这些知识来打造属于自己的自定义认证安全框架。根据常规的项目需求，我们可以整理出这样的流程图：
从图中可以总结出我们的需求有登录和校验两方面。
登录方面，我们要实现 自定义登录接口 和 UserDetailsService 。
- 自定义登录接口 : 调用 ProviderManager 的方法进行认证 如果认证通过生成 JWT，把用户信息存入 Redis 中。
自定义 UserDetailsService : 在这个实现类中去查询数据库。
校验方面，我们要实现 定义 JWT 认证过滤器。
- 定义 JWT 认证过滤器 : 获取 Token 解析获取其中的 userid ，并根据 ID 从 Redis 中获取用户信息，随后存入 SecurityContextHolder 。
5.2 准备工作
我们需要先添加依赖：
<!-- 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>接着依次添加 Redis 配置类：FastJsonRedisSerializer、RedisConfig
/**
* 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);
}
}@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;
}
}
Json 响应类：
@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;
}
}
工具类：JwtUtil、RedisCache、WebUtils
/**
* JWT工具类
*/
public class JwtUtil {
//有效期为
public static final Long JWT_TTL = 60 * 60 *1000L;// 60 * 60 *1000 一个小时
//设置秘钥明文
public static final String JWT_KEY = "sangeng";
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("sg") // 签发者
.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();
}
}
@SuppressWarnings(value = { "unchecked", "rawtypes" })
@Component
public class RedisCache
{
@Autowired
public RedisTemplate redisTemplate;
/**
* 缓存基本的对象，Integer、String、实体类等
*
* @param key 缓存的键值
* @param value 缓存的值
*/
public <T> void setCacheObject(final String key, final T value)
{
redisTemplate.opsForValue().set(key, value);
}
/**
* 缓存基本的对象，Integer、String、实体类等
*
* @param key 缓存的键值
* @param value 缓存的值
* @param timeout 时间
* @param timeUnit 时间颗粒度
*/
public <T> void setCacheObject(final String key, final T value, final 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);
}
}
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;
}
}
实体类：
/**
* 用户表(User)实体类
*/
@Data
@AllArgsConstructor
@NoArgsConstructor
public class User implements Serializable {
private static final long serialVersionUID = -40356785423868312L;
/**
* 主键
*/
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;
}
5.3 具体实现
5.3.1 数据库连接
从之前的分析我们可以知道，我们可以自定义一个 UserDetailsService ,让 Spring Security 使用我们的 UserDetailsService 。我们自己的 UserDetailsService 可以从数据库中查询用户名和密码。
那么我们就先要创建一个数据表sys_user
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='用户表'同时再次添加依赖，这次添加的是 MybatisPlus、JUnit、MYSQL 驱动。
<!-- MyBatis-Plus -->
<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>
<version>8.0.27</version>
</dependency>在配置文件中配置数据库信息：
spring:
datasource:
url: jdbc:mysql://localhost:3306/dailystudy?characterEncoding=utf-8&serverTimezone=UTC
username: root
password: 123456
driver-class-name: com.mysql.cj.jdbc.Driver定义Mapper接口
public interface UserMapper extends BaseMapper<User> {
}修改 User 实体类
类名上加@TableName(value = "sys_user") 注解 ,id字段上加 @TableId 注解
在启动类上配置 Mapper 扫描注解
@SpringBootApplication
@MapperScan("[填写自己的Mapper包路径]")
public class SpringSecurityApplication {
public static void main(String[] args) {
SpringApplication.run(SpringSecurityApplication.class, args);
}
}添加单元测试类测试数据库连接
@SpringBootTest
public class SpringSecurityApplicationTests {
@Autowired
private UserMapper userMapper;
@Test
void contextLoads() {
List<User> users = userMapper.selectList(null);
System.out.println(users);
}
}执行成功后可以获得如下结果：
5.3.2 核心接口实现
创建一个类实现 UserDetailsService 接口，重写其中的方法。根据用户名从数据库中查询用户信息。
@Service
public class UserDetailsServiceImpl implements UserDetailsService {
@Autowired
private UserMapper userMapper;
@Override
public UserDetails loadUserByUsername(String username) throws UsernameNotFoundException {
//根据用户名查询用户信息
LambdaQueryWrapper<User> wrapper = new LambdaQueryWrapper<>();
wrapper.eq(User::getUserName,username);
User user = userMapper.selectOne(wrapper);
//如果查询不到数据就通过抛出异常来给出提示
if(Objects.isNull(user)){
throw new RuntimeException("用户名或密码错误");
}
//TODO 根据用户查询权限信息 添加到LoginUser中
//封装成UserDetails对象返回
return new LoginUser(user);
}
}因为 UserDetailsService 方法的返回值是 UserDetails 类型，所以需要定义一个类，实现该接口，把用户信息封装在其中。
@Data
@NoArgsConstructor
@AllArgsConstructor
public class LoginUser implements UserDetails {
private User user;
@Override
public Collection<? extends GrantedAuthority> getAuthorities() {
return null;
}
@Override
public String getPassword() {
return user.getPassword();
}
@Override
public String getUsername() {
return user.getUserName();
}
@Override
public boolean isAccountNonExpired() {
return true;
}
@Override
public boolean isAccountNonLocked() {
return true;
}
@Override
public boolean isCredentialsNonExpired() {
return true;
}
@Override
public boolean isEnabled() {
return true;
}
}5.3.3 密码加密存储
注意：如果要测试，需要往用户表中写入用户数据，并且如果你想让用户的密码是明文存储，需要在密码前加{noop}。
这样登陆的时候就可以用明空Minempty作为用户名，123456作为密码来登陆了。
但是实际项目中我们不会把密码明文存储在数据库中。
默认使用的 PasswordEncoder 要求数据库中的密码格式为：{id}password。它会根据 id 去判断密码的加密方式。但是我们一般不会采用这种方式。所以就需要替换 PasswordEncoder 。
我们一般使用 Spring Security 为我们提供的 BCryptPasswordEncoder 。
我们只需要使用把 BCryptPasswordEncoder 对象注入 Spring 容器中，Spring Security 就会使用该 PasswordEncoder 来进行密码校验。
@Configuration
public class SecurityConfig extends WebSecurityConfigurerAdapter {
@Bean
public PasswordEncoder passwordEncoder(){
return new BCryptPasswordEncoder();
}
}5.3.4 登录接口
接下我们需要自定义登录接口 LoginController 来进行登录接口的映射，让他调用 LoginService 接口中的login()方法，该方法返回的就是包含 JWT 认证信息的 JSON 格式响应体。
@RestController
public class LoginController {
@Autowired
private LoginService loginService;
@PostMapping("/user/login")
public ResponseResult login(@RequestBody User user){
return loginService.login(user);
}
}为了让 Spring Security 对这个登录接口放行，需要重写 confiure() 方法，让用户访问这个接口的时候不用登录也能访问。
同时在 LoginService 接口中的login()方法实现类中，我们需要通过 AuthenticationManager 的authenticate()方法来进行用户认证，所以需要在 SecurityConfig 中配置把 AuthenticationManager 注入容器以获取实例对象。
修改后的 SecurityConfig 类 如下代码所示：
@Configuration
public class SecurityConfig extends WebSecurityConfigurerAdapter {
...
@Override
protected void configure(HttpSecurity http) throws Exception {
http
//[CSRF 配置] 关闭
.csrf().disable()
//[Session创建策略 配置] 不通过Session获取SecurityContext
.sessionManagement().sessionCreationPolicy(SessionCreationPolicy.STATELESS)
.and()
//[认证方式 配置]
.authorizeRequests()
//[全局访问 配置] 一般会填写 静态资源路径
.antMatchers("/hello").permitAll()
//[匿名访问 配置] 一般会填写 特定接口请求地址
.antMatchers("/user/login").anonymous()
//[鉴权认证 配置] 除上面外的所有请求全部需要鉴权认证
.anyRequest().authenticated();
}
@Bean
@Override
public AuthenticationManager authenticationManagerBean() throws Exception {
return super.authenticationManagerBean();
}
}接着我们来完善 LoginService 接口的实现类 LoginServiceImpl 。
在之前我们提到过，需要通过 AuthenticationManager 的authenticate()方法来进行用户认证，而该方法所需的参数对象为 Authentication 接口的实现类，这就需要我们先获取该对象实例，那么就只需要新建一个 Authentication 的实现类: UsernamePasswordAuthenticationToken 实例即可，该实现类的构造函数帮助我们只需传入用户账号和信息，即可返回一个 Authentication 认证对象。LoginServiceImpl 实现类代码如下：
@Service
public class LoginServiceImpl implements LoginService {
@Autowired
private AuthenticationManager authenticationManager;
@Autowired
private RedisCache redisCache;
@Override
public ResponseResult login(User user) {
UsernamePasswordAuthenticationToken authenticationToken = new UsernamePasswordAuthenticationToken(user.getUserName(),user.getPassword());
Authentication authenticate = authenticationManager.authenticate(authenticationToken);
if(Objects.isNull(authenticate)){
throw new RuntimeException("用户名或密码错误");
}
//使用userid生成token
LoginUser loginUser = (LoginUser) authenticate.getPrincipal();
String userId = loginUser.getUser().getId().toString();
String jwt = JwtUtil.createJWT(userId);
//authenticate存入redis
redisCache.setCacheObject("login:"+userId,loginUser);
//把token响应给前端
HashMap<String,String> map = new HashMap<>();
map.put("token",jwt);
return new ResponseResult(200,"登陆成功",map);
}
}最后我们来测试一下，将用户 ID 为 1 的用户信息作为请求参数并进行接口请求，正常的结果如下图：登录成功，返回给用户一个包含用户信息的JWT值，Redis中包含该用户的用户信息。
5.3.5 认证过滤器
我们需要自定义一个过滤器，这个过滤器会去获取请求头中的 Token ，对 Token 进行解析取出其中的 userid 。
使用 userid 去 Redis 中获取对应的 LoginUser 对象。
然后封装 Authentication 对象存入 SecurityContextHolder 。以便于 Spring Security 在下一次拦截请求的时候，先查看该请求是否携带认证信息，若没有，则抛出未认证的异常；若有，则对认证Token值进行解析获取用户信息，并放行。
@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 token = request.getHeader("token");
if (!StringUtils.hasText(token)) {
//放行
filterChain.doFilter(request, response);
return;
}
//解析token
String userid;
try {
Claims claims = JwtUtil.parseJWT(token);
userid = claims.getSubject();
} catch (Exception e) {
e.printStackTrace();
throw new RuntimeException("token非法");
}
//从redis中获取用户信息
String redisKey = "login:" + userid;
LoginUser loginUser = redisCache.getCacheObject(redisKey);
if(Objects.isNull(loginUser)){
throw new RuntimeException("用户未登录");
}
//TODO 获取权限信息封装到Authentication中
//该方法与用户登录获取的 Authentication 认证对象方法不同，此次的重载方法携带三个参数，作用是认证判断
UsernamePasswordAuthenticationToken authenticationToken =
new UsernamePasswordAuthenticationToken(loginUser,null,null);
//存入SecurityContextHolder
SecurityContextHolder.getContext().setAuthentication(authenticationToken);
//放行
filterChain.doFilter(request, response);
}
}随后再次完善 SecurityConfig 配置类的配置
@Configuration
public class SecurityConfig extends WebSecurityConfigurerAdapter {
...
@Autowired
JwtAuthenticationTokenFilter jwtAuthenticationTokenFilter;
@Override
protected void configure(HttpSecurity http) throws Exception {
...
//把token校验过滤器添加到过滤器链中
http.addFilterBefore(jwtAuthenticationTokenFilter, UsernamePasswordAuthenticationFilter.class);
}
...
}5.3.6 退出登录
有了登录认证还需要退出登录的逻辑，我们只需要在 LoginService 中定义并实现一个登出方法，获取 SecurityContextHolder 中的认证信息，删除 Redis 中对应的数据即可。
@Service
public class LoginServiceImpl implements LoginService {
@Autowired
private AuthenticationManager authenticationManager;
@Autowired
private RedisCache redisCache;
...
@Override
public ResponseResult logout() {
Authentication authentication = SecurityContextHolder.getContext().getAuthentication();
LoginUser loginUser = (LoginUser) authentication.getPrincipal();
Long userid = loginUser.getUser().getId();
redisCache.deleteObject("login:"+userid);
return new ResponseResult(200,"退出成功");
}
}随后在 LoginController 中添加相关请求接口即可：
@RestController
public class LoginController {
...
@PostMapping("/user/logout")
public ResponseResult logout(){
return loginService.logout();
}
}最后我们来测试一下退出，效果如下图所示：
6. Sercurity 实战之 授权
6.1 基本介绍
在现在常见的 Spring 项目中，基本上都会使用 Spring Security 作为系统的认证授权框架，在之前我们讲过了认证功能，接下来讲解一下授权功能。在授权功能中，通过设计权限模型来实现不同角色访问的不同的系统权限，最常用的权限模型设计便是RBAC权限模型。通过设计用户表、权限表、菜单表，以及表之间的关联表，来进行相关用户的相关权限列表。一个最基础的RBAC权限模型如下图所示：
6.2 详细流程
在 Spring Security 中，会使用默认的 FilterSecurityInterceptor 来进行权限校验。在 FilterSecurityInterceptor 中会从 SecurityContextHolder 获取其中的 Authentication 对象，然后获取其中的权限信息。当前用户是否拥有访问当前资源所需的权限。
所以我们在项目中只需要把当前登录用户的权限信息也存入 Authentication 对象即可。
6.3 具体实现
6.3.1 创建 Mapper 层
首先我们先来到数据库，建立相应的表结构和一些测试数据，相关表创建指令如下:
/*
Navicat Premium Data Transfer
Source Server : Minempty
Source Server Type : MySQL
Source Server Version : 80025
Source Host : localhost:3306
Source Schema : dailystudy
Target Server Type : MySQL
Target Server Version : 80025
File Encoding : 65001
Date: 24/03/2023 09:46:59
*/
SET NAMES utf8mb4;
SET FOREIGN_KEY_CHECKS = 0;
-- ----------------------------
-- Table structure for sys_menu
-- ----------------------------
DROP TABLE IF EXISTS `sys_menu`;
CREATE TABLE `sys_menu` (
`id` bigint NOT NULL AUTO_INCREMENT,
`menu_name` varchar(64) CHARACTER SET utf8mb4 COLLATE utf8mb4_0900_ai_ci NOT NULL DEFAULT 'NULL' COMMENT '菜单名',
`path` varchar(200) CHARACTER SET utf8mb4 COLLATE utf8mb4_0900_ai_ci NULL DEFAULT NULL COMMENT '路由地址',
`component` varchar(255) CHARACTER SET utf8mb4 COLLATE utf8mb4_0900_ai_ci NULL DEFAULT NULL COMMENT '组件路径',
`visible` char(1) CHARACTER SET utf8mb4 COLLATE utf8mb4_0900_ai_ci NULL DEFAULT '0' COMMENT '菜单状态（0显示 1隐藏）',
`status` char(1) CHARACTER SET utf8mb4 COLLATE utf8mb4_0900_ai_ci NULL DEFAULT '0' COMMENT '菜单状态（0正常 1停用）',
`perms` varchar(100) CHARACTER SET utf8mb4 COLLATE utf8mb4_0900_ai_ci NULL DEFAULT NULL COMMENT '权限标识',
`icon` varchar(100) CHARACTER SET utf8mb4 COLLATE utf8mb4_0900_ai_ci NULL DEFAULT '#' COMMENT '菜单图标',
`create_by` bigint NULL DEFAULT NULL,
`create_time` datetime NULL DEFAULT NULL,
`update_by` bigint NULL DEFAULT NULL,
`update_time` datetime NULL DEFAULT NULL,
`del_flag` int NULL DEFAULT 0 COMMENT '是否删除（0未删除 1已删除）',
`remark` varchar(500) CHARACTER SET utf8mb4 COLLATE utf8mb4_0900_ai_ci NULL DEFAULT NULL COMMENT '备注',
PRIMARY KEY (`id`) USING BTREE
) ENGINE = InnoDB AUTO_INCREMENT = 2 CHARACTER SET = utf8mb4 COLLATE = utf8mb4_0900_ai_ci COMMENT = '菜单表' ROW_FORMAT = Dynamic;
-- ----------------------------
-- Records of sys_menu
-- ----------------------------
INSERT INTO `sys_menu` VALUES (1, '部门管理', 'dept', 'system/dept/index', '0', '0', 'system:dept:list', '#', NULL, NULL, NULL, NULL, 0, NULL);
INSERT INTO `sys_menu` VALUES (2, '人员管理', 'test', 'system/manage/index', '0', '0', 'system:manage:list', '#', NULL, NULL, NULL, NULL, 0, NULL);
-- ----------------------------
-- Table structure for sys_role
-- ----------------------------
DROP TABLE IF EXISTS `sys_role`;
CREATE TABLE `sys_role` (
`id` bigint NOT NULL AUTO_INCREMENT,
`name` varchar(128) CHARACTER SET utf8mb4 COLLATE utf8mb4_0900_ai_ci NULL DEFAULT NULL,
`role_key` varchar(100) CHARACTER SET utf8mb4 COLLATE utf8mb4_0900_ai_ci NULL DEFAULT NULL COMMENT '角色权限字符串',
`status` char(1) CHARACTER SET utf8mb4 COLLATE utf8mb4_0900_ai_ci NULL DEFAULT '0' COMMENT '角色状态（0正常 1停用）',
`del_flag` int NULL DEFAULT 0 COMMENT 'del_flag',
`create_by` bigint NULL DEFAULT NULL,
`create_time` datetime NULL DEFAULT NULL,
`update_by` bigint NULL DEFAULT NULL,
`update_time` datetime NULL DEFAULT NULL,
`remark` varchar(500) CHARACTER SET utf8mb4 COLLATE utf8mb4_0900_ai_ci NULL DEFAULT NULL COMMENT '备注',
PRIMARY KEY (`id`) USING BTREE
) ENGINE = InnoDB AUTO_INCREMENT = 3 CHARACTER SET = utf8mb4 COLLATE = utf8mb4_0900_ai_ci COMMENT = '角色表' ROW_FORMAT = Dynamic;
-- ----------------------------
-- Records of sys_role
-- ----------------------------
INSERT INTO `sys_role` VALUES (1, 'CEO', 'ceo', '0', 0, NULL, NULL, NULL, NULL, NULL);
INSERT INTO `sys_role` VALUES (2, 'CODER', 'coder', '0', 0, NULL, NULL, NULL, NULL, NULL);
-- ----------------------------
-- Table structure for sys_role_menu
-- ----------------------------
DROP TABLE IF EXISTS `sys_role_menu`;
CREATE TABLE `sys_role_menu` (
`role_id` bigint NOT NULL AUTO_INCREMENT COMMENT '角色ID',
`menu_id` bigint NOT NULL DEFAULT 0 COMMENT '菜单id',
PRIMARY KEY (`role_id`, `menu_id`) USING BTREE
) ENGINE = InnoDB AUTO_INCREMENT = 2 CHARACTER SET = utf8mb4 COLLATE = utf8mb4_0900_ai_ci ROW_FORMAT = Dynamic;
-- ----------------------------
-- Records of sys_role_menu
-- ----------------------------
INSERT INTO `sys_role_menu` VALUES (1, 1);
INSERT INTO `sys_role_menu` VALUES (1, 2);
-- ----------------------------
-- Table structure for sys_user_role
-- ----------------------------
DROP TABLE IF EXISTS `sys_user_role`;
CREATE TABLE `sys_user_role` (
`user_id` bigint NOT NULL AUTO_INCREMENT COMMENT '用户id',
`role_id` bigint NOT NULL DEFAULT 0 COMMENT '角色id',
PRIMARY KEY (`user_id`, `role_id`) USING BTREE
) ENGINE = InnoDB CHARACTER SET = utf8mb4 COLLATE = utf8mb4_0900_ai_ci ROW_FORMAT = Dynamic;
-- ----------------------------
-- Records of sys_user_role
-- ----------------------------
INSERT INTO `sys_user_role` VALUES (1, 1);
SET FOREIGN_KEY_CHECKS = 1;创建完数据表之后可以留意一下数据表sys_menu，这里模拟了两个权限功能，同时我们最后要查询的结果集是该数据表中的perms字段，这个字段的数据也将作为对应权限的权限参数。
再一次强调，我们要实现的功能是根据用户 ID 查询对应的权限列表，在数据表预置的数据中，内置了用户 ID 为 1 的权限 ID 列表有 1 和 2 。
随后我们开始定义SQL语句，根据用户ID查询相关的权限列表，SQL语句会写到指定的 Mapper.xml 文件下，在那之前我们开始创建所需的实体类，由于我们只需要获取权限列表字段，那么我们只需要创建权限字段有关的实体类即可，那就是 Menu 数据表，Menu 实体类的创建如下所示：
@TableName(value="sys_menu")
@Data
@AllArgsConstructor
@NoArgsConstructor
@JsonInclude(JsonInclude.Include.NON_NULL)
public class Menu implements Serializable {
private static final long serialVersionUID = -54979041104113736L;
@TableId
private Long id;
/**
* 菜单名
*/
private String menuName;
/**
* 路由地址
*/
private String path;
/**
* 组件路径
*/
private String component;
/**
* 菜单状态（0显示 1隐藏）
*/
private String visible;
/**
* 菜单状态（0正常 1停用）
*/
private String status;
/**
* 权限标识
*/
private String perms;
/**
* 菜单图标
*/
private String icon;
private Long createBy;
private Date createTime;
private Long updateBy;
private Date updateTime;
/**
* 是否删除（0未删除 1已删除）
*/
private Integer delFlag;
/**
* 备注
*/
private String remark;
}接着我们为这个实体类创建对应的 Mapper 层，并定义一个待实现方法getPermsListByUserId()，如下所示：
public interface MenuMapper extends BaseMapper<Menu> {
List<String> getPermsListByUserId(Long id);
}最后在 resource 文件夹里创建 Mapper 文件夹，并新建 MenuMapper.xml 文件，开始定义SQL语句：
<?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.minempty.springsecurity.mapper.MenuMapper">
<select id="getPermsListByUserId" 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>注意：如果要修改 Mapper.xml 的路径，可以在 Spring 配置文件中添加路径，如下所示:
mybatis-plus:
mapper-locations: classpath*:/mapper/**/*.xml6.3.2 修改 自定义 UserDetailsService 对象
设计好了SQL语句，接着我们就要来到自定义的 UserDetailsService 对象：UserDetailsServiceImpl 类中，添加相关逻辑代码，为获取当前用户的相关权限列表，修改后的代码如下所示：
@Service
public class UserDetailsServiceImpl implements UserDetailsService {
...
@Autowired
private MenuMapper menuMapper;
@Override
public UserDetails loadUserByUsername(String username) throws UsernameNotFoundException {
...
// 根据 用户ID 查询权限信息 添加到LoginUser中
List<String> permissions = menuMapper.getPermsListByUserId(user.getId());
//封装成UserDetails对象返回
return new LoginUser(user,permissions);
}
}6.3.3 修改 自定义 UserDetails 对象
可以在上面看到，我们对自定义的 UserDetails 对象：LoginUser 类中的构造函数进行了修改，因此我们就要来到 LoginUser 对其添加权限列表相关的属性List<String> permissions，并创建相关的构造函数。
但是在 Spring Security 中，默认使用 UserDetails 的getAuthorities()方法来获取权限列表的，我们来看一下这个方法重写前的样子：
@Override
public Collection<? extends GrantedAuthority> getAuthorities() {
return null;
}我们可以看到这个方法返回的类型必须为定义好的泛型 GrantedAuthority 的子类对象集合，那么我们就需要用这个泛型的子类封装权限列表，因此我们还要创建一个List<SimpleGrantedAuthority> authorities属性来存放认证列表，但是要注意，这个属性不能被 Redis 所存储，因为 Redis 设立了一个安全机制，那就是不允许存储携带泛型的属性，因此我们需要用到@JSONField(serialize = false)注解来禁止这个属性序列化，本身这个属性也只是用于封装返回对象，因此不需要存入到 Redis 中，最后通过 String 流来实现集合类型转换，修改后的代码如下所示：
@Data
@NoArgsConstructor
@AllArgsConstructor
public class LoginUser implements UserDetails {
...
private List<String> permissions;
@JSONField(serialize = false)
private List<SimpleGrantedAuthority> authorities;
public LoginUser(User user, List<String> permissions) {
this.user = user;
this.permissions = permissions;
}
@Override
public Collection<? extends GrantedAuthority> getAuthorities() {
if (authorities != null) { return authorities; }
authorities = permissions.stream().map(SimpleGrantedAuthority::new).collect(Collectors.toList());
return authorities;
}
...
6.3.4 修改 自定义 认证过滤器
我们来到 JwtAuthenticationTokenFilter 自定义认证过滤器，在认证方法上添加用户权限列表的参数，在最后我们就可以从 SecurityContextHolder 对象中获取到用户的信息和对应的权限列表，修改内容如下代码：
@Component
public class JwtAuthenticationTokenFilter extends OncePerRequestFilter {
...
@Override
protected void doFilterInternal(HttpServletRequest request, HttpServletResponse response, FilterChain filterChain) throws ServletException, IOException {
...
//存入SecurityContextHolder
UsernamePasswordAuthenticationToken authenticationToken =
new UsernamePasswordAuthenticationToken(loginUser, null, loginUser.getAuthorities());
SecurityContextHolder.getContext().setAuthentication(authenticationToken);
...
}
}6.3.5 测试 授权
在上面的教学中我们已经完整的修改好了授权功能，接着对授权功能进行测试，我们先在启动类中添加@EnableGlobalMethodSecurity(prePostEnabled = true)注解，这个注解是为了开启另一个注解@PreAuthorize，该注解的作用是标识特定接口所需权限列表。
接着创建一个 DeptController 控制层，来模拟部门管理首页的请求接口，且该接口需要的权限参数为system:dept:list，代码如下所示：
@RestController
@RequestMapping("/dept")
public class DeptController {
@RequestMapping("/index")
@PreAuthorize("hasAnyAuthority('system:dept:list')")
public String index(){
return "This is Dept Manage Index Page.";
}
}随后我们重启项目，先访问/user/login，并输入有关用户信息的请求参数，进行登录，登录成功后，我们需要复制返回的 token 值，并在访问/dept/index的请求头中添加 token 值，最后成功访问，效果如下图：
7 自定义 异常处理
在认证和授权的自定义开发过程中，我们也编写了一些异常情况处理的代码，但是这些异常抛出并不是特别友善的，因为在一个项目中，我们希望对前后端之间请求响应时出现的异常进行人性化的弹窗提醒，这就需要后端将异常封装起来并通过 JSON 格式返回给前端作进一步的处理。
在 Spring Security 中，如果我们在认证或者授权的过程中出现了异常会被 ExceptionTranslationFilter 捕获到。在 ExceptionTranslationFilter 中会去判断是认证失败还是授权失败出现的异常。
如果是认证过程中出现的异常会被封装成 AuthenticationException 然后调用 AuthenticationEntryPoint 对象的方法去进行异常处理。
如果是授权过程中出现的异常会被封装成 AccessDeniedException 然后调用 AccessDeniedHandler 对象的方法去进行异常处理。
所以如果我们需要自定义异常处理，我们只需要自定义这两个对象然后配置给 Spring Security 即可。
接下来我们将分别创建认证、授权失败的异常处理类。
新建认证失败处理类 AuthenticationEntryPointImpl
@Component
public class AuthenticationEntryPointImpl implements AuthenticationEntryPoint {
@Override
public void commence(HttpServletRequest request, HttpServletResponse response, AuthenticationException authException) throws IOException, ServletException {
ResponseResult result = new ResponseResult(HttpStatus.UNAUTHORIZED.value(), "认证失败请重新登录");
String json = JSON.toJSONString(result);
WebUtils.renderString(response,json);
}
}新建授权失败处理类 AccessDeniedHandlerImpl
@Component
public class AccessDeniedHandlerImpl implements AccessDeniedHandler {
@Override
public void handle(HttpServletRequest request, HttpServletResponse response, AccessDeniedException accessDeniedException) throws IOException, ServletException {
ResponseResult result = new ResponseResult(HttpStatus.FORBIDDEN.value(), "权限不足");
String json = JSON.toJSONString(result);
WebUtils.renderString(response,json);
}
}接着我们需要在 Spring 配置类中把这些自定义异常处理进行添加，修改的代码如下：
@Configuration
public class SecurityConfig extends WebSecurityConfigurerAdapter {
...
@Autowired
private AuthenticationEntryPoint authenticationEntryPoint;
@Autowired
private AccessDeniedHandler accessDeniedHandler;
@Override
protected void configure(HttpSecurity http) throws Exception {
...
//[认证失败 添加配置]
http.exceptionHandling().authenticationEntryPoint(authenticationEntryPoint)
//[授权失败 添加配置]
.accessDeniedHandler(accessDeniedHandler);
}
...
}最后我们来测试一下，效果如下图所示：
8 跨域问题
浏览器出于安全的考虑，使用 XMLHttpRequest 对象发起 HTTP 请求时必须遵守同源策略，否则就是跨域的 HTTP 请求，默认情况下是被禁止的。同源策略要求源相同才能正常进行通信，即协议、域名、端口号都完全一致。
前后端分离项目，前端项目和后端项目一般都不是同源的，所以肯定会存在跨域请求的问题。
所以我们就要对后端代码进行修改，让前端能进行跨域请求。
先为项目添加 CorsConfig 配置类，并注册到容器中：
@Configuration
public class CorsConfig implements WebMvcConfigurer {
@Override
public void addCorsMappings(CorsRegistry registry) {
// 设置允许跨域的路径
registry.addMapping("/**")
// 设置允许跨域请求的域名
.allowedOriginPatterns("*")
// 是否允许cookie
.allowCredentials(true)
// 设置允许的请求方式
.allowedMethods("GET", "POST", "DELETE", "PUT")
// 设置允许的header属性
.allowedHeaders("*")
// 跨域允许时间
.maxAge(3600);
}
}随后在 Spring 配置类中进行修改，之后就可以实现跨域请求了，修改代码如下所示：
@Configuration
public class SecurityConfig extends WebSecurityConfigurerAdapter {
...
@Override
protected void configure(HttpSecurity http) throws Exception {
http
//[允许跨域 配置]
.cors()
.and()
...
...
}
...
}