SpringBoot+Shiro+JWT实现授权

最新推荐文章于 2024-08-13 11:39:44 发布

帅帅气气的黑猫警长

最新推荐文章于 2024-08-13 11:39:44 发布

阅读量1.3k

点赞数 2

分类专栏： SpringBoot 文章标签： spring boot java

本文链接：https://blog.csdn.net/hao_ge_666/article/details/126678602

版权

SpringBoot 专栏收录该内容

6 篇文章 0 订阅

订阅专栏

一、需求

1、前后端分离项目，前端Vue，后端SpringBoot，需要实现后端鉴权；

2、当前端发送请求之后，判断是否登录或用户是否具有相应权限；

3、使用Token实现，不使用Session。

二、实现思路

1、前端Vue的axios设置请求拦截器，在请求头中添加token；

2、后端自定义JWT拦截器，继承BasicHttpAuthenticationFilter，

如果请求头中含有token，则进行认证鉴权操作；

如果请求头中不含有token，禁止访问需要登录之后才能访问的资源；

3、ShiroFilterFactoryBean中自定义拦截url，排除不需要验证的界面（如login、404、401等），其余请求的url，一律拦截至我们自定义的JWTFilter；

4、因为使用JWT验证身份，不存在Session，若没有使用缓冲池，每次鉴权都需要执行登录操作，重新获取身份信息，鉴权前执行登录操作；

5、调用自定义Realm中的doGetAuthorizationInfo，从数据库中获取该用户所对应角色或权限，进行鉴权。

三、Shiro授权原理

授权流程

流程如下：

首先调用 Subject.isPermitted*/hasRole*接口，其会委托给 SecurityManager，而 SecurityManager 接着会委托给 Authorizer；
Authorizer 是真正的授权者，如果我们调用如 isPermitted(“user:view”)，其首先会通过 PermissionResolver 把字符串转换成相应的 Permission 实例；
在进行授权之前，其会调用相应的 Realm 获取 Subject 相应的角色/权限用于匹配传入的角色/权限；
Authorizer 会判断 Realm 的角色/权限是否和传入的匹配，如果有多个 Realm，会委托给 ModularRealmAuthorizer 进行循环判断，如果匹配如 isPermitted*/hasRole* 会返回 true，否则返回 false 表示授权失败。

四、关键代码

首先是pom.xml

        <!--shiro和springboot整合包-->
        <dependency>
            <groupId>org.apache.shiro</groupId>
            <artifactId>shiro-spring-boot-starter</artifactId>
            <version>1.6.0</version>
        </dependency>
        <!--jwt-->
        <dependency>
            <groupId>io.jsonwebtoken</groupId>
            <artifactId>jjwt</artifactId>
            <version>0.9.1</version>
        </dependency>

JWTtoken的加密、解析和check已经在我的其他博客写过

1、自定义JWTToken，继承自AuthenticationToke

JWTToken差不多就是Shiro用户名密码的载体。因为我们是前后端分离，服务器无需保存用户状态，简单的实现下AuthenticationToken接口即可，因为项目使用了MD5加密，数据库存储的密码是加盐之后的密码，此处还要保存一下加盐之后的密码，将getCredentials返回为这个加盐之后的密码，因为授权还需要进行一次登录操作，此处又不能使用明文密码，所有只能将加密后的密码再使用相同的盐再加密，再将“加密之后的密码”按照相同的方法加密之后（此处有点绕嘴），再放入SimpleAuthenticationInfo中，在执行Subject.login()。（有更好的方法可以分享一下）

public class JWTToken implements AuthenticationToken {

    private String token;
    // 用户密码（数据库里存储的用户加密之后的密码）
    private String credentials;


    // 有参构造
    public JWTToken(String token) {
        this.token = token;
    }

    // 无参构造
    public JWTToken() {
    }

    @Override
    public Object getPrincipal() {
        return this.token;
    }

    @Override
    public Object getCredentials() {
        return this.credentials;
    }

    public void setCredentials(String credentials) {
        this.credentials = credentials;
    }
}

2、自定义JWT拦截器

我们使用的是 shiro 默认的权限拦截 Filter，而因为JWT的整合，我们需要自定义自己的过滤器 JWTFilter，JWTFilter 继承了 BasicHttpAuthenticationFilter，并部分方法进行了重写。所有的请求都会先经过Filter，所以我们继承官方的BasicHttpAuthenticationFilter，并且重写鉴权的方法。代码执行的流程：

preHandle -> isAccessAllowed -> isLoginAttempt -> executeLogin

public class JWTFilter extends BasicHttpAuthenticationFilter {

