shiro进阶—与项目整合

发表于 | 分类于 |
字数统计: 5,144 字 | 阅读时长 ≈ 24 分钟

0.数据库原型

数据库原型如下图所示：

1.引入jar

除在入门中引入的jar包之外，在web项目中如果用到shiro，还需要引入以下jar：
shiro-web-1.2.3.jar
shiro-spring-1.2.3.jar
shiro-quartz-1.2.3.jar
quartz-1.6.1.jar
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
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
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
<?xml version="1.0" encoding="UTF-8"?>
<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">
  <display-name>permission1110</display-name>
  <!-- 配置spring容器监听器 -->
	<context-param>
		<param-name>contextConfigLocation</param-name>
		<param-value>/WEB-INF/classes/spring/applicationContext-*.xml</param-value>
	</context-param>
	<listener>
		<listener-class>org.springframework.web.context.ContextLoaderListener</listener-class>
	</listener>

	<!-- 前端控制器 -->
	<servlet>
		<servlet-name>springmvc</servlet-name>
		<servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
		<!-- 加载springmvc配置 -->
		<init-param>
			<param-name>contextConfigLocation</param-name>
			<!-- 配置文件的地址 如果不配置contextConfigLocation， 默认查找的配置文件名称classpath下的：servlet名称+"-serlvet.xml"即：springmvc-serlvet.xml -->
			<param-value>classpath:spring/springmvc.xml</param-value>
		</init-param>

	</servlet>
	<servlet-mapping>
		<servlet-name>springmvc</servlet-name>
		<!-- 可以配置/ ，此工程 所有请求全部由springmvc解析，此种方式可以实现 RESTful方式，需要特殊处理对静态文件的解析不能由springmvc解析 
			可以配置*.do或*.action，所有请求的url扩展名为.do或.action由springmvc解析，此种方法常用 不可以/*，如果配置/*，返回jsp也由springmvc解析，这是不对的。 -->
		<url-pattern>*.action</url-pattern>
	</servlet-mapping>
	
	<!--这里就是配置的shiro过滤器-->
	<!-- shiro的filter -->
	<!-- shiro过虑器，DelegatingFilterProxy通过代理模式将spring容器中的bean和filter关联起来 -->
	<filter>
		<filter-name>shiroFilter</filter-name>
		<filter-class>org.springframework.web.filter.DelegatingFilterProxy</filter-class>
		<!-- 设置true由servlet容器控制filter的生命周期 -->
		<init-param>
			<param-name>targetFilterLifecycle</param-name>
			<param-value>true</param-value>
		</init-param>
		<!-- 设置spring容器filter的bean id，如果不设置则找与filter-name一致的bean-->
		<init-param>
			<param-name>targetBeanName</param-name>
			<param-value>shiroFilter</param-value>
		</init-param>
	</filter>
	<filter-mapping>
		<filter-name>shiroFilter</filter-name>
		<url-pattern>/*</url-pattern>
	</filter-mapping>
	
	<!-- post乱码处理 -->
	<filter>
		<filter-name>CharacterEncodingFilter</filter-name>
		<filter-class>org.springframework.web.filter.CharacterEncodingFilter</filter-class>
		<init-param>
			<param-name>encoding</param-name>
			<param-value>utf-8</param-value>
		</init-param>
	</filter>
	<filter-mapping>
		<filter-name>CharacterEncodingFilter</filter-name>
		<url-pattern>/*</url-pattern>
	</filter-mapping>
  <welcome-file-list>
    <welcome-file>index.html</welcome-file>
    <welcome-file>index.htm</welcome-file>
    <welcome-file>index.jsp</welcome-file>
    <welcome-file>default.html</welcome-file>
    <welcome-file>default.htm</welcome-file>
    <welcome-file>default.jsp</welcome-file>
  </welcome-file-list>
</web-app>

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

配置代码如下：

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
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
<beans xmlns="http://www.springframework.org/schema/beans"
	xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:mvc="http://www.springframework.org/schema/mvc"
	xmlns:context="http://www.springframework.org/schema/context"
	xmlns:aop="http://www.springframework.org/schema/aop" xmlns:tx="http://www.springframework.org/schema/tx"
	xsi:schemaLocation="http://www.springframework.org/schema/beans 
		http://www.springframework.org/schema/beans/spring-beans-3.2.xsd 
		http://www.springframework.org/schema/mvc 
		http://www.springframework.org/schema/mvc/spring-mvc-3.2.xsd 
		http://www.springframework.org/schema/context 
		http://www.springframework.org/schema/context/spring-context-3.2.xsd 
		http://www.springframework.org/schema/aop 
		http://www.springframework.org/schema/aop/spring-aop-3.2.xsd 
		http://www.springframework.org/schema/tx 
		http://www.springframework.org/schema/tx/spring-tx-3.2.xsd ">
	<!-- web.xml中shiro的filter对应的bean -->
	<!-- Shiro 的Web过滤器 -->
	<bean id="shiroFilter" class="org.apache.shiro.spring.web.ShiroFilterFactoryBean">
		<property name="securityManager" ref="securityManager" />
		<!-- loginUrl认证提交地址，如果没有认证将会请求此地址进行认证，请求此地址将由formAuthenticationFilter进行表单认证 -->
		<property name="loginUrl" value="/login.action" />
		<!-- 认证成功统一跳转到first.action，建议不配置，shiro会自动在认证成功后跳转到到上一个请求路径 -->
		<property name="successUrl" value="/first.action"/>
		<!-- 通过unauthorizedUrl指定没有权限操作时跳转页面-->
		<property name="unauthorizedUrl" value="/refuse.jsp" />
		<!-- 过滤器链定义，从上向下顺序执行，一般将/**放在最下边 -->
		<property name="filterChainDefinitions">
			<value>
				<!-- 对静态资源设置匿名访问 -->
				/images/** = anon
				/js/** = anon
				/styles/** = anon
				<!-- 验证码，可匿名访问 -->
				/validatecode.jsp = anon
				
				<!-- 请求 logout.action地址，shiro去清除session-->
				/logout.action = logout
				<!-- 配置记住我或认证通过可以访问的地址 -->
				/index.jsp  = user
				/first.action = user
				/welcome.jsp = user
				<!-- /** = authc 所有url都必须认证通过才可以访问-->
				/** = authc
				<!-- /** = anon所有url都可以匿名访问 -->
				
			</value>
		</property>
	</bean>

	<!-- securityManager安全管理器 -->
	<bean id="securityManager" class="org.apache.shiro.web.mgt.DefaultWebSecurityManager">
		<property name="realm" ref="customRealm" />
	</bean>

<!-- 自定义realm -->
<bean id="customRealm" class="com.catchu.ssm.shiro.CustomRealm">
	<!-- 将凭证匹配器设置到realm中，realm按照凭证匹配器的要求进行散列 -->
	<property name="credentialsMatcher" ref="credentialsMatcher"/>
</bean>

<!-- 凭证匹配器 -->
 <bean id="credentialsMatcher"
	class="org.apache.shiro.authc.credential.HashedCredentialsMatcher">
	<property name="hashAlgorithmName" value="md5" />
	<property name="hashIterations" value="1" />
</bean>
</beans>

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

4.自定义realm进行认证

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

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
/**
 * @Description 用于认证
 * @Author 刘俊重
 * @date 2017年8月1日
 */
