使用shiro拦截器链实现权限管理

最新推荐文章于 2024-04-27 09:13:51 发布

m0_67392811

最新推荐文章于 2024-04-27 09:13:51 发布

阅读量689

点赞数

分类专栏： java 文章标签： java 后端

本文链接：https://blog.csdn.net/m0_67392811/article/details/124467587

版权

java 专栏收录该内容

275 篇文章 7 订阅

订阅专栏

在开篇之前，先介绍一下shiro，那么

什么是shiro呢？

Apache Shiro（发音为“shee-roh”，日语“堡垒（Castle）”的意思）是一个强大易用的Java安全框架，提供了认证、授权、加密和会话管理功能，可为任何应用提供安全保障 - 从命令行应用、移动应用到大型网络及企业应用。

Shiro为解决下列问题（我喜欢称它们为应用安全的四要素）提供了保护应用的API：
认证 - 用户身份识别，常被称为用户“登录”；
授权 - 访问控制；
密码加密 - 保护或隐藏数据防止被偷窥；
会话管理 -每用户相关的时间敏感的状态。

Shiro还支持一些辅助特性，如Web应用安全、单元测试和多线程，它们的存在强化了上面提到的四个要素

由上面介绍可知，shiro可以实现认证及授权，这也是本篇的重点，使用shiro实现认证和授权。

使用shiro实现权限管理

首先看一下我的项目结构：
这里写图片描述
图 1.项目结构

项目代码地址：GitHub地址

我们跳过无关紧要的内容，直接讲最关建的shiro部分。

shiro

我们先看一下项目中和shiro有关的文件，java文件三个，分别是：MyRealm.java、ShiroConfig.java、ShiroManager.java；
在spring-mvc.xml文件中，我们对shiro的bean注解开启了配置

<context:component-scan base-package="shiro"/>

在web.xml文件中，我们配置了shiro的过滤器

<!-- shiro过滤器定义 -->
  <filter>
    <filter-name>shiroFilter</filter-name>
    <filter-class>org.springframework.web.filter.DelegatingFilterProxy</filter-class>
    <init-param>
      <!-- 该值缺省为false,表示生命周期由SpringApplicationContext管理,设置为true则表示由ServletContainer管理 -->
      <param-name>targetFilterLifecycle</param-name>
      <param-value>true</param-value>
    </init-param>
  </filter>
  <filter-mapping>
    <filter-name>shiroFilter</filter-name>
    <url-pattern>/a/*</url-pattern>
  </filter-mapping>

由此，我们开始整理shiro的实现脉路。

shiro拦截器链的实现原理

首先我们的请求通过web.xml的时候被shiro的拦截器过滤了一波，也就是

<!-- shiro过滤器定义 -->
  <filter>
    <filter-name>shiroFilter</filter-name>
    <filter-class>org.springframework.web.filter.DelegatingFilterProxy</filter-class>
    <init-param>
      <!-- 该值缺省为false,表示生命周期由SpringApplicationContext管理,设置为true则表示由ServletContainer管理 -->
      <param-name>targetFilterLifecycle</param-name>
      <param-value>true</param-value>
    </init-param>
  </filter>
  <filter-mapping>
    <filter-name>shiroFilter</filter-name>
    <url-pattern>/a/*</url-pattern>
  </filter-mapping>

在起效，这里看一看到所有的/a开头的url都需要经过shiro的过滤器。
spring-mvc.xml中的注解开启配置就不说了，主要是shiro的java代码中涉及了比较多的注解配置，所以这条配置是必须的

<context:component-scan base-package="shiro"/>

接下来，我们看shiro的主体部分，也是本篇的重点
首先是MyRealm.java

package shiro;

import model.Role;
import model.User;
import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;
import org.apache.shiro.authc.*;
import org.apache.shiro.authc.credential.AllowAllCredentialsMatcher;
import org.apache.shiro.authz.AuthorizationInfo;
import org.apache.shiro.authz.SimpleAuthorizationInfo;
import org.apache.shiro.realm.AuthorizingRealm;
import org.apache.shiro.subject.PrincipalCollection;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;
import service.RoleService;
import service.UserService;
import util.SplitUtil;

import java.util.HashSet;
import java.util.List;
import java.util.Set;

/**
 * Created by yubotao on 2017/12/03.
 */
@SuppressWarnings("ALL")
@Component
public class MyRealm extends AuthorizingRealm{
    private static final Log log = LogFactory.getLog(MyRealm.class);
    public MyRealm(){
        super(new AllowAllCredentialsMatcher());
        setAuthenticationTokenClass(UsernamePasswordToken.class);
        //FIXME:暂时禁用Cache
        setCachingEnabled(false);
    }