    /**
     * 最后始终返回true
     * @param request
     * @param response
     * @param mappedValue
     * @return
     */
    @Override
    protected boolean isAccessAllowed(ServletRequest request, ServletResponse response, Object mappedValue) {
        System.out.println("JWTFilter启动");

        //指定请求不经过该过滤器
        if(((HttpServletRequest) request).getRequestURI().endsWith("login")){
            return true;
        }
        // 判断请求的请求头是否带token属性，也就是判断用户是否一定登录
        if(isLoginAttempt(request, response)){
            // 如果请求头中包含token，则执行executeLogin方法进行登入操作，检查token是否正确
            System.out.println("用户已经登录");
            try {
                return executeLogin(request, response);
            }catch (Exception e){
                e.printStackTrace();
            }
        }else {
            System.out.println("用户没有登录");
            try {
                Result result = new Result(Code.TOKEN_INVALID, null, "Token为空！");
                this.returnErrorMsg(response, result);
            }catch (IOException e){
                e.printStackTrace();
            }
        }

        return false;
    }

    /**
     * 判断用户是否想要登录
     *  在请求头中检查是否有token就行
     * @param request
     * @param response
     * @return
     */
    @Override
    protected boolean isLoginAttempt(ServletRequest request, ServletResponse response) {
        // System.out.println("判断用户是否想要登入");
        HttpServletRequest httpServletRequest = (HttpServletRequest) request;
        return null != httpServletRequest.getHeader("token");
    }

    /**
     * 执行登录
     * @param request
     * @param response
     * @return
     * @throws Exception
     */
    @Override
    protected boolean executeLogin(ServletRequest request, ServletResponse response) throws Exception {
        System.out.println("执行登录");
        HttpServletRequest httpServletRequest = (HttpServletRequest) request;
        String token = httpServletRequest.getHeader("token");
        try{
            getSubject(request, response).login(new JWTToken(token));
            return true;
        }catch (Exception e){
            e.printStackTrace();
            Result result = new Result(Code.TOKEN_INVALID, null, "Token失效！");
            this.returnErrorMsg(response, result);
            return false;
        }
    }

    /**
     * 返回给前端自定义错误信息
     * @param response
     * @param result
     * @throws IOException
     */
    private void returnErrorMsg(ServletResponse response,Result result) throws IOException {
        //响应token为空
        response.setContentType("application/json;charset=UTF-8");
        response.setCharacterEncoding("UTF-8");
        //清空第一次流响应的内容
        response.resetBuffer();
        //转成json格式
        ObjectMapper object = new ObjectMapper();
        String asString = object.writeValueAsString(result);
        response.getWriter().println(asString);
    }

    /**
     * 因为前后端分离，需对跨域提供支持
     * @param request
     * @param response
     * @return
     * @throws Exception
     */
    @Override
    protected boolean preHandle(ServletRequest request, ServletResponse response) throws Exception {
        // System.out.println("跨域支持");
        HttpServletRequest httpServletRequest = (HttpServletRequest) request;
        HttpServletResponse httpServletResponse = (HttpServletResponse) response;

        httpServletResponse.setHeader("Access-control-Allow-Origin", httpServletRequest.getHeader("Origin"));
        httpServletResponse.setHeader("Access-Control-Allow-Methods", "GET,POST,OPTIONS,PUT,DELETE");
        httpServletResponse.setHeader("Access-Control-Allow-Headers", httpServletRequest.getHeader("Access-Control-Request-Headers"));
        // 跨域时会首先发送一个 option请求，这里我们给 option请求直接返回正常状态
        if(httpServletRequest.getMethod().equals(RequestMethod.OPTIONS.name())){
            httpServletResponse.setStatus(HttpStatus.OK.value());
            return false;
        }
        return super.preHandle(request, response);
    }
}

上面代码的大致分析：

①、拦截所有的请求，先通过Interceptor解决跨域请求问题；

②、isAccessAllowed方法启动，启动之后，调用isLoginAttempt方法；

③、isLoginAttempt是判断用户是想要执行登录操作还是要授权登录，判断的依据就是请求头里面是否含有token；

④、如果请求头里面含有token，就说明用户已经登录，那就再执行一次登录，用于鉴权；如果没有登录，那就返回前端Result；

3、Shiro全局配置类中增加自定义jwtFilter过滤器，用来拦截并处理携带JWT token的请求

/**
 * Shiro配置类
 */
@Configuration
public class ShiroConfig {
 
    /*
     * 倒序配置
     *   1、先自定义过滤器 MyRealm
     *   2、创建第二个DefaultWebSecurityManager，将MyRealm注入
     *   3、装配第三个ShiroFilterFactoryBean，将DefaultWebSecurityManager注入，并注入认证及授权规则
     * */
 
