360SDN.COM

Shiro与Web项目整合

来源:Java开发日记  2017-09-11 11:26:00    评论:0点击:

0.数据库原型

数据库原型如下图所示:

1.引入jar

除在入门中引入的jar包之外,在web项目中如果用到shiro,还需要引入以下jar:

  • shiro-web: shiro-web-1.2.3.jar

  • shiro-spring: shiro-spring-1.2.3.jar

  • shiro-quartz(根据需要): shiro-quartz-1.2.3.jar quartz-1.6.1.jar

  • shiro-ehcache(根据需要): ehcache-core-2.5.0.jar shiro-ehcache-1.2.3.jar

2.在web.xml中配置shiro的filter

在web项目中也通过filter(过滤器)拦截shiro,filter拦截后将操作权交给在spring.xml中配置的过滤器链(fliterchain)处理,shiro中提供许多过滤器。在web.xml中配置shiro过滤器的web.xml完整代码如下:

  
  1.   <?xml version="1.0" encoding="UTF-8"?>

  2.   <web-app xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns="http://java.sun.com/xml/ns/javaee" xmlns:web="http://java.sun.com/xml/ns/javaee/web-app_2_5.xsd" xsi:schemaLocation="http://java.sun.com/xml/ns/javaee http://java.sun.com/xml/ns/javaee/web-app_2_5.xsd" id="WebApp_ID" version="2.5">

  3.     <display-name>permission1110</display-name>

  4.     <!-- 配置spring容器监听器 -->

  5.       <context-param>

  6.           <param-name>contextConfigLocation</param-name>

  7.           <param-value>/WEB-INF/classes/spring/applicationContext-*.xml</param-value>

  8.       </context-param>

  9.       <listener>

  10.           <listener-class>org.springframework.web.context.ContextLoaderListener</listener-class>

  11.       </listener>

  12.       <!-- 前端控制器 -->

  13.       <servlet>

  14.           <servlet-name>springmvc</servlet-name>

  15.           <servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>

  16.           <!-- 加载springmvc配置 -->

  17.           <init-param>

  18.               <param-name>contextConfigLocation</param-name>

  19.               <!-- 配置文件的地址 如果不配置contextConfigLocation, 默认查找的配置文件名称classpath下的:servlet名称+"-serlvet.xml"即:springmvc-serlvet.xml -->

  20.               <param-value>classpath:spring/springmvc.xml</param-value>

  21.           </init-param>

  22.       </servlet>

  23.       <servlet-mapping>

  24.           <servlet-name>springmvc</servlet-name>

  25.           <!-- 可以配置/ ,此工程 所有请求全部由springmvc解析,此种方式可以实现 RESTful方式,需要特殊处理对静态文件的解析不能由springmvc解析

  26.               可以配置*.do或*.action,所有请求的url扩展名为.do或.action由springmvc解析,此种方法常用 不可以/*,如果配置/*,返回jsp也由springmvc解析,这是不对的。 -->

  27.           <url-pattern>*.action</url-pattern>

  28.       </servlet-mapping>

  29.       <!--这里就是配置的shiro过滤器-->

  30.       <!-- shiro的filter -->

  31.       <!-- shiro过虑器,DelegatingFilterProxy通过代理模式将spring容器中的bean和filter关联起来 -->

  32.       <filter>

  33.           <filter-name>shiroFilter</filter-name>

  34.           <filter-class>org.springframework.web.filter.DelegatingFilterProxy</filter-class>

  35.           <!-- 设置true由servlet容器控制filter的生命周期 -->

  36.           <init-param>

  37.               <param-name>targetFilterLifecycle</param-name>

  38.               <param-value>true</param-value>

  39.           </init-param>

  40.           <!-- 设置spring容器filter的bean id,如果不设置则找与filter-name一致的bean-->

  41.           <init-param>

  42.               <param-name>targetBeanName</param-name>

  43.               <param-value>shiroFilter</param-value>

  44.           </init-param>

  45.       </filter>

  46.       <filter-mapping>

  47.           <filter-name>shiroFilter</filter-name>

  48.           <url-pattern>/*</url-pattern>

  49.       </filter-mapping>

  50.       <!-- post乱码处理 -->

  51.       <filter>

  52.           <filter-name>CharacterEncodingFilter</filter-name>

  53.           <filter-class>org.springframework.web.filter.CharacterEncodingFilter</filter-class>

  54.           <init-param>

  55.               <param-name>encoding</param-name>

  56.               <param-value>utf-8</param-value>

  57.           </init-param>

  58.       </filter>

  59.       <filter-mapping>

  60.           <filter-name>CharacterEncodingFilter</filter-name>

  61.           <url-pattern>/*</url-pattern>

  62.       </filter-mapping>

  63.     <welcome-file-list>

  64.       <welcome-file>index.html</welcome-file>

  65.       <welcome-file>index.htm</welcome-file>

  66.       <welcome-file>index.jsp</welcome-file>

  67.       <welcome-file>default.html</welcome-file>

  68.       <welcome-file>default.htm</welcome-file>

  69.       <welcome-file>default.jsp</welcome-file>

  70.     </welcome-file-list>

  71.   </web-app>

3. 在spring-shiro.xml中配置web.xml中过滤器对应spring容器中的bean.

配置代码如下:

  
  1.   <beans xmlns="http://www.springframework.org/schema/beans"

  2.       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:mvc="http://www.springframework.org/schema/mvc"

  3.       xmlns:context="http://www.springframework.org/schema/context"

  4.       xmlns:aop="http://www.springframework.org/schema/aop" xmlns:tx="http://www.springframework.org/schema/tx"

  5.       xsi:schemaLocation="http://www.springframework.org/schema/beans

  6.           http://www.springframework.org/schema/beans/spring-beans-3.2.xsd

  7.           http://www.springframework.org/schema/mvc

  8.           http://www.springframework.org/schema/mvc/spring-mvc-3.2.xsd

  9.           http://www.springframework.org/schema/context

  10.           http://www.springframework.org/schema/context/spring-context-3.2.xsd

  11.           http://www.springframework.org/schema/aop

  12.           http://www.springframework.org/schema/aop/spring-aop-3.2.xsd

  13.           http://www.springframework.org/schema/tx

  14.           http://www.springframework.org/schema/tx/spring-tx-3.2.xsd ">

  15.       <!-- web.xml中shiro的filter对应的bean -->

  16.       <!-- Shiro 的Web过滤器 -->

  17.       <bean id="shiroFilter" class="org.apache.shiro.spring.web.ShiroFilterFactoryBean">

  18.           <property name="securityManager" ref="securityManager" />

  19.           <!-- loginUrl认证提交地址,如果没有认证将会请求此地址进行认证,请求此地址将由formAuthenticationFilter进行表单认证 -->

  20.           <property name="loginUrl" value="/login.action" />

  21.           <!-- 认证成功统一跳转到first.action,建议不配置,shiro会自动在认证成功后跳转到到上一个请求路径 -->

  22.           <property name="successUrl" value="/first.action"/>

  23.           <!-- 通过unauthorizedUrl指定没有权限操作时跳转页面-->

  24.           <property name="unauthorizedUrl" value="/refuse.jsp" />

  25.           <!-- 过滤器链定义,从上向下顺序执行,一般将/**放在最下边 -->

  26.           <property name="filterChainDefinitions">

  27.               <value>

  28.                   <!-- 对静态资源设置匿名访问 -->

  29.                   /images/** = anon

  30.                   /js/** = anon

  31.                   /styles/** = anon

  32.                   <!-- 验证码,可匿名访问 -->

  33.                   /validatecode.jsp = anon

  34.                   <!-- 请求 logout.action地址,shiro去清除session-->

  35.                   /logout.action = logout

  36.                   <!-- 配置记住我或认证通过可以访问的地址 -->

  37.                   /index.jsp  = user

  38.                   /first.action = user

  39.                   /welcome.jsp = user

  40.                   <!-- /** = authc 所有url都必须认证通过才可以访问-->

  41.                   /** = authc

  42.                   <!-- /** = anon所有url都可以匿名访问 -->

  43.               </value>

  44.           </property>

  45.       </bean>

  46.       <!-- securityManager安全管理器 -->

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

  48.           <property name="realm" ref="customRealm" />

  49.       </bean>

  50.   <!-- 自定义realm -->

  51.   <bean id="customRealm" class="com.catchu.ssm.shiro.CustomRealm">

  52.       <!-- 将凭证匹配器设置到realm中,realm按照凭证匹配器的要求进行散列 -->

  53.       <property name="credentialsMatcher" ref="credentialsMatcher"/>

  54.   </bean>

  55.   <!-- 凭证匹配器 -->

  56.    <bean id="credentialsMatcher"

  57.       class="org.apache.shiro.authc.credential.HashedCredentialsMatcher">

  58.       <property name="hashAlgorithmName" value="md5" />

  59.       <property name="hashIterations" value="1" />

  60.   </bean>

  61.   </beans>

我把自定义realm也放在了这一步进行配置

4.自定义realm进行认证

我们在上一步spring-shiro.xml中配置了loginUrl,当用户没有登录时将会请求此地址进行登录,FormAuthenticationFilter会拦截到用户的请求,获取到username,password(默认,可以进行配置),之后调用我们自定义的Realm进行认证。自定义realm代码如下:

  
  1.       /**

  2.        * @Description 用于认证

  3.        * @Author 刘俊重

  4.        * @date 2017年8月1日

  5.        */

  6.       @Override

  7.       protected AuthenticationInfo doGetAuthenticationInfo(AuthenticationToken token) throws AuthenticationException {

  8.           //从token获取principal(身份信息),token中存的是用户名和密码

  9.           String userCode = (String) token.getPrincipal();

  10.           //根据用户名查询用户信息

  11.           SysUser sysUser = null;

  12.           try {

  13.               sysUser = sysService.findSysUserByUserCode(userCode);

  14.           } catch (Exception e1) {

  15.               // TODO Auto-generated catch block

  16.               e1.printStackTrace();

  17.           }

  18.           //用户不存在返回null

  19.           if(null== sysUser){

  20.               return null;

  21.           }

  22.           //用户存在,获取用户散列后的密码,盐

  23.           String password = sysUser.getPassword();

  24.           String salt = sysUser.getSalt();

  25.           //activeUser就是用户的身份信息

  26.           ActiveUser activeUser = new ActiveUser();

  27.           activeUser.setUserid("zhangsan");

  28.           activeUser.setUsercode("zhangsan");

  29.           activeUser.setUsername("zhangsan");

  30.           //根据用户id查询菜单

  31.           List<SysPermission> menuList = null;

  32.           try {

  33.               menuList = sysService.findMenuListByUserId("zhangsan");

  34.           } catch (Exception e) {

  35.               e.printStackTrace();

  36.           }

  37.           activeUser.setMenus(menuList);

  38.           //将用户身份信息activeUser设置到SimpleAuthenticationInfo中

  39.           SimpleAuthenticationInfo simpleAuthenticationInfo = new SimpleAuthenticationInfo(activeUser,

  40.                   password,ByteSource.Util.bytes(salt),getName());

  41.           return simpleAuthenticationInfo;

  42.       }

