Apache Shiro入门

﹏ヽ暗。殇╰゛Y 2022-07-13 11:44 202阅读 0赞

目录[(?)][Link 1][\[+\]][Link 1]

1.  [Apache Shiro入门][Apache Shiro]
    
    1.  [Apache Shiro基本概述][Apache Shiro 1]
        
        1.  [Apache Shiro基本概念][Apache Shiro 2]
            
            1.  [使用Shiro能做什么][Shiro]
            2.  [Shiro的特性][Shiro 1]
        2.  [Shiro框架的调用流程][Shiro 2]
        3.  [Shiro框架][Shiro 3]
    2.  [快速入门案例][Link 2]
        
        1.  [引入Maven依赖][Maven]
        2.  [在webxml中配置spring框架提供的过滤器用于整合shiro框架][webxml_spring_shiro]
        3.  [在Spring配置文件中配置bean][Spring_bean]
            
            1.  [配置安全管理器对象shiro框架最核心的对象][shiro]
            2.  [配置Shiro提供的一个工厂对象用于产生过滤器对象][Shiro 4]
        4.  [自定义一个Realm类][Realm]
        5.  [将该Realm配置到安全管理器中][Realm 1]
        6.  [写一个登录方法][Link 3]
        7.  [补充默认拦截器][Link 4]
    3.  [权限控制的四种方式][Link 5]
        
        1.  [基于URL的权限控制][URL]
        2.  [基于注解的权限控制][Link 6]
            
            1.  [在Spring配置文件中启动注解支持][Spring]
            2.  [在Action的方法上使用shiro注解进行权限控制][Action_shiro]
        3.  [基于JSTL标签库的权限控制][JSTL]
            
            1.  [在jsp页面中引入shiro的标签库][jsp_shiro]
            2.  [使用shiro提供的标签进行权限控制][shiro 1]
        4.  [基于编程的权限控制][Link 7]
    4.  [使用ehcache缓存权限数据][ehcache]
        
        1.  [引入ehcache的依赖][ehcache 1]
        2.  [引入ehcache配置文件][ehcache 2]
        3.  [在spring配置文件中配置缓存管理器对象并注入给安全管理器][spring]

# Apache Shiro入门 #

@(Shiro)\[shiro,安全框架\]

*  [Apache Shiro入门][Apache Shiro 3]
    
     *  [Apache Shiro基本概述][Apache Shiro 4]
        
         *  [Apache Shiro基本概念][Apache Shiro 5]
            
             *  [使用Shiro能做什么][Shiro 5]
             *  [Shiro的特性][Shiro 6]
         *  [Shiro框架的调用流程][Shiro 7]
         *  [Shiro框架][Shiro 8]
     *  [快速入门案例][Link 8]
        
         *  [引入Maven依赖][Maven 1]
         *  [在webxml中配置spring框架提供的过滤器用于整合shiro框架][webxml_spring_shiro 1]
         *  [在Spring配置文件中配置bean][Spring_bean 1]
            
             *  [配置安全管理器对象shiro框架最核心的对象][shiro 2]
             *  [配置Shiro提供的一个工厂对象用于产生过滤器对象][Shiro 9]
         *  [自定义一个Realm类][Realm 2]
         *  [将该Realm配置到安全管理器中][Realm 3]
         *  [写一个登录方法][Link 9]
         *  [补充默认拦截器][Link 10]
     *  [权限控制的四种方式][Link 11]
        
         *  [基于URL的权限控制][URL 1]
         *  [基于注解的权限控制][Link 12]
            
             *  [在Spring配置文件中启动注解支持][Spring 1]
             *  [在Action的方法上使用shiro注解进行权限控制][Action_shiro 1]
         *  [基于JSTL标签库的权限控制][JSTL 1]
            
             *  [在jsp页面中引入shiro的标签库][jsp_shiro 1]
             *  [使用shiro提供的标签进行权限控制][shiro 3]
         *  [基于编程的权限控制][Link 13]
     *  [使用ehcache缓存权限数据][ehcache 3]
        
         *  [引入ehcache的依赖][ehcache 4]
         *  [引入ehcache配置文件][ehcache 5]
         *  [在spring配置文件中配置缓存管理器对象并注入给安全管理器][spring 1]

## Apache Shiro基本概述 ##