    //3、装配ShiroFilterFactoryBean，并将 DefaultWebSecurityManager 注入到 ShiroFilterFactoryBean 中
    @Bean
    public ShiroFilterFactoryBean factoryBean(DefaultWebSecurityManager manager){
        ShiroFilterFactoryBean factoryBean = new ShiroFilterFactoryBean();
        factoryBean.setSecurityManager(manager);//将 DefaultWebSecurityManager 注入到 ShiroFilterFactoryBean 中
// 自定义拦截url
        Map<String, Filter> filterMap = new LinkedHashMap<>();
        filterMap.put("jwt", new JWTFilter());
        factoryBean.setFilters(filterMap);
        //添加默认过滤器
        //表示指定登录页面
        factoryBean.setLoginUrl("/login");
        //未授权页面
        //factoryBean.setUnauthorizedUrl("/unauthorized");
        //拦截器, 配置不会被拦截的链接 顺序判断
        Map<String, String> filterChainDefinitionMap = new LinkedHashMap<>();
        //所有匿名用户均可访问到Controller层的该方法下

        filterChainDefinitionMap.put("/login", "anon");
        filterChainDefinitionMap.put("/checkToken", "anon");

        //user表示配置记住我或认证通过可以访问的地址
        //filterChainDefinitionMap.put("/remember", "user");
        //filterChainDefinitionMap.put("/logout", "logout");

        //authc:所有url都必须认证通过才可以访问; anon:所有url都都可以匿名访问
        //filterChainDefinitionMap.put("/**", "authc");

        //所有url都必须认证通过jwt过滤器才可以访问
        filterChainDefinitionMap.put("/**", "jwt");
        factoryBean.setFilterChainDefinitionMap(filterChainDefinitionMap);
        //注入认证及授权规则
        return factoryBean;
    }
 
    //2、创建DefaultWebSecurityManager ，并且将 MyRealm 注入到 DefaultWebSecurityManager bean 中
    @Bean
    public DefaultWebSecurityManager manager(MyRealm myRealm){
        DefaultWebSecurityManager manager = new DefaultWebSecurityManager();
        manager.setRealm(myRealm);//将自定义的 MyRealm 注入到 DefaultWebSecurityManager bean 中
        /*
         *  关闭shiro自带的session
         *      用了jwt的访问认证，所以要把默认session支持关掉
         *      即不保存用户登录状态，保证每次请求都重新认证
         */
        DefaultSubjectDAO subjectDAO = new DefaultSubjectDAO();
        DefaultSessionStorageEvaluator defaultSessionStorageEvaluator = new DefaultSessionStorageEvaluator();
        defaultSessionStorageEvaluator.setSessionStorageEnabled(false);
        subjectDAO.setSessionStorageEvaluator(defaultSessionStorageEvaluator);
        manager.setSubjectDAO(subjectDAO);
        return manager;
    }
 
    //1、自定义过滤器Realm
    @Bean
    public MyRealm myRealm(@Qualifier("hashedCredentialsMatcher") HashedCredentialsMatcher matcher){
        MyRealm myRealm = new MyRealm();
        // 密码匹配器
        myRealm.setCredentialsMatcher(matcher);
        return myRealm;
    }
 
    /**
     * 密码匹配器
     * @return HashedCredentialsMatcher
     */
    @Bean("hashedCredentialsMatcher")
    public HashedCredentialsMatcher hashedCredentialsMatcher(){
        HashedCredentialsMatcher matcher = new HashedCredentialsMatcher();
        // 设置哈希算法名称
        matcher.setHashAlgorithmName("MD5");
        // 设置哈希迭代次数
        matcher.setHashIterations(1024);
        // 设置存储凭证(true:十六进制编码,false:base64)
        matcher.setStoredCredentialsHexEncoded(true);
 
        return matcher;
    }

     /**
     * SpringShiroFilter首先注册到spring容器
     * 然后被包装成FilterRegistrationBean
     * 最后通过FilterRegistrationBean注册到servlet容器
     * @return
     */
    @Bean
    public FilterRegistrationBean delegatingFilterProxy() {
        FilterRegistrationBean filterRegistrationBean = new FilterRegistrationBean();
        DelegatingFilterProxy proxy = new DelegatingFilterProxy();
        proxy.setTargetFilterLifecycle(true);
        proxy.setTargetBeanName("factoryBean");
        filterRegistrationBean.setFilter(proxy);
        return filterRegistrationBean;
    }

    /**
     * 注解访问授权动态拦截，
     *  不然不会执行Realm中的doGetAuthenticationInfo
     * @param manager
     * @return
     */
    @Bean
    public AuthorizationAttributeSourceAdvisor authorizationAttributeSourceAdvisor( SecurityManager manager){
        AuthorizationAttributeSourceAdvisor authorizationAttributeSourceAdvisor = new AuthorizationAttributeSourceAdvisor();
        authorizationAttributeSourceAdvisor.setSecurityManager(manager);
        return authorizationAttributeSourceAdvisor;
    }
}

