脚本之家 服务器常用软件
快捷导航
您的位置：首页 → 软件编程 → java → SpringSecurity自定义Token校验

使用SpringSecurity 进行自定义Token校验

 更新时间：2021年06月23日 09:59:47   作者：TerrellChen  
这篇文章主要介绍了使用SpringSecurity 进行自定义Token校验操作，具有很好的参考价值，希望对大家有所帮助。如有错误或未考虑完全的地方，望不吝赐教

背景

Spring Security默认使用「用户名/密码」的方式进行登陆校验，并通过cookie的方式存留登陆信息。在一些定制化场景，比如希望单独使用token串进行部分页面的访问权限控制时，默认方案无法支持。

在未能在网上搜索出相关实践的情况下，通过官方文档及个别Stack Overflow的零散案例，形成整体思路并实践测试通过，本文即关于该方案的一个分享。

参考官方文档

SpringSecurity校验流程

基本的SpringSecurity使用方式网上很多，不是本文关注的重点。

关于校验的整个流程简单的说，整个链路有三个关键点，

  • 将需要鉴权的类/方法/url），定义为需要鉴权（本文代码示例为方法上注解@PreAuthorize("hasPermission('TARGET','PERMISSION')")
  • 根据访问的信息产生一个来访者的权限信息Authentication，并插入到上下文中
  • 在调用鉴权方法时，根据指定的鉴权方式，验证权限信息是否符合权限要求

完整的调用链建议在IDE中通过单步调试亲自体会，本文不做相关整理。

如何自定义

我的需求，是使用自定义的token，验证权限，涉及到：

  • 产生Authentication并插入到上下文中
  • 针对token的验证方式

需要做的事情如下：

  • 自定义TokenAuthentication类，实现org.springframework.security.core.Authenticaion，作为token权限信息
  • 自定义AuthenticationTokenFilter类，实现javax.servlet.Filter，在收到访问时，根据访问信息生成TokenAuthentication实例，并插入上下文
  • 自定义SecurityPermissionEvalutor类，实现org.springframework.security.access.PermissionEvaluator，完成权限的自定义验证逻辑
  • 在全局的配置中，定义使用SecurityPermissionEvalutor作为权限校验方式

TokenAuthentication.java

/**
 * @author: Blaketairan
 */
import org.springframework.security.core.Authentication;
import org.springframework.security.core.GrantedAuthority;
import java.util.ArrayList;
import java.util.Collection;
/**
 * Description: spring-security的Authentication的自定义实现（用于校验token）
 */
public class TokenAuthentication implements Authentication{
    private String token;
    public TokenAuthentication(String token){
        this.token = token;
    }
    @Override
    public Collection<? extends GrantedAuthority> getAuthorities() {
        return new ArrayList<GrantedAuthority>(0);
    }
    @Override
    public Object getCredentials(){
        return token;
    }
    @Override
    public Object getDetails() {
        return null;
    }
    @Override
    public Object getPrincipal() {
        return null;
    }
    @Override
    public boolean isAuthenticated() {
        return true;
    }
    @Override
    public void setAuthenticated(boolean isAuthenticated) throws IllegalArgumentException {
    }
    @Override
    public String getName() {
        return null;
    }
}

AuthenticationTokenFilter.java

/**
 * @author: Blaketairan
 */
import com.google.common.base.Strings;
import com.blaketairan.spring.security.configuration.TokenAuthentication;
import org.springframework.context.annotation.Configuration;
import org.springframework.security.core.Authentication;
import org.springframework.security.core.context.SecurityContextHolder;
import javax.servlet.*;
import javax.servlet.http.HttpServletRequest;
import java.io.IOException;
/**
 * Description: 用于处理收到的token并为spring-security上下文生成及注入Authenticaion实例
 */
@Configuration
public class AuthenticationTokenFilter implements Filter{
    @Override
    public void init(FilterConfig filterConfig) throws ServletException{
    }
    @Override
    public void doFilter(ServletRequest servletRequest, ServletResponse servletResponse,FilterChain filterChain)
            throws IOException, ServletException{
        if (servletRequest instanceof HttpServletRequest){
            String token = ((HttpServletRequest) servletRequest).getHeader("PRIVATE-TOKEN");
            if (!Strings.isNullOrEmpty(token)){
                Authentication authentication = new TokenAuthentication(token);
                SecurityContextHolder.getContext().setAuthentication(authentication);
                System.out.println("Set authentication with non-empty token");
            } else {
                /**
                 * 在未收到Token时，至少塞入空TokenAuthenticaion实例，避免进入SpringSecurity的用户名密码默认模式
                 */
                Authentication authentication = new TokenAuthentication("");
                SecurityContextHolder.getContext().setAuthentication(authentication);
                System.out.println("Set authentication with empty token");
            }
        }
        filterChain.doFilter(servletRequest, servletResponse);
    }
    @Override
    public void destroy(){
    }
}