> Apache Shiro是一个强大且易用的[Java][]安全框架,执行身份验证、授权、密码学和会话管理。使用Shiro的易于理解的API,您可以快速、轻松地获得任何应用程序,从最小的移动应用程序到最大的网络和企业应用程序。
> 
> ——参考《百度百科》

官网：[Apache Shiro官网][Apache Shiro 6]

### Apache Shiro基本概念 ###

#### 使用Shiro能做什么 ####

*  验证用户（认证）。
 *  对用户执行访问控制，像是：  
    
    
     *  判断用户是否具有某一角色。
     *  判断用户是否具有做某事的权限。
 *  在任何环境下都能使用Session API，即使没有诸如Spring，EJB这样的容器。
 *  在授权，访问控制或者会话生命周期中，都能响应事件。
 *  可以使用多个数据源。
 *  支持单点登录（SSO）功能。
 *  支持”Remember Me”服务。

#### Shiro的特性 ####

![这里写图片描述][SouthEast]

从上图可以看出，shiro有4个主要特性，分别是认证（Authentication）、授权（Authorization）、会话管理（Session Management）和密码（Cryptography）服务。

以及6个附加（支持）特性，分别是Web支持（Web Support）、缓存（Caching）、并发（Concurrency）、[测试][Link 14]（Testing）支持、以…运行（Run As）、记住我（Remember Me）。

参照开涛的解释，如下：

`Authentication`：身份认证/登录，验证用户是不是拥有相应的身份；

`Authorization`：授权，即权限验证，验证某个已认证的用户是否拥有某个权限；即判断用户是否能做事情，常见的如：验证某个用户是否拥有某个角色。或者细粒度的验证某个用户对某个资源是否具有某个权限；

`Session Manager`：会话管理，即用户登录后就是一次会话，在没有退出之前，它的所有信息都在会话中；会话可以是普通JavaSE环境的，也可以是如Web环境的；

`Cryptography`：加密，保护数据的安全性，如密码加密存储到[数据库][Link 15]，而不是明文存储；

`Web Support`：Web支持，可以非常容易的集成到Web环境；

`Caching`：缓存，比如用户登录后，其用户信息、拥有的角色/权限不必每次去查，这样可以提高效率；

`Concurrency`：shiro支持多线程应用的并发验证，即如在一个线程中开启另一个线程，能把权限自动传播过去；

`Testing`：提供测试支持；

`Run As`：允许一个用户假装为另一个用户（如果他们允许）的身份进行访问；

`Remember Me`：记住我，这个是非常常见的功能，即一次登录后，下次再来的话不用登录了。

### Shiro框架的调用流程 ###

![这里写图片描述][SouthEast 1]

Shiro框架有三个核心组件，分别是：`Subject`, `SecurityManager` 和 `Realms`.

`Subject`：即“当前操作用户”。但是，在Shiro中，Subject这一概念并不仅仅指人，也可以是第三方进程、后台帐户（Daemon Account）或其他类似事物。它仅仅意味着“当前跟软件交互的东西”。但考虑到大多数目的和用途，你可以把它认为是Shiro的“用户”概念。

`Subject`代表了当前用户的安全操作，`SecurityManager`则管理所有用户的安全操作。  
　　  
`SecurityManager`：它是Shiro框架的核心，典型的Facade模式，Shiro通过`SecurityManager`来管理内部组件实例，并通过它来提供安全管理的各种服务。

`Realm`： `Realm`充当了Shiro与应用安全数据间的“桥梁”或者“连接器”。也就是说，当对用户执行认证（登录）和授权（访问控制）验证时，Shiro会从应用配置的`Realm`中查找用户及其权限信息。

从这个意义上讲，`Realm`实质上是一个安全相关的DAO：它封装了数据源的连接细节，并在需要时将相关数据提供给Shiro。当配置Shiro时，你必须至少指定一个`Realm`，用于认证和（或）授权。配置多个`Realm`是可以的，但是至少需要一个。

Shiro内置了可以连接大量安全数据源（又名目录）的`Realm`，如LDAP、关系数据库（JDBC）、类似INI的文本配置资源以及属性文件等。如果缺省的`Realm`不能满足需求，你还可以插入代表自定义数据源的自己的`Realm`实现。

### Shiro框架 ###

![这里写图片描述][SouthEast 2]

## 快速入门案例 ##

### 引入Maven依赖 ###

<dependency>
        <groupId>org.apache.shiro</groupId>
        <artifactId>shiro-all</artifactId>
        <version>1.2.2</version>
    </dependency>