@Override
protected AuthenticationInfo doGetAuthenticationInfo(AuthenticationToken token) throws AuthenticationException {
	//从token获取principal（身份信息）,token中存的是用户名和密码
	String userCode = (String) token.getPrincipal();
	
	//根据用户名查询用户信息
	SysUser sysUser = null;
	try {
		sysUser = sysService.findSysUserByUserCode(userCode);
	} catch (Exception e1) {
		// TODO Auto-generated catch block
		e1.printStackTrace();
	}
	
	//用户不存在返回null
	if(null== sysUser){
		return null;
	}
	
	//用户存在，获取用户散列后的密码，盐
	String password = sysUser.getPassword();
	String salt = sysUser.getSalt();
	
	//activeUser就是用户的身份信息
	ActiveUser activeUser = new ActiveUser();
	activeUser.setUserid("zhangsan");
	activeUser.setUsercode("zhangsan");
	activeUser.setUsername("zhangsan");
	//根据用户id查询菜单
	List<SysPermission> menuList = null;
	try {
		menuList = sysService.findMenuListByUserId("zhangsan");
	} catch (Exception e) {
		e.printStackTrace();
	}
	activeUser.setMenus(menuList);
	
	//将用户身份信息activeUser设置到SimpleAuthenticationInfo中
	SimpleAuthenticationInfo simpleAuthenticationInfo = new SimpleAuthenticationInfo(activeUser,
			password,ByteSource.Util.bytes(salt),getName());
	return simpleAuthenticationInfo;
}

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

