SpringBoot3整合SpringSecurity，实现自定义接口权限过滤

接口权限过滤是指对于某些接口或功能，系统通过设定一定的权限规则，只允许经过身份认证且拥有相应权限的用户或应用程序进行访问和操作。这种技术可以有效地保护系统资源和数据安全，防止未授权的用户或程序进行恶意操作或非法访问。通常情况下，接口权限过滤需要配合其他安全措施一起使用，例如加密、身份认证、审计等，以达到综合保护的效果。

本文将使用 SpringBoot3 整合 SpringSecurity，实现自定义接口权限过滤，源码在 项目仓库 中，需要者可自助参考。

一、导入依赖

在实现自定义接口权限过滤之前，首先要导入依赖，首先是 SpringBoot 父依赖。

<parent>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-parent</artifactId>
    <version>3.1.0</version>
</parent>
1
2
3
4
5

接下来是 Spring Boot Web 依赖，用于提供最基本的接口支持。

<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-web</artifactId>
</dependency>
1
2
3
4

在实现登录时需要设计 Token，整合 Redis，所以需要加上以下依赖。

<dependency>
    <groupId>org.springframework.integration</groupId>
    <artifactId>spring-integration-redis</artifactId>
</dependency>
<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-data-redis</artifactId>
</dependency>
<dependency>
    <groupId>org.redisson</groupId>
    <artifactId>redisson-spring-boot-starter</artifactId>
    <version>3.21.3</version>
</dependency>
1
2
3
4
5
6
7
8
9
10
11
12
13

最后就是 Spring Security 依赖，用于实现权限控制。

<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-security</artifactId>
</dependency>
1
2
3
4

Spring Boot 3.1 版本对应的 Spring Security 依赖为 6.1.0 版本，废弃了 WebSecurityConfigurerAdapter 类，配置内容和 Spring Security 5 有着明显不同，版本依赖如下图所示。

---

二、编写登录提示接口

要实现自定义接口权限过滤，首先要定义一个登录提示接口，用于被拦截时返回用户的数据，如下图所示。

请同学们新建一个控制器 SecurityController，定义这个 /zwz/common/needLogin 接口，代码如下。

@RestController
@RequestMapping("/zwz/common")
@Api(tags = "公共接口")
@Transactional
public class SecurityController {

    @RequestMapping(value = "/needLogin", method = RequestMethod.GET)
    @ApiOperation(value = "未登录返回的数据")
    public Result<Object> needLogin(){
        return ResultUtil.error(401, "登录失效");
    }
}
1
2
3
4
5
6
7
8
9
10
11
12

---

三、编写登录成功处理函数

很多同学会问，Spring Security项目中登录接口在哪里，如何实现登录功能，此时…

在 Spring Security 中，我们只需要对登录接口、登录成功/失败回调、过滤器等内容进行配置即可，开发者无需关注登录的具体实现。

请同学们新建 AuthenticationSuccessHandler 类，继承于 Spring Security 的 SavedRequestAwareAuthenticationSuccessHandler 类 ，用于回调用户登录成功的方法，。

@ApiOperation(value = "登录成功回调")
@Slf4j
@Component
public class AuthenticationSuccessHandler extends SavedRequestAwareAuthenticationSuccessHandler {
}
1
2
3
4
5

3.1 判断是否保存登录

请同学们首先重写 AuthenticationSuccessHandler 类中的 onAuthenticationSuccess 方法，这个方法用于实现登录成功回调。

@Override
@ApiOperation(value = "登录成功回调")
@SystemLog(about = "登录系统", type = LogType.LOGIN)
public void onAuthenticationSuccess(HttpServletRequest request, HttpServletResponse response, Authentication ac) throws IOException, ServletException {
}
1
2
3
4
5

在实现登录成功回调的开始，首先要判断用户是否勾选了自动登录，获取是否登录的代码如下。

String saveLogin = request.getParameter(ZwzLoginProperties.SAVE_LOGIN_PRE);
Boolean saveLoginFlag = false;
if(!ZwzNullUtils.isNull(saveLogin) && Objects.equals(saveLogin,"true")){
    saveLoginFlag = true;
}
1
2
3
4
5