注意点1、关闭Shiro自带的session；

因为用了jwt的访问认证，所以要把默认session支持关掉。即不保存用户登录状态，保证每次请求都重新认证。


DefaultSubjectDAO subjectDAO = new DefaultSubjectDAO();
DefaultSessionStorageEvaluator defaultSessionStorageEvaluator = new DefaultSessionStorageEvaluator();
defaultSessionStorageEvaluator.setSessionStorageEnabled(false);
subjectDAO.setSessionStorageEvaluator(defaultSessionStorageEvaluator);
defaultWebSecurityManager.setSubjectDAO(subjectDAO);

4、配置Realm

/**
 * Shiro自定义Realm
 */
public class MyRealm extends AuthorizingRealm {
 
    @Autowired
    private UserService userService;
 
    /**
     * 授权
     * @param principalCollection
     * @return
     */
    @Override
    protected AuthorizationInfo doGetAuthorizationInfo(PrincipalCollection principalCollection) {
        System.out.println("获取权限信息");
        //1.获取身份信息
        User pricipal = (User) principalCollection.getPrimaryPrincipal();

        //2.根据身份获取、角色权限等信息
        ArrayList<String> roles = new ArrayList<>();
        roles = ...自己Service获取Role的方法...;
        // System.out.println("用户所具有角色："+roles);
        ArrayList<String> permissions = new ArrayList<>();
        permissions = ...自己Service获取Permissions的方法...;
        System.out.println("用户所具有权限："+permissions);

        //3.将角色、权限添加到授权信息里面
        SimpleAuthorizationInfo info = new SimpleAuthorizationInfo();
        info.addRoles(roles);
        info.addStringPermissions(permissions);
        return info;
    }
 
    /**
     * 认证
     * @param authenticationToken
     * @return
     * @throws AuthenticationException
     *
     * 客户端传来的 username 和 password 会自动封装到 token，先根据 username 进行查询，
     *      如果返回 null，则表示用户名错误，直接 return null 即可，Shiro 会自动抛出 UnknownAccountException 异常。
     *      如果返回不为 null，则表示用户名正确，再验证密码，直接返回  SimpleAuthenticationInfo 对象即可，
     *          如果密码验证成功，Shiro 认证通过，否则返回 IncorrectCredentialsException 异常。
     */
    @Override
    protected AuthenticationInfo doGetAuthenticationInfo(AuthenticationToken authenticationToken) throws AuthenticationException {
        //System.out.println("启动认证");
        String userId;
        // 如果这个token是来自JWTToken，说明此次登录目的是授权验证的登录
        if(authenticationToken instanceof JWTToken){
            JWTToken token = (JWTToken) authenticationToken;
            userId = ...自己解析token获取ID的方法...;
            User user = userService.getByUsername(token.getUsername());
            token.setCredentials(user.getPassword());
            if(user != null && user.getStatus().equals(1)){
                // 用数据库中已经加密的密码，再用数据库中对应的盐值加密一次
                String pwd2 = SaltUtil.encryption(user.getPassword(), user.getSalt());
                // 参数列表（实体信息，密码，盐值，realm名称）
                return new SimpleAuthenticationInfo(user,pwd2, ByteSource.Util.bytes(user.getSalt()),getName());
        }else{
            // 此操作是用户真正执行登录操作
            UsernamePasswordToken token = (UsernamePasswordToken) authenticationToken;
            //获取存放到数据库中的实体类
            User user = userService.getByUsername(token.getUsername());
            //System.out.println(user);
            if(user != null && user.getStatus().equals(1)){
                // 参数列表（实体信息，密码，盐值，realm名称）
                return new SimpleAuthenticationInfo(user,user.getPassword(), ByteSource.Util.bytes(user.getSalt()),getName());
            }
        }
        
        return null;
    }
}

4、再需要鉴权的Controller上面，添加注释就可以啦

//需要user角色
@RequiresRoles("user")
 
//必须同时属于user和admin角色
@RequiresRoles({"user","admin"})

//用户具有index:menu权限才可访问
@RequiresPermissions("index:menu")

五、总结

1、目前没有使用缓存，每次鉴权都要去数据库查Role、查Permissions；

2、鉴权时段的登录操作，因为token中不能封装明文密码，又不能移除加密器，所以要对数据库中已经加密的密码，在此基础上再把这个密码进行一次加密，出现了不必要的资源浪费；

3、虽然实现功能，但是实现过程复杂；

最后，感谢“桃子屁屁”的大力支持。

帅帅气气的黑猫警长

关注

2
点赞
踩
6

收藏

觉得还不错? 一键收藏
2
评论
复制链接

分享到 QQ

分享到新浪微博

扫一扫

专栏目录