    @Autowired
    UserService userService;
    @Autowired
    RoleService roleService;

    //验证时调用
    //此方法调用subject.hasRole("admin")或subject.isPermitted("admin");
    //自己去调用这个是否有什么角色或有什么权限
    @Override
    protected AuthorizationInfo doGetAuthorizationInfo(PrincipalCollection principals){
        User user = (User) principals.getPrimaryPrincipal();
        SimpleAuthorizationInfo authorizationInfo = new SimpleAuthorizationInfo();

        User user1 = null;

        /*新建角色与权限的set*/
        Set<String> shiroPermissions = new HashSet<>();
        Set<String> roleSet = new HashSet<>();
        try{
            /*1.通过userName获取userId*/
            user1 = userService.getUserByName(user.getName());
            if(user1 != null){
                Role role = roleService.getRoleById(user.getRole());
                log.info("role permission : " + role.getPermission());
                SplitUtil splitUtil = new SplitUtil();
                List<Integer> permissionList = splitUtil.stringToIntegerList(role.getPermission());
                log.info("permisson list : " + permissionList);
                for (int i = 0; i < permissionList.size(); i++){
                    shiroPermissions.add(permissionList.get(i).toString());
                }
                authorizationInfo.setStringPermissions(shiroPermissions);
                log.info("shiroPermissions : " + shiroPermissions);
                return authorizationInfo;
            }
        }catch (Exception e){
            e.printStackTrace();
        }
        return null;
    }

    //登陆时调用
    //调用Subject currentUser = SecurityUtils.getSubject();
    //    currentUser.login(token);
    @Override
    protected AuthenticationInfo doGetAuthenticationInfo(AuthenticationToken token){
        String username = (String) token.getPrincipal();
        log.info("username : " + username);
        User user = null;
        String password = null;

        try{
            /*通过username获取User*/
            user = userService.getUserByName(username);
            log.info("user : " + user);
            password = new String((char[]) token.getCredentials());
            log.info("password : " + password);
            //账号不存在
            if(user == null){
                throw new UnknownAccountException("账号不正确");
            }
            //密码错误
            //简单起见，没有加密，应该加上
            if(!password.equals(user.getPassword())){
                throw new UnknownAccountException("密码错误");
            }
        }catch (Exception e){
            throw new AuthenticationException();
        }

        SimpleAuthenticationInfo info = new SimpleAuthenticationInfo(user,password,getName());

        return info;
    }

}

在讲解该部分代码前，我们首先介绍一下Realm这个shiro的组件。

Realm

此部分内容参考该blog：Realm的介绍

Realm 是一个能够访问应用程序特定的安全数据（如用户、角色及权限）的组件。

Realm 通常和数据源是一对一的对应关系，如关系数据库，LDAP 目录，文件系统，或其他类似资源。Realm
实质上就是一个特定安全的DAO。

因为这些数据源大多通常存储身份验证数据（如密码的凭证）以及授权数据（如角色或权限），每个Realm能够执行身份验证和授权操作。

由这篇blog我们可以整理出如下信息：
1.shiro的认证最后是交给Realm的，调用的是doGetAuthenticationInfo()方法；
2.如果验证通过，会返回一个非空的AuthenticationInfo实例来代表来自该数据源的Subject账户信息。

为了便于理解，这里首先介绍俩个词：
Authorization —— 授权
Authentication —— 认证
然后我们看一下我们自定义的MyRealm的内容，首先是构造函数

 public MyRealm(){
        super(new AllowAllCredentialsMatcher());
        setAuthenticationTokenClass(UsernamePasswordToken.class);
        //FIXME:暂时禁用Cache
        setCachingEnabled(false);
    }

这里借用一张图：该图源自对于shiro有比较深入的介绍
这里写图片描述
这张图展示了shiro的认证匹配接口结构图，这里面就有我们提到的AllowAllCredentialsMatcher，它的含义是：只要该用户名存在即可，不用去验证密码是否匹配。
然后我们在构造函数中将Cache设为暂不使用。

接下来是Realm中的认证内容