在这里要注意的是:我们从token中获取到的是用户输入请求过来的用户名和密码,然后根据用户名查询数据库获得的用户信息并封装成ActiveUser,放在SimpleAuthenticationInfo中,之后ActiveUser就是主体的身份信息而不是username(你在SimpleAuthenticationInfo把谁放进去了,谁就是主体的身份信息)。

5.自定义Realm进行授权

直接入正题,我们这里采用注解进行springmvc的授权操作,注解中填权限标识符。首先需要在spring-mvc.xml中配置对shiro注解的支持。在原有spring-mvc.xml的代码中加入以下配置:

  
  1.       <!-- 开启aop,对类代理 -->

  2.       <aop:config proxy-target-class="true"></aop:config>

  3.       <!-- 开启shiro注解支持 -->

  4.       <bean

  5.           class=" org.apache.shiro.spring.security.interceptor.AuthorizationAttributeSourceAdvisor">

  6.           <property name="securityManager" ref="securityManager" />

  7.       </bean>

在请求的Controller方法中配置@RequiresPermissions注解(里面填权限标识符),示例代码如下:

  
  1.       //商品信息方法

  2.       @RequestMapping("/queryItem")

  3.       @RequiresPermissions("item:query")  //表明请求这个queryItem时需要item:query权限,会调用自定义realm(调用数据库)查询主体拥有的权限,判断是否有访问本请求的权限

  4.       public ModelAndView queryItems(HttpServletRequest request) throws Exception {

  5.           System.out.println(request.getParameter("id"));

  6.           //调用service查询商品列表

  7.           List<ItemsCustom> itemsList = itemsService.findItemsList(null);

  8.           ModelAndView modelAndView = new ModelAndView();

  9.           modelAndView.addObject("itemsList", itemsList);

  10.           // 指定逻辑视图名

  11.           modelAndView.setViewName("itemsList");

  12.           return modelAndView;

  13.       }