### 在web.xml中配置spring框架提供的过滤器，用于整合shiro框架 ###

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

### 在Spring配置文件中配置bean ###

#### 配置安全管理器对象（shiro框架最核心的对象） ####

<bean id="securityManager" class="org.apache.shiro.web.mgt.DefaultWebSecurityManager">
    
    </bean>

#### 配置Shiro提供的一个工厂对象，用于产生过滤器对象 ####

<bean id="shiroFilter" class="org.apache.shiro.spring.web.ShiroFilterFactoryBean">
        
        
        <property name="loginUrl" value="/login.jsp"/>
        
        <property name="successUrl" value="/home.jsp"/>
        
        <property name="unauthorizedUrl" value="/unauthorized.jsp"/>
        
        <property name="filterChainDefinitions">
            <value>
                /css/** = anon
                /js/** =  anon
                /images/** = anon
                /login.jsp* = anon
                /userAction_login* = anon
                /manager* = perms["manager"]
                /* = authc
            </value>
        </property>
        <property name="securityManager" ref="securityManager"/>
    </bean>

PS：Bean的ID要和过滤器中名称一致，因为过滤器在初始化时，就会加载与其名称一致的Bean。

### 自定义一个Realm类 ###

package com.service.realm;
    
    import java.util.List;
    
    import javax.annotation.Resource;
    
    import org.apache.shiro.authc.AuthenticationException;
    import org.apache.shiro.authc.AuthenticationInfo;
    import org.apache.shiro.authc.AuthenticationToken;
    import org.apache.shiro.authc.SimpleAuthenticationInfo;
    import org.apache.shiro.authc.UsernamePasswordToken;
    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.hibernate.criterion.DetachedCriteria;
    import org.hibernate.criterion.Restrictions;
    
    import com.dao.FunctionDao;
    import com.dao.UserDao;
    import com.domain.Function;
    import com.domain.User;
    
    /** * 用户Realm * * @author Switch * @data 2016年12月26日 * @version V1.0 */
    public class UserRealm extends AuthorizingRealm { 
        // 注入用户Dao对象
        @Resource(name = "userDao")
        private UserDao userDao;
        // 注入权限Dao对象
        @Resource(name = "functionDao")
        private FunctionDao functionDao;
    
        // 授予权限
        @Override
        protected AuthorizationInfo doGetAuthorizationInfo(PrincipalCollection principals) {
            // 创建简单授权对象
            SimpleAuthorizationInfo info = new SimpleAuthorizationInfo();
            // 为用户授权
    
            // 权限列表
            List<Function> functions = null;
    
            // 获取当前用户
            User user = (User) principals.getPrimaryPrincipal();
            if ("admin".equals(user.getUsername())) {
                // 超级管理员，获取所有权限
                functions = functionDao.findAll();
            } else {
                // 普通用户，通过用户id获取其对应的权限
                functions = functionDao.findByUserId(user.getId());
            }
    
            if (functions != null && functions.size() > 0) {
                for (Function function : functions) {
                    // 添加许可
                    info.addStringPermission(function.getCode());
                }
            }
            return info;
        }
    
        // 权限认证
        @Override
        protected AuthenticationInfo doGetAuthenticationInfo(AuthenticationToken token) throws AuthenticationException {
            // 强转为子类，用户名密码token，获取Subject传递过来的数据
            UsernamePasswordToken userToken = (UsernamePasswordToken) token;
            // 获取用户名
            String username = userToken.getUsername();
            // 在数据库中查询客户
            DetachedCriteria detachedCriteria = DetachedCriteria.forClass(User.class);
            detachedCriteria.add(Restrictions.eq("username", username));
            List<User> userList = userDao.findByCriteria(detachedCriteria);
            if (userList != null && userList.size() > 0) {
                User user = userList.get(0);
                // 获取密码
                String password = user.getPassword();
                // 简单认证信息对象,由SecurityManager负责对比密码数据
                // 参数1：Object principal————一般是认证对象，在这里就是用户对象
                // 参数2：Object credentials————证书，也就是负责校验认证的对象
                // 参数3：String realmName————realm的名字，随意，但必须唯一
                AuthenticationInfo info = new SimpleAuthenticationInfo(user, password, this.getName());
                return info;
            }
            return null;
        }
    }

### 将该Realm配置到安全管理器中 ###