SecurityPermissionEvalutor.java

/**
 * @author: Blaketairan
 */
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.security.access.PermissionEvaluator;
import org.springframework.security.core.Authentication;
import java.io.Serializable;
/**
 * Description: spring-security 自定义的权限处理模块（鉴权）
 */
public class SecurityPermissionEvaluator implements PermissionEvaluator {
    @Override
    public boolean hasPermission(Authentication authentication,Object targetDomainObject, Object permission){
        String targetDomainObjectString = null;
        String permissionString = null;
        String token = null;
        try {
            targetDomainObjectString = (String)targetDomainObject;
            permissionString = (String)permission;
            token = (String)authentication.getCredentials();
        } catch (ClassCastException e){
            e.printStackTrace();
            return false;
        }
        return hasPermission(token, targetDomainObjectString, permissionString);
    }
    @Override
    public boolean hasPermission(Authentication authentication, Serializable targetId, String targetType, Object permission){
        /**
         * 使用@PreAuthorize("hasPermission('TARGET','PERMISSION')")方式，不使用该鉴权逻辑
         */
        return false;
    }
    private boolean hasPermission(String token,String targetDomain, String permission){
        /**
         * 验证权限
        **/
        return true;
    }
}

SecurityConfig.java 全局配置

/**
 * @author: Blaketairan
 */
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.security.access.PermissionEvaluator;
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.EnableWebSecurity;
import org.springframework.security.config.annotation.web.configuration.WebSecurityConfigurerAdapter;
/**
 * Description: spring-security配置，指定使用自定义的权限评估方法
 */
@Configuration
@EnableWebSecurity
@EnableGlobalMethodSecurity(prePostEnabled = true)
public class SecurityConfig extends WebSecurityConfigurerAdapter{
    @Bean
    @Override
    protected AuthenticationManager authenticationManager() throws Exception{
        return super.authenticationManager();
    }
    @Bean
    public PermissionEvaluator permissionEvaluator() {
        /**
         * 使用自定义的权限验证
        **/
        SecurityPermissionEvaluator securityPermissionEvaluator = new SecurityPermissionEvaluator();
        return securityPermissionEvaluator;
    }
    @Override
    protected void configure(HttpSecurity httpSecurity) throws Exception{
        /**
         * 关掉csrf方便本地ip调用调试
        **/
        httpSecurity
                .csrf()
                .disable()
                .httpBasic()
                .disable();
    }
}

BaseRepository.java 某个需要权限验证的方法

/**
 * @author: Blaketairan
 */
import org.springframework.security.access.prepost.PreAuthorize;
import java.util.List;
/**
 * Description: 
 */
public interface BaseRepository{
    @PreAuthorize("hasPermission('DOMAIN', 'PERMISSION')")
    void deleteAll();
}

spring security 自定义token无法通过框架认证

自定义token和refreshToken，如代码所示：

UserDO userDO = userMapper.getByName(username);
UserDetails userDetails = 
userService.loadUserByUsername(userForBase.getName());
String token = jwtTokenComponent.generateToken(userDO);
String refreshToken = jwtTokenComponent.generateRefreshToken(userDO);
storeToken(userDO, token,refreshToken);
jsonObject.put("principal", userDetails);
jsonObject.put("token_type", "bearer");
return jsonObject;

无法通过框架的认证？搞它：

UserDO userDO = userMapper.getByName(username);
UserDetails userDetails = 
userService.loadUserByUsername(userForBase.getName());
String token = jwtTokenComponent.generateToken(userDO);
String refreshToken = jwtTokenComponent.generateRefreshToken(userDO);
storeToken(userDO, token,refreshToken);
jsonObject.put("access_token", token);
jsonObject.put("refresh_token", refreshToken);
jsonObject.put("principal", userDetails);
jsonObject.put("token_type", "bearer");
return jsonObject;
private void storeToken(UserDO userDO, String token,String refreshToken) {
        Map<String, String> tokenParams = new HashMap<>();
        tokenParams.put("access_token", token);
        tokenParams.put("expires_in", "7200");
        tokenParams.put("token_type", "bearer");
        OAuth2AccessToken oAuth2AccessToken = DefaultOAuth2AccessToken.valueOf(tokenParams);
        DefaultOAuth2RefreshToken oAuth2RefreshToken = new DefaultOAuth2RefreshToken(refreshToken);
        // 创建redisTemplate,序列化对象
        Map<String, String> requestMap = new HashMap<>();
        requestMap.put("username", userDO.getUsername());
        requestMap.put("grant_type", "password");
        Map<String, Object> queryMap = new HashMap<String, Object>();
        queryMap.put("id",userDO.getUserId());
        List<String> perms = menuMapper.listUserPerms(queryMap);
        Set<GrantedAuthority> authorities = new HashSet<>();
        for (String perm : perms) {
if (StringUtils.isNotBlank(perm)) {
    authorities.add(new SimpleGrantedAuthority(perm.trim()));
}
        }
        OAuth2Request storedRequest = new OAuth2Request(requestMap, "oms-web", authorities, true, null,
    null, null, null, null);
        CustomUserDetails userEnhancer = new CustomUserDetails(userDO, true, true, true, true, authorities);
        UsernamePasswordAuthenticationToken authentication = new UsernamePasswordAuthenticationToken(userEnhancer, null, userEnhancer.getAuthorities());
        authentication.setDetails(requestMap);
        OAuth2Authentication oAuth2Authentication = new OAuth2Authentication(storedRequest, authentication);
        tokenStore.storeAccessToken(oAuth2AccessToken, oAuth2Authentication);
        tokenStore.storeRefreshToken(oAuth2RefreshToken, oAuth2Authentication);
    }