比如当请求/queryItem过来时,看到有RequiresPermissions注解,表明本请求需要要权限才能访问,就会调用自定义的realm查询本主体(subject)所有的权限,看这个权限标识符是否在该主体拥有的权限标识符中,自定义realm进行授权代码如下:

  
  1.       /**

  2.        * @Description 用于授权

  3.        * @Author 刘俊重

  4.        * @date 2017年8月1日

  5.        */

  6.       @Override

  7.       protected AuthorizationInfo doGetAuthorizationInfo(PrincipalCollection principals) {

  8.           //从principals中获取主身份信息。在上一步认证中把身份信息activeUser放进了SimpleAuthenticationInfo,这里再取出来。

  9.           ActiveUser activeUser = (ActiveUser) principals.getPrimaryPrincipal();

  10.           //从数据库中根据身份信息查询到的权限信息

  11.           List<SysPermission> permissionList = null;

  12.           try {

  13.               permissionList = sysService.findPermissionListByUserId(activeUser.getUserid());

  14.           } catch (Exception e) {

  15.               e.printStackTrace();

  16.           }

  17.           List<String> permissions = new ArrayList<String>();

  18.           if(permissionList!=null && permissionList.size()>0){

  19.               for(SysPermission permission:permissionList){

  20.                   //将用户权限标识符放在list之后填充到SimpleAuthorizationInfo并返回

  21.                   permissions.add(permission.getPercode());

  22.               }

  23.           }

  24.           //构建授权信息,并返回

  25.           SimpleAuthorizationInfo simpleAuthorizationInfo = new SimpleAuthorizationInfo();

  26.           simpleAuthorizationInfo.addStringPermissions(permissions);

  27.           return simpleAuthorizationInfo;

  28.       }