5.自定义Realm进行授权

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

1
2
3
4
5
6
7
<!-- 开启aop，对类代理 -->
<aop:config proxy-target-class="true"></aop:config>
<!-- 开启shiro注解支持 -->
<bean
	class="	org.apache.shiro.spring.security.interceptor.AuthorizationAttributeSourceAdvisor">
	<property name="securityManager" ref="securityManager" />
</bean>

在请求的Controller方法中配置@RequiresPermissions注解（里面填权限标识符），示例代码如下：

1
2
3
4
5
6
7
8
9
10
11
12
13
//商品信息方法
@RequestMapping("/queryItem")
@RequiresPermissions("item:query")  //表明请求这个queryItem时需要item:query权限，会调用自定义realm（调用数据库）查询主体拥有的权限，判断是否有访问本请求的权限
public ModelAndView queryItems(HttpServletRequest request) throws Exception {
	System.out.println(request.getParameter("id"));
	//调用service查询商品列表
	List<ItemsCustom> itemsList = itemsService.findItemsList(null);
	ModelAndView modelAndView = new ModelAndView();
	modelAndView.addObject("itemsList", itemsList);
	// 指定逻辑视图名
	modelAndView.setViewName("itemsList");
	return modelAndView;
}

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

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
/**
 * @Description 用于授权
 * @Author 刘俊重
 * @date 2017年8月1日
 */
@Override
protected AuthorizationInfo doGetAuthorizationInfo(PrincipalCollection principals) {
	//从principals中获取主身份信息。在上一步认证中把身份信息activeUser放进了SimpleAuthenticationInfo，这里再取出来。
	ActiveUser activeUser = (ActiveUser) principals.getPrimaryPrincipal();
	//从数据库中根据身份信息查询到的权限信息
	List<SysPermission> permissionList = null;
	try {
		permissionList = sysService.findPermissionListByUserId(activeUser.getUserid());
	} catch (Exception e) {
		e.printStackTrace();
	}
	List<String> permissions = new ArrayList<String>();
	if(permissionList!=null && permissionList.size()>0){
		for(SysPermission permission:permissionList){
			//将用户权限标识符放在list之后填充到SimpleAuthorizationInfo并返回
			permissions.add(permission.getPercode());
		}
	}
	//构建授权信息，并返回
	SimpleAuthorizationInfo simpleAuthorizationInfo = new SimpleAuthorizationInfo();
	simpleAuthorizationInfo.addStringPermissions(permissions);
	return simpleAuthorizationInfo;
}

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:hasAnyRoles name=”abc,123” 在有abc或者123角色时
shiro:hasRole name=”abc” 拥有角色abc
shiro:lacksRole name=”abc” 没有角色abc
shiro:hasPermission name=”abc” 拥有权限资源abc
shiro:lacksPermission name=”abc” 没有abc权限资源
shiro:principal 显示用户身份()名称

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