以上为个人经验，希望能给大家一个参考，也希望大家多多支持脚本之家。

您可能感兴趣的文章:

相关文章

  • Java抽象的本质解析

    Java抽象的本质解析

    对于面向对象编程来说,抽象是它的一大特征之一,在 Java 中可以通过两种形式来体现OOP的抽象:接口和抽象类,下面这篇文章主要给大家介绍了关于Java基础抽象的相关资料,需要的朋友可以参考下
    2022-03-03
  • JVM常用垃圾收集器及GC算法解读

    JVM常用垃圾收集器及GC算法解读

    这篇文章主要介绍了JVM常用垃圾收集器及GC算法,具有很好的参考价值,希望对大家有所帮助,如有错误或未考虑完全的地方,望不吝赐教
    2024-04-04
  • springboot+mybatis报错找不到实体类的问题

    springboot+mybatis报错找不到实体类的问题

    这篇文章主要介绍了springboot+mybatis报错找不到实体类的问题，具有很好的参考价值，希望对大家有所帮助。如有错误或未考虑完全的地方，望不吝赐教
    2022-01-01
  • 详解SpringMVC验证框架Validation特殊用法

    详解SpringMVC验证框架Validation特殊用法

    本篇文章主要介绍了详解SpringMVC验证框架Validation特殊用法，小编觉得挺不错的，现在分享给大家，也给大家做个参考。一起跟随小编过来看看吧
    2017-02-02
  • Java OpenCV学习之Mat的基本操作详解

    Java OpenCV学习之Mat的基本操作详解

    OpenCV用来存储图像，很多时候都会用到这个Mat方法。数字图像可看做一个数值矩阵, 其中的每一个元素表明一个像素点。Mat在 OpenCV 中表示的是 N 维稠密矩阵，与稠密矩阵相对的是稀疏矩阵。本文将重点介绍OpenCV中Mat的一些基本操作，需要的可以参考一下
    2022-03-03
  • Java深入学习图形用户界面GUI之事件处理

    Java深入学习图形用户界面GUI之事件处理

    这篇文章主要介绍了基于Java GUI 事件处理方式，一个图形界面制作完成了，在程序开发中只是完成了起步的工作。要想让一个组件都发挥自己的作用.就必须对所有的组件进行事件处理
    2022-05-05
  • Java基于TCP协议的Socket通信

    Java基于TCP协议的Socket通信

    本文详细讲解了Java基于TCP协议的Socket通信，文中通过示例代码介绍的非常详细。对大家的学习或者工作具有一定的参考学习价值，需要的朋友们下面随着小编来一起学习学习吧
    2021-12-12
  • String转BigDecimal,BigDecimal常用操作,以及避免踩坑记录

    String转BigDecimal,BigDecimal常用操作,以及避免踩坑记录

    这篇文章主要介绍了String转BigDecimal,BigDecimal常用操作,以及避免踩坑记录，具有很好的参考价值，希望对大家有所帮助。如有错误或未考虑完全的地方，望不吝赐教
    2023-07-07
  • Java Long类型对比分析

    Java Long类型对比分析

    这篇文章主要介绍了Java Long类型对比分析，具有很好的参考价值，希望对大家有所帮助。如有错误或未考虑完全的地方，望不吝赐教
    2021-07-07
  • MybatisPlus关联查询的完美实现方案

    MybatisPlus关联查询的完美实现方案

    我们在项目开发的时候,难免会遇到连表查询的操作,所以下面这篇文章主要给大家介绍了关于MybatisPlus关联查询的相关资料,文中通过实例代码介绍的非常详细,需要的朋友可以参考下
    2021-12-12

最新评论