6.常用的shiro过滤器

常用的shiro过滤器如下,可以关联源码,在shiro-web包下查看源代码:

过滤器简称 对应的java类
anon org.apache.shiro.web.filter.authc.AnonymousFilter
authc org.apache.shiro.web.filter.authc.FormAuthenticationFilter
authcBasic org.apache.shiro.web.filter.authc.BasicHttpAuthenticationFilter
perms org.apache.shiro.web.filter.authz.PermissionsAuthorizationFilter
port org.apache.shiro.web.filter.authz.PortFilter
rest org.apache.shiro.web.filter.authz.HttpMethodPermissionFilter
roles org.apache.shiro.web.filter.authz.RolesAuthorizationFilter
ssl org.apache.shiro.web.filter.authz.SslFilter
user org.apache.shiro.web.filter.authc.UserFilter
logout org.apache.shiro.web.filter.authc.LogoutFilter

anon:例子/admins/=anon 没有参数,表示可以匿名使用。 authc:例如/admins/user/=authc表示需要认证(登录)才能使用,FormAuthenticationFilter是表单认证,没有参数 perms:例子/admins/user/*=perms[user:add:],参数可以写多个,多个时必须加上引号,并且参数之间用逗号分割,例如/admins/user/=perms["user:add:,user:modify:"],当有多个参数时必须每个参数都通过才通过,想当于isPermitedAll()方法。

user:例如/admins/user/**=user没有参数表示必须存在用户, 身份认证通过或通过记住我认证通过的可以访问,当登入操作时不做检查

7.Jsp标签授权

在jsp或者html页面中,如果开发者想对项目控制的粒度更加精细,可以在页面中使用标签授权(类似于ifelse的判断形式),Jsp页面添加:

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

标签名称 标签条件(均是显示标签内容)
<shiro:authenticated> 登录之后
<shiro:notAuthenticated> 不在登录状态时
<shiro:guest> 用户在没有RememberMe时
<shiro:user> 用户在RememberMe时
<shiro:hasAnyRolesname="abc,123"> 在有abc或者123角色时
<shiro:hasRolename="abc"> 拥有角色abc
<shiro:lacksRolename="abc"> 没有角色abc
<shiro:hasPermissionname="abc"> 拥有权限资源abc
<shiro:lacksPermissionname="abc"> 没有abc权限资源
<shiro:principal> 显示用户身份名称

到这里其实shiro跟web项目的整合已经配置完成了,正常使用是没有问题的,下面涉及到的都是优化的操作

8.shiro缓存

通过上一步打断点我们会看出,只要用户发请求了,而且controller中有RequiresPermissions注解了,都会重复调用自定义realm的授权方法,重复的查询数据库,我们就想到了用缓存来提高速度。 shiro中提供了对认证信息和授权信息的缓存。shiro默认是关闭认证信息缓存的,对于授权信息的缓存shiro默认开启的。主要研究授权信息缓存,因为授权的数据量大。

用户认证通过。

该用户第一次授权:调用realm查询数据库

该用户第二次授权:不调用realm查询数据库,直接从缓存中取出授权信息(权限标识符)。

  • 添加ehcache的jar,并且配置shiro-ehcache.xml,代码如下:

  
  1.   <ehcache xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"

  2.       xsi:noNamespaceSchemaLocation="../config/ehcache.xsd">

  3.       <!--diskStore:缓存数据持久化的目录 地址  -->

  4.       <diskStore path="F:\develop\ehcache" />

  5.       <defaultCache

  6.           maxElementsInMemory="1000"

  7.           maxElementsOnDisk="10000000"

  8.           eternal="false"

  9.           overflowToDisk="false"

  10.           diskPersistent="false"

  11.           timeToIdleSeconds="120"

  12.           timeToLiveSeconds="120"

  13.           diskExpiryThreadIntervalSeconds="120"

  14.           memoryStoreEvictionPolicy="LRU">

  15.       </defaultCache>

  16.   </ehcache>

  • 在spring-shiro.xml配置文件中,配置安全管理器(securityManger)中引入shiro-ehcache.xml:

  
  1.         <!-- securityManager安全管理器 -->

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

  3.             <property name="realm" ref="customRealm" />

  4.             <!-- 注入缓存管理器 -->

  5.             <property name="cacheManager" ref="cacheManager"/>  

  6.         </bean>

  7.         <!-- 缓存管理器 -->

  8.      <bean id="cacheManager" class="org.apache.shiro.cache.ehcache.EhCacheManager">

  9.         <property name="cacheManagerConfigFile" value="classpath:shiro-ehcache.xml"/>

  10.     </bean>

  • 清空缓存: 如果用户正常退出,缓存自动清空。 如果用户非正常退出,缓存自动清空。 如果修改了用户的权限,而用户不退出系统,修改的权限无法立即生效。

    需要手动进行编程实现:  在权限修改后调用自定义realm的clearCache方法清除缓存。 在自定义Realm定义的清空缓存的方法如下:

  
  1.         //清除缓存

  2.         public void clearCached() {

  3.             PrincipalCollection principals = SecurityUtils.getSubject().getPrincipals();

  4.             super.clearCache(principals);

  5.         }

  
  1. 在修改完用户的权限之后的serviceImpl层中可以直接调用清除缓存:

  
  1.         //注入realm

  2.         @Autowired

  3.         private CustomRealm customRealm;

  4.         @RequestMapping("/clearShiroCache")

  5.         public String clearShiroCache(){

  6.             //清除缓存,将来正常开发要在service调用customRealm.clearCached()

  7.             customRealm.clearCached();

  8.             return "success";

  9.         }

9.自定义表单认证过滤器

现在有一个需求,就是用户登录时不止提交有用户名,密码,还有验证码。那么原有的表单验证拦截器只验证用户名和密码就不行了。我们继承FormAuthenticationFilter拦截器实现自己的拦截器即可。代码如下:

  
  1.   package com.catchu.ssm.shiro;

  2.   import javax.servlet.ServletRequest;

  3.   import javax.servlet.ServletResponse;

  4.   import javax.servlet.http.HttpServletRequest;

  5.   import javax.servlet.http.HttpSession;

  6.   import org.apache.shiro.web.filter.authc.FormAuthenticationFilter;

  7.   /**

  8.    * @author 刘俊重

  9.    * @Description 自定义FormAuthenticationFilter,认证之前实现 验证码校验

  10.    * @date 2017年8月4日

  11.    */

  12.   public class CustomFormAuthenticationFilter extends FormAuthenticationFilter {

  13.       //原FormAuthenticationFilter的认证方法

  14.       @Override

  15.       protected boolean onAccessDenied(ServletRequest request,

  16.               ServletResponse response) throws Exception {

  17.           //在这里进行验证码的校验

  18.           //从session获取正确验证码

  19.           HttpServletRequest httpServletRequest = (HttpServletRequest) request;

  20.           HttpSession session =httpServletRequest.getSession();

  21.           //取出session的验证码(正确的验证码)

  22.           String validateCode = (String) session.getAttribute("validateCode");

  23.           //取出页面的验证码

  24.           //输入的验证和session中的验证进行对比

  25.           String randomcode = httpServletRequest.getParameter("randomcode");

  26.           if(randomcode!=null && validateCode!=null && !randomcode.equals(validateCode)){

  27.               //如果校验失败,将验证码错误失败信息,通过shiroLoginFailure设置到request中

  28.               httpServletRequest.setAttribute("shiroLoginFailure", "randomCodeError");

  29.               //拒绝访问,不再校验账号和密码

  30.               return true;

  31.           }

  32.           return super.onAccessDenied(request, response);

  33.       }  

  34.   }

