Java

权限管理之Shiro

略

简介

Apache Shiro是Java的一个安全框架。目前，使用Apache Shiro的人越来越多，因为它相当简单，对比Spring Security，可能没有Spring Security做的功能强大，但是在实际工作时可能并不需要那么复杂的东西，所以使用小而简单的Shiro就足够了。对于它俩到底哪个好，这个不必纠结，能更简单的解决项目问题就好了。

Shiro的组成

  • Authentication：身份认证/登录，验证用户是不是拥有相应的身份；
  • Authorization：授权，即权限验证，验证某个已认证的用户是否拥有某个权限；即判断用户是否能做事情，常见的如：验证某个用户是否拥有某个角色。或者细粒度的验证某个用户对某个资源是否具有某个权限；
  • Session Manager：会话管理，即用户登录后就是一次会话，在没有退出之前，它的所有信息都在会话中；会话可以是普通JavaSE环境的，也可以是如Web环境的；
  • Cryptography：加密，保护数据的安全性，如密码加密存储到数据库，而不是明文存储；
  • Web Support：Web支持，可以非常容易的集成到Web环境；
  • Caching：缓存，比如用户登录后，其用户信息、拥有的角色/权限不必每次去查，这样可以提高效率；
  • Concurrency：shiro支持多线程应用的并发验证，即如在一个线程中开启另一个线程，能把权限自动传播过去；
  • Testing：提供测试支持；
  • Run As：允许一个用户假装为另一个用户（如果他们允许）的身份进行访问；
  • Remember Me：记住我，这个是非常常见的功能，即一次登录后，下次再来的话不用登录了。

记住一点，Shiro不会去维护用户、维护权限；这些需要我们自己去设计/提供；然后通过相应的接口注入给Shiro即可。

基本架构

image

可以看到：应用代码直接交互的对象是Subject，也就是说Shiro的对外API核心就是Subject；其每个API的含义：

  • Subject：主体，代表了当前“用户”，这个用户不一定是一个具体的人，与当前应用交互的任何东西都是Subject，如网络爬虫，机器人等；即一个抽象概念；所有Subject都绑定到SecurityManager，与Subject的所有交互都会委托给SecurityManager；可以把Subject认为是一个门面；SecurityManager才是实际的执行者；
  • SecurityManager：安全管理器；即所有与安全有关的操作都会与SecurityManager交互；且它管理着所有Subject；可以看出它是Shiro的核心，它负责与后边介绍的其他组件进行交互，如果学习过SpringMVC，你可以把它看成DispatcherServlet前端控制器；
  • Realm：域，Shiro从从Realm获取安全数据（如用户、角色、权限），就是说SecurityManager要验证用户身份，那么它需要从Realm获取相应的用户进行比较以确定用户身份是否合法；也需要从Realm得到用户相应的角色/权限进行验证用户是否能进行操作；可以把Realm看成DataSource，即安全数据源。
  1. 应用代码通过Subject来进行认证和授权，而Subject又委托给SecurityManager；
  2. 我们需要给Shiro的SecurityManager注入Realm，从而让SecurityManager能得到合法的用户及其权限进行判断。

使用

粗粒度的权限控制