@Override
    protected AuthorizationInfo doGetAuthorizationInfo(PrincipalCollection principals){
        User user = (User) principals.getPrimaryPrincipal();
        SimpleAuthorizationInfo authorizationInfo = new SimpleAuthorizationInfo();

        User user1 = null;

        /*新建角色与权限的set*/
        Set<String> shiroPermissions = new HashSet<>();
        Set<String> roleSet = new HashSet<>();
        try{
            /*1.通过userName获取userId*/
            user1 = userService.getUserByName(user.getName());
            if(user1 != null){
                Role role = roleService.getRoleById(user.getRole());
                log.info("role permission : " + role.getPermission());
                SplitUtil splitUtil = new SplitUtil();
                List<Integer> permissionList = splitUtil.stringToIntegerList(role.getPermission());
                log.info("permisson list : " + permissionList);
                for (int i = 0; i < permissionList.size(); i++){
                    shiroPermissions.add(permissionList.get(i).toString());
                }
                authorizationInfo.setStringPermissions(shiroPermissions);
                log.info("shiroPermissions : " + shiroPermissions);
                return authorizationInfo;
            }
        }catch (Exception e){
            e.printStackTrace();
        }
        return null;
    }

这里可以看到，该代码块的主要逻辑就是，获取用户对应角色所拥有的权限，然后将这些权限放到SimpleAuthorizationInfo的权限认证书中，这个地方是为了之后的shiro权限认证所做的铺垫。
这里使用了PrincipalCollection，这个接口是干什么用的呢，经过查阅，发现该值是唯一的，在所有用户帐户中唯一的字符串用户名。所以代码中的

User user = (User) principals.getPrimaryPrincipal();

使用它来获取当前subject中的唯一用户。
到此，我们已经完成了授权，接下来就就是认证了。

 @Override
    protected AuthenticationInfo doGetAuthenticationInfo(AuthenticationToken token){
        String username = (String) token.getPrincipal();
        log.info("username : " + username);
        User user = null;
        String password = null;

        try{
            /*通过username获取User*/
            user = userService.getUserByName(username);
            log.info("user : " + user);
            password = new String((char[]) token.getCredentials());
            log.info("password : " + password);
            //账号不存在
            if(user == null){
                throw new UnknownAccountException("账号不正确");
            }
            //密码错误
            //简单起见，没有加密，应该加上
            if(!password.equals(user.getPassword())){
                throw new UnknownAccountException("密码错误");
            }
        }catch (Exception e){
            throw new AuthenticationException();
        }

        SimpleAuthenticationInfo info = new SimpleAuthenticationInfo(user,password,getName());

        return info;
    }

这部分的代码块主要逻辑是：通过token.getPrincipal()方法获取到Token中的用户名，然后根据用户名查找数据库，找出数据库中记录并进行对比，如果确实有该用户，并且帐密无误，那么就会通过

SimpleAuthenticationInfo info = new SimpleAuthenticationInfo(user,password,getName());

生成一个认证信息。
到此，我们的自定义Realm内容就完毕了。

ShiroManager

首先看一下ShiroManager.java的代码：

package shiro;

/**
 * Created by yubotao on 2017/12/03.
 */

import org.apache.shiro.mgt.DefaultSecurityManager;
import org.apache.shiro.spring.LifecycleBeanPostProcessor;
import org.apache.shiro.spring.security.interceptor.AuthorizationAttributeSourceAdvisor;
import org.springframework.aop.framework.autoproxy.DefaultAdvisorAutoProxyCreator;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.DependsOn;

/**
 * shiro Config Manager
 * */
public class ShiroManager {

    /**
     * 保证了实现shiro内部的lifecycle函数的bean执行
     * */
    @Bean(name = "lifecycleBeanPostProcessor")
    public LifecycleBeanPostProcessor lifecycleBeanPostProcessor(){return new LifecycleBeanPostProcessor();}

    @Bean(name = "defaultAdvisorAutoProxyCreator")
    @DependsOn("lifecycleBeanPostProcessor")
    public DefaultAdvisorAutoProxyCreator defaultAdvisorAutoProxyCreator(){
        DefaultAdvisorAutoProxyCreator defaultAdvisorAutoProxyCreator = new DefaultAdvisorAutoProxyCreator();
        defaultAdvisorAutoProxyCreator.setProxyTargetClass(true);
        return defaultAdvisorAutoProxyCreator;
    }

    @Bean
    public AuthorizationAttributeSourceAdvisor getAuthorizationAttributeSourceAdvisor(DefaultSecurityManager securityManager){
        AuthorizationAttributeSourceAdvisor aasa = new AuthorizationAttributeSourceAdvisor();
        aasa.setSecurityManager(securityManager);
        return aasa;
    }

}

首先这个ShiroManager的名字就暴露出，这部分是管理shiro的一些bean的，那么我们先来看第一个代码块：

@Bean(name = "lifecycleBeanPostProcessor")
    public LifecycleBeanPostProcessor lifecycleBeanPostProcessor(){return new LifecycleBeanPostProcessor();}