这样就可以把用户是否保存登录的标识保存在 saveLoginFlag 变量中，以备后续保存 Token 使用。

3.2 保存用户的信息和菜单权限

用户登录成功后，需要加载用户的菜单，此时需要把用户的账号和菜单保存到缓存中。

用户第二次免登进入系统，即可快速从缓存中获取菜单数据，加快用户的菜单加载速度，降低数据库的读取压力。

首先定义一个 TokenUser 类，用于存储临时用户信息（账号、菜单权限），代码如下。

@ApiOperation(value = "临时用户类")
@Data
@AllArgsConstructor
@NoArgsConstructor
public class TokenUser implements Serializable{

    private static final long serialVersionUID = 1L;

    @ApiModelProperty(value = "用户名")
    private String username;

    @ApiModelProperty(value = "拥有的菜单权限")
    private List<String> permissions;

    @ApiModelProperty(value = "是否自动登录")
    private Boolean saveLogin;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

接着继续在 onAuthenticationSuccess 方法中实现菜单拉取。

List<String> permissionsList = new ArrayList<>();
List<GrantedAuthority> authorities = (List<GrantedAuthority>) ((UserDetails)ac.getPrincipal()).getAuthorities();
for(GrantedAuthority g : authorities){
    permissionsList.add(g.getAuthority());
}
String username = ((UserDetails)ac.getPrincipal()).getUsername();
TokenUser user = new TokenUser(username, permissionsList, saveLoginFlag);
1
2
3
4
5
6
7

上述代码将指定用户的菜单权限拉取出来，保存到 TokenUser 临时用户类中，以备后续调用。

3.3 单点登录处理

单点登录（SSO）是一种身份认证的技术或协议，允许用户在多个应用系统中使用同一组凭据（例如用户名和密码），只需进行一次身份验证即可访问所有的应用系统，从而实现了不同应用系统之间的身份认证信息共享。这种技术可以提高用户的使用便利性，避免重复登录，减少密码管理负担，同时也能够增强系统的安全性，降低密码泄露和被攻击的风险。

对于一般的管理系统来说，都支持单点登录。

通俗点来说，单点登录就是单个账号只允许一个地点登录，电脑 A 登录时，如果登录到电脑 B，此时电脑 A 会被 “顶” 下线。

接着继续在 onAuthenticationSuccess 方法中实现单点登录。

public static final String HTTP_TOKEN_PRE = "ZWZ_TOKEN_PRE:";

public static final String USER_TOKEN_PRE = "ZWZ_USER_TOKEN:";
1
2
3

String oldToken = redisTemplate.opsForValue().get(ZwzLoginProperties.USER_TOKEN_PRE + username);
if(StrUtil.isNotBlank(oldToken)){
    redisTemplate.delete(ZwzLoginProperties.HTTP_TOKEN_PRE + oldToken);
}
1
2
3
4

如果老的 Token 还存在，就把老 Token 删除，即可实现单点登录功能。

3.4 持久化登录信息

最后，将用户的数据持久化到 Redis 中，将 Token 返回给前端，存储到 Cookie 中，前端就可以使用 Token 免登进入、访问系统。

首先是 Token 的生成，可以采用 UUID 类辅助生成，代码如下。

String token = UUID.randomUUID().toString();
1

注入 Redis 工具类，代码如下。

import org.springframework.data.redis.core.StringRedisTemplate;

@Autowired
private StringRedisTemplate redisTemplate;
1
2
3
4

接着根据 3.1 步中的 是否保存 结果，进行持久化的处理，同学们可以自定义 Token 的前缀 USER_TOKEN_PRE 。

public static final String HTTP_TOKEN_PRE = "ZWZ_TOKEN_PRE:";

public static final String USER_TOKEN_PRE = "ZWZ_USER_TOKEN:";
1
2
3

if(saveLoginFlag){
    redisTemplate.opsForValue().set(ZwzLoginProperties.USER_TOKEN_PRE + username, token, 30, TimeUnit.DAYS);
    redisTemplate.opsForValue().set(ZwzLoginProperties.HTTP_TOKEN_PRE + token, JSON.toJSONString(user), 30, TimeUnit.DAYS);
}else{
    redisTemplate.opsForValue().set(ZwzLoginProperties.USER_TOKEN_PRE + username, token, 60, TimeUnit.MINUTES);
    redisTemplate.opsForValue().set(ZwzLoginProperties.HTTP_TOKEN_PRE + token, JSON.toJSONString(user), 60, TimeUnit.MINUTES);
}
ResponseUtil.out(response, ResponseUtil.resultMap(true, 200, "登录成功", token));
1
2
3
4
5
6
7
8

当用户勾选了保存登录，系统保存 Token 30天，即用户可以在未来 30 天内，免登进入系统。

如果用户没有勾选保存登录，系统保存 Token 60 分钟，即用户可以在未来 1 小时内，免登进入系统。

完整代码如下。

@ApiOperation(value = "登录成功回调")
@Slf4j
@Component
public class AuthenticationSuccessHandler extends SavedRequestAwareAuthenticationSuccessHandler {