对于request请求来说的,就是控制那些页面进的去,那些页面进不去

  1. Maven导包

    1
    2
    3
    4
    5
    <dependency>
        <groupId>org.apache.shiro</groupId>
        <artifactId>shiro-all</artifactId>
        <version>${shiro.version}</version>
    </dependency>

  2. web.xml

    通过这个过滤器来把Shiro加入到web项目中.

    1
    2
    3
    4
    5
    6
    7
    8
    <filter>
        <filter-name>shiroFilter</filter-name>
        <filter-class>org.springframework.web.filter.DelegatingFilterProxy</filter-class>
    </filter>
    <filter-mapping>
        <filter-name>shiroFilter</filter-name>
        <url-pattern>/*</url-pattern>
    </filter-mapping>

  3. applicationContext-shiro.xml

    使用Spring来管理Shiro,Spring会通过filter的name属性在IoC容器中找到对应的bean(filter-name与bean的id属性相同)

    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
    <!-- FactoryBean -->
    <bean id="shiroFilter" class="org.apache.shiro.spring.web.ShiroFilterFactoryBean">
        <!-- 注入的securityManager -->
        <property name="securityManager" ref="securityManager"/>
        <!--登陆的页面-->
        <property name="loginUrl" value="/login.html"/>
        <!--登陆成功的页面-->
        <property name="successUrl" value="/index.html"/>
        <!--进入未授权的页面时跳转到哪里-->
        <property name="unauthorizedUrl" value="/unauthorized.html"/>
        <!--过滤规则-->
        <property name="filterChainDefinitions">
            <value>
                /login.html* = anon
                /css/** = anon
                /js/** = anon
                /upload/** = anon
                /images/** = anon
                /validatecode.jsp* = anon
                /services/** = anon
                /user_login.action* = anon
                /pages/base/area.html* = roles[base]
                /pages/base/courier.html* = perms[courier:list]
                /** = authc
            </value>
        </property>
    </bean>
    <!-- 安全管理器 -->
    <bean id="securityManager" class="org.apache.shiro.web.mgt.DefaultWebSecurityManager">
        <!-- 注入的realm -->
        <property name="realm" ref="myRealm"/>
        <!-- 缓存 -->
        <property name="cacheManager" ref="shiroCacheManager"/>
    </bean>
    <!-- realm -->
    <bean id="myRealm" class="com.yuda.realm.BosRealm">
        <!-- 缓存 -->
        <property name="authorizationCacheName" value="bos"/>
    </bean>

    Shiro的使用规则是:请求被Filter拦截,然后Spring通过拦截器在容器中找到与过滤器同名的bean,通过该bean中配置的拦截规则,然后调用securityManager安全管理器中找到用户自定义的realm,realm中有自定义的认证和授权的操作方式,所以shiroFilter中注入securityManager,securityManager中注入myRealm

    shiroFilter的拦截规则

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    <!--*号表示当前目录-->
    <!--双*号表示当前目录和其子目录-->
    <!--roles[base]表示有名字为base的角色才可以访问-->
    <!--perms[courier:list]表示有名字为courier:list的权限才可以访问-->
    <!--后面的Java代码写了如何给当前用户赋予角色和权限,向下看-->
    /login.html* = anon
    /css/** = anon
    /js/** = anon
    /upload/** = anon
    /images/** = anon
    /validatecode.jsp* = anon
    /services/** = anon
    /user_login.action* = anon
    /pages/base/area.html* = roles[base]
    /pages/base/courier.html* = perms[courier:list]
    /** = authc
    1. anon 未认证可以访问
    2. authc 认证后可以访问
    3. perms 需要特定权限才能访问
    4. roles 需要特定角色才能访问
    5. user 需要特定用户才能访问
    6. port 需要特定端口才能访问
    7. reset 根据指定 HTTP 请求访问才能访问

  4. 认证(登陆)操作

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    //通过SecurityUtils获得Subject对象
    Subject subject = SecurityUtils.getSubject();
    //封装用户名和密码
    AuthenticationToken authenticationToken = new UsernamePasswordToken(model.getUsername(), model.getPassword());

    try {
        //登陆操作,会到自定义的Realm中去进行认证
        subject.login(authenticationToken);
        System.out.println("执行登录后...");
        //调用一下getSession()方法,给session过时时间
        Session session = subject.getSession();
        session.setTimeout(-1000L);
        return SUCCESS;
    } catch (AuthenticationException e) {
        e.printStackTrace();
        return ERROR;
    }

    这个操作进行后,会调用自定义的Realm中的doGetAuthenticationInfo()方法.

  5. 登陆(认证)与授权

    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
    //AuthorizingRealm接口实现了两个方法,一个是认证,一个是授权.
    public class BosRealm extends AuthorizingRealm {

        //...略字段

        @Override
        protected AuthorizationInfo doGetAuthorizationInfo(PrincipalCollection principalCollection) {
            System.out.println("授权中...");
            //获得subject
            SimpleAuthorizationInfo simpleAuthorizationInfo = new SimpleAuthorizationInfo();
            Subject subject = SecurityUtils.getSubject();
            //通过subject获得当前用户
            User user = (User) subject.getPrincipal();
            //数据库中查询到role角色集合
            List<Role> roles = roleService.findByUser(user);
            //遍历,然后一一赋予角色
            for (Role role : roles) {
                simpleAuthorizationInfo.addRole(role.getKeyword());
            }
            //数据库中查询到权限,然后遍历,一一赋予权限
            List<Permission> permissions = permissionService.findByUser(user);
            for (Permission permission : permissions) {
                simpleAuthorizationInfo.addStringPermission(permission.getKeyword());
            }
            //返回一个有角色信息和权限信息的AuthorizationInfo对象
            return simpleAuthorizationInfo;
        }

        @Override
        protected AuthenticationInfo doGetAuthenticationInfo(AuthenticationToken authenticationToken) throws AuthenticationException {
            System.out.println("认证中...");
            //获得刚刚封装的用户名和密码
            UsernamePasswordToken usernamePasswordToken = (UsernamePasswordToken) authenticationToken;

            String username = usernamePasswordToken.getUsername();
            //数据库中查询用户名对于的用户,执行登陆操作
            User user = userService.findByUsername(username);

            //登陆成功或失败
            if (user == null) {
                return null;
            } else {
                //返回一个当前用户对应的user,和用户密码
                //这里需要注意,这里传递真实的密码,而subject的login方法中是前台传来的方法,
                //Shiro会在底层对比这两个密码,相同则完成登陆认证,否则失败
                return new SimpleAuthenticationInfo(user, user.getPassword(), getName());
            }
        }
    }

    当登陆时会调用doGetAuthenticationInfo来认证,
    当进入需要授权的页面时会调用doGetAuthorizationInfo来授权.

细粒度的权限控制

要求当前用户可以调用那些方法,不可以调用那些方法,通过细粒度的权限控制可以做到.需要在运用权限管理的方法上加上一些注解.具体做法:

  1. applicationContext-shiro.xml

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    <!-- Shiro生命周期处理器  -->
    <bean id="lifecycleBeanPostProcessor"
          class="org.apache.shiro.spring.LifecycleBeanPostProcessor"/>

    <!-- 开启shiro注解模式  -->
    <bean class="org.springframework.aop.framework.autoproxy.DefaultAdvisorAutoProxyCreator"
          depends-on="lifecycleBeanPostProcessor">
        <!--用到了Spring AOP-->
        <!--开启CGLib方式代理(基于接口的代理会导致注解无效,所以要使用CGLib)-->
        <!--事务的AOP也需要改为CGLib方式的代理-->
        <property name="proxyTargetClass" value="true"/>
    </bean>

    <!--触发了权限管理的方法时的通知-->
    <bean class="org.apache.shiro.spring.security.interceptor.AuthorizationAttributeSourceAdvisor">
        <property name="securityManager" ref="securityManager"/>
    </bean>

    执行过程:
    1. 运行了有权限控制注解的方法.
    2. 由于Spring AOP的存在(CGLib方式),所以它会执行通知—AuthorizationAttributeSourceAdvisor.
    3. AuthorizationAttributeSourceAdvisor中注入了一个securityManager.
    4. securityManager通过注入的realm来进行授权操作.

  2. 注解的使用

    1
    2
    3
    4
    5
    @Override
    @RequiresPermissions("courier:add")
    public void save(Courier courier) {
        courierRepository.save(courier);
    }

    声明了该方法仅仅可以给拥有courier:add权限的当前用户使用(需要在realm中给当前用户授权);

    其他注解

    • @RequiresAuthentication 验证用户是否登录
    • @RequiresUser 验证用户是否被记忆,当前是否有用户
    • @RequiresGuet 验证是否是一个guest(访客)请求,与RequiresUser相反
    • @RequiresRoles 验证当前用户是否是有指定的角色
    • @RequiresPermissions 验证当前用户是否有指定的权限

Jsp遇到Shiro

1
<%@taglib uri="http://shiro.apache.org/tags" prefix="shiro" %>

通过shiro的标签来控制按钮是否显示:

1
2
3
4
5
6
7
8
9
10
11
12
<shiro:hasPermission name="courier:add">
    <a href="#" class="easyui-linkbutton" >添加</a>
</shiro:hasPermission>
<shiro:hasPermission name="courier:edit">
    <a href="#" class="easyui-linkbutton" >修改</a>
</shiro:hasPermission>
<shiro:hasPermission name="courier:delete">
    <a href="#" class="easyui-linkbutton" >删除</a>
</shiro:hasPermission>
<shiro:hasPermission name="courier:list">
    <a href="#" class="easyui-linkbutton" >查询</a>
</shiro:hasPermission>
  1. <shiro:hasPermission name="abc"> 有权限abc时
  2. <shiro:authenticated> 登陆后
  3. <shiro:notAuthenticated> 未登陆
  4. <shiro:guest> 用户没有RememberMe时
  5. <shiro:user> 用户在RememberMe时
  6. <shiro:hasAnyRoles name="abc,123"> 有123或者abc角色时
  7. <shiro:hasRole name="abc"> 有角色abc时
  8. <shiro:lacksRole name="abc"> 无角色abc时
  9. <shiro:lacksPermission name="abc"> 无权限abc时
  10. <shiro:principal> 默认显示用户名称

注销登陆

1
2
Subject subject = SecurityUtils.getSubject();
subject.logout();