8.shiro缓存

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

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

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    <ehcache xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    	xsi:noNamespaceSchemaLocation="../config/ehcache.xsd">
    	<!--diskStore：缓存数据持久化的目录 地址  -->
    	<diskStore path="F:\develop\ehcache" />
    	<defaultCache 
    		maxElementsInMemory="1000" 
    		maxElementsOnDisk="10000000"
    		eternal="false" 
    		overflowToDisk="false" 
    		diskPersistent="false"
    		timeToIdleSeconds="120"
    		timeToLiveSeconds="120" 
    		diskExpiryThreadIntervalSeconds="120"
    		memoryStoreEvictionPolicy="LRU">
    	</defaultCache>
    </ehcache>

  • 在spring-shiro.xml配置文件中，配置安全管理器（securityManger）中引入shiro-ehcache.xml:

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    	<!-- securityManager安全管理器 -->
    	<bean id="securityManager" class="org.apache.shiro.web.mgt.DefaultWebSecurityManager">
    		<property name="realm" ref="customRealm" />
    		<!-- 注入缓存管理器 -->
    		<property name="cacheManager" ref="cacheManager"/>	
    	</bean>
    	
    	<!-- 缓存管理器 -->
     <bean id="cacheManager" class="org.apache.shiro.cache.ehcache.EhCacheManager">
        <property name="cacheManagerConfigFile" value="classpath:shiro-ehcache.xml"/>
    </bean>

  • 清空缓存：
    如果用户正常退出，缓存自动清空。
    如果用户非正常退出，缓存自动清空。
    如果修改了用户的权限，而用户不退出系统，修改的权限无法立即生效。
    需要手动进行编程实现：在权限修改后调用自定义realm的clearCache方法清除缓存。
    在自定义Realm定义的清空缓存的方法如下：

    1
    2
    3
    4
    5
    //清除缓存
    public void clearCached() {
    	PrincipalCollection principals = SecurityUtils.getSubject().getPrincipals();
    	super.clearCache(principals);
    }

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

1
2
3
4
5
6
7
8
9
10
//注入realm
@Autowired
private CustomRealm customRealm;

@RequestMapping("/clearShiroCache")
public String clearShiroCache(){
	//清除缓存，将来正常开发要在service调用customRealm.clearCached()
	customRealm.clearCached();
	return "success";
}

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

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

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
package com.catchu.ssm.shiro;
import javax.servlet.ServletRequest;
import javax.servlet.ServletResponse;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpSession;
import org.apache.shiro.web.filter.authc.FormAuthenticationFilter;
/**
 * @author 刘俊重
 * @Description 自定义FormAuthenticationFilter，认证之前实现 验证码校验
 * @date 2017年8月4日
 */
public class CustomFormAuthenticationFilter extends FormAuthenticationFilter {
	//原FormAuthenticationFilter的认证方法
	@Override
	protected boolean onAccessDenied(ServletRequest request,
			ServletResponse response) throws Exception {
		//在这里进行验证码的校验
		
		//从session获取正确验证码
		HttpServletRequest httpServletRequest = (HttpServletRequest) request;
		HttpSession session =httpServletRequest.getSession();
		//取出session的验证码（正确的验证码）
		String validateCode = (String) session.getAttribute("validateCode");
		
		//取出页面的验证码
		//输入的验证和session中的验证进行对比 
		String randomcode = httpServletRequest.getParameter("randomcode");
		if(randomcode!=null && validateCode!=null && !randomcode.equals(validateCode)){
			//如果校验失败，将验证码错误失败信息，通过shiroLoginFailure设置到request中
			httpServletRequest.setAttribute("shiroLoginFailure", "randomCodeError");
			//拒绝访问，不再校验账号和密码 
			return true; 
		}
		return super.onAccessDenied(request, response);
	}	
}

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

1
2
3
4
5
6
7
8
9
10
11
<!-- 自定义form认证过虑器 -->
<!-- 基于Form表单的身份验证过滤器，不配置将也会注册此过虑器，表单中的用户账号、密码及loginurl将采用默认值，建议配置 -->
<bean id="formAuthenticationFilter" 
	class="com.catchu.ssm.shiro.CustomFormAuthenticationFilter ">
		<!-- 表单中账号的input名称 -->
		<property name="usernameParam" value="username" />
		<!-- 表单中密码的input名称 -->
		<property name="passwordParam" value="password" />
		<!-- 记住我input的名称 -->
		<property name="rememberMeParam" value="rememberMe"/>
 </bean>