<bean id="userRealm" class="com.itheima.bos.service.realm.UserRealm"/>
    
    
    <bean id="securityManager" class="org.apache.shiro.web.mgt.DefaultWebSecurityManager">
        
        <property name="realm" ref="userRealm"/>
    </bean>

### 写一个登录方法 ###

public String login() throws Exception {
        // 获取session中的验证码
        String loginCheckCode = (String) ActionContext.getContext().getSession().get("loginCheckCode");
        if (StringUtils.isBlank(checkcode) || !loginCheckCode.equals(checkcode)) {
            this.addActionError("验证码错误");
            return LOGIN;
        }
    
        // Shiro认证
        // 获取subject，代表当前用户对象，状态为：未认证
        Subject subject = SecurityUtils.getSubject();
        AuthenticationToken token = new UsernamePasswordToken(model.getUsername(), MD5Utils.md5(model.getPassword()));
    
        try {
            // 验证
            subject.login(token);
            // 从本地线程中获取SimpleAuthenticationInfo放入的对象
            User loginUser = (User) subject.getPrincipal();
    
            // 加入Session
            ActionContext.getContext().getSession().put("loginUser", loginUser);
            return HOME;
        } catch (Exception e) {
            e.printStackTrace();
            this.addActionError("用户名或密码错误！");
            return LOGIN;
        }
    }

### 补充：默认拦截器 ###

Shiro内置了很多默认的拦截器，比如身份验证、授权等相关的。默认拦截器可以参考`org.apache.shiro.web.filter.mgt.DefaultFilter`中的枚举拦截器：