    @Autowired
    private ZwzLoginProperties tokenProperties;

    @Autowired
    private StringRedisTemplate redisTemplate;

    private static final boolean RESPONSE_SUCCESS_FLAG = true;

    private static final int RESPONSE_SUCCESS_CODE = 200;

    private static final String TOKEN_REPLACE_STR_FRONT = "-";

    private static final String TOKEN_REPLACE_STR_BACK = "";

    @Override
    @ApiOperation(value = "登录成功回调")
    @SystemLog(about = "登录系统", type = LogType.LOGIN)
    public void onAuthenticationSuccess(HttpServletRequest request, HttpServletResponse response, Authentication ac) throws IOException, ServletException {
        String saveLogin = request.getParameter(ZwzLoginProperties.SAVE_LOGIN_PRE);
        Boolean saveLoginFlag = false;
        if(!ZwzNullUtils.isNull(saveLogin) && Objects.equals(saveLogin,"true")){
            saveLoginFlag = true;
        }
        List<String> permissionsList = new ArrayList<>();
        List<GrantedAuthority> authorities = (List<GrantedAuthority>) ((UserDetails)ac.getPrincipal()).getAuthorities();
        for(GrantedAuthority g : authorities){
            permissionsList.add(g.getAuthority());
        }
        String token = UUID.randomUUID().toString().replace(TOKEN_REPLACE_STR_FRONT, TOKEN_REPLACE_STR_BACK);
        String username = ((UserDetails)ac.getPrincipal()).getUsername();
        TokenUser user = new TokenUser(username, permissionsList, saveLoginFlag);
        // 判断是否存储菜单权限
        if(!tokenProperties.getSaveRoleFlag()){
            user.setPermissions(null);
        }
        // 单点登录判断
        if(tokenProperties.getSsoFlag()){
            String oldToken = redisTemplate.opsForValue().get(ZwzLoginProperties.USER_TOKEN_PRE + username);
            if(StrUtil.isNotBlank(oldToken)){
                redisTemplate.delete(ZwzLoginProperties.HTTP_TOKEN_PRE + oldToken);
            }
        }
        if(saveLoginFlag){
            redisTemplate.opsForValue().set(ZwzLoginProperties.USER_TOKEN_PRE + username, token, tokenProperties.getUserSaveLoginTokenDays(), TimeUnit.DAYS);
            redisTemplate.opsForValue().set(ZwzLoginProperties.HTTP_TOKEN_PRE + token, JSON.toJSONString(user), tokenProperties.getUserSaveLoginTokenDays(), TimeUnit.DAYS);
        }else{
            redisTemplate.opsForValue().set(ZwzLoginProperties.USER_TOKEN_PRE + username, token, tokenProperties.getUserTokenInvalidDays(), TimeUnit.MINUTES);
            redisTemplate.opsForValue().set(ZwzLoginProperties.HTTP_TOKEN_PRE + token, JSON.toJSONString(user), tokenProperties.getUserTokenInvalidDays(), TimeUnit.MINUTES);
        }
        ResponseUtil.out(response, ResponseUtil.resultMap(RESPONSE_SUCCESS_FLAG,RESPONSE_SUCCESS_CODE,"登录成功", token));
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57

---

四、编写登录失败处理函数

请同学们新建 AuthenticationFailHandler 类，继承于 Spring Security 的 SimpleUrlAuthenticationFailureHandler 类 ，用于回调用户登录失败 的方法，。

@ApiOperation(value = "登录失败回调")
@Slf4j
@Component
public class AuthenticationFailHandler extends SimpleUrlAuthenticationFailureHandler {
}
1
2
3
4
5

4.1 判断是否密码错误

请同学们首先重写 AuthenticationFailHandler 类中的 onAuthenticationFailure 方法，这个方法用于实现登录失败回调。

@Override
@ApiOperation(value = "登录失败回调")
public void onAuthenticationFailure(HttpServletRequest request, HttpServletResponse response, AuthenticationException exception) {
}
1
2
3
4

在实现登录失败回调的开始，首先要判断用户是否输入了错误的密码。

其中错误的密码包括：

1. 用户密码输入错误。（UsernameNotFoundException 异常）
2. 用户输入了正确的密码，但没有加密。（BadCredentialsException 异常）

if (exception instanceof BadCredentialsException || exception instanceof UsernameNotFoundException) {
    recordLoginTime(request.getParameter("username:"));
    String failTimesStr = stringRedisTemplate.opsForValue().get("LOGIN_FAIL_TIMES_PRE:" + request.getParameter("username:"));
    // 已错误的次数
    int userFailTimes = 0;
    if(!ZwzNullUtils.isNull(failTimesStr)){
        userFailTimes = Integer.parseInt(failTimesStr);
    }
    int restLoginTime = 10 - userFailTimes;
    if(restLoginTime < 5 && restLoginTime > 0){
        ResponseUtil.out(response, ResponseUtil.resultMap(false,500,"账号密码不正确，还能尝试登录" + restLoginTime + "次"));
    } else if(restLoginTime < 1) {
        ResponseUtil.out(response, ResponseUtil.resultMap(false,500,"重试超限，请您" + 10 + "分后再登录"));
    } else {
        ResponseUtil.out(response, ResponseUtil.resultMap(false,500,"账号密码不正确"));
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

默认设定 10 次登录试错次数，如果超限会被临时禁止登录。

其中 recordLoginTime 方法用于查询登录失败的次数，代码如下。

@ApiOperation(value = "查询登录失败的次数")
public boolean recordLoginTime(String username) {
    String loginFailTimeStr = stringRedisTemplate.opsForValue().get(LOGIN_FAIL_TIMES_PRE + username);
    int loginFailTime = 0;
    // 已错误次数
    if(!ZwzNullUtils.isNull(loginFailTimeStr)){
        loginFailTime = Integer.parseInt(loginFailTimeStr) + 1;
    }
    stringRedisTemplate.opsForValue().set("LOGIN_FAIL_TIMES_PRE:" + username, loginFailTime + "", 10, TimeUnit.MINUTES);
    if(loginFailTime >= 10){
        stringRedisTemplate.opsForValue().set("userLoginDisableFlag:"+username, "fail", 10, TimeUnit.MINUTES);
        return false;
    }
    return true;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

4.2 判断是否系统鉴权失败

接着判断是否是自定义异常 ZwzAuthException，如果属于自定义异常，则抛出自定义异常的信息，代码如下。

if (exception instanceof ZwzAuthException){
    ResponseUtil.out(response, ResponseUtil.resultMap(false,500,((ZwzAuthException) exception).getMsg()));
}
1
2
3

其中自定义异常定义如下。

@ApiOperation(value = "自定义异常")
public class ZwzAuthException extends InternalAuthenticationServiceException {

    private static final long serialVersionUID = 1L;

    private static final String DEFAULT_MSG = "系统鉴权失败";

    @ApiModelProperty(value = "异常消息内容")
    private String msg;

    public ZwzAuthException(String msg){
        super(msg);
        this.msg = msg;
    }

    public ZwzAuthException(){
        super(DEFAULT_MSG);
        this.msg = DEFAULT_MSG;
    }

    public ZwzAuthException(String msg, Throwable t) {
        super(msg, t);
        this.msg = msg;
    }

    public String getMsg() {
        return msg;
    }

    public void setMsg(String msg) {
        this.msg = msg;
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34

4.3 判断账户是否被禁用

管理系统一般支持账户禁用功能，即把 status 值设定为某个状态，如 -1。

接着判断是否是账户禁用异常 DisabledException，如果属于账户禁用，则给与提示，代码如下。

if (exception instanceof DisabledException) {
    ResponseUtil.out(response, ResponseUtil.resultMap(false,500,"账户处于禁用状态，无法登录"));
}
1
2
3

用户是否禁用通常是实体类的一个字段，如 status。

4.4 其他登录失败处理

如果不属于上面的三种情况，则给与通用的报错提示，代码如下。

else {
    ResponseUtil.out(response, ResponseUtil.resultMap(RESPONSE_FAIL_FLAG,RESPONSE_FAIL_CODE,"系统当前不能登录，请稍后再试"));
}
1
2
3

完整代码如下。

@ApiOperation(value = "登录失败回调")
@Slf4j
@Component
public class AuthenticationFailHandler extends SimpleUrlAuthenticationFailureHandler {

    @Autowired
    private ZwzLoginProperties tokenProperties;

    @Autowired
    private StringRedisTemplate stringRedisTemplate;

    private static final String LOGIN_FAIL_TIMES_PRE = "LOGIN_FAIL_TIMES_PRE:";

    private static final String REQUEST_PARAMETER_USERNAME = "username:";

    private static final boolean RESPONSE_FAIL_FLAG = false;

    private static final int RESPONSE_FAIL_CODE = 500;

    @ApiOperation(value = "查询登录失败的次数")
    public boolean recordLoginTime(String username) {
        String loginFailTimeStr = stringRedisTemplate.opsForValue().get(LOGIN_FAIL_TIMES_PRE + username);
        int loginFailTime = 0;
        // 已错误次数
        if(!ZwzNullUtils.isNull(loginFailTimeStr)){
            loginFailTime = Integer.parseInt(loginFailTimeStr) + 1;
        }
        stringRedisTemplate.opsForValue().set(LOGIN_FAIL_TIMES_PRE + username, loginFailTime + "", tokenProperties.getLoginFailMaxThenLockTimes(), TimeUnit.MINUTES);
        if(loginFailTime >= tokenProperties.getMaxLoginFailTimes()){
            stringRedisTemplate.opsForValue().set("userLoginDisableFlag:"+username, "fail", tokenProperties.getLoginFailMaxThenLockTimes(), TimeUnit.MINUTES);
            return false;
        }
        return true;
    }

    @Override
    @ApiOperation(value = "登录失败回调")
    public void onAuthenticationFailure(HttpServletRequest request, HttpServletResponse response, AuthenticationException exception) {
        if (exception instanceof BadCredentialsException || exception instanceof UsernameNotFoundException) {
            recordLoginTime(request.getParameter(REQUEST_PARAMETER_USERNAME));
            String failTimesStr = stringRedisTemplate.opsForValue().get(LOGIN_FAIL_TIMES_PRE + request.getParameter(REQUEST_PARAMETER_USERNAME));
            //已错误的次数
            int userFailTimes = 0;
            if(!ZwzNullUtils.isNull(failTimesStr)){
                userFailTimes = Integer.parseInt(failTimesStr);
            }
            int restLoginTime = tokenProperties.getMaxLoginFailTimes() - userFailTimes;
            if(restLoginTime < 5 && restLoginTime > 0){
                ResponseUtil.out(response, ResponseUtil.resultMap(RESPONSE_FAIL_FLAG,RESPONSE_FAIL_CODE,"账号密码不正确，还能尝试登录" + restLoginTime + "次"));
            } else if(restLoginTime < 1) {
                ResponseUtil.out(response, ResponseUtil.resultMap(RESPONSE_FAIL_FLAG,RESPONSE_FAIL_CODE,"重试超限，请您" + tokenProperties.getLoginFailMaxThenLockTimes() + "分后再登录"));
            } else {
                ResponseUtil.out(response, ResponseUtil.resultMap(RESPONSE_FAIL_FLAG,RESPONSE_FAIL_CODE,"账号密码不正确"));
            }
        } else if (exception instanceof ZwzAuthException){
            ResponseUtil.out(response, ResponseUtil.resultMap(RESPONSE_FAIL_FLAG,RESPONSE_FAIL_CODE,((ZwzAuthException) exception).getMsg()));
        } else if (exception instanceof DisabledException) {
            ResponseUtil.out(response, ResponseUtil.resultMap(RESPONSE_FAIL_FLAG,RESPONSE_FAIL_CODE,"账户处于禁用状态，无法登录"));
        } else {
            ResponseUtil.out(response, ResponseUtil.resultMap(RESPONSE_FAIL_FLAG,RESPONSE_FAIL_CODE,"系统当前不能登录，请稍后再试"));
        }
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63

---

五、编写过滤器

5.1 基于 Token 的权限过滤

请同学们新建 JwtTokenOncePerRequestFilter 过滤器，继承于 OncePerRequestFilter，重写 doFilterInternal 过滤方法，代码如下。

@ApiOperation(value = "自定义权限过滤")
@Slf4j
public class JwtTokenOncePerRequestFilter extends OncePerRequestFilter {

    private SecurityUtil securityUtil;

    @Autowired
    private RedisTemplateHelper redisTemplate;

    private ZwzLoginProperties zwzLoginProperties;

    private static final boolean RESPONSE_FAIL_FLAG = false;

    private static final int RESPONSE_NO_ROLE_CODE = 401;


    @Override
    protected void doFilterInternal(HttpServletRequest request, HttpServletResponse response, FilterChain filterChain) throws ServletException, IOException {
        String tokenHeader = request.getHeader(ZwzLoginProperties.HTTP_HEADER);
        if(ZwzNullUtils.isNull(tokenHeader)){
            tokenHeader = request.getParameter(ZwzLoginProperties.HTTP_HEADER);
        }
        if (ZwzNullUtils.isNull(tokenHeader)) {
            filterChain.doFilter(request, response);
            return;
        }
        try {
            UsernamePasswordAuthenticationToken token = getUsernamePasswordAuthenticationToken(tokenHeader, response);
            SecurityContextHolder.getContext().setAuthentication(token);
        }catch (Exception e){
            log.warn("自定义权限过滤失败" + e);
        }
        filterChain.doFilter(request, response);
    }

    @ApiOperation(value = "判断登录是否失效")
    private UsernamePasswordAuthenticationToken getUsernamePasswordAuthenticationToken(String header, HttpServletResponse response) {
        String userName = null;
        String tokenInRedis = redisTemplate.get(ZwzLoginProperties.HTTP_TOKEN_PRE + header);
        if(ZwzNullUtils.isNull(tokenInRedis)){
            ResponseUtil.out(response, ResponseUtil.resultMap(RESPONSE_FAIL_FLAG,RESPONSE_NO_ROLE_CODE,"登录状态失效，需要重登！"));
            return null;
        }

        TokenUser tokenUser = JSONObject.parseObject(tokenInRedis,TokenUser.class);
        userName = tokenUser.getUsername();
        List<GrantedAuthority> permissionList = new ArrayList<>();
        if(zwzLoginProperties.getSaveRoleFlag()){
            for(String permission : tokenUser.getPermissions()){
                permissionList.add(new SimpleGrantedAuthority(permission));
            }
        } else{
            permissionList = securityUtil.getCurrUserPerms(userName);
        }
        if(!tokenUser.getSaveLogin()){
            redisTemplate.set(ZwzLoginProperties.USER_TOKEN_PRE + userName, header, zwzLoginProperties.getUserTokenInvalidDays(), TimeUnit.MINUTES);
            redisTemplate.set(ZwzLoginProperties.HTTP_TOKEN_PRE + header, tokenInRedis, zwzLoginProperties.getUserTokenInvalidDays(), TimeUnit.MINUTES);
        }
        if(!ZwzNullUtils.isNull(userName)) {
            User user = new User(userName, "", permissionList);
            return new UsernamePasswordAuthenticationToken(user, null, permissionList);
        }
        return null;
    }

    public JwtTokenOncePerRequestFilter(RedisTemplateHelper redis, SecurityUtil securityUtil,ZwzLoginProperties zwzLoginProperties) {
        this.redisTemplate = redis;
        this.securityUtil = securityUtil;
        this.zwzLoginProperties = zwzLoginProperties;
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71

以上代码用于判断用户的 Token 状态，依次判断用户登录是否还处于有效状态。

5.2 图形验证码过滤

请同学们新建 ImageValidateFilter 过滤器，继承于 OncePerRequestFilter，重写 doFilterInternal 过滤方法。

过滤器首先需要读取需要验证的接口，如果无需验证则放行，代码如下。

Boolean filterFlag = false;
for(String requestURI : captchaProperties.getVerification()){
    if(pathMatcher.match(requestURI, request.getRequestURI())){
        filterFlag = true;
        break;
    }
}
if(!filterFlag) {
    filterChain.doFilter(request, response);
    return;
}
1
2
3
4
5
6
7
8
9
10
11

如果确定需要进行验证码过滤，则尝试读取验证码 ID captchaId 和输入的验证码值 code，在 Redis 进行取值判断。

过滤器需要判断验证码是否为空、是否过期、是否正确，最后给与处理，代码如下。

String verificationCodeId = request.getParameter("captchaId");
String userInputCode = request.getParameter("code");
if(ZwzNullUtils.isNull(userInputCode) || ZwzNullUtils.isNull(verificationCodeId)){
    ResponseUtil.out(response, ResponseUtil.resultMap(RESPONSE_FAIL_FLAG,RESPONSE_CODE_FAIL_CODE,"验证码为空"));
    return;
}
String codeAnsInRedis = redisTemplate.opsForValue().get(verificationCodeId);
if(ZwzNullUtils.isNull(codeAnsInRedis)){
    ResponseUtil.out(response, ResponseUtil.resultMap(RESPONSE_FAIL_FLAG,RESPONSE_CODE_FAIL_CODE,"已过期的验证码，需要重新填写"));
    return;
}
if(!Objects.equals(codeAnsInRedis.toLowerCase(),userInputCode.toLowerCase())) {
    ResponseUtil.out(response, ResponseUtil.resultMap(RESPONSE_FAIL_FLAG,RESPONSE_CODE_FAIL_CODE,"验证码不正确"));
    return;
}
redisTemplate.delete(verificationCodeId);
filterChain.doFilter(request, response);
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

---

六、WebSecurityConfig 类整合

6.1 WebSecurityConfig 类配置

请同学们创建 WebSecurityConfig 类，增加 @Configuration 注解，定义为配置类，代码如下。

@ApiOperation(value = "SpringSecurity配置类")
@Configuration
@EnableMethodSecurity
public class WebSecurityConfig {
}
1
2
3
4
5

接着创建 securityFilterChain 方法，配置 Spring Security。

首先是配置白名单，即配置不需要拦截的接口明细，代码如下。

.requestMatchers("/zwz/dictData/getByType/**","/zwz/file/view/**","/zwz/user/regist","/zwz/common/**","/*/*.js","/*/*.css","/*/*.png","/*/*.ico", "/swagger-ui.html")
1

接着配置提示登录页面和登录接口，代码如下。

.formLogin().loginPage("/zwz/common/needLogin").loginProcessingUrl("/zwz/login").permitAll()
1

接着配置登录成功回调处理类，代码如下。

.successHandler(authenticationSuccessHandler)
1

接着配置登录失败回调处理类，代码如下。

.failureHandler(authenticationFailHandler)
1

最后配置过滤器，包括自定义权限过滤器和图形验证码过滤器，代码如下。

.addFilterBefore(authenticationJwtTokenFilter(), UsernamePasswordAuthenticationFilter.class)
.addFilterBefore(imageValidateFilter, UsernamePasswordAuthenticationFilter.class);
1
2

完整代码如下所示。

@ApiOperation(value = "SpringSecurity配置类")
@Configuration
@EnableMethodSecurity
public class WebSecurityConfig {

    @Autowired
    private ZwzLoginProperties zwzLoginProperties;

    @Autowired
    private UserDetailsServiceImpl userDetailsService;

    @Autowired
    private AuthenticationSuccessHandler authenticationSuccessHandler;

    @Autowired
    private AuthenticationFailHandler authenticationFailHandler;

    @Autowired
    private ZwzAccessDeniedHandler zwzAccessDeniedHandler;

    @Autowired
    private ImageValidateFilter imageValidateFilter;

    @Autowired
    private RedisTemplateHelper redisTemplate;

    @Autowired
    private SecurityUtil securityUtil;

    @Bean
    public SecurityFilterChain securityFilterChain(HttpSecurity http) throws Exception {

        http.authorizeHttpRequests().requestMatchers("/zwz/dictData/getByType/**","/zwz/file/view/**","/zwz/user/regist","/zwz/common/**","/*/*.js","/*/*.css","/*/*.png","/*/*.ico", "/swagger-ui.html").permitAll()
                .and().formLogin().loginPage("/zwz/common/needLogin").loginProcessingUrl("/zwz/login").permitAll()
                .successHandler(authenticationSuccessHandler).failureHandler(authenticationFailHandler).and()
                .headers().frameOptions().disable().and()
                .logout()
                .permitAll()
                .and()
                .authorizeHttpRequests()
                .anyRequest()
                .authenticated()
                .and()
                .cors().and()
                .csrf().disable()
                .sessionManagement().sessionCreationPolicy(SessionCreationPolicy.STATELESS)
                .and()
                .exceptionHandling().accessDeniedHandler(zwzAccessDeniedHandler)
                .and()
                .authenticationProvider(authenticationProvider())
                .addFilterBefore(authenticationJwtTokenFilter(), UsernamePasswordAuthenticationFilter.class)
                .addFilterBefore(imageValidateFilter, UsernamePasswordAuthenticationFilter.class);
        return http.build();
    }

    @Bean
    public UserDetailsService userDetailsService() {
        return username -> userDetailsService.loadUserByUsername(username);
    }

    @Bean
    public PasswordEncoder passwordEncoder() {
        return new BCryptPasswordEncoder();
    }

    @Bean
    public AuthenticationProvider authenticationProvider() {
        DaoAuthenticationProvider authProvider = new DaoAuthenticationProvider();
        authProvider.setUserDetailsService(userDetailsService());
        authProvider.setPasswordEncoder(passwordEncoder());
        return authProvider;
    }

    @Bean
    public AuthenticationManager authenticationManager(AuthenticationConfiguration config) throws Exception {
        return config.getAuthenticationManager();
    }

    @Bean
    public JwtTokenOncePerRequestFilter authenticationJwtTokenFilter() throws Exception {
        return new JwtTokenOncePerRequestFilter(redisTemplate, securityUtil, zwzLoginProperties);
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83

6.2 测试

请同学们运行项目后端，首先使用浏览器访问 http://localhost:8081/，系统自动重定向到登录提示页面，如下图所示。

接着访问免登接口 http://localhost:8081/zwz/dictData/getByType/sex，发现可以正常读取数据。

最终，本文成功将 SpringBoot3 整合了 SpringSecurity，实现了自定义接口权限过滤。