注入到安全管理器（securitymanager）

1
2
3
4
5
6
7
<!-- 自定义filter配置 -->
<property name="filters">
	<map>
		<!-- 将自定义 的FormAuthenticationFilter注入shiroFilter中 -->
		<entry key="authc" value-ref="formAuthenticationFilter" />
	</map>
</property>

10.配置rememberMe

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

  • jsp中页面代码如下：

    1
    2
    3
    4
    <tr>
    <TD></TD>
    <td><input type="checkbox" name="rememberMe" />自动登陆</td>
    </tr>

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

    1
    2
    3
    4
    5
    public class ActiveUser implements java.io.Serializable {
    	private String userid;//用户id（主键）
    	private String usercode;// 用户账号
    	private String username;// 用户名称
    	}

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

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    <!-- rememberMeManager管理器，写cookie，取出cookie生成用户信息 -->
     	<bean id="rememberMeManager" class="org.apache.shiro.web.mgt.CookieRememberMeManager">
    		<property name="cookie" ref="rememberMeCookie" />
    	</bean>
    	<!-- 记住我cookie -->
    	<bean id="rememberMeCookie" class="org.apache.shiro.web.servlet.SimpleCookie">
    		<!-- rememberMe是cookie的名字 -->
    		<constructor-arg value="rememberMe" />
    		<!-- 记住我cookie生效时间30天 -->
    		<property name="maxAge" value="2592000" />
    	</bean>

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

    1
    2
    3
    4
    <!-- 配置记住我或认证通过可以访问的地址 -->
    				/index.jsp  = user
    				/first.action = user
    				/welcome.jsp = user