查看shiro的官方文档我们发现，这个LifecycleBeanPostProcessor是shiro和Spring整合的一个生命周期bean，自动使用init和destroy，无需我们进行管理；
接下来第二个代码块

 @Bean(name = "defaultAdvisorAutoProxyCreator")
    @DependsOn("lifecycleBeanPostProcessor")
    public DefaultAdvisorAutoProxyCreator defaultAdvisorAutoProxyCreator(){
        DefaultAdvisorAutoProxyCreator defaultAdvisorAutoProxyCreator = new DefaultAdvisorAutoProxyCreator();
        defaultAdvisorAutoProxyCreator.setProxyTargetClass(true);
        return defaultAdvisorAutoProxyCreator;
    }

这里关键的类时DefaultAdvisorAutoProxyCreator，该类时spring-aop包下的类，具体功能为：自动创建代理，它会搜寻所有的Advisor，并自动将Advisor应用到符合的PointCuts（切点）物件上。
通俗讲就是我们生成了一个可以自动帮我们实现aop代理的bean，并且对相应的切点使用已有的Advisor。
接下来我们看第三个代码块

@Bean
    public AuthorizationAttributeSourceAdvisor getAuthorizationAttributeSourceAdvisor(DefaultSecurityManager securityManager){
        AuthorizationAttributeSourceAdvisor aasa = new AuthorizationAttributeSourceAdvisor();
        aasa.setSecurityManager(securityManager);
        return aasa;
    }

这个类可以在shiro官方文档中查看，我们通过查看可以看到这个AuthorizationAttributeSourceAdvisor就是我们刚才提到的Advisor，并且它实际上使用了AopAllianceAnnotationsAuthorizingMethodInterceptor，而该类的官方文档解释为：

Allows Shiro Annotations to work in any AOP Alliance specific implementation environment (for example, Spring).

使shiro注解能够在任意的特定AOP联合环境工作，比如我们现在使用的Spring。
至此，ShiroManager的讲解也完毕了。

ShiroConfig

这里是整个shiro拦截链的关键。
ShiroConfig.java

package shiro;

import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;
import org.apache.shiro.cache.CacheManager;
import org.apache.shiro.cache.MemoryConstrainedCacheManager;
import org.apache.shiro.mgt.DefaultSecurityManager;
import org.apache.shiro.realm.Realm;
import org.apache.shiro.spring.web.ShiroFilterFactoryBean;
import org.apache.shiro.web.mgt.DefaultWebSecurityManager;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.DependsOn;
import org.springframework.context.annotation.Import;

import java.util.LinkedHashMap;

/**
 * Created by yubotao on 2017/12/03.
 */
@Configuration
@Import(ShiroManager.class)
public class ShiroConfig {
    private static final Log log = LogFactory.getLog(ShiroConfig.class);

    @Bean(name = "realm")
    @DependsOn("lifecycleBeanPostProcessor")
    public Realm realm(){return new MyRealm();}

    /**
     * 用户授权信息Cache
     * */
    @Bean(name = "shiroCacheManager")
    public CacheManager cacheManager(){return new MemoryConstrainedCacheManager();}

    @Bean(name = "securityManager")
    public DefaultSecurityManager securityManager(){
        //这里注意，需要实现DefaultWebSecurityManager
        DefaultSecurityManager sm = new DefaultWebSecurityManager();
        sm.setCacheManager(cacheManager());
        return sm;
    }

    /**
     * shiro核心，拦截器链，顺序执行
     * */
    @Bean(name = "shiroFilter")
    @DependsOn("securityManager")
    public ShiroFilterFactoryBean getShiroFilterFactoryBean(DefaultSecurityManager securityManager,Realm realm){
        securityManager.setRealm(realm);

        ShiroFilterFactoryBean shiroFilter = new ShiroFilterFactoryBean();
        shiroFilter.setSecurityManager(securityManager);
        shiroFilter.setLoginUrl("/a/login/fail");//未登录跳转
        shiroFilter.setUnauthorizedUrl("/a/login/fail");//未授权跳转
        LinkedHashMap<String,String> filterChainDefinitionMap = new LinkedHashMap<>();

        filterChainDefinitionMap.put("/a/u/first","perms[1]");
        log.info("第一链");
        filterChainDefinitionMap.put("/a/u/second","perms[2]");
        log.info("第二链");
        filterChainDefinitionMap.put("/a/u/third","perms[3]");
        log.info("第三链");

        filterChainDefinitionMap.put("/a//**","anon");

        log.info("执行顺序 : " + filterChainDefinitionMap);

        shiroFilter.setFilterChainDefinitionMap(filterChainDefinitionMap);
        return shiroFilter;
    }


}

