一、导入依赖

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

<parent>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-parent</artifactId>
    <version>3.1.0</version>
</parent>

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

<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-web</artifactId>
</dependency>

在实现登录时需要设计 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>

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

<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-security</artifactId>
</dependency>

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, "登录失效");
    }
}

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

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

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

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

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

3.1 判断是否保存登录

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

@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;
}

这样就可以把用户是否保存登录的标识保存在 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;
}

接着继续在 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);

上述代码将指定用户的菜单权限拉取出来，保存到 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:";

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

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

3.4 持久化登录信息

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

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

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

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

import org.springframework.data.redis.core.StringRedisTemplate;
@Autowired
private StringRedisTemplate redisTemplate;

接着根据 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:";

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));

当用户勾选了保存登录，系统保存 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));
    }
}

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

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

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

4.1 判断是否密码错误

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

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

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

其中错误的密码包括：

用户密码输入错误。（UsernameNotFoundException 异常）

用户输入了正确的密码，但没有加密。（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,"账号密码不正确"));
    }
}

默认设定 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;
}

4.2 判断是否系统鉴权失败

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

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

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

@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;
    }
}

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

一、导入依赖

二、编写登录提示接口

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

3.1 判断是否保存登录

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

3.3 单点登录处理

3.4 持久化登录信息

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

4.1 判断是否密码错误

4.2 判断是否系统鉴权失败

热门文章

最新文章

相关课程

相关电子书

相关实验场景

热门

活动广场

任务中心

开发者评测

高校计划

乘风者计划

训练营

阿里云MVP

话题

直播

下载

镜像站

技术资料

插件

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

一、导入依赖

二、编写登录提示接口

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

3.1 判断是否保存登录

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

3.3 单点登录处理

3.4 持久化登录信息

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

4.1 判断是否密码错误

4.2 判断是否系统鉴权失败

热门文章

最新文章

相关课程

相关电子书

相关实验场景