<table> 
 <thead> 
  <tr> 
   <th align="left">默认拦截器名</th> 
   <th align="left">拦截器类</th> 
   <th align="left">说明（括号里的表示默认值）</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td align="left"><strong>身份验证相关的</strong></td> 
   <td align="left">&nbsp;</td> 
   <td align="left">&nbsp;</td> 
  </tr> 
  <tr> 
   <td align="left">authc</td> 
   <td align="left">org.apache.shiro.web.filter.authc.FormAuthenticationFilter</td> 
   <td align="left">基于表单的拦截器；如“/**=authc”，如果没有登录会跳到相应的登录页面登录；<br> 主要属性：<br> usernameParam：表单提交的用户名参数名（ username ） ；<br> passwordParam：表单提交的密码参数名（password）；<br> rememberMeParam：表单提交的密码参数名（rememberMe）；<br> loginUrl：登录页面地址（/login.jsp）；<br> successUrl：登录成功后的默认重定向地址；<br> failureKeyAttribute：登录失败后错误信息存储key（shiroLoginFailure）；</td> 
  </tr> 
  <tr> 
   <td align="left">authcBasic</td> 
   <td align="left">org.apache.shiro.web.filter.authc.BasicHttpAuthenticationFilter</td> 
   <td align="left">Basic HTTP身份验证拦截器，<br> 主要属性：<br> applicationName：弹出登录框显示的信息（application）；</td> 
  </tr> 
  <tr> 
   <td align="left">logout</td> 
   <td align="left">org.apache.shiro.web.filter.authc.LogoutFilter</td> 
   <td align="left">退出拦截器，<br> 主要属性：<br> redirectUrl：退出成功后重定向的地址（/）;示例“/logout=logout”</td> 
  </tr> 
  <tr> 
   <td align="left">user</td> 
   <td align="left">org.apache.shiro.web.filter.authc.UserFilter</td> 
   <td align="left">用户拦截器，用户已经身份验证/记住我登录的都可；示例“/**=user”</td> 
  </tr> 
  <tr> 
   <td align="left">anon</td> 
   <td align="left">org.apache.shiro.web.filter.authc.AnonymousFilter</td> 
   <td align="left">匿名拦截器，即不需要登录即可访问；一般用于静态资源过滤； 示例“/static/**=anon”</td> 
  </tr> 
  <tr> 
   <td align="left"><strong>授权相关的</strong></td> 
   <td align="left">&nbsp;</td> 
   <td align="left">&nbsp;</td> 
  </tr> 
  <tr> 
   <td align="left">roles</td> 
   <td align="left">org.apache.shiro.web.filter.authz.RolesAuthorizationFilter</td> 
   <td align="left">角色授权拦截器，验证用户是否拥有所有角色；<br> 主要属性：<br> loginUrl：登录页面地址（/login.jsp）；<br> unauthorizedUrl：未授权后重定向的地址； 示例“/admin/**=roles[admin]”</td> 
  </tr> 
  <tr> 
   <td align="left">perms</td> 
   <td align="left">org.apache.shiro.web.filter.authz.PermissionsAuthorizationFilter</td> 
   <td align="left">权限授权拦截器，验证用户是否拥有所有权限； 属性和roles 一样； 示例“/user/**=perms[“user:create”]”</td> 
  </tr> 
  <tr> 
   <td align="left">port</td> 
   <td align="left">org.apache.shiro.web.filter.authz.PortFilter</td> 
   <td align="left">端口拦截器，主要属性：port（80）：可以通过的端口；示例“/test= port[80]”，如果用户访问该页面是非80，将自动将请求端口改为80 并重定向到该80 端口，其他路径/参数等都一样</td> 
  </tr> 
  <tr> 
   <td align="left">rest</td> 
   <td align="left">org.apache.shiro.web.filter.authz.HttpMethodPermissionFilter</td> 
   <td align="left">rest 风格拦截器，自动根据请求方法构建权限字符串<br> （ GET=read,POST=create,PUT=update,DELETE=delete,<br> HEAD=read,TRACE=read,OPTIONS=read, MKCOL=create）构建权限字符串；<br> 示例“/users=rest[user]”，会自动拼出“user:read,user:create,user:update,user:delete”权限字符串进行权限匹配（所有都得匹配，isPermittedAll）；</td> 
  </tr> 
  <tr> 
   <td align="left">ssl</td> 
   <td align="left">org.apache.shiro.web.filter.authz.SslFilter</td> 
   <td align="left">SSL 拦截器，只有请求协议是https 才能通过；否则自动跳转会https端口（443）；其他和port拦截器一样；</td> 
  </tr> 
  <tr> 
   <td align="left">其他</td> 
   <td align="left">&nbsp;</td> 
   <td align="left">&nbsp;</td> 
  </tr> 
  <tr> 
   <td align="left">noSessionCreation</td> 
   <td align="left">org.apache.shiro.web.filter.session.NoSessionCreationFilter</td> 
   <td align="left">不创建会话拦截器， 调用subject.getSession(false)不会有什么问题，但是如果subject.getSession(true)将抛出DisabledSessionException异常；</td> 
  </tr> 
 </tbody> 
</table>

PS：在配置URL拦截规则的时候，使用了很多默认拦截器。

## 权限控制的四种方式 ##

在了解权限控制之前，先模拟下授权操作，授予manager的权限。

// 授予权限
    @Override
    protected AuthorizationInfo doGetAuthorizationInfo(PrincipalCollection principals) {
        // 创建简单授权对象
        SimpleAuthorizationInfo info = new SimpleAuthorizationInfo();
        // 为用户授权
        // TODO : 这里只是模拟授权，一般还需要到数据库中认证
        info.addStringPermission("manager");
        return info;
    }

### 基于URL的权限控制 ###

<property name="filterChainDefinitions">
        <value>
            /css/** = anon
            /js/** =  anon
            /images/** = anon
            /login.jsp* = anon
            /userAction_login* = anon
            /manager* = perms["manager:*"]
            /* = authc
        </value>
    </property>

### 基于注解的权限控制 ###

#### 在Spring配置文件中启动注解支持 ####

<aop:config proxy-target-class="true"/> 
        
        <bean id="defaultAdvisorAutoProxyCreator" class="org.springframework.aop.framework.autoproxy.DefaultAdvisorAutoProxyCreator">
            
            <property name="proxyTargetClass" value="true"/>
        </bean>
    
        
        <bean class="org.apache.shiro.spring.security.interceptor.AuthorizationAttributeSourceAdvisor" />

#### 在Action的方法上使用shiro注解进行权限控制 ####

//调用该方法，需要manager:delete权限
    @RequiresPermissions("manager:delete")
    public void deleteIds() throws Exception {
    
    }

### 基于JSTL标签库的权限控制 ###

#### 在jsp页面中引入shiro的标签库 ####

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

#### 使用shiro提供的标签进行权限控制 ####

<%-- 拥有manager:view才会显示 --%>
    <shiro:hasPermission name="manager:view">
        <input type="text" name="name"/>    
    </shiro:hasPermission>

### 基于编程的权限控制 ###

public void edit() throws Exception {
        // 编程实现权限控制
        // 调用Shiro框架提供的工具类，获取本地线程上的Subject对象
        Subject subject = SecurityUtils.getSubject();
        // 检测权限，无则抛出异常
        subject.checkPermission("manager:update");
    }

PS：当尚未授予manager权限时，会抛出`org.apache.shiro.authz.UnauthorizedException`这个异常，所以注意捕获并处理这个异常。如果使用`Struts2`框架，可以采取如下方式捕获并处理：

<package name="basePackage" extends="struts-default" abstract="true">
        
        <global-results>
            <result name="login">/login.jsp</result>
            <result name="Unauthorized">/unauthorized.jsp</result>
        </global-results>
    
        
        <global-exception-mappings>
            <exception-mapping result="Unauthorized" exception="org.apache.shiro.authz.UnauthorizedException"/>
        </global-exception-mappings>
    </package>

## 使用ehcache缓存权限数据 ##

### 引入ehcache的依赖 ###

<dependency>
        <groupId>net.sf.ehcache</groupId>
        <artifactId>ehcache-core</artifactId>
        <version>2.6.6</version>
    </dependency>

### 引入ehcache配置文件 ###

PS：将配置文件`ehcache.xml`放在类根目录下。

### 在spring配置文件中配置缓存管理器对象，并注入给安全管理器 ###

<bean id="securityManager" class="org.apache.shiro.web.mgt.DefaultWebSecurityManager">
        
        <property name="realm" ref="userRealm"/>
                
        <property name="cacheManager" ref="cacheManager"/>
    </bean>
    
    
    <bean id="cacheManager" class="org.apache.shiro.cache.ehcache.EhCacheManager">
        
        <property name="cacheManagerConfigFile" value="classpath:ehcache.xml"/>
    </bean>

———–参考《[张开涛，跟我学Shiro][Shiro 10]》  
———–参考《[官网文档][Link 16]》

[Link 1]: http://blog.csdn.net/q547550831/article/details/54174158#
[Apache Shiro]: http://blog.csdn.net/q547550831/article/details/54174158#t0
[Apache Shiro 1]: http://blog.csdn.net/q547550831/article/details/54174158#t1
[Apache Shiro 2]: http://blog.csdn.net/q547550831/article/details/54174158#t2
[Shiro]: http://blog.csdn.net/q547550831/article/details/54174158#t3
[Shiro 1]: http://blog.csdn.net/q547550831/article/details/54174158#t4
[Shiro 2]: http://blog.csdn.net/q547550831/article/details/54174158#t5
[Shiro 3]: http://blog.csdn.net/q547550831/article/details/54174158#t6
[Link 2]: http://blog.csdn.net/q547550831/article/details/54174158#t7
[Maven]: http://blog.csdn.net/q547550831/article/details/54174158#t8
[webxml_spring_shiro]: http://blog.csdn.net/q547550831/article/details/54174158#t9
[Spring_bean]: http://blog.csdn.net/q547550831/article/details/54174158#t10
[shiro]: http://blog.csdn.net/q547550831/article/details/54174158#t11
[Shiro 4]: http://blog.csdn.net/q547550831/article/details/54174158#t12
[Realm]: http://blog.csdn.net/q547550831/article/details/54174158#t13
[Realm 1]: http://blog.csdn.net/q547550831/article/details/54174158#t14
[Link 3]: http://blog.csdn.net/q547550831/article/details/54174158#t15
[Link 4]: http://blog.csdn.net/q547550831/article/details/54174158#t16
[Link 5]: http://blog.csdn.net/q547550831/article/details/54174158#t17
[URL]: http://blog.csdn.net/q547550831/article/details/54174158#t18
[Link 6]: http://blog.csdn.net/q547550831/article/details/54174158#t19
[Spring]: http://blog.csdn.net/q547550831/article/details/54174158#t20
[Action_shiro]: http://blog.csdn.net/q547550831/article/details/54174158#t21
[JSTL]: http://blog.csdn.net/q547550831/article/details/54174158#t22
[jsp_shiro]: http://blog.csdn.net/q547550831/article/details/54174158#t23
[shiro 1]: http://blog.csdn.net/q547550831/article/details/54174158#t24
[Link 7]: http://blog.csdn.net/q547550831/article/details/54174158#t25
[ehcache]: http://blog.csdn.net/q547550831/article/details/54174158#t26
[ehcache 1]: http://blog.csdn.net/q547550831/article/details/54174158#t27
[ehcache 2]: http://blog.csdn.net/q547550831/article/details/54174158#t28
[spring]: http://blog.csdn.net/q547550831/article/details/54174158#t29
[Apache Shiro 3]: http://blog.csdn.net/q547550831/article/details/54174158#apache-shiro入门
[Apache Shiro 4]: http://blog.csdn.net/q547550831/article/details/54174158#apache-shiro基本概述
[Apache Shiro 5]: http://blog.csdn.net/q547550831/article/details/54174158#apache-shiro基本概念
[Shiro 5]: http://blog.csdn.net/q547550831/article/details/54174158#使用shiro能做什么
[Shiro 6]: http://blog.csdn.net/q547550831/article/details/54174158#shiro的特性
[Shiro 7]: http://blog.csdn.net/q547550831/article/details/54174158#shiro框架的调用流程
[Shiro 8]: http://blog.csdn.net/q547550831/article/details/54174158#shiro框架
[Link 8]: http://blog.csdn.net/q547550831/article/details/54174158#快速入门案例
[Maven 1]: http://blog.csdn.net/q547550831/article/details/54174158#引入maven依赖
[webxml_spring_shiro 1]: http://blog.csdn.net/q547550831/article/details/54174158#在webxml中配置spring框架提供的过滤器用于整合shiro框架
[Spring_bean 1]: http://blog.csdn.net/q547550831/article/details/54174158#在spring配置文件中配置bean
[shiro 2]: http://blog.csdn.net/q547550831/article/details/54174158#配置安全管理器对象shiro框架最核心的对象
[Shiro 9]: http://blog.csdn.net/q547550831/article/details/54174158#配置shiro提供的一个工厂对象用于产生过滤器对象
[Realm 2]: http://blog.csdn.net/q547550831/article/details/54174158#自定义一个realm类
[Realm 3]: http://blog.csdn.net/q547550831/article/details/54174158#将该realm配置到安全管理器中
[Link 9]: http://blog.csdn.net/q547550831/article/details/54174158#写一个登录方法
[Link 10]: http://blog.csdn.net/q547550831/article/details/54174158#补充默认拦截器
[Link 11]: http://blog.csdn.net/q547550831/article/details/54174158#权限控制的四种方式
[URL 1]: http://blog.csdn.net/q547550831/article/details/54174158#基于url的权限控制
[Link 12]: http://blog.csdn.net/q547550831/article/details/54174158#基于注解的权限控制
[Spring 1]: http://blog.csdn.net/q547550831/article/details/54174158#在spring配置文件中启动注解支持
[Action_shiro 1]: http://blog.csdn.net/q547550831/article/details/54174158#在action的方法上使用shiro注解进行权限控制
[JSTL 1]: http://blog.csdn.net/q547550831/article/details/54174158#基于jstl标签库的权限控制
[jsp_shiro 1]: http://blog.csdn.net/q547550831/article/details/54174158#在jsp页面中引入shiro的标签库
[shiro 3]: http://blog.csdn.net/q547550831/article/details/54174158#使用shiro提供的标签进行权限控制
[Link 13]: http://blog.csdn.net/q547550831/article/details/54174158#基于编程的权限控制
[ehcache 3]: http://blog.csdn.net/q547550831/article/details/54174158#使用ehcache缓存权限数据
[ehcache 4]: http://blog.csdn.net/q547550831/article/details/54174158#引入ehcache的依赖
[ehcache 5]: http://blog.csdn.net/q547550831/article/details/54174158#引入ehcache配置文件
[spring 1]: http://blog.csdn.net/q547550831/article/details/54174158#在spring配置文件中配置缓存管理器对象并注入给安全管理器
[Java]: http://lib.csdn.net/base/javase
[Apache Shiro 6]: http://blog.csdn.net/q547550831/article/details/shiro.apache.org
[SouthEast]: /images/20220713/5ade56b82084454f8e043969db5fc385.png
[Link 14]: http://lib.csdn.net/base/softwaretest
[Link 15]: http://lib.csdn.net/base/mysql
[SouthEast 1]: /images/20220713/d3ad5991c0ed414b85e3e5c04b1d5ae0.png
[SouthEast 2]: /images/20220713/ffe9cad325864343a7be0be5393f9ead.png
[Shiro 10]: http://jinnianshilongnian.iteye.com/blog/2018936
[Link 16]: http://shiro.apache.org/introduction.html