和之前一样，我们还是逐个击破。
首先这里使用了注解@Import(ShiroManager.class)，也就是引用了我们刚才配置的ShiroManager，也就是在这个类里，完成了所有shiro配置的大汇合。
先看第一个代码块

@Bean(name = "realm")
    @DependsOn("lifecycleBeanPostProcessor")
    public Realm realm(){return new MyRealm();}

这里我们依赖了刚才配置的生命周期bean，并且配置出了我们自定义的MyRealm。
然后是第二个代码块

/**
     * 用户授权信息Cache
     * */
    @Bean(name = "shiroCacheManager")
    public CacheManager cacheManager(){return new MemoryConstrainedCacheManager();}

这里我们将使用用户授权信息的Cache。
第三个代码块

 @Bean(name = "securityManager")
    public DefaultSecurityManager securityManager(){
        //这里注意，需要实现DefaultWebSecurityManager
        DefaultSecurityManager sm = new DefaultWebSecurityManager();
        sm.setCacheManager(cacheManager());
        return sm;
    }

这里需要注意的是需要实现DefaultWebSecurityManager，否则会在使用shiro拦截链的时候报错，一开始的时候我在这里没有注意，少写了个Web，然后就出错了，一定要特别注意。
那么为什么这个类这么重要呢？
我们可以参考该文章：对于DefaultWebSecurityManager的介绍
大概解释如下

DefaultWebSecurityManager类主要定义了设置subjectDao，获取会话模式，设置会话模式，设置会话管理器，是否是http会话模式等操作，它继承了DefaultSecurityManager类，实现了WebSecurityManager接口

也就是说，如果没有使用这个类，我们无法验证会话中登陆的用户，也就无法进行登陆、校验、登出等操作；主要和Subject有关。
接下来就是本文的核心，shiro的拦截器链：

/**
     * shiro核心，拦截器链，顺序执行
     * */
    @Bean(name = "shiroFilter")
    @DependsOn("securityManager")
    public ShiroFilterFactoryBean getShiroFilterFactoryBean(DefaultSecurityManager securityManager,Realm realm){
        securityManager.setRealm(realm);

        ShiroFilterFactoryBean shiroFilter = new ShiroFilterFactoryBean();
        shiroFilter.setSecurityManager(securityManager);
        shiroFilter.setLoginUrl("/a/login/fail");//未登录跳转
        shiroFilter.setUnauthorizedUrl("/a/login/fail");//未授权跳转
        LinkedHashMap<String,String> filterChainDefinitionMap = new LinkedHashMap<>();

        filterChainDefinitionMap.put("/a/u/first","perms[1]");
        log.info("第一链");
        filterChainDefinitionMap.put("/a/u/second","perms[2]");
        log.info("第二链");
        filterChainDefinitionMap.put("/a/u/third","perms[3]");
        log.info("第三链");

        filterChainDefinitionMap.put("/a//**","anon");

        log.info("执行顺序 : " + filterChainDefinitionMap);

        shiroFilter.setFilterChainDefinitionMap(filterChainDefinitionMap);
        return shiroFilter;
    }

相信注解已经很清楚了，这里的逻辑就是：新建shiro的拦截链，然后设置未登录和未授权的两种跳转，这里为了简便，我将两种跳转设置为一个了；然后向拦截链里添加规则，最后返回shiro的拦截链信息。

成果展示

经过如上的讲解，我们检验一下效果。
当我们处于未登录状态的时候，请求权限url会跳转至之前设定的失败页面
这里写图片描述

当我们登陆后有对应权限时
这里写图片描述

当我们登陆后无权限访问时
这里写图片描述

至此整个shiro的拦截器链实现权限管理讲解结束，如有疏漏或错误，还请不吝赐教。

m0_67392811

关注

0
点赞
踩
3

收藏

觉得还不错? 一键收藏
0
评论
使用shiro拦截器链实现权限管理

在开篇之前，先介绍一下shiro，那么什么是shiro呢？Apache Shiro（发音为“shee-roh”，日语“堡垒（Castle）”的意思）是一个强大易用的Java安全框架，提供了认证、授权、加密和会话管理功能，可为任何应用提供安全保障 - 从命令行应用、移动应用到大型网络及企业应用。Shiro为解决下列问题（我喜欢称它们为应用安全的四要素）提供了保护应用的API：认证 - 用户身份识别，常被称为用户“登录”；授权 - 访问控制；密码加密 - 保护或隐藏数据防止被偷窥；会话管理 -每
复制链接

扫一扫