都配置完成之后，在浏览器的cookie中查看即可看到cookie信息。
附：spring-shiro.xml中所有配置如下：

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
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
<beans xmlns="http://www.springframework.org/schema/beans"
	xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:mvc="http://www.springframework.org/schema/mvc"
	xmlns:context="http://www.springframework.org/schema/context"
	xmlns:aop="http://www.springframework.org/schema/aop" xmlns:tx="http://www.springframework.org/schema/tx"
	xsi:schemaLocation="http://www.springframework.org/schema/beans 
		http://www.springframework.org/schema/beans/spring-beans-3.2.xsd 
		http://www.springframework.org/schema/mvc 
		http://www.springframework.org/schema/mvc/spring-mvc-3.2.xsd 
		http://www.springframework.org/schema/context 
		http://www.springframework.org/schema/context/spring-context-3.2.xsd 
		http://www.springframework.org/schema/aop 
		http://www.springframework.org/schema/aop/spring-aop-3.2.xsd 
		http://www.springframework.org/schema/tx 
		http://www.springframework.org/schema/tx/spring-tx-3.2.xsd ">

	<!-- web.xml中shiro的filter对应的bean -->
	<!-- Shiro 的Web过滤器 -->
	<bean id="shiroFilter" class="org.apache.shiro.spring.web.ShiroFilterFactoryBean">
		<property name="securityManager" ref="securityManager" />
		<!-- loginUrl认证提交地址，如果没有认证将会请求此地址进行认证，请求此地址将由formAuthenticationFilter进行表单认证 -->
		<property name="loginUrl" value="/login.action" />
		<!-- 认证成功统一跳转到first.action，建议不配置，shiro会自动在认证成功后跳转到到上一个请求路径 -->
		<property name="successUrl" value="/first.action"/>
		<!-- 通过unauthorizedUrl指定没有权限操作时跳转页面-->
		<property name="unauthorizedUrl" value="/refuse.jsp" />
		<!-- 自定义filter配置 -->
		<property name="filters">
			<map>
				<!-- 将自定义 的FormAuthenticationFilter注入shiroFilter中 -->
				<entry key="authc" value-ref="formAuthenticationFilter" />
			</map>
		</property>
		
		<!-- 过滤器链定义，从上向下顺序执行，一般将/**放在最下边 -->
		<property name="filterChainDefinitions">
			<value>
				<!-- 对静态资源设置匿名访问 -->
				/images/** = anon
				/js/** = anon
				/styles/** = anon
				<!-- 验证码，可匿名访问 -->
				/validatecode.jsp = anon
				
				<!-- 请求 logout.action地址，shiro去清除session-->
				/logout.action = logout
				<!--商品查询需要商品查询权限 ，取消url拦截配置，使用注解授权方式 -->
				<!-- /item/queryItem.action = perms[item:query]
				/items/editItems.action = perms[item:edit] -->
				<!-- 配置记住我或认证通过可以访问的地址 -->
				/index.jsp  = user
				/first.action = user
				/welcome.jsp = user
				<!-- /** = authc 所有url都必须认证通过才可以访问-->
				/** = authc
				<!-- /** = anon所有url都可以匿名访问 -->
				
			</value>
		</property>
	</bean>

	<!-- securityManager安全管理器 -->
	<bean id="securityManager" class="org.apache.shiro.web.mgt.DefaultWebSecurityManager">
		<property name="realm" ref="customRealm" />
		<!-- 注入缓存管理器 -->
		<property name="cacheManager" ref="cacheManager"/>
		<!-- 注入session管理器 -->
		<property name="sessionManager" ref="sessionManager" />
		<!-- 记住我 -->
 		<property name="rememberMeManager" ref="rememberMeManager"/>
		
	</bean>

<!-- 自定义realm -->
<bean id="customRealm" class="com.catchu.ssm.shiro.CustomRealm">
	<!-- 将凭证匹配器设置到realm中，realm按照凭证匹配器的要求进行散列 -->
	<property name="credentialsMatcher" ref="credentialsMatcher"/>
</bean>

<!-- 凭证匹配器 -->
 <bean id="credentialsMatcher"
	class="org.apache.shiro.authc.credential.HashedCredentialsMatcher">
	<property name="hashAlgorithmName" value="md5" />
	<property name="hashIterations" value="1" />
</bean>

<!-- 缓存管理器 -->
 <bean id="cacheManager" class="org.apache.shiro.cache.ehcache.EhCacheManager">
    <property name="cacheManagerConfigFile" value="classpath:shiro-ehcache.xml"/>
</bean>

<!-- 会话管理器 -->
<bean id="sessionManager" class="org.apache.shiro.web.session.mgt.DefaultWebSessionManager">
   	<!-- session的失效时长，单位毫秒 -->
   	<property name="globalSessionTimeout" value="5000"/>
  	<!--  删除失效的session -->
    <property name="deleteInvalidSessions" value="true"/>
</bean>

<!-- 自定义form认证过虑器 -->
<!-- 基于Form表单的身份验证过滤器，不配置将也会注册此过虑器，表单中的用户账号、密码及loginurl将采用默认值，建议配置 -->
<bean id="formAuthenticationFilter" 
	class="com.catchu.ssm.shiro.CustomFormAuthenticationFilter ">
		<!-- 表单中账号的input名称 -->
		<property name="usernameParam" value="username" />
		<!-- 表单中密码的input名称 -->
		<property name="passwordParam" value="password" />
		<!-- 记住我input的名称 -->
		<property name="rememberMeParam" value="rememberMe"/>
 </bean>

<!-- rememberMeManager管理器，写cookie，取出cookie生成用户信息 -->
 	<bean id="rememberMeManager" class="org.apache.shiro.web.mgt.CookieRememberMeManager">
		<property name="cookie" ref="rememberMeCookie" />
	</bean>
	<!-- 记住我cookie -->
	<bean id="rememberMeCookie" class="org.apache.shiro.web.servlet.SimpleCookie">
		<!-- rememberMe是cookie的名字 -->
		<constructor-arg value="rememberMe" />
		<!-- 记住我cookie生效时间30天 -->
		<property name="maxAge" value="2592000" />
	</bean>
	</beans>

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

刘俊重 wechat
欢迎关注我的微信公众号
坚持原创技术分享
分享到： 收藏夹 复制网址 邮件 微信 QQ空间 腾讯微博 豆瓣 一键分享 更多