在spring-shiro.xml中配置代码如下:

  
  1.   <!-- 自定义form认证过虑器 -->

  2.   <!-- 基于Form表单的身份验证过滤器,不配置将也会注册此过虑器,表单中的用户账号、密码及loginurl将采用默认值,建议配置 -->

  3.   <bean id="formAuthenticationFilter"

  4.       class="com.catchu.ssm.shiro.CustomFormAuthenticationFilter ">

  5.           <!-- 表单中账号的input名称 -->

  6.           <property name="usernameParam" value="username" />

  7.           <!-- 表单中密码的input名称 -->

  8.           <property name="passwordParam" value="password" />

  9.           <!-- 记住我input的名称 -->

  10.           <property name="rememberMeParam" value="rememberMe"/>

  11.    </bean>

注入到安全管理器(securitymanager)

  
  1.           <!-- 自定义filter配置 -->

  2.           <property name="filters">

  3.               <map>

  4.                   <!-- 将自定义 的FormAuthenticationFilter注入shiroFilter中 -->

  5.                   <entry key="authc" value-ref="formAuthenticationFilter" />

  6.               </map>

  7.           </property>

10.配置rememberMe

有时用户登录之后需要记住用户名和密码,保存在cookie中,下次登录可以直接访问。

  • jsp中页面代码如下:

  
  1.     <tr>

  2.     <TD></TD>

  3.     <td><input type="checkbox" name="rememberMe" />自动登陆</td>

  4.     </tr>

  • ActiveUser类要实现序列化(用户身份信息,存入session 由于tomcat将session会序列化在本地硬盘上,所以使用Serializable接口):

  
  1.     public class ActiveUser implements java.io.Serializable {

  2.         private String userid;//用户id(主键)

  3.         private String usercode;// 用户账号

  4.         private String username;// 用户名称

  5.         }

  • spring-shiro.xml中配置rememberMeManager管理器

  
  1.     <!-- rememberMeManager管理器,写cookie,取出cookie生成用户信息 -->

  2.          <bean id="rememberMeManager" class="org.apache.shiro.web.mgt.CookieRememberMeManager">

  3.             <property name="cookie" ref="rememberMeCookie" />

  4.         </bean>

  5.         <!-- 记住我cookie -->

  6.         <bean id="rememberMeCookie" class="org.apache.shiro.web.servlet.SimpleCookie">

  7.             <!-- rememberMe是cookie的名字 -->

  8.             <constructor-arg value="rememberMe" />

  9.             <!-- 记住我cookie生效时间30天 -->

  10.             <property name="maxAge" value="2592000" />

  11.         </bean>

  • 使用UserFilter 如果设置记住我,下次访问某些url时可以不用登陆。将记住我即可访问的地址配置让UserFilter拦截。在spring-shiro.xml中配置如下:

  
  1.     <!-- 配置记住我或认证通过可以访问的地址 -->

  2.                     /index.jsp  = user

  3.                     /first.action = user

  4.                     /welcome.jsp = user

  
  1. 都配置完成之后,在浏览器的cookie中查看即可看到cookie信息。

代码下载地址:http://git.oschina.net/catchu/permission-shiro

阅读原文

为您推荐

友情链接 |九搜汽车网 |手机ok生活信息网|ok生活信息网|ok微生活
 Powered by www.360SDN.COM   京ICP备11022651号-4 © 2012-2016 版权