shiro框架

shiro框架资料 挺详细 感谢作者 另附转载地址：http://jinnianshilongnian.iteye.com/blog/2018398

1.1  简介

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

本教程只介绍基本的Shiro使用，不会过多分析源码等，重在使用。

 

Shiro可以非常容易的开发出足够好的应用，其不仅可以用在JavaSE环境，也可以用在JavaEE环境。Shiro可以帮助我们完成：认证、授权、加密、会话管理、与Web集成、缓存等。这不就是我们想要的嘛，而且Shiro的API也是非常简单；其基本功能点如下图所示：

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

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

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

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

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

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

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

Testing：提供测试支持；

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

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

 

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

 

接下来我们分别从外部和内部来看看Shiro的架构，对于一个好的框架，从外部来看应该具有非常简单易于使用的API，且API契约明确；从内部来看的话，其应该有一个可扩展的架构，即非常容易插入用户自定义实现，因为任何框架都不能满足所有需求。

 

首先，我们从外部来看Shiro吧，即从应用程序角度的来观察如何使用Shiro完成工作。如下图：

 

可以看到：应用代码直接交互的对象是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，即安全数据源。

 

也就是说对于我们而言，最简单的一个Shiro应用：

1、应用代码通过Subject来进行认证和授权，而Subject又委托给SecurityManager；

2、我们需要给Shiro的SecurityManager注入Realm，从而让SecurityManager能得到合法的用户及其权限进行判断。

 

从以上也可以看出，Shiro不提供维护用户/权限，而是通过Realm让开发人员自己注入。

 

接下来我们来从Shiro内部来看下Shiro的架构，如下图所示：

  

Subject：主体，可以看到主体可以是任何可以与应用交互的“用户”；

SecurityManager：相当于SpringMVC中的DispatcherServlet或者Struts2中的FilterDispatcher；是Shiro的心脏；所有具体的交互都通过SecurityManager进行控制；它管理着所有Subject、且负责进行认证和授权、及会话、缓存的管理。

Authenticator：认证器，负责主体认证的，这是一个扩展点，如果用户觉得Shiro默认的不好，可以自定义实现；其需要认证策略（Authentication Strategy），即什么情况下算用户认证通过了；

Authrizer：授权器，或者访问控制器，用来决定主体是否有权限进行相应的操作；即控制着用户能访问应用中的哪些功能；

Realm：可以有1个或多个Realm，可以认为是安全实体数据源，即用于获取安全实体的；可以是JDBC实现，也可以是LDAP实现，或者内存实现等等；由用户提供；注意：Shiro不知道你的用户/权限存储在哪及以何种格式存储；所以我们一般在应用中都需要实现自己的Realm；

SessionManager：如果写过Servlet就应该知道Session的概念，Session呢需要有人去管理它的生命周期，这个组件就是SessionManager；而Shiro并不仅仅可以用在Web环境，也可以用在如普通的JavaSE环境、EJB等环境；所有呢，Shiro就抽象了一个自己的Session来管理主体与应用之间交互的数据；这样的话，比如我们在Web环境用，刚开始是一台Web服务器；接着又上了台EJB服务器；这时想把两台服务器的会话数据放到一个地方，这个时候就可以实现自己的分布式会话（如把数据放到Memcached服务器）；

SessionDAO：DAO大家都用过，数据访问对象，用于会话的CRUD，比如我们想把Session保存到数据库，那么可以实现自己的SessionDAO，通过如JDBC写到数据库；比如想把Session放到Memcached中，可以实现自己的Memcached SessionDAO；另外SessionDAO中可以使用Cache进行缓存，以提高性能；

CacheManager：缓存控制器，来管理如用户、角色、权限等的缓存的；因为这些数据基本上很少去改变，放到缓存中后可以提高访问的性能

Cryptography：密码模块，Shiro提高了一些常见的加密组件用于如密码加密/解密的。

 

到此Shiro架构及其组件就认识完了，接下来挨着学习Shiro的组件吧。

@1@

身份验证，即在应用中谁能证明他就是他本人。一般提供如他们的身份ID一些标识信息来表明他就是他本人，如提供身份证，用户名/密码来证明。

在shiro中，用户需要提供principals （身份）和credentials（证明）给shiro，从而应用能验证用户身份：

principals：身份，即主体的标识属性，可以是任何东西，如用户名、邮箱等，唯一即可。一个主体可以有多个principals，但只有一个Primary principals，一般是用户名/密码/手机号。

credentials：证明/凭证，即只有主体知道的安全值，如密码/数字证书等。

最常见的principals和credentials组合就是用户名/密码了。接下来先进行一个基本的身份认证。

 

另外两个相关的概念是之前提到的Subject及Realm，分别是主体及验证主体的数据源。

 

2.2  环境准备

本文使用Maven构建，因此需要一点Maven知识。首先准备环境依赖： 

Java代码  

1. <dependencies>  
2.     <dependency>  
3.         <groupId>junit</groupId>  
4.         <artifactId>junit</artifactId>  
5.         <version>4.9</version>  
6.     </dependency>  
7.     <dependency>  
8.         <groupId>commons-logging</groupId>  
9.         <artifactId>commons-logging</artifactId>  
10.         <version>1.1.3</version>  
11.     </dependency>  
12.     <dependency>  
13.         <groupId>org.apache.shiro</groupId>  
14.         <artifactId>shiro-core</artifactId>  
15.         <version>1.2.2</version>  
16.     </dependency>  
17. </dependencies>   

添加junit、common-logging及shiro-core依赖即可。

 

2.3  登录/退出

1、首先准备一些用户身份/凭据（shiro.ini）

Java代码  

1. [users]  
2. zhang=123  
3. wang=123  

此处使用ini配置文件，通过[users]指定了两个主体：zhang/123、wang/123。

  

2、测试用例（com.github.zhangkaitao.shiro.chapter2.LoginLogoutTest） 

Java代码  

1. @Test  
2. public void testHelloworld() {  
3.     //1、获取SecurityManager工厂，此处使用Ini配置文件初始化SecurityManager  
4.     Factory<org.apache.shiro.mgt.SecurityManager> factory =  
5.             new IniSecurityManagerFactory("classpath:shiro.ini");  
6.     //2、得到SecurityManager实例 并绑定给SecurityUtils  
7.     org.apache.shiro.mgt.SecurityManager securityManager = factory.getInstance();  
8.     SecurityUtils.setSecurityManager(securityManager);  
9.     //3、得到Subject及创建用户名/密码身份验证Token（即用户身份/凭证）  
10.     Subject subject = SecurityUtils.getSubject();  
11.     UsernamePasswordToken token = new UsernamePasswordToken("zhang", "123");  
12.   
13.     try {  
14.         //4、登录，即身份验证  
15.         subject.login(token);  
16.     } catch (AuthenticationException e) {  
17.         //5、身份验证失败  
18.     }  
19.   
20.     Assert.assertEquals(true, subject.isAuthenticated()); //断言用户已经登录  
21.   
22.     //6、退出  
23.     subject.logout();  
24. }  
25.    

2.1、首先通过new IniSecurityManagerFactory并指定一个ini配置文件来创建一个SecurityManager工厂；

2.2、接着获取SecurityManager并绑定到SecurityUtils，这是一个全局设置，设置一次即可；

2.3、通过SecurityUtils得到Subject，其会自动绑定到当前线程；如果在web环境在请求结束时需要解除绑定；然后获取身份验证的Token，如用户名/密码；

2.4、调用subject.login方法进行登录，其会自动委托给SecurityManager.login方法进行登录；

2.5、如果身份验证失败请捕获AuthenticationException或其子类，常见的如： DisabledAccountException（禁用的帐号）、LockedAccountException（锁定的帐号）、UnknownAccountException（错误的帐号）、ExcessiveAttemptsException（登录失败次数过多）、IncorrectCredentialsException （错误的凭证）、ExpiredCredentialsException（过期的凭证）等，具体请查看其继承关系；对于页面的错误消息展示，最好使用如“用户名/密码错误”而不是“用户名错误”/“密码错误”，防止一些恶意用户非法扫描帐号库；

2.6、最后可以调用subject.logout退出，其会自动委托给SecurityManager.logout方法退出。

 

从如上代码可总结出身份验证的步骤：

1、收集用户身份/凭证，即如用户名/密码；

2、调用Subject.login进行登录，如果失败将得到相应的AuthenticationException异常，根据异常提示用户错误信息；否则登录成功；

3、最后调用Subject.logout进行退出操作。

 

如上测试的几个问题：

1、用户名/密码硬编码在ini配置文件，以后需要改成如数据库存储，且密码需要加密存储；

2、用户身份Token可能不仅仅是用户名/密码，也可能还有其他的，如登录时允许用户名/邮箱/手机号同时登录。 

 

2.4  身份认证流程

流程如下：

1、首先调用Subject.login(token)进行登录，其会自动委托给Security Manager，调用之前必须通过SecurityUtils. setSecurityManager()设置；

2、SecurityManager负责真正的身份验证逻辑；它会委托给Authenticator进行身份验证；

3、Authenticator才是真正的身份验证者，Shiro API中核心的身份认证入口点，此处可以自定义插入自己的实现；

4、Authenticator可能会委托给相应的AuthenticationStrategy进行多Realm身份验证，默认ModularRealmAuthenticator会调用AuthenticationStrategy进行多Realm身份验证；

5、Authenticator会把相应的token传入Realm，从Realm获取身份验证信息，如果没有返回/抛出异常表示身份验证失败了。此处可以配置多个Realm，将按照相应的顺序及策略进行访问。

 

2.5  Realm

Realm：域，Shiro从从Realm获取安全数据（如用户、角色、权限），就是说SecurityManager要验证用户身份，那么它需要从Realm获取相应的用户进行比较以确定用户身份是否合法；也需要从Realm得到用户相应的角色/权限进行验证用户是否能进行操作；可以把Realm看成DataSource，即安全数据源。如我们之前的ini配置方式将使用org.apache.shiro.realm.text.IniRealm。

 

org.apache.shiro.realm.Realm接口如下： 

Java代码  

1. String getName(); //返回一个唯一的Realm名字  
2. boolean supports(AuthenticationToken token); //判断此Realm是否支持此Token  
3. AuthenticationInfo getAuthenticationInfo(AuthenticationToken token)  
4.  throws AuthenticationException;  //根据Token获取认证信息  

 

单Realm配置

1、自定义Realm实现（com.github.zhangkaitao.shiro.chapter2.realm.MyRealm1）：  

Java代码  

1. public class MyRealm1 implements Realm {  
2.     @Override  
3.     public String getName() {  
4.         return "myrealm1";  
5.     }  
6.     @Override  
7.     public boolean supports(AuthenticationToken token) {  
8.         //仅支持UsernamePasswordToken类型的Token  
9.         return token instanceof UsernamePasswordToken;   
10.     }  
11.     @Override  
12.     public AuthenticationInfo getAuthenticationInfo(AuthenticationToken token) throws AuthenticationException {  
13.         String username = (String)token.getPrincipal();  //得到用户名  
14.         String password = new String((char[])token.getCredentials()); //得到密码  
15.         if(!"zhang".equals(username)) {  
16.             throw new UnknownAccountException(); //如果用户名错误  
17.         }  
18.         if(!"123".equals(password)) {  
19.             throw new IncorrectCredentialsException(); //如果密码错误  
20.         }  
21.         //如果身份认证验证成功，返回一个AuthenticationInfo实现；  
22.         return new SimpleAuthenticationInfo(username, password, getName());  
23.     }  
24. }   

 

2、ini配置文件指定自定义Realm实现(shiro-realm.ini)  

Java代码  

1. #声明一个realm  
2. myRealm1=com.github.zhangkaitao.shiro.chapter2.realm.MyRealm1  
3. #指定securityManager的realms实现  
4. securityManager.realms=$myRealm1   

通过$name来引入之前的realm定义

 

3、测试用例请参考com.github.zhangkaitao.shiro.chapter2.LoginLogoutTest的testCustomRealm测试方法，只需要把之前的shiro.ini配置文件改成shiro-realm.ini即可。

 

多Realm配置

1、ini配置文件（shiro-multi-realm.ini）  

Java代码  

1. #声明一个realm  
2. myRealm1=com.github.zhangkaitao.shiro.chapter2.realm.MyRealm1  
3. myRealm2=com.github.zhangkaitao.shiro.chapter2.realm.MyRealm2  
4. #指定securityManager的realms实现  
5. securityManager.realms=$myRealm1,$myRealm2   

securityManager会按照realms指定的顺序进行身份认证。此处我们使用显示指定顺序的方式指定了Realm的顺序，如果删除“securityManager.realms=$myRealm1,$myRealm2”，那么securityManager会按照realm声明的顺序进行使用（即无需设置realms属性，其会自动发现），当我们显示指定realm后，其他没有指定realm将被忽略，如“securityManager.realms=$myRealm1”，那么myRealm2不会被自动设置进去。

 

2、测试用例请参考com.github.zhangkaitao.shiro.chapter2.LoginLogoutTest的testCustomMultiRealm测试方法。

 

Shiro默认提供的Realm

以后一般继承AuthorizingRealm（授权）即可；其继承了AuthenticatingRealm（即身份验证），而且也间接继承了CachingRealm（带有缓存实现）。其中主要默认实现如下：

org.apache.shiro.realm.text.IniRealm：[users]部分指定用户名/密码及其角色；[roles]部分指定角色即权限信息；

org.apache.shiro.realm.text.PropertiesRealm： user.username=password,role1,role2指定用户名/密码及其角色；role.role1=permission1,permission2指定角色及权限信息；

org.apache.shiro.realm.jdbc.JdbcRealm：通过sql查询相应的信息，如“select password from users where username = ?”获取用户密码，“select password, password_salt from users where username = ?”获取用户密码及盐；“select role_name from user_roles where username = ?”获取用户角色；“select permission from roles_permissions where role_name = ?”获取角色对应的权限信息；也可以调用相应的api进行自定义sql；

 

JDBC Realm使用

1、数据库及依赖

Java代码  

1. <dependency>  
2.     <groupId>mysql</groupId>  
3.     <artifactId>mysql-connector-java</artifactId>  
4.     <version>5.1.25</version>  
5. </dependency>  
6. <dependency>  
7.     <groupId>com.alibaba</groupId>  
8.     <artifactId>druid</artifactId>  
9.     <version>0.2.23</version>  
10. </dependency>   

本文将使用mysql数据库及druid连接池； 

 

2、到数据库shiro下建三张表：users（用户名/密码）、user_roles（用户/角色）、roles_permissions（角色/权限），具体请参照shiro-example-chapter2/sql/shiro.sql；并添加一个用户记录，用户名/密码为zhang/123；

 

3、ini配置（shiro-jdbc-realm.ini） 

Java代码  

1. jdbcRealm=org.apache.shiro.realm.jdbc.JdbcRealm  
2. dataSource=com.alibaba.druid.pool.DruidDataSource  
3. dataSource.driverClassName=com.mysql.jdbc.Driver  
4. dataSource.url=jdbc:mysql://localhost:3306/shiro  
5. dataSource.username=root  
6. #dataSource.password=  
7. jdbcRealm.dataSource=$dataSource  
8. securityManager.realms=$jdbcRealm   

1、变量名=全限定类名会自动创建一个类实例

2、变量名.属性=值 自动调用相应的setter方法进行赋值

3、$变量名 引用之前的一个对象实例 

4、测试代码请参照com.github.zhangkaitao.shiro.chapter2.LoginLogoutTest的testJDBCRealm方法，和之前的没什么区别。

 

2.6  Authenticator及AuthenticationStrategy

Authenticator的职责是验证用户帐号，是Shiro API中身份验证核心的入口点： 

Java代码  

1. public AuthenticationInfo authenticate(AuthenticationToken authenticationToken)  
2.             throws AuthenticationException;   

如果验证成功，将返回AuthenticationInfo验证信息；此信息中包含了身份及凭证；如果验证失败将抛出相应的AuthenticationException实现。

 

SecurityManager接口继承了Authenticator，另外还有一个ModularRealmAuthenticator实现，其委托给多个Realm进行验证，验证规则通过AuthenticationStrategy接口指定，默认提供的实现：

FirstSuccessfulStrategy：只要有一个Realm验证成功即可，只返回第一个Realm身份验证成功的认证信息，其他的忽略；

AtLeastOneSuccessfulStrategy：只要有一个Realm验证成功即可，和FirstSuccessfulStrategy不同，返回所有Realm身份验证成功的认证信息；

AllSuccessfulStrategy：所有Realm验证成功才算成功，且返回所有Realm身份验证成功的认证信息，如果有一个失败就失败了。

 

ModularRealmAuthenticator默认使用AtLeastOneSuccessfulStrategy策略。

 

假设我们有三个realm：

myRealm1： 用户名/密码为zhang/123时成功，且返回身份/凭据为zhang/123；

myRealm2： 用户名/密码为wang/123时成功，且返回身份/凭据为wang/123；

myRealm3： 用户名/密码为zhang/123时成功，且返回身份/凭据为zhang@163.com/123，和myRealm1不同的是返回时的身份变了；

 

1、ini配置文件(shiro-authenticator-all-success.ini) 

Java代码  

1. #指定securityManager的authenticator实现  
2. authenticator=org.apache.shiro.authc.pam.ModularRealmAuthenticator  
3. securityManager.authenticator=$authenticator  
4.   
5. #指定securityManager.authenticator的authenticationStrategy  
6. allSuccessfulStrategy=org.apache.shiro.authc.pam.AllSuccessfulStrategy  
7. securityManager.authenticator.authenticationStrategy=$allSuccessfulStrategy  

Java代码  

1. myRealm1=com.github.zhangkaitao.shiro.chapter2.realm.MyRealm1  
2. myRealm2=com.github.zhangkaitao.shiro.chapter2.realm.MyRealm2  
3. myRealm3=com.github.zhangkaitao.shiro.chapter2.realm.MyRealm3  
4. securityManager.realms=$myRealm1,$myRealm3  

 

2、测试代码（com.github.zhangkaitao.shiro.chapter2.AuthenticatorTest）

2.1、首先通用化登录逻辑 

Java代码  

1. private void login(String configFile) {  
2.     //1、获取SecurityManager工厂，此处使用Ini配置文件初始化SecurityManager  
3.     Factory<org.apache.shiro.mgt.SecurityManager> factory =  
4.             new IniSecurityManagerFactory(configFile);  
5.   
6.     //2、得到SecurityManager实例 并绑定给SecurityUtils  
7.     org.apache.shiro.mgt.SecurityManager securityManager = factory.getInstance();  
8.     SecurityUtils.setSecurityManager(securityManager);  
9.   
10.     //3、得到Subject及创建用户名/密码身份验证Token（即用户身份/凭证）  
11.     Subject subject = SecurityUtils.getSubject();  
12.     UsernamePasswordToken token = new UsernamePasswordToken("zhang", "123");  
13.   
14.     subject.login(token);  
15. }  

 

2.2、测试AllSuccessfulStrategy成功：    

Java代码  

1. @Test  
2. public void testAllSuccessfulStrategyWithSuccess() {  
3.     login("classpath:shiro-authenticator-all-success.ini");  
4.     Subject subject = SecurityUtils.getSubject();  
5.   
6.     //得到一个身份集合，其包含了Realm验证成功的身份信息  
7.     PrincipalCollection principalCollection = subject.getPrincipals();  
8.     Assert.assertEquals(2, principalCollection.asList().size());  
9. }   

即PrincipalCollection包含了zhang和zhang@163.com身份信息。

 

2.3、测试AllSuccessfulStrategy失败：

Java代码  

1.     @Test(expected = UnknownAccountException.class)  
2.     public void testAllSuccessfulStrategyWithFail() {  
3.         login("classpath:shiro-authenticator-all-fail.ini");  
4.         Subject subject = SecurityUtils.getSubject();  
5. }   

shiro-authenticator-all-fail.ini与shiro-authenticator-all-success.ini不同的配置是使用了securityManager.realms=$myRealm1,$myRealm2；即myRealm验证失败。

 

对于AtLeastOneSuccessfulStrategy和FirstSuccessfulStrategy的区别，请参照testAtLeastOneSuccessfulStrategyWithSuccess和testFirstOneSuccessfulStrategyWithSuccess测试方法。唯一不同点一个是返回所有验证成功的Realm的认证信息；另一个是只返回第一个验证成功的Realm的认证信息。

 

自定义AuthenticationStrategy实现，首先看其API：

Java代码  

1. //在所有Realm验证之前调用  
2. AuthenticationInfo beforeAllAttempts(  
3. Collection<? extends Realm> realms, AuthenticationToken token)   
4. throws AuthenticationException;  
5. //在每个Realm之前调用  
6. AuthenticationInfo beforeAttempt(  
7. Realm realm, AuthenticationToken token, AuthenticationInfo aggregate)   
8. throws AuthenticationException;  
9. //在每个Realm之后调用  
10. AuthenticationInfo afterAttempt(  
11. Realm realm, AuthenticationToken token,   
12. AuthenticationInfo singleRealmInfo, AuthenticationInfo aggregateInfo, Throwable t)  
13. throws AuthenticationException;  
14. //在所有Realm之后调用  
15. AuthenticationInfo afterAllAttempts(  
16. AuthenticationToken token, AuthenticationInfo aggregate)   
17. throws AuthenticationException;   

因为每个AuthenticationStrategy实例都是无状态的，所有每次都通过接口将相应的认证信息传入下一次流程；通过如上接口可以进行如合并/返回第一个验证成功的认证信息。

 

自定义实现时一般继承org.apache.shiro.authc.pam.AbstractAuthenticationStrategy即可，具体可以参考代码com.github.zhangkaitao.shiro.chapter2.authenticator.strategy包下OnlyOneAuthenticatorStrategy 和AtLeastTwoAuthenticatorStrategy。

 

到此基本的身份验证就搞定了，对于AuthenticationToken 、AuthenticationInfo和Realm的详细使用后续章节再陆续介绍。

@2@

授权，也叫访问控制，即在应用中控制谁能访问哪些资源（如访问页面/编辑数据/页面操作等）。在授权中需了解的几个关键对象：主体（Subject）、资源（Resource）、权限（Permission）、角色（Role）。

主体

主体，即访问应用的用户，在Shiro中使用Subject代表该用户。用户只有授权后才允许访问相应的资源。

资源

在应用中用户可以访问的任何东西，比如访问JSP页面、查看/编辑某些数据、访问某个业务方法、打印文本等等都是资源。用户只要授权后才能访问。

权限

安全策略中的原子授权单位，通过权限我们可以表示在应用中用户有没有操作某个资源的权力。即权限表示在应用中用户能不能访问某个资源，如：

访问用户列表页面

查看/新增/修改/删除用户数据（即很多时候都是CRUD（增查改删）式权限控制）

打印文档等等。。。

 

如上可以看出，权限代表了用户有没有操作某个资源的权利，即反映在某个资源上的操作允不允许，不反映谁去执行这个操作。所以后续还需要把权限赋予给用户，即定义哪个用户允许在某个资源上做什么操作（权限），Shiro不会去做这件事情，而是由实现人员提供。

 

Shiro支持粗粒度权限（如用户模块的所有权限）和细粒度权限（操作某个用户的权限，即实例级别的），后续部分介绍。

角色

角色代表了操作集合，可以理解为权限的集合，一般情况下我们会赋予用户角色而不是权限，即这样用户可以拥有一组权限，赋予权限时比较方便。典型的如：项目经理、技术总监、CTO、开发工程师等都是角色，不同的角色拥有一组不同的权限。

隐式角色：即直接通过角色来验证用户有没有操作权限，如在应用中CTO、技术总监、开发工程师可以使用打印机，假设某天不允许开发工程师使用打印机，此时需要从应用中删除相应代码；再如在应用中CTO、技术总监可以查看用户、查看权限；突然有一天不允许技术总监查看用户、查看权限了，需要在相关代码中把技术总监角色从判断逻辑中删除掉；即粒度是以角色为单位进行访问控制的，粒度较粗；如果进行修改可能造成多处代码修改。

显示角色：在程序中通过权限控制谁能访问某个资源，角色聚合一组权限集合；这样假设哪个角色不能访问某个资源，只需要从角色代表的权限集合中移除即可；无须修改多处代码；即粒度是以资源/实例为单位的；粒度较细。

 

 

请google搜索“RBAC”和“RBAC新解”分别了解“基于角色的访问控制”“基于资源的访问控制(Resource-Based Access Control)”。

 

3.1 授权方式

Shiro支持三种方式的授权：

 

编程式：通过写if/else授权代码块完成： 

Java代码  

1. Subject subject = SecurityUtils.getSubject();  
2. if(subject.hasRole(“admin”)) {  
3.     //有权限  
4. } else {  
5.     //无权限  
6. }   

 

注解式：通过在执行的Java方法上放置相应的注解完成： 

Java代码  

1. @RequiresRoles("admin")  
2. public void hello() {  
3.     //有权限  
4. }   

没有权限将抛出相应的异常；

 

JSP/GSP标签：在JSP/GSP页面通过相应的标签完成： 

Java代码  

1. <shiro:hasRole name="admin">  
2. <!— 有权限 —>  
3. </shiro:hasRole>   

后续部分将详细介绍如何使用。   

 

3.2 授权

基于角色的访问控制（隐式角色）

 

1、在ini配置文件配置用户拥有的角色（shiro-role.ini） 

Java代码  

1. [users]  
2. zhang=123,role1,role2  
3. wang=123,role1   

规则即：“用户名=密码,角色1，角色2”，如果需要在应用中判断用户是否有相应角色，就需要在相应的Realm中返回角色信息，也就是说Shiro不负责维护用户-角色信息，需要应用提供，Shiro只是提供相应的接口方便验证，后续会介绍如何动态的获取用户角色。

 

2、测试用例（com.github.zhangkaitao.shiro.chapter3.RoleTest） 

Java代码  

1. @Test  
2. public void testHasRole() {  
3.     login("classpath:shiro-role.ini", "zhang", "123");  
4.     //判断拥有角色：role1  
5.     Assert.assertTrue(subject().hasRole("role1"));  
6.     //判断拥有角色：role1 and role2  
7.     Assert.assertTrue(subject().hasAllRoles(Arrays.asList("role1", "role2")));  
8.     //判断拥有角色：role1 and role2 and !role3  
9.     boolean[] result = subject().hasRoles(Arrays.asList("role1", "role2", "role3"));  
10.     Assert.assertEquals(true, result[0]);  
11.     Assert.assertEquals(true, result[1]);  
12.     Assert.assertEquals(false, result[2]);  
13. }   

Shiro提供了hasRole/hasRole用于判断用户是否拥有某个角色/某些权限；但是没有提供如hashAnyRole用于判断是否有某些权限中的某一个。 

 

Java代码  

1. @Test(expected = UnauthorizedException.class)  
2. public void testCheckRole() {  
3.     login("classpath:shiro-role.ini", "zhang", "123");  
4.     //断言拥有角色：role1  
5.     subject().checkRole("role1");  
6.     //断言拥有角色：role1 and role3 失败抛出异常  
7.     subject().checkRoles("role1", "role3");  
8. }   

Shiro提供的checkRole/checkRoles和hasRole/hasAllRoles不同的地方是它在判断为假的情况下会抛出UnauthorizedException异常。

 

到此基于角色的访问控制（即隐式角色）就完成了，这种方式的缺点就是如果很多地方进行了角色判断，但是有一天不需要了那么就需要修改相应代码把所有相关的地方进行删除；这就是粗粒度造成的问题。

 

基于资源的访问控制（显示角色）

1、在ini配置文件配置用户拥有的角色及角色-权限关系（shiro-permission.ini） 

Java代码  

1. [users]  
2. zhang=123,role1,role2  
3. wang=123,role1  
4. [roles]  
5. role1=user:create,user:update  
6. role2=user:create,user:delete   

规则：“用户名=密码，角色1，角色2”“角色=权限1，权限2”，即首先根据用户名找到角色，然后根据角色再找到权限；即角色是权限集合；Shiro同样不进行权限的维护，需要我们通过Realm返回相应的权限信息。只需要维护“用户——角色”之间的关系即可。

 

2、测试用例（com.github.zhangkaitao.shiro.chapter3.PermissionTest）     

Java代码  

1. @Test  
2. public void testIsPermitted() {  
3.     login("classpath:shiro-permission.ini", "zhang", "123");  
4.     //判断拥有权限：user:create  
5.     Assert.assertTrue(subject().isPermitted("user:create"));  
6.     //判断拥有权限：user:update and user:delete  
7.     Assert.assertTrue(subject().isPermittedAll("user:update", "user:delete"));  
8.     //判断没有权限：user:view  
9.     Assert.assertFalse(subject().isPermitted("user:view"));  
10. }   

Shiro提供了isPermitted和isPermittedAll用于判断用户是否拥有某个权限或所有权限，也没有提供如isPermittedAny用于判断拥有某一个权限的接口。

 

Java代码  

1. @Test(expected = UnauthorizedException.class)  
2. public void testCheckPermission () {  
3.     login("classpath:shiro-permission.ini", "zhang", "123");  
4.     //断言拥有权限：user:create  
5.     subject().checkPermission("user:create");  
6.     //断言拥有权限：user:delete and user:update  
7.     subject().checkPermissions("user:delete", "user:update");  
8.     //断言拥有权限：user:view 失败抛出异常  
9.     subject().checkPermissions("user:view");  
10. }   

但是失败的情况下会抛出UnauthorizedException异常。

 

到此基于资源的访问控制（显示角色）就完成了，也可以叫基于权限的访问控制，这种方式的一般规则是“资源标识符：操作”，即是资源级别的粒度；这种方式的好处就是如果要修改基本都是一个资源级别的修改，不会对其他模块代码产生影响，粒度小。但是实现起来可能稍微复杂点，需要维护“用户——角色，角色——权限（资源：操作）”之间的关系。  

 

3.3 Permission

字符串通配符权限

规则：“资源标识符：操作：对象实例ID”  即对哪个资源的哪个实例可以进行什么操作。其默认支持通配符权限字符串，“:”表示资源/操作/实例的分割；“,”表示操作的分割；“*”表示任意资源/操作/实例。

  

1、单个资源单个权限 

Java代码  

1. subject().checkPermissions("system:user:update");  

用户拥有资源“system:user”的“update”权限。

 

2、单个资源多个权限

ini配置文件 

Java代码  

1. role41=system:user:update,system:user:delete  

然后通过如下代码判断

Java代码  

1. subject().checkPermissions("system:user:update", "system:user:delete");  

用户拥有资源“system:user”的“update”和“delete”权限。如上可以简写成：

 

ini配置（表示角色4拥有system:user资源的update和delete权限）   

Java代码  

1. role42="system:user:update,delete"    

 接着可以通过如下代码判断 

Java代码  

1. subject().checkPermissions("system:user:update,delete");  

通过“system:user:update,delete”验证"system:user:update, system:user:delete"是没问题的，但是反过来是规则不成立。

 

3、单个资源全部权限

ini配置 

Java代码  

1. role51="system:user:create,update,delete,view"  

然后通过如下代码判断 

Java代码  

1. subject().checkPermissions("system:user:create,delete,update:view");  

用户拥有资源“system:user”的“create”、“update”、“delete”和“view”所有权限。如上可以简写成：

 

ini配置文件（表示角色5拥有system:user的所有权限）

Java代码  

1. role52=system:user:*  

也可以简写为（推荐上边的写法）：

Java代码  

1. role53=system:user  

然后通过如下代码判断

Java代码  

1. subject().checkPermissions("system:user:*");  
2. subject().checkPermissions("system:user");   

通过“system:user:*”验证“system:user:create,delete,update:view”可以，但是反过来是不成立的。

 

4、所有资源全部权限

ini配置 

Java代码  

1. role61=*:view  

然后通过如下代码判断

Java代码  

1. subject().checkPermissions("user:view");  

用户拥有所有资源的“view”所有权限。假设判断的权限是“"system:user:view”，那么需要“role5=*:*:view”这样写才行。

 

5、实例级别的权限

5.1、单个实例单个权限

ini配置

Java代码  

1. role71=user:view:1  

对资源user的1实例拥有view权限。

然后通过如下代码判断 

Java代码  

1. subject().checkPermissions("user:view:1");  

 

5.2、单个实例多个权限

ini配置           

Java代码  

1. role72="user:update,delete:1"  

对资源user的1实例拥有update、delete权限。

然后通过如下代码判断

Java代码  

1. subject().checkPermissions("user:delete,update:1");  
2. subject().checkPermissions("user:update:1", "user:delete:1");   

  

5.3、单个实例所有权限

ini配置  

Java代码  

1. role73=user:*:1  

对资源user的1实例拥有所有权限。

然后通过如下代码判断 

Java代码  

1. subject().checkPermissions("user:update:1", "user:delete:1", "user:view:1");  

   

5.4、所有实例单个权限

ini配置 

Java代码  

1. role74=user:auth:*  

对资源user的1实例拥有所有权限。

然后通过如下代码判断 

Java代码  

1. subject().checkPermissions("user:auth:1", "user:auth:2");  

  

5.5、所有实例所有权限

ini配置 

Java代码  

1. role75=user:*:*  

对资源user的1实例拥有所有权限。

然后通过如下代码判断     

Java代码  

1. subject().checkPermissions("user:view:1", "user:auth:2");  

  

6、Shiro对权限字符串缺失部分的处理

如“user:view”等价于“user:view:*”；而“organization”等价于“organization:*”或者“organization:*:*”。可以这么理解，这种方式实现了前缀匹配。

另外如“user:*”可以匹配如“user:delete”、“user:delete”可以匹配如“user:delete:1”、“user:*:1”可以匹配如“user:view:1”、“user”可以匹配“user:view”或“user:view:1”等。即*可以匹配所有，不加*可以进行前缀匹配；但是如“*:view”不能匹配“system:user:view”，需要使用“*:*:view”，即后缀匹配必须指定前缀（多个冒号就需要多个*来匹配）。

 

7、WildcardPermission

如下两种方式是等价的：  

Java代码  

1. subject().checkPermission("menu:view:1");  
2. subject().checkPermission(new WildcardPermission("menu:view:1"));   

因此没什么必要的话使用字符串更方便。

 

8、性能问题

通配符匹配方式比字符串相等匹配来说是更复杂的，因此需要花费更长时间，但是一般系统的权限不会太多，且可以配合缓存来提供其性能，如果这样性能还达不到要求我们可以实现位操作算法实现性能更好的权限匹配。另外实例级别的权限验证如果数据量太大也不建议使用，可能造成查询权限及匹配变慢。可以考虑比如在sql查询时加上权限字符串之类的方式在查询时就完成了权限匹配。 

 

3.4 授权流程

流程如下：

1、首先调用Subject.isPermitted*/hasRole*接口，其会委托给SecurityManager，而SecurityManager接着会委托给Authorizer；

2、Authorizer是真正的授权者，如果我们调用如isPermitted(“user:view”)，其首先会通过PermissionResolver把字符串转换成相应的Permission实例；

3、在进行授权之前，其会调用相应的Realm获取Subject相应的角色/权限用于匹配传入的角色/权限；

4、Authorizer会判断Realm的角色/权限是否和传入的匹配，如果有多个Realm，会委托给ModularRealmAuthorizer进行循环判断，如果匹配如isPermitted*/hasRole*会返回true，否则返回false表示授权失败。

 

ModularRealmAuthorizer进行多Realm匹配流程：

1、首先检查相应的Realm是否实现了实现了Authorizer；

2、如果实现了Authorizer，那么接着调用其相应的isPermitted*/hasRole*接口进行匹配；

3、如果有一个Realm匹配那么将返回true，否则返回false。

 

如果Realm进行授权的话，应该继承AuthorizingRealm，其流程是：

1.1、如果调用hasRole*，则直接获取AuthorizationInfo.getRoles()与传入的角色比较即可；

1.2、首先如果调用如isPermitted(“user:view”)，首先通过PermissionResolver将权限字符串转换成相应的Permission实例，默认使用WildcardPermissionResolver，即转换为通配符的WildcardPermission；

2、通过AuthorizationInfo.getObjectPermissions()得到Permission实例集合；通过AuthorizationInfo. getStringPermissions()得到字符串集合并通过PermissionResolver解析为Permission实例；然后获取用户的角色，并通过RolePermissionResolver解析角色对应的权限集合（默认没有实现，可以自己提供）；

3、接着调用Permission. implies(Permission p)逐个与传入的权限比较，如果有匹配的则返回true，否则false。 

 

3.5 Authorizer、PermissionResolver及RolePermissionResolver

Authorizer的职责是进行授权（访问控制），是Shiro API中授权核心的入口点，其提供了相应的角色/权限判断接口，具体请参考其Javadoc。SecurityManager继承了Authorizer接口，且提供了ModularRealmAuthorizer用于多Realm时的授权匹配。PermissionResolver用于解析权限字符串到Permission实例，而RolePermissionResolver用于根据角色解析相应的权限集合。

 

我们可以通过如下ini配置更改Authorizer实现： 

Java代码  

1. authorizer=org.apache.shiro.authz.ModularRealmAuthorizer  
2. securityManager.authorizer=$authorizer   

对于ModularRealmAuthorizer，相应的AuthorizingSecurityManager会在初始化完成后自动将相应的realm设置进去，我们也可以通过调用其setRealms()方法进行设置。对于实现自己的authorizer可以参考ModularRealmAuthorizer实现即可，在此就不提供示例了。

 

设置ModularRealmAuthorizer的permissionResolver，其会自动设置到相应的Realm上（其实现了PermissionResolverAware接口），如：

Java代码  

1. permissionResolver=org.apache.shiro.authz.permission.WildcardPermissionResolver  
2. authorizer.permissionResolver=$permissionResolver   

 

设置ModularRealmAuthorizer的rolePermissionResolver，其会自动设置到相应的Realm上（其实现了RolePermissionResolverAware接口），如：

Java代码  

1. rolePermissionResolver=com.github.zhangkaitao.shiro.chapter3.permission.MyRolePermissionResolver  
2. authorizer.rolePermissionResolver=$rolePermissionResolver   

 

示例

1、ini配置（shiro-authorizer.ini）    

Java代码  

1. [main]  
2. #自定义authorizer  
3. authorizer=org.apache.shiro.authz.ModularRealmAuthorizer  
4. #自定义permissionResolver  
5. #permissionResolver=org.apache.shiro.authz.permission.WildcardPermissionResolver  
6. permissionResolver=com.github.zhangkaitao.shiro.chapter3.permission.BitAndWildPermissionResolver  
7. authorizer.permissionResolver=$permissionResolver  
8. #自定义rolePermissionResolver  
9. rolePermissionResolver=com.github.zhangkaitao.shiro.chapter3.permission.MyRolePermissionResolver  
10. authorizer.rolePermissionResolver=$rolePermissionResolver  
11.   
12. securityManager.authorizer=$authorizer  

Java代码  

1. #自定义realm 一定要放在securityManager.authorizer赋值之后（因为调用setRealms会将realms设置给authorizer，并给各个Realm设置permissionResolver和rolePermissionResolver）  
2. realm=com.github.zhangkaitao.shiro.chapter3.realm.MyRealm  
3. securityManager.realms=$realm   

设置securityManager 的realms一定要放到最后，因为在调用SecurityManager.setRealms时会将realms设置给authorizer，并为各个Realm设置permissionResolver和rolePermissionResolver。另外，不能使用IniSecurityManagerFactory创建的IniRealm，因为其初始化顺序的问题可能造成后续的初始化Permission造成影响。

 

2、定义BitAndWildPermissionResolver及BitPermission

BitPermission用于实现位移方式的权限，如规则是：

权限字符串格式：+资源字符串+权限位+实例ID；以+开头中间通过+分割；权限：0 表示所有权限；1 新增（二进制：0001）、2 修改（二进制：0010）、4 删除（二进制：0100）、8 查看（二进制：1000）；如 +user+10 表示对资源user拥有修改/查看权限。

Java代码  

1. public class BitPermission implements Permission {  
2.     private String resourceIdentify;  
3.     private int permissionBit;  
4.     private String instanceId;  
5.     public BitPermission(String permissionString) {  
6.         String[] array = permissionString.split("\\+");  
7.         if(array.length > 1) {  
8.             resourceIdentify = array[1];  
9.         }  
10.         if(StringUtils.isEmpty(resourceIdentify)) {  
11.             resourceIdentify = "*";  
12.         }  
13.         if(array.length > 2) {  
14.             permissionBit = Integer.valueOf(array[2]);  
15.         }  
16.         if(array.length > 3) {  
17.             instanceId = array[3];  
18.         }  
19.         if(StringUtils.isEmpty(instanceId)) {  
20.             instanceId = "*";  
21.         }  
22.     }  
23.   
24.     @Override  
25.     public boolean implies(Permission p) {  
26.         if(!(p instanceof BitPermission)) {  
27.             return false;  
28.         }  
29.         BitPermission other = (BitPermission) p;  
30.         if(!("*".equals(this.resourceIdentify) || this.resourceIdentify.equals(other.resourceIdentify))) {  
31.             return false;  
32.         }  
33.         if(!(this.permissionBit ==0 || (this.permissionBit & other.permissionBit) != 0)) {  
34.             return false;  
35.         }  
36.         if(!("*".equals(this.instanceId) || this.instanceId.equals(other.instanceId))) {  
37.             return false;  
38.         }  
39.         return true;  
40.     }  
41. }   

Permission接口提供了boolean implies(Permission p)方法用于判断权限匹配的；

Java代码  

1. public class BitAndWildPermissionResolver implements PermissionResolver {  
2.     @Override  
3.     public Permission resolvePermission(String permissionString) {  
4.         if(permissionString.startsWith("+")) {  
5.             return new BitPermission(permissionString);  
6.         }  
7.         return new WildcardPermission(permissionString);  
8.     }  
9. }   

BitAndWildPermissionResolver实现了PermissionResolver接口，并根据权限字符串是否以“+”开头来解析权限字符串为BitPermission或WildcardPermission。

 

3、定义MyRolePermissionResolver

RolePermissionResolver用于根据角色字符串来解析得到权限集合。

Java代码  

1. public class MyRolePermissionResolver implements RolePermissionResolver {  
2.     @Override  
3.     public Collection<Permission> resolvePermissionsInRole(String roleString) {  
4.         if("role1".equals(roleString)) {  
5.             return Arrays.asList((Permission)new WildcardPermission("menu:*"));  
6.         }  
7.         return null;  
8.     }  
9. }   

此处的实现很简单，如果用户拥有role1，那么就返回一个“menu:*”的权限。

 

4、自定义Realm

Java代码  

1. public class MyRealm extends AuthorizingRealm {  
2.     @Override  
3.     protected AuthorizationInfo doGetAuthorizationInfo(PrincipalCollection principals) {  
4.         SimpleAuthorizationInfo authorizationInfo = new SimpleAuthorizationInfo();  
5.         authorizationInfo.addRole("role1");  
6.         authorizationInfo.addRole("role2");  
7.         authorizationInfo.addObjectPermission(new BitPermission("+user1+10"));  
8.         authorizationInfo.addObjectPermission(new WildcardPermission("user1:*"));  
9.         authorizationInfo.addStringPermission("+user2+10");  
10.         authorizationInfo.addStringPermission("user2:*");  
11.         return authorizationInfo;  
12.     }  
13.     @Override  
14.     protected AuthenticationInfo doGetAuthenticationInfo(AuthenticationToken token) throws AuthenticationException {  
15.         //和com.github.zhangkaitao.shiro.chapter2.realm.MyRealm1. getAuthenticationInfo代码一样，省略  
16. }  
17. }   

此时我们继承AuthorizingRealm而不是实现Realm接口；推荐使用AuthorizingRealm，因为：

AuthenticationInfo doGetAuthenticationInfo(AuthenticationToken token)：表示获取身份验证信息；

AuthorizationInfo doGetAuthorizationInfo(PrincipalCollection principals)：表示根据用户身份获取授权信息。

这种方式的好处是当只需要身份验证时只需要获取身份验证信息而不需要获取授权信息。对于AuthenticationInfo和AuthorizationInfo请参考其Javadoc获取相关接口信息。

 

另外我们可以使用JdbcRealm，需要做的操作如下：

1、执行sql/ shiro-init-data.sql 插入相关的权限数据；

2、使用shiro-jdbc-authorizer.ini配置文件，需要设置jdbcRealm.permissionsLookupEnabled

为true来开启权限查询。

 

此次还要注意就是不能把我们自定义的如“+user1+10”配置到INI配置文件，即使有IniRealm完成，因为IniRealm在new完成后就会解析这些权限字符串，默认使用了WildcardPermissionResolver完成，即此处是一个设计权限，如果采用生命周期（如使用初始化方法）的方式进行加载就可以解决我们自定义permissionResolver的问题。

 

5、测试用例

Java代码  

1. public class AuthorizerTest extends BaseTest {  
2.   
3.     @Test  
4.     public void testIsPermitted() {  
5.         login("classpath:shiro-authorizer.ini", "zhang", "123");  
6.         //判断拥有权限：user:create  
7.         Assert.assertTrue(subject().isPermitted("user1:update"));  
8.         Assert.assertTrue(subject().isPermitted("user2:update"));  
9.         //通过二进制位的方式表示权限  
10.         Assert.assertTrue(subject().isPermitted("+user1+2"));//新增权限  
11.         Assert.assertTrue(subject().isPermitted("+user1+8"));//查看权限  
12.         Assert.assertTrue(subject().isPermitted("+user2+10"));//新增及查看  
13.   
14.         Assert.assertFalse(subject().isPermitted("+user1+4"));//没有删除权限  
15.   
16.         Assert.assertTrue(subject().isPermitted("menu:view"));//通过MyRolePermissionResolver解析得到的权限  
17.     }  
18. }   

通过如上步骤可以实现自定义权限验证了。另外因为不支持hasAnyRole/isPermittedAny这种方式的授权，可以参考我的一篇《简单shiro扩展实现NOT、AND、OR权限验证 》进行简单的扩展完成这个需求，在这篇文章中通过重写AuthorizingRealm里的验证逻辑实现的。 

@3@ 

之前章节我们已经接触过一些INI配置规则了，如果大家使用过如Spring之类的IoC/DI容器的话，Shiro提供的INI配置也是非常类似的，即可以理解为是一个IoC/DI容器，但是区别在于它从一个根对象securityManager开始。

 

4.1 根对象SecurityManager

从之前的Shiro架构图可以看出，Shiro是从根对象SecurityManager进行身份验证和授权的；也就是所有操作都是自它开始的，这个对象是线程安全且真个应用只需要一个即可，因此Shiro提供了SecurityUtils让我们绑定它为全局的，方便后续操作。

 

因为Shiro的类都是POJO的，因此都很容易放到任何IoC容器管理。但是和一般的IoC容器的区别在于，Shiro从根对象securityManager开始导航；Shiro支持的依赖注入：public空参构造器对象的创建、setter依赖注入。

 

1、纯Java代码写法（com.github.zhangkaitao.shiro.chapter4.NonConfigurationCreateTest）： 

Java代码  

1. DefaultSecurityManager securityManager = new DefaultSecurityManager();  
2. //设置authenticator  
3. ModularRealmAuthenticator authenticator = new ModularRealmAuthenticator();  
4. authenticator.setAuthenticationStrategy(new AtLeastOneSuccessfulStrategy());  
5. securityManager.setAuthenticator(authenticator);  
6.   
7. //设置authorizer  
8. ModularRealmAuthorizer authorizer = new ModularRealmAuthorizer();  
9. authorizer.setPermissionResolver(new WildcardPermissionResolver());  
10. securityManager.setAuthorizer(authorizer);  
11.   
12. //设置Realm  
13. DruidDataSource ds = new DruidDataSource();  
14. ds.setDriverClassName("com.mysql.jdbc.Driver");  
15. ds.setUrl("jdbc:mysql://localhost:3306/shiro");  
16. ds.setUsername("root");  
17. ds.setPassword("");  
18.   
19. JdbcRealm jdbcRealm = new JdbcRealm();  
20. jdbcRealm.setDataSource(ds);  
21. jdbcRealm.setPermissionsLookupEnabled(true);  
22. securityManager.setRealms(Arrays.asList((Realm) jdbcRealm));  
23.   
24. //将SecurityManager设置到SecurityUtils 方便全局使用  
25. SecurityUtils.setSecurityManager(securityManager);  
26.   
27. Subject subject = SecurityUtils.getSubject();  
28. UsernamePasswordToken token = new UsernamePasswordToken("zhang", "123");  
29. subject.login(token);  
30. Assert.assertTrue(subject.isAuthenticated());  
31.   
32.    

 

2.1、等价的INI配置（shiro-config.ini） 

Java代码  

1. [main]  
2. #authenticator  
3. authenticator=org.apache.shiro.authc.pam.ModularRealmAuthenticator  
4. authenticationStrategy=org.apache.shiro.authc.pam.AtLeastOneSuccessfulStrategy  
5. authenticator.authenticationStrategy=$authenticationStrategy  
6. securityManager.authenticator=$authenticator  
7.   
8. #authorizer  
9. authorizer=org.apache.shiro.authz.ModularRealmAuthorizer  
10. permissionResolver=org.apache.shiro.authz.permission.WildcardPermissionResolver  
11. authorizer.permissionResolver=$permissionResolver  
12. securityManager.authorizer=$authorizer  
13.   
14. #realm  
15. dataSource=com.alibaba.druid.pool.DruidDataSource  
16. dataSource.driverClassName=com.mysql.jdbc.Driver  
17. dataSource.url=jdbc:mysql://localhost:3306/shiro  
18. dataSource.username=root  
19. #dataSource.password=  
20. jdbcRealm=org.apache.shiro.realm.jdbc.JdbcRealm  
21. jdbcRealm.dataSource=$dataSource  
22. jdbcRealm.permissionsLookupEnabled=true  
23. securityManager.realms=$jdbcRealm   

即使没接触过IoC容器的知识，如上配置也是很容易理解的：

1、对象名=全限定类名  相对于调用public无参构造器创建对象

2、对象名.属性名=值    相当于调用setter方法设置常量值

3、对象名.属性名=$对象引用    相当于调用setter方法设置对象引用

 

2.2、Java代码（com.github.zhangkaitao.shiro.chapter4.ConfigurationCreateTest） 

Java代码  

1. Factory<org.apache.shiro.mgt.SecurityManager> factory =  
2.          new IniSecurityManagerFactory("classpath:shiro-config.ini");  
3.   
4. org.apache.shiro.mgt.SecurityManager securityManager = factory.getInstance();  
5.   
6. //将SecurityManager设置到SecurityUtils 方便全局使用  
7. SecurityUtils.setSecurityManager(securityManager);  
8. Subject subject = SecurityUtils.getSubject();  
9. UsernamePasswordToken token = new UsernamePasswordToken("zhang", "123");  
10. subject.login(token);  
11.   
12. Assert.assertTrue(subject.isAuthenticated());   

如上代码是从Shiro INI配置中获取相应的securityManager实例：

1、默认情况先创建一个名字为securityManager，类型为org.apache.shiro.mgt.DefaultSecurityManager的默认的SecurityManager，如果想自定义，只需要在ini配置文件中指定“securityManager=SecurityManager实现类”即可，名字必须为securityManager，它是起始的根；

2、IniSecurityManagerFactory是创建securityManager的工厂，其需要一个ini配置文件路径，其支持“classpath:”（类路径）、“file:”（文件系统）、“url:”（网络）三种路径格式，默认是文件系统；

3、接着获取SecuriyManager实例，后续步骤和之前的一样。

 

从如上可以看出Shiro INI配置方式本身提供了一个简单的IoC/DI机制方便在配置文件配置，但是是从securityManager这个根对象开始导航。   

 

4.2 INI配置

ini配置文件类似于Java中的properties（key=value），不过提供了将key/value分类的特性，key是每个部分不重复即可，而不是整个配置文件。如下是INI配置分类： 

Java代码  

1. [main]  
2. #提供了对根对象securityManager及其依赖的配置  
3. securityManager=org.apache.shiro.mgt.DefaultSecurityManager  
4. …………  
5. securityManager.realms=$jdbcRealm  
6.   
7. [users]  
8. #提供了对用户/密码及其角色的配置，用户名=密码，角色1，角色2  
9. username=password,role1,role2  
10.   
11. [roles]  
12. #提供了角色及权限之间关系的配置，角色=权限1，权限2  
13. role1=permission1,permission2  
14.   
15. [urls]  
16. #用于web，提供了对web url拦截相关的配置，url=拦截器[参数]，拦截器  
17. /index.html = anon  
18. /admin/** = authc, roles[admin], perms["permission1"]  

 

[main]部分

提供了对根对象securityManager及其依赖对象的配置。

创建对象 

Java代码  

1. securityManager=org.apache.shiro.mgt.DefaultSecurityManager  

其构造器必须是public空参构造器，通过反射创建相应的实例。

 

常量值setter注入 

Java代码  

1. dataSource.driverClassName=com.mysql.jdbc.Driver  
2. jdbcRealm.permissionsLookupEnabled=true   

会自动调用jdbcRealm.setPermissionsLookupEnabled(true)，对于这种常量值会自动类型转换。

 

对象引用setter注入 

Java代码  

1. authenticator=org.apache.shiro.authc.pam.ModularRealmAuthenticator  
2. authenticationStrategy=org.apache.shiro.authc.pam.AtLeastOneSuccessfulStrategy  
3. authenticator.authenticationStrategy=$authenticationStrategy  
4. securityManager.authenticator=$authenticator   

会自动通过securityManager.setAuthenticator(authenticator)注入引用依赖。

 

嵌套属性setter注入 

Java代码  

1. securityManager.authenticator.authenticationStrategy=$authenticationStrategy   

也支持这种嵌套方式的setter注入。

 

byte数组setter注入 

Java代码  

1. #base64 byte[]  
2. authenticator.bytes=aGVsbG8=  
3. #hex byte[]  
4. authenticator.bytes=0x68656c6c6f   

默认需要使用Base64进行编码，也可以使用0x十六进制。

 

Array/Set/List setter注入 

Java代码  

1. authenticator.array=1,2,3  
2. authenticator.set=$jdbcRealm,$jdbcRealm   

多个之间通过“，”分割。

 

Map setter注入

Java代码  

1. authenticator.map=$jdbcRealm:$jdbcRealm,1:1,key:abc  

即格式是：map=key：value，key：value，可以注入常量及引用值，常量的话都看作字符串（即使有泛型也不会自动造型）。        

 

实例化/注入顺序 

Java代码  

1. realm=Realm1  
2. realm=Realm12  
3.   
4. authenticator.bytes=aGVsbG8=  
5. authenticator.bytes=0x68656c6c6f   

后边的覆盖前边的注入。

 

测试用例请参考配置文件shiro-config-main.ini。 

 

[users]部分

配置用户名/密码及其角色，格式：“用户名=密码，角色1，角色2”，角色部分可省略。如：

Java代码  

1. [users]  
2. zhang=123,role1,role2  
3. wang=123   

密码一般生成其摘要/加密存储，后续章节介绍。

 

[roles]部分

配置角色及权限之间的关系，格式：“角色=权限1，权限2”；如：

Java代码  

1. [roles]  
2. role1=user:create,user:update  
3. role2=*   

如果只有角色没有对应的权限，可以不配roles，具体规则请参考授权章节。

 

[urls]部分

配置url及相应的拦截器之间的关系，格式：“url=拦截器[参数]，拦截器[参数]，如：  

Java代码  

1. [urls]  
2. /admin/** = authc, roles[admin], perms["permission1"]   

具体规则参见web相关章节。 

@4@

在涉及到密码存储问题上，应该加密/生成密码摘要存储，而不是存储明文密码。比如之前的600w csdn账号泄露对用户可能造成很大损失，因此应加密/生成不可逆的摘要方式存储。

 

5.1 编码/解码 

Shiro提供了base64和16进制字符串编码/解码的API支持，方便一些编码解码操作。Shiro内部的一些数据的存储/表示都使用了base64和16进制字符串。

Java代码  

1. String str = "hello";  
2. String base64Encoded = Base64.encodeToString(str.getBytes());  
3. String str2 = Base64.decodeToString(base64Encoded);  
4. Assert.assertEquals(str, str2);   

通过如上方式可以进行base64编码/解码操作，更多API请参考其Javadoc。

Java代码  

1. String str = "hello";  
2. String base64Encoded = Hex.encodeToString(str.getBytes());  
3. String str2 = new String(Hex.decode(base64Encoded.getBytes()));  
4. Assert.assertEquals(str, str2);   

通过如上方式可以进行16进制字符串编码/解码操作，更多API请参考其Javadoc。

 

还有一个可能经常用到的类CodecSupport，提供了toBytes(str, "utf-8") / toString(bytes, "utf-8")用于在byte数组/String之间转换。

 

5.2 散列算法

散列算法一般用于生成数据的摘要信息，是一种不可逆的算法，一般适合存储密码之类的数据，常见的散列算法如MD5、SHA等。一般进行散列时最好提供一个salt（盐），比如加密密码“admin”，产生的散列值是“21232f297a57a5a743894a0e4a801fc3”，可以到一些md5解密网站很容易的通过散列值得到密码“admin”，即如果直接对密码进行散列相对来说破解更容易，此时我们可以加一些只有系统知道的干扰数据，如用户名和ID（即盐）；这样散列的对象是“密码+用户名+ID”，这样生成的散列值相对来说更难破解。

Java代码  

1. String str = "hello";  
2. String salt = "123";  
3. String md5 = new Md5Hash(str, salt).toString();//还可以转换为 toBase64()/toHex()   

如上代码通过盐“123”MD5散列“hello”。另外散列时还可以指定散列次数，如2次表示：md5(md5(str))：“new Md5Hash(str, salt, 2).toString()”。

  

Java代码  

1. String str = "hello";  
2. String salt = "123";  
3. String sha1 = new Sha256Hash(str, salt).toString();   

使用SHA256算法生成相应的散列数据，另外还有如SHA1、SHA512算法。     

 

Shiro还提供了通用的散列支持：

Java代码  

1. String str = "hello";  
2. String salt = "123";  
3. //内部使用MessageDigest  
4. String simpleHash = new SimpleHash("SHA-1", str, salt).toString();   

通过调用SimpleHash时指定散列算法，其内部使用了Java的MessageDigest实现。

 

为了方便使用，Shiro提供了HashService，默认提供了DefaultHashService实现。

Java代码  

1. DefaultHashService hashService = new DefaultHashService(); //默认算法SHA-512  
2. hashService.setHashAlgorithmName("SHA-512");  
3. hashService.setPrivateSalt(new SimpleByteSource("123")); //私盐，默认无  
4. hashService.setGeneratePublicSalt(true);//是否生成公盐，默认false  
5. hashService.setRandomNumberGenerator(new SecureRandomNumberGenerator());//用于生成公盐。默认就这个  
6. hashService.setHashIterations(1); //生成Hash值的迭代次数  
7.   
8. HashRequest request = new HashRequest.Builder()  
9.             .setAlgorithmName("MD5").setSource(ByteSource.Util.bytes("hello"))  
10.             .setSalt(ByteSource.Util.bytes("123")).setIterations(2).build();  
11. String hex = hashService.computeHash(request).toHex();   

1、首先创建一个DefaultHashService，默认使用SHA-512算法；

2、可以通过hashAlgorithmName属性修改算法；

3、可以通过privateSalt设置一个私盐，其在散列时自动与用户传入的公盐混合产生一个新盐；

4、可以通过generatePublicSalt属性在用户没有传入公盐的情况下是否生成公盐；

5、可以设置randomNumberGenerator用于生成公盐；

6、可以设置hashIterations属性来修改默认加密迭代次数；

7、需要构建一个HashRequest，传入算法、数据、公盐、迭代次数。

 

SecureRandomNumberGenerator用于生成一个随机数：

Java代码  

1. SecureRandomNumberGenerator randomNumberGenerator =  
2.      new SecureRandomNumberGenerator();  
3. randomNumberGenerator.setSeed("123".getBytes());  
4. String hex = randomNumberGenerator.nextBytes().toHex();   

 

5.3 加密/解密

Shiro还提供对称式加密/解密算法的支持，如AES、Blowfish等；当前还没有提供对非对称加密/解密算法支持，未来版本可能提供。

 

AES算法实现：

Java代码  

1. AesCipherService aesCipherService = new AesCipherService();  
2. aesCipherService.setKeySize(128); //设置key长度  
3. //生成key  
4. Key key = aesCipherService.generateNewKey();  
5. String text = "hello";  
6. //加密  
7. String encrptText =   
8. aesCipherService.encrypt(text.getBytes(), key.getEncoded()).toHex();  
9. //解密  
10. String text2 =  
11.  new String(aesCipherService.decrypt(Hex.decode(encrptText), key.getEncoded()).getBytes());  
12.   
13. Assert.assertEquals(text, text2);   

更多算法请参考示例com.github.zhangkaitao.shiro.chapter5.hash.CodecAndCryptoTest。

 

5.4 PasswordService/CredentialsMatcher

Shiro提供了PasswordService及CredentialsMatcher用于提供加密密码及验证密码服务。

Java代码  

1. public interface PasswordService {  
2.     //输入明文密码得到密文密码  
3.     String encryptPassword(Object plaintextPassword) throws IllegalArgumentException;  
4. }  

Java代码  

1. public interface CredentialsMatcher {  
2.     //匹配用户输入的token的凭证（未加密）与系统提供的凭证（已加密）  
3.     boolean doCredentialsMatch(AuthenticationToken token, AuthenticationInfo info);  
4. }   

Shiro默认提供了PasswordService实现DefaultPasswordService；CredentialsMatcher实现PasswordMatcher及HashedCredentialsMatcher（更强大）。

 

DefaultPasswordService配合PasswordMatcher实现简单的密码加密与验证服务

1、定义Realm（com.github.zhangkaitao.shiro.chapter5.hash.realm.MyRealm）

Java代码  

1. public class MyRealm extends AuthorizingRealm {  
2.     private PasswordService passwordService;  
3.     public void setPasswordService(PasswordService passwordService) {  
4.         this.passwordService = passwordService;  
5.     }  
6.      //省略doGetAuthorizationInfo，具体看代码   
7.     @Override  
8.     protected AuthenticationInfo doGetAuthenticationInfo(AuthenticationToken token) throws AuthenticationException {  
9.         return new SimpleAuthenticationInfo(  
10.                 "wu",  
11.                 passwordService.encryptPassword("123"),  
12.                 getName());  
13.     }  
14. }   

为了方便，直接注入一个passwordService来加密密码，实际使用时需要在Service层使用passwordService加密密码并存到数据库。

 

2、ini配置（shiro-passwordservice.ini）

Java代码  

1. [main]  
2. passwordService=org.apache.shiro.authc.credential.DefaultPasswordService  
3. hashService=org.apache.shiro.crypto.hash.DefaultHashService  
4. passwordService.hashService=$hashService  
5. hashFormat=org.apache.shiro.crypto.hash.format.Shiro1CryptFormat  
6. passwordService.hashFormat=$hashFormat  
7. hashFormatFactory=org.apache.shiro.crypto.hash.format.DefaultHashFormatFactory  
8. passwordService.hashFormatFactory=$hashFormatFactory  
9.   
10. passwordMatcher=org.apache.shiro.authc.credential.PasswordMatcher  
11. passwordMatcher.passwordService=$passwordService  
12.   
13. myRealm=com.github.zhangkaitao.shiro.chapter5.hash.realm.MyRealm  
14. myRealm.passwordService=$passwordService  
15. myRealm.credentialsMatcher=$passwordMatcher  
16. securityManager.realms=$myRealm   

2.1、passwordService使用DefaultPasswordService，如果有必要也可以自定义；

2.2、hashService定义散列密码使用的HashService，默认使用DefaultHashService（默认SHA-256算法）；

2.3、hashFormat用于对散列出的值进行格式化，默认使用Shiro1CryptFormat，另外提供了Base64Format和HexFormat，对于有salt的密码请自定义实现ParsableHashFormat然后把salt格式化到散列值中；

2.4、hashFormatFactory用于根据散列值得到散列的密码和salt；因为如果使用如SHA算法，那么会生成一个salt，此salt需要保存到散列后的值中以便之后与传入的密码比较时使用；默认使用DefaultHashFormatFactory；

2.5、passwordMatcher使用PasswordMatcher，其是一个CredentialsMatcher实现；

2.6、将credentialsMatcher赋值给myRealm，myRealm间接继承了AuthenticatingRealm，其在调用getAuthenticationInfo方法获取到AuthenticationInfo信息后，会使用credentialsMatcher来验证凭据是否匹配，如果不匹配将抛出IncorrectCredentialsException异常。

 

3、测试用例请参考com.github.zhangkaitao.shiro.chapter5.hash.PasswordTest。

 

另外可以参考配置shiro-jdbc-passwordservice.ini，提供了JdbcRealm的测试用例，测试前请先调用sql/shiro-init-data.sql初始化用户数据。

 

如上方式的缺点是：salt保存在散列值中；没有实现如密码重试次数限制。

 

HashedCredentialsMatcher实现密码验证服务

Shiro提供了CredentialsMatcher的散列实现HashedCredentialsMatcher，和之前的PasswordMatcher不同的是，它只用于密码验证，且可以提供自己的盐，而不是随机生成盐，且生成密码散列值的算法需要自己写，因为能提供自己的盐。

 

1、生成密码散列值

此处我们使用MD5算法，“密码+盐（用户名+随机数）”的方式生成散列值：

Java代码  

1. String algorithmName = "md5";  
2. String username = "liu";  
3. String password = "123";  
4. String salt1 = username;  
5. String salt2 = new SecureRandomNumberGenerator().nextBytes().toHex();  
6. int hashIterations = 2;  
7.   
8. SimpleHash hash = new SimpleHash(algorithmName, password, salt1 + salt2, hashIterations);  
9. String encodedPassword = hash.toHex();   

如果要写用户模块，需要在新增用户/重置密码时使用如上算法保存密码，将生成的密码及salt2存入数据库（因为我们的散列算法是：md5(md5(密码+username+salt2))）。

 

2、生成Realm（com.github.zhangkaitao.shiro.chapter5.hash.realm.MyRealm2）

Java代码  

1. protected AuthenticationInfo doGetAuthenticationInfo(AuthenticationToken token) throws AuthenticationException {  
2.     String username = "liu"; //用户名及salt1  
3.     String password = "202cb962ac59075b964b07152d234b70"; //加密后的密码  
4.     String salt2 = "202cb962ac59075b964b07152d234b70";  
5. SimpleAuthenticationInfo ai =   
6.         new SimpleAuthenticationInfo(username, password, getName());  
7.     ai.setCredentialsSalt(ByteSource.Util.bytes(username+salt2)); //盐是用户名+随机数  
8.         return ai;  
9. }   

此处就是把步骤1中生成的相应数据组装为SimpleAuthenticationInfo，通过SimpleAuthenticationInfo的credentialsSalt设置盐，HashedCredentialsMatcher会自动识别这个盐。

 

如果使用JdbcRealm，需要修改获取用户信息（包括盐）的sql：“select password, password_salt from users where username = ?”，而我们的盐是由username+password_salt组成，所以需要通过如下ini配置（shiro-jdbc-hashedCredentialsMatcher.ini）修改：

Java代码  

1. jdbcRealm.saltStyle=COLUMN  
2. jdbcRealm.authenticationQuery=select password, concat(username,password_salt) from users where username = ?  
3. jdbcRealm.credentialsMatcher=$credentialsMatcher   

1、saltStyle表示使用密码+盐的机制，authenticationQuery第一列是密码，第二列是盐；

2、通过authenticationQuery指定密码及盐查询SQL；

 

此处还要注意Shiro默认使用了apache commons BeanUtils，默认是不进行Enum类型转型的，此时需要自己注册一个Enum转换器“BeanUtilsBean.getInstance().getConvertUtils().register(new EnumConverter(), JdbcRealm.SaltStyle.class);”具体请参考示例“com.github.zhangkaitao.shiro.chapter5.hash.PasswordTest”中的代码。

 

另外可以参考配置shiro-jdbc-passwordservice.ini，提供了JdbcRealm的测试用例，测试前请先调用sql/shiro-init-data.sql初始化用户数据。

 

3、ini配置（shiro-hashedCredentialsMatcher.ini）

Java代码  

1. [main]  
2. credentialsMatcher=org.apache.shiro.authc.credential.HashedCredentialsMatcher  
3. credentialsMatcher.hashAlgorithmName=md5  
4. credentialsMatcher.hashIterations=2  
5. credentialsMatcher.storedCredentialsHexEncoded=true  
6. myRealm=com.github.zhangkaitao.shiro.chapter5.hash.realm.MyRealm2  
7. myRealm.credentialsMatcher=$credentialsMatcher  
8. securityManager.realms=$myRealm   

1、通过credentialsMatcher.hashAlgorithmName=md5指定散列算法为md5，需要和生成密码时的一样；

2、credentialsMatcher.hashIterations=2，散列迭代次数，需要和生成密码时的意义；

3、credentialsMatcher.storedCredentialsHexEncoded=true表示是否存储散列后的密码为16进制，需要和生成密码时的一样，默认是base64；

 

此处最需要注意的就是HashedCredentialsMatcher的算法需要和生成密码时的算法一样。另外HashedCredentialsMatcher会自动根据AuthenticationInfo的类型是否是SaltedAuthenticationInfo来获取credentialsSalt盐。

 

4、测试用例请参考com.github.zhangkaitao.shiro.chapter5.hash.PasswordTest。

 

密码重试次数限制

如在1个小时内密码最多重试5次，如果尝试次数超过5次就锁定1小时，1小时后可再次重试，如果还是重试失败，可以锁定如1天，以此类推，防止密码被暴力破解。我们通过继承HashedCredentialsMatcher，且使用Ehcache记录重试次数和超时时间。

 

com.github.zhangkaitao.shiro.chapter5.hash.credentials.RetryLimitHashedCredentialsMatcher：

Java代码  

1. public boolean doCredentialsMatch(AuthenticationToken token, AuthenticationInfo info) {  
2.        String username = (String)token.getPrincipal();  
3.         //retry count + 1  
4.         Element element = passwordRetryCache.get(username);  
5.         if(element == null) {  
6.             element = new Element(username , new AtomicInteger(0));  
7.             passwordRetryCache.put(element);  
8.         }  
9.         AtomicInteger retryCount = (AtomicInteger)element.getObjectValue();  
10.         if(retryCount.incrementAndGet() > 5) {  
11.             //if retry count > 5 throw  
12.             throw new ExcessiveAttemptsException();  
13.         }  
14.   
15.         boolean matches = super.doCredentialsMatch(token, info);  
16.         if(matches) {  
17.             //clear retry count  
18.             passwordRetryCache.remove(username);  
19.         }  
20.         return matches;  
21. }   

如上代码逻辑比较简单，即如果密码输入正确清除cache中的记录；否则cache中的重试次数+1，如果超出5次那么抛出异常表示超出重试次数了。

@5@

6.1 Realm

【2.5 Realm】及【3.5 Authorizer】部分都已经详细介绍过Realm了，接下来再来看一下一般真实环境下的Realm如何实现。

  

1、定义实体及关系

即用户-角色之间是多对多关系，角色-权限之间是多对多关系；且用户和权限之间通过角色建立关系；在系统中验证时通过权限验证，角色只是权限集合，即所谓的显示角色；其实权限应该对应到资源（如菜单、URL、页面按钮、Java方法等）中，即应该将权限字符串存储到资源实体中，但是目前为了简单化，直接提取一个权限表，【综合示例】部分会使用完整的表结构。

 

用户实体包括：编号(id)、用户名(username)、密码(password)、盐(salt)、是否锁定(locked)；是否锁定用于封禁用户使用，其实最好使用Enum字段存储，可以实现更复杂的用户状态实现。

角色实体包括：、编号(id)、角色标识符（role）、描述（description）、是否可用（available）；其中角色标识符用于在程序中进行隐式角色判断的，描述用于以后再前台界面显示的、是否可用表示角色当前是否激活。

权限实体包括：编号（id）、权限标识符（permission）、描述（description）、是否可用（available）；含义和角色实体类似不再阐述。

 

另外还有两个关系实体：用户-角色实体（用户编号、角色编号，且组合为复合主键）；角色-权限实体（角色编号、权限编号，且组合为复合主键）。

 

sql及实体请参考源代码中的sql\shiro.sql 和 com.github.zhangkaitao.shiro.chapter6.entity对应的实体。

 

2、环境准备

为了方便数据库操作，使用了“org.springframework: spring-jdbc: 4.0.0.RELEASE”依赖，虽然是spring4版本的，但使用上和spring3无区别。其他依赖请参考源码的pom.xml。

 

3、定义Service及Dao

为了实现的简单性，只实现必须的功能，其他的可以自己实现即可。

 

PermissionService

Java代码  

1. public interface PermissionService {  
2.     public Permission createPermission(Permission permission);  
3.     public void deletePermission(Long permissionId);  
4. }  

实现基本的创建/删除权限。

 

RoleService 

Java代码  

1. public interface RoleService {  
2.     public Role createRole(Role role);  
3.     public void deleteRole(Long roleId);  
4.     //添加角色-权限之间关系  
5.     public void correlationPermissions(Long roleId, Long... permissionIds);  
6.     //移除角色-权限之间关系  
7.     public void uncorrelationPermissions(Long roleId, Long... permissionIds);//  
8. }   

相对于PermissionService多了关联/移除关联角色-权限功能。

 

UserService 

Java代码  

1. public interface UserService {  
2.     public User createUser(User user); //创建账户  
3.     public void changePassword(Long userId, String newPassword);//修改密码  
4.     public void correlationRoles(Long userId, Long... roleIds); //添加用户-角色关系  
5.     public void uncorrelationRoles(Long userId, Long... roleIds);// 移除用户-角色关系  
6.     public User findByUsername(String username);// 根据用户名查找用户  
7.     public Set<String> findRoles(String username);// 根据用户名查找其角色  
8.     public Set<String> findPermissions(String username); //根据用户名查找其权限  
9. }   

此处使用findByUsername、findRoles及findPermissions来查找用户名对应的帐号、角色及权限信息。之后的Realm就使用这些方法来查找相关信息。

 

UserServiceImpl  

Java代码  

1. public User createUser(User user) {  
2.     //加密密码  
3.     passwordHelper.encryptPassword(user);  
4.     return userDao.createUser(user);  
5. }  
6. public void changePassword(Long userId, String newPassword) {  
7.     User user =userDao.findOne(userId);  
8.     user.setPassword(newPassword);  
9.     passwordHelper.encryptPassword(user);  
10.     userDao.updateUser(user);  
11. }   

在创建账户及修改密码时直接把生成密码操作委托给PasswordHelper。

 

PasswordHelper

Java代码  

1. public class PasswordHelper {  
2.     private RandomNumberGenerator randomNumberGenerator =  
3.      new SecureRandomNumberGenerator();  
4.     private String algorithmName = "md5";  
5.     private final int hashIterations = 2;  
6.     public void encryptPassword(User user) {  
7.         user.setSalt(randomNumberGenerator.nextBytes().toHex());  
8.         String newPassword = new SimpleHash(  
9.                 algorithmName,  
10.                 user.getPassword(),  
11.                 ByteSource.Util.bytes(user.getCredentialsSalt()),  
12.                 hashIterations).toHex();  
13.         user.setPassword(newPassword);  
14.     }  
15. }   

之后的CredentialsMatcher需要和此处加密的算法一样。user.getCredentialsSalt()辅助方法返回username+salt。

 

为了节省篇幅，对于DAO/Service的接口及实现，具体请参考源码com.github.zhangkaitao.shiro.chapter6。另外请参考Service层的测试用例com.github.zhangkaitao.shiro.chapter6.service.ServiceTest。

 

4、定义Realm

RetryLimitHashedCredentialsMatcher 

和第五章的一样，在此就不罗列代码了，请参考源码com.github.zhangkaitao.shiro.chapter6.credentials.RetryLimitHashedCredentialsMatcher。

  

UserRealm

另外请参考Service层的测试用例com.github.zhangkaitao.shiro.chapter6.service.ServiceTest。 

Java代码  

1. public class UserRealm extends AuthorizingRealm {  
2.     private UserService userService = new UserServiceImpl();  
3.     protected AuthorizationInfo doGetAuthorizationInfo(PrincipalCollection principals) {  
4.         String username = (String)principals.getPrimaryPrincipal();  
5.         SimpleAuthorizationInfo authorizationInfo = new SimpleAuthorizationInfo();  
6.         authorizationInfo.setRoles(userService.findRoles(username));  
7.         authorizationInfo.setStringPermissions(userService.findPermissions(username));  
8.         return authorizationInfo;  
9.     }  
10.     protected AuthenticationInfo doGetAuthenticationInfo(AuthenticationToken token) throws AuthenticationException {  
11.         String username = (String)token.getPrincipal();  
12.         User user = userService.findByUsername(username);  
13.         if(user == null) {  
14.             throw new UnknownAccountException();//没找到帐号  
15.         }  
16.         if(Boolean.TRUE.equals(user.getLocked())) {  
17.             throw new LockedAccountException(); //帐号锁定  
18.         }  
19.         //交给AuthenticatingRealm使用CredentialsMatcher进行密码匹配，如果觉得人家的不好可以在此判断或自定义实现  
20.         SimpleAuthenticationInfo authenticationInfo = new SimpleAuthenticationInfo(  
21.                 user.getUsername(), //用户名  
22.                 user.getPassword(), //密码  
23.                 ByteSource.Util.bytes(user.getCredentialsSalt()),//salt=username+salt  
24.                 getName()  //realm name  
25.         );  
26.         return authenticationInfo;  
27.     }  
28. }   

1、UserRealm父类AuthorizingRealm将获取Subject相关信息分成两步：获取身份验证信息（doGetAuthenticationInfo）及授权信息（doGetAuthorizationInfo）；

2、doGetAuthenticationInfo获取身份验证相关信息：首先根据传入的用户名获取User信息；然后如果user为空，那么抛出没找到帐号异常UnknownAccountException；如果user找到但锁定了抛出锁定异常LockedAccountException；最后生成AuthenticationInfo信息，交给间接父类AuthenticatingRealm使用CredentialsMatcher进行判断密码是否匹配，如果不匹配将抛出密码错误异常IncorrectCredentialsException；另外如果密码重试此处太多将抛出超出重试次数异常ExcessiveAttemptsException；在组装SimpleAuthenticationInfo信息时，需要传入：身份信息（用户名）、凭据（密文密码）、盐（username+salt），CredentialsMatcher使用盐加密传入的明文密码和此处的密文密码进行匹配。

3、doGetAuthorizationInfo获取授权信息：PrincipalCollection是一个身份集合，因为我们现在就一个Realm，所以直接调用getPrimaryPrincipal得到之前传入的用户名即可；然后根据用户名调用UserService接口获取角色及权限信息。

 

5、测试用例

为了节省篇幅，请参考测试用例com.github.zhangkaitao.shiro.chapter6.realm.UserRealmTest。包含了：登录成功、用户名错误、密码错误、密码超出重试次数、有/没有角色、有/没有权限的测试。

 

6.2 AuthenticationToken

AuthenticationToken用于收集用户提交的身份（如用户名）及凭据（如密码）：

Java代码  

1. public interface AuthenticationToken extends Serializable {  
2.     Object getPrincipal(); //身份  
3.     Object getCredentials(); //凭据  
4. }   

扩展接口RememberMeAuthenticationToken：提供了“boolean isRememberMe()”现“记住我”的功能；

扩展接口是HostAuthenticationToken：提供了“String getHost()”方法用于获取用户“主机”的功能。

 

Shiro提供了一个直接拿来用的UsernamePasswordToken，用于实现用户名/密码Token组，另外其实现了RememberMeAuthenticationToken和HostAuthenticationToken，可以实现记住我及主机验证的支持。

 

6.3 AuthenticationInfo

AuthenticationInfo有两个作用：

1、如果Realm是AuthenticatingRealm子类，则提供给AuthenticatingRealm内部使用的CredentialsMatcher进行凭据验证；（如果没有继承它需要在自己的Realm中自己实现验证）；

2、提供给SecurityManager来创建Subject（提供身份信息）；

 

MergableAuthenticationInfo用于提供在多Realm时合并AuthenticationInfo的功能，主要合并Principal、如果是其他的如credentialsSalt，会用后边的信息覆盖前边的。

 

比如HashedCredentialsMatcher，在验证时会判断AuthenticationInfo是否是SaltedAuthenticationInfo子类，来获取盐信息。

 

Account相当于我们之前的User，SimpleAccount是其一个实现；在IniRealm、PropertiesRealm这种静态创建帐号信息的场景中使用，这些Realm直接继承了SimpleAccountRealm，而SimpleAccountRealm提供了相关的API来动态维护SimpleAccount；即可以通过这些API来动态增删改查SimpleAccount；动态增删改查角色/权限信息。及如果您的帐号不是特别多，可以使用这种方式，具体请参考SimpleAccountRealm Javadoc。

 

其他情况一般返回SimpleAuthenticationInfo即可。

 

6.4 PrincipalCollection

因为我们可以在Shiro中同时配置多个Realm，所以呢身份信息可能就有多个；因此其提供了PrincipalCollection用于聚合这些身份信息：

Java代码  

1. public interface PrincipalCollection extends Iterable, Serializable {  
2.     Object getPrimaryPrincipal(); //得到主要的身份  
3.     <T> T oneByType(Class<T> type); //根据身份类型获取第一个  
4.     <T> Collection<T> byType(Class<T> type); //根据身份类型获取一组  
5.     List asList(); //转换为List  
6.     Set asSet(); //转换为Set  
7.     Collection fromRealm(String realmName); //根据Realm名字获取  
8.     Set<String> getRealmNames(); //获取所有身份验证通过的Realm名字  
9.     boolean isEmpty(); //判断是否为空  
10. }   

因为PrincipalCollection聚合了多个，此处最需要注意的是getPrimaryPrincipal，如果只有一个Principal那么直接返回即可，如果有多个Principal，则返回第一个（因为内部使用Map存储，所以可以认为是返回任意一个）；oneByType / byType根据凭据的类型返回相应的Principal；fromRealm根据Realm名字（每个Principal都与一个Realm关联）获取相应的Principal。

 

MutablePrincipalCollection是一个可变的PrincipalCollection接口，即提供了如下可变方法：

Java代码  

1. public interface MutablePrincipalCollection extends PrincipalCollection {  
2.     void add(Object principal, String realmName); //添加Realm-Principal的关联  
3.     void addAll(Collection principals, String realmName); //添加一组Realm-Principal的关联  
4.     void addAll(PrincipalCollection principals);//添加PrincipalCollection  
5.     void clear();//清空  
6. }   

目前Shiro只提供了一个实现SimplePrincipalCollection，还记得之前的AuthenticationStrategy实现嘛，用于在多Realm时判断是否满足条件的，在大多数实现中（继承了AbstractAuthenticationStrategy）afterAttempt方法会进行AuthenticationInfo（实现了MergableAuthenticationInfo）的merge，比如SimpleAuthenticationInfo会合并多个Principal为一个PrincipalCollection。

 

对于PrincipalMap是Shiro 1.2中的一个实验品，暂时无用，具体可以参考其Javadoc。接下来通过示例来看看PrincipalCollection。

 

1、准备三个Realm

MyRealm1

Java代码  

1. public class MyRealm1 implements Realm {  
2.     @Override  
3.     public String getName() {  
4.         return "a"; //realm name 为 “a”  
5.     }  
6.     //省略supports方法，具体请见源码  
7.     @Override  
8.     public AuthenticationInfo getAuthenticationInfo(AuthenticationToken token) throws AuthenticationException {  
9.         return new SimpleAuthenticationInfo(  
10.                 "zhang", //身份 字符串类型  
11.                 "123",   //凭据  
12.                 getName() //Realm Name  
13.         );  
14.     }  
15. }  

         

MyRealm2 

和MyRealm1完全一样，只是Realm名字为b。

  

MyRealm3

Java代码  

1. public class MyRealm3 implements Realm {  
2.     @Override  
3.     public String getName() {  
4.         return "c"; //realm name 为 “c”  
5.     }  
6.     //省略supports方法，具体请见源码  
7.     @Override  
8.     public AuthenticationInfo getAuthenticationInfo(AuthenticationToken token) throws AuthenticationException {  
9.         User user = new User("zhang", "123");  
10.         return new SimpleAuthenticationInfo(  
11.                 user, //身份 User类型  
12.                 "123",   //凭据  
13.                 getName() //Realm Name  
14.         );  
15.     }  
16. }   

和MyRealm1同名，但返回的Principal是User类型。

 

2、ini配置（shiro-multirealm.ini）

Java代码  

1. [main]  
2. realm1=com.github.zhangkaitao.shiro.chapter6.realm.MyRealm1  
3. realm2=com.github.zhangkaitao.shiro.chapter6.realm.MyRealm2  
4. realm3=com.github.zhangkaitao.shiro.chapter6.realm.MyRealm3  
5. securityManager.realms=$realm1,$realm2,$realm3   

3、测试用例（com.github.zhangkaitao.shiro.chapter6.realm.PrincialCollectionTest）

因为我们的Realm中没有进行身份及凭据验证，所以相当于身份验证都是成功的，都将返回：

Java代码  

1. Object primaryPrincipal1 = subject.getPrincipal();  
2. PrincipalCollection princialCollection = subject.getPrincipals();  
3. Object primaryPrincipal2 = princialCollection.getPrimaryPrincipal();   

我们可以直接调用subject.getPrincipal获取PrimaryPrincipal（即所谓的第一个）；或者通过getPrincipals获取PrincipalCollection；然后通过其getPrimaryPrincipal获取PrimaryPrincipal。

 

Java代码  

1. Set<String> realmNames = princialCollection.getRealmNames();  

获取所有身份验证成功的Realm名字。      

 

Java代码  

1. Set<Object> principals = princialCollection.asSet(); //asList和asSet的结果一样  

将身份信息转换为Set/List，即使转换为List，也是先转换为Set再完成的。

 

Java代码  

1. Collection<User> users = princialCollection.fromRealm("c");  

根据Realm名字获取身份，因为Realm名字可以重复，所以可能多个身份，建议Realm名字尽量不要重复。

 

6.4 AuthorizationInfo

AuthorizationInfo用于聚合授权信息的：

Java代码  

1. public interface AuthorizationInfo extends Serializable {  
2.     Collection<String> getRoles(); //获取角色字符串信息  
3.     Collection<String> getStringPermissions(); //获取权限字符串信息  
4.     Collection<Permission> getObjectPermissions(); //获取Permission对象信息  
5. }   

当我们使用AuthorizingRealm时，如果身份验证成功，在进行授权时就通过doGetAuthorizationInfo方法获取角色/权限信息用于授权验证。

 

Shiro提供了一个实现SimpleAuthorizationInfo，大多数时候使用这个即可。

 

对于Account及SimpleAccount，之前的【6.3 AuthenticationInfo】已经介绍过了，用于SimpleAccountRealm子类，实现动态角色/权限维护的。

 

6.5 Subject

Subject是Shiro的核心对象，基本所有身份验证、授权都是通过Subject完成。

1、身份信息获取

Java代码  

1. Object getPrincipal(); //Primary Principal  
2. PrincipalCollection getPrincipals(); // PrincipalCollection   

 

2、身份验证

Java代码  

1. void login(AuthenticationToken token) throws AuthenticationException;  
2. boolean isAuthenticated();  
3. boolean isRemembered();  

通过login登录，如果登录失败将抛出相应的AuthenticationException，如果登录成功调用isAuthenticated就会返回true，即已经通过身份验证；如果isRemembered返回true，表示是通过记住我功能登录的而不是调用login方法登录的。isAuthenticated/isRemembered是互斥的，即如果其中一个返回true，另一个返回false。

  

3、角色授权验证 

Java代码  

1. boolean hasRole(String roleIdentifier);  
2. boolean[] hasRoles(List<String> roleIdentifiers);  
3. boolean hasAllRoles(Collection<String> roleIdentifiers);  
4. void checkRole(String roleIdentifier) throws AuthorizationException;  
5. void checkRoles(Collection<String> roleIdentifiers) throws AuthorizationException;  
6. void checkRoles(String... roleIdentifiers) throws AuthorizationException;   

hasRole*进行角色验证，验证后返回true/false；而checkRole*验证失败时抛出AuthorizationException异常。 

 

4、权限授权验证

Java代码  

1. boolean isPermitted(String permission);  
2. boolean isPermitted(Permission permission);  
3. boolean[] isPermitted(String... permissions);  
4. boolean[] isPermitted(List<Permission> permissions);  
5. boolean isPermittedAll(String... permissions);  
6. boolean isPermittedAll(Collection<Permission> permissions);  
7. void checkPermission(String permission) throws AuthorizationException;  
8. void checkPermission(Permission permission) throws AuthorizationException;  
9. void checkPermissions(String... permissions) throws AuthorizationException;  
10. void checkPermissions(Collection<Permission> permissions) throws AuthorizationException;  

isPermitted*进行权限验证，验证后返回true/false；而checkPermission*验证失败时抛出AuthorizationException。

 

5、会话

Java代码  

1. Session getSession(); //相当于getSession(true)  
2. Session getSession(boolean create);    

类似于Web中的会话。如果登录成功就相当于建立了会话，接着可以使用getSession获取；如果create=false如果没有会话将返回null，而create=true如果没有会话会强制创建一个。

 

6、退出 

Java代码  

1. void logout();  

 

7、RunAs  

Java代码  

1. void runAs(PrincipalCollection principals) throws NullPointerException, IllegalStateException;  
2. boolean isRunAs();  
3. PrincipalCollection getPreviousPrincipals();  
4. PrincipalCollection releaseRunAs();   

RunAs即实现“允许A假设为B身份进行访问”；通过调用subject.runAs(b)进行访问；接着调用subject.getPrincipals将获取到B的身份；此时调用isRunAs将返回true；而a的身份需要通过subject. getPreviousPrincipals获取；如果不需要RunAs了调用subject. releaseRunAs即可。

 

8、多线程

Java代码  

1. <V> V execute(Callable<V> callable) throws ExecutionException;  
2. void execute(Runnable runnable);  
3. <V> Callable<V> associateWith(Callable<V> callable);  
4. Runnable associateWith(Runnable runnable);   

实现线程之间的Subject传播，因为Subject是线程绑定的；因此在多线程执行中需要传播到相应的线程才能获取到相应的Subject。最简单的办法就是通过execute(runnable/callable实例)直接调用；或者通过associateWith(runnable/callable实例)得到一个包装后的实例；它们都是通过：1、把当前线程的Subject绑定过去；2、在线程执行结束后自动释放。

 

Subject自己不会实现相应的身份验证/授权逻辑，而是通过DelegatingSubject委托给SecurityManager实现；及可以理解为Subject是一个面门。

 

对于Subject的构建一般没必要我们去创建；一般通过SecurityUtils.getSubject()获取：

Java代码  

1. public static Subject getSubject() {  
2.     Subject subject = ThreadContext.getSubject();  
3.     if (subject == null) {  
4.         subject = (new Subject.Builder()).buildSubject();  
5.         ThreadContext.bind(subject);  
6.     }  
7.     return subject;  
8. }   

即首先查看当前线程是否绑定了Subject，如果没有通过Subject.Builder构建一个然后绑定到现场返回。

 

如果想自定义创建，可以通过：

Java代码  

1. new Subject.Builder().principals(身份).authenticated(true/false).buildSubject()  

这种可以创建相应的Subject实例了，然后自己绑定到线程即可。在new Builder()时如果没有传入SecurityManager，自动调用SecurityUtils.getSecurityManager获取；也可以自己传入一个实例。

 

对于Subject我们一般这么使用：

1、身份验证（login）

2、授权（hasRole*/isPermitted*或checkRole*/checkPermission*）

3、将相应的数据存储到会话（Session）

4、切换身份（RunAs）/多线程身份传播

5、退出

 

 

而我们必须的功能就是1、2、5。到目前为止我们就可以使用Shiro进行应用程序的安全控制了，但是还是缺少如对Web验证、Java方法验证等的一些简化实现。    

@6@

Shiro提供了与Web集成的支持，其通过一个ShiroFilter入口来拦截需要安全控制的URL，然后进行相应的控制，ShiroFilter类似于如Strut2/SpringMVC这种web框架的前端控制器，其是安全控制的入口点，其负责读取配置（如ini配置文件），然后判断URL是否需要登录/权限等工作。

 

7.1 准备环境

1、创建webapp应用 

此处我们使用了jetty-maven-plugin和tomcat7-maven-plugin插件；这样可以直接使用“mvn jetty:run”或“mvn tomcat7:run”直接运行webapp了。然后通过URLhttp://localhost:8080/chapter7/访问即可。

 

2、依赖 

Servlet3

Java代码  

1. <dependency>  
2.     <groupId>javax.servlet</groupId>  
3.     <artifactId>javax.servlet-api</artifactId>  
4.     <version>3.0.1</version>  
5.     <scope>provided</scope>  
6. </dependency>   

Servlet3的知识可以参考https://github.com/zhangkaitao/servlet3-showcase及Servlet3规范http://www.iteye.com/blogs/subjects/Servlet-3-1。

 

shiro-web

Java代码  

1. <dependency>  
2.     <groupId>org.apache.shiro</groupId>  
3.     <artifactId>shiro-web</artifactId>  
4.     <version>1.2.2</version>  
5. </dependency>   

其他依赖请参考源码的pom.xml。

 

7.2 ShiroFilter入口

1、Shiro 1.1及以前版本配置方式  

Java代码  

1. <filter>  
2.     <filter-name>iniShiroFilter</filter-name>  
3.     <filter-class>org.apache.shiro.web.servlet.IniShiroFilter</filter-class>  
4.     <init-param>  
5.         <param-name>configPath</param-name>  
6.         <param-value>classpath:shiro.ini</param-value>  
7.     </init-param>  
8. </filter>  
9. <filter-mapping>  
10.     <filter-name>iniShiroFilter</filter-name>  
11.     <url-pattern>/*</url-pattern>  
12. </filter-mapping>   

1、使用IniShiroFilter作为Shiro安全控制的入口点，通过url-pattern指定需要安全的URL；

2、通过configPath指定ini配置文件位置，默认是先从/WEB-INF/shiro.ini加载，如果没有就默认加载classpath:shiro.ini，即默认相对于web应用上下文根路径；

3、也可以通过如下方式直接内嵌ini配置文件内容到web.xml

Java代码  

1. <init-param>  
2.     <param-name>config</param-name>  
3.     <param-value>  
4.         ini配置文件贴在这  
5.     </param-value>  
6. </init-param>  

 

2、Shiro 1.2及以后版本的配置方式

从Shiro 1.2开始引入了Environment/WebEnvironment的概念，即由它们的实现提供相应的SecurityManager及其相应的依赖。ShiroFilter会自动找到Environment然后获取相应的依赖。

Java代码  

1. <listener>  
2.    <listener-class>org.apache.shiro.web.env.EnvironmentLoaderListener</listener-class>  
3. </listener>   

通过EnvironmentLoaderListener来创建相应的WebEnvironment，并自动绑定到ServletContext，默认使用IniWebEnvironment实现。

 

可以通过如下配置修改默认实现及其加载的配置文件位置：

Java代码  

1. <context-param>  
2.    <param-name>shiroEnvironmentClass</param-name>  
3.    <param-value>org.apache.shiro.web.env.IniWebEnvironment</param-value>  
4. </context-param>  
5.     <context-param>  
6.         <param-name>shiroConfigLocations</param-name>  
7.         <param-value>classpath:shiro.ini</param-value>  
8.     </context-param>   

shiroConfigLocations默认是“/WEB-INF/shiro.ini”，IniWebEnvironment默认是先从/WEB-INF/shiro.ini加载，如果没有就默认加载classpath:shiro.ini。

 

3、与Spring集成

Java代码  

1. <filter>  
2.     <filter-name>shiroFilter</filter-name>  
3.     <filter-class>org.springframework.web.filter.DelegatingFilterProxy</filter-class>  
4.     <init-param>  
5.         <param-name>targetFilterLifecycle</param-name>  
6.         <param-value>true</param-value>  
7.     </init-param>  
8. </filter>  
9. <filter-mapping>  
10.     <filter-name>shiroFilter</filter-name>  
11.     <url-pattern>/*</url-pattern>  
12. </filter-mapping>   

DelegatingFilterProxy作用是自动到spring容器查找名字为shiroFilter（filter-name）的bean并把所有Filter的操作委托给它。然后将ShiroFilter配置到spring容器即可：

Java代码  

1. <bean id="shiroFilter" class="org.apache.shiro.spring.web.ShiroFilterFactoryBean">  
2. <property name="securityManager" ref="securityManager"/>  
3. <!—忽略其他，详见与Spring集成部分 -->  
4. </bean>   

最后不要忘了使用org.springframework.web.context.ContextLoaderListener加载这个spring配置文件即可。

因为我们现在的shiro版本是1.2的，因此之后的测试都是使用1.2的配置。

 

7.3 Web INI配置

ini配置部分和之前的相比将多出对url部分的配置。     

Java代码  

1. [main]  
2. #默认是/login.jsp  
3. authc.loginUrl=/login  
4. roles.unauthorizedUrl=/unauthorized  
5. perms.unauthorizedUrl=/unauthorized  
6. [users]  
7. zhang=123,admin  
8. wang=123  
9. [roles]  
10. admin=user:*,menu:*  
11. [urls]  
12. /login=anon  
13. /unauthorized=anon  
14. /static/**=anon  
15. /authenticated=authc  
16. /role=authc,roles[admin]  
17. /permission=authc,perms["user:create"]   

其中最重要的就是[urls]部分的配置，其格式是： “url=拦截器[参数]，拦截器[参数]”；即如果当前请求的url匹配[urls]部分的某个url模式，将会执行其配置的拦截器。比如anon拦截器表示匿名访问（即不需要登录即可访问）；authc拦截器表示需要身份认证通过后才能访问；roles[admin]拦截器表示需要有admin角色授权才能访问；而perms["user:create"]拦截器表示需要有“user:create”权限才能访问。

 

url模式使用Ant风格模式

Ant路径通配符支持?、*、**，注意通配符匹配不包括目录分隔符“/”：

?：匹配一个字符，如”/admin?”将匹配/admin1，但不匹配/admin或/admin2；

*：匹配零个或多个字符串，如/admin*将匹配/admin、/admin123，但不匹配/admin/1；

**：匹配路径中的零个或多个路径，如/admin/**将匹配/admin/a或/admin/a/b。

 

url模式匹配顺序

url模式匹配顺序是按照在配置中的声明顺序匹配，即从头开始使用第一个匹配的url模式对应的拦截器链。如：

Java代码  

1. /bb/**=filter1  
2. /bb/aa=filter2  
3. /**=filter3   

如果请求的url是“/bb/aa”，因为按照声明顺序进行匹配，那么将使用filter1进行拦截。

 

拦截器将在下一节详细介绍。接着我们来看看身份验证、授权及退出在web中如何实现。

 

1、身份验证（登录）

1.1、首先配置需要身份验证的url  

Java代码  

1. /authenticated=authc  
2. /role=authc,roles[admin]  
3. /permission=authc,perms["user:create"]   

即访问这些地址时会首先判断用户有没有登录，如果没有登录默会跳转到登录页面，默认是/login.jsp，可以通过在[main]部分通过如下配置修改： 

Java代码  

1. authc.loginUrl=/login  

 

1.2、登录Servlet（com.github.zhangkaitao.shiro.chapter7.web.servlet.LoginServlet） 

Java代码  

1. @WebServlet(name = "loginServlet", urlPatterns = "/login")  
2. public class LoginServlet extends HttpServlet {  
3.     @Override  
4.     protected void doGet(HttpServletRequest req, HttpServletResponse resp)  
5.       throws ServletException, IOException {  
6.         req.getRequestDispatcher("/WEB-INF/jsp/login.jsp").forward(req, resp);  
7.     }  
8.     @Override  
9.     protected void doPost(HttpServletRequest req, HttpServletResponse resp)  
10.       throws ServletException, IOException {  
11.         String error = null;  
12.         String username = req.getParameter("username");  
13.         String password = req.getParameter("password");  
14.         Subject subject = SecurityUtils.getSubject();  
15.         UsernamePasswordToken token = new UsernamePasswordToken(username, password);  
16.         try {  
17.             subject.login(token);  
18.         } catch (UnknownAccountException e) {  
19.             error = "用户名/密码错误";  
20.         } catch (IncorrectCredentialsException e) {  
21.             error = "用户名/密码错误";  
22.         } catch (AuthenticationException e) {  
23.             //其他错误，比如锁定，如果想单独处理请单独catch处理  
24.             error = "其他错误：" + e.getMessage();  
25.         }  
26.         if(error != null) {//出错了，返回登录页面  
27.             req.setAttribute("error", error);  
28.             req.getRequestDispatcher("/WEB-INF/jsp/login.jsp").forward(req, resp);  
29.         } else {//登录成功  
30.             req.getRequestDispatcher("/WEB-INF/jsp/loginSuccess.jsp").forward(req, resp);  
31.         }  
32.     }  
33. }   

1、doGet请求时展示登录页面；

2、doPost时进行登录，登录时收集username/password参数，然后提交给Subject进行登录。如果有错误再返回到登录页面；否则跳转到登录成功页面（此处应该返回到访问登录页面之前的那个页面，或者没有上一个页面时访问主页）。

3、JSP页面请参考源码。

 

1.3、测试

首先输入http://localhost:8080/chapter7/login进行登录，登录成功后接着可以访问http://localhost:8080/chapter7/authenticated来显示当前登录的用户： 

Java代码  

1. ${subject.principal}身份验证已通过。  

当前实现的一个缺点就是，永远返回到同一个成功页面（比如首页），在实际项目中比如支付时如果没有登录将跳转到登录页面，登录成功后再跳回到支付页面；对于这种功能大家可以在登录时把当前请求保存下来，然后登录成功后再重定向到该请求即可。

 

Shiro内置了登录（身份验证）的实现：基于表单的和基于Basic的验证，其通过拦截器实现。

 

2、基于Basic的拦截器身份验证

2.1、shiro-basicfilterlogin.ini配置 

Java代码  

1. [main]  
2. authcBasic.applicationName=please login  
3. ………省略users  
4. [urls]  
5. /role=authcBasic,roles[admin]   

 

1、authcBasic是org.apache.shiro.web.filter.authc.BasicHttpAuthenticationFilter类型的实例，其用于实现基于Basic的身份验证；applicationName用于弹出的登录框显示信息使用，如图：

2、[urls]部分配置了/role地址需要走authcBasic拦截器，即如果访问/role时还没有通过身份验证那么将弹出如上图的对话框进行登录，登录成功即可访问。

 

2.2、web.xml

把shiroConfigLocations改为shiro-basicfilterlogin.ini即可。

 

2.3、测试

输入http://localhost:8080/chapter7/role，会弹出之前的Basic验证对话框输入“zhang/123”即可登录成功进行访问。

 

3、基于表单的拦截器身份验证

基于表单的拦截器身份验证和【1】类似，但是更简单，因为其已经实现了大部分登录逻辑；我们只需要指定：登录地址/登录失败后错误信息存哪/成功的地址即可。

  

3.1、shiro-formfilterlogin.ini 

Java代码  

1. [main]  
2. authc.loginUrl=/formfilterlogin  
3. authc.usernameParam=username  
4. authc.passwordParam=password  
5. authc.successUrl=/  
6. authc.failureKeyAttribute=shiroLoginFailure  
7.   
8. [urls]  
9. /role=authc,roles[admin]   

1、authc是org.apache.shiro.web.filter.authc.FormAuthenticationFilter类型的实例，其用于实现基于表单的身份验证；通过loginUrl指定当身份验证时的登录表单；usernameParam指定登录表单提交的用户名参数名；passwordParam指定登录表单提交的密码参数名；successUrl指定登录成功后重定向的默认地址（默认是“/”）（如果有上一个地址会自动重定向带该地址）；failureKeyAttribute指定登录失败时的request属性key（默认shiroLoginFailure）；这样可以在登录表单得到该错误key显示相应的错误消息；

 

3.2、web.xml

把shiroConfigLocations改为shiro- formfilterlogin.ini即可。

 

3.3、登录Servlet 

Java代码  

1. @WebServlet(name = "formFilterLoginServlet", urlPatterns = "/formfilterlogin")  
2. public class FormFilterLoginServlet extends HttpServlet {  
3.     @Override  
4.     protected void doGet(HttpServletRequest req, HttpServletResponse resp)  
5.       throws ServletException, IOException {  
6.         doPost(req, resp);  
7.     }  
8.     @Override  
9.     protected void doPost(HttpServletRequest req, HttpServletResponse resp)  
10.      throws ServletException, IOException {  
11.         String errorClassName = (String)req.getAttribute("shiroLoginFailure");  
12.         if(UnknownAccountException.class.getName().equals(errorClassName)) {  
13.             req.setAttribute("error", "用户名/密码错误");  
14.         } else if(IncorrectCredentialsException.class.getName().equals(errorClassName)) {  
15.             req.setAttribute("error", "用户名/密码错误");  
16.         } else if(errorClassName != null) {  
17.             req.setAttribute("error", "未知错误：" + errorClassName);  
18.         }  
19.         req.getRequestDispatcher("/WEB-INF/jsp/formfilterlogin.jsp").forward(req, resp);  
20.     }  
21. }  

在登录Servlet中通过shiroLoginFailure得到authc登录失败时的异常类型名，然后根据此异常名来决定显示什么错误消息。

 

4、测试

输入http://localhost:8080/chapter7/role，会跳转到“/formfilterlogin”登录表单，提交表单如果authc拦截器登录成功后，会直接重定向会之前的地址“/role”；假设我们直接访问“/formfilterlogin”的话登录成功将直接到默认的successUrl。

 

4、授权（角色/权限验证）

4.1、shiro.ini   

Java代码  

1. [main]  
2. roles.unauthorizedUrl=/unauthorized  
3. perms.unauthorizedUrl=/unauthorized  
4.  [urls]  
5. /role=authc,roles[admin]  
6. /permission=authc,perms["user:create"]   

通过unauthorizedUrl属性指定如果授权失败时重定向到的地址。roles是org.apache.shiro.web.filter.authz.RolesAuthorizationFilter类型的实例，通过参数指定访问时需要的角色，如“[admin]”，如果有多个使用“，”分割，且验证时是hasAllRole验证，即且的关系。Perms是org.apache.shiro.web.filter.authz.PermissionsAuthorizationFilter类型的实例，和roles类似，只是验证权限字符串。

 

4.2、web.xml

把shiroConfigLocations改为shiro.ini即可。

 

4.3、RoleServlet/PermissionServlet  

Java代码  

1. @WebServlet(name = "permissionServlet", urlPatterns = "/permission")  
2. public class PermissionServlet extends HttpServlet {  
3.     @Override  
4.     protected void doGet(HttpServletRequest req, HttpServletResponse resp)  
5.       throws ServletException, IOException {  
6.         Subject subject = SecurityUtils.getSubject();  
7.         subject.checkPermission("user:create");  
8.         req.getRequestDispatcher("/WEB-INF/jsp/hasPermission.jsp").forward(req, resp);  
9.     }  
10. }  

Java代码  

1. @WebServlet(name = "roleServlet", urlPatterns = "/role")  
2. public class RoleServlet extends HttpServlet {  
3.     @Override  
4.     protected void doGet(HttpServletRequest req, HttpServletResponse resp)  
5.       throws ServletException, IOException {  
6.         Subject subject = SecurityUtils.getSubject();  
7.         subject.checkRole("admin");  
8.         req.getRequestDispatcher("/WEB-INF/jsp/hasRole.jsp").forward(req, resp);  
9.     }  
10. }   

 

4.4、测试

首先访问http://localhost:8080/chapter7/login，使用帐号“zhang/123”进行登录，再访问/role或/permission时会跳转到成功页面（因为其授权成功了）；如果使用帐号“wang/123”登录成功后访问这两个地址会跳转到“/unauthorized”即没有授权页面。

 

5、退出

5.1、shiro.ini 

Java代码  

1. [urls]  
2. /logout=anon   

指定/logout使用anon拦截器即可，即不需要登录即可访问。

 

5.2、LogoutServlet

Java代码  

1. @WebServlet(name = "logoutServlet", urlPatterns = "/logout")  
2. public class LogoutServlet extends HttpServlet {  
3.     protected void doGet(HttpServletRequest req, HttpServletResponse resp)  
4.       throws ServletException, IOException {  
5.         SecurityUtils.getSubject().logout();  
6.         req.getRequestDispatcher("/WEB-INF/jsp/logoutSuccess.jsp").forward(req, resp);  
7.     }  
8. }   

直接调用Subject.logout即可，退出成功后转发/重定向到相应页面即可。

 

5.3、测试

首先访问http://localhost:8080/chapter7/login，使用帐号“zhang/123”进行登录，登录成功后访问/logout即可退出。

 

Shiro也提供了logout拦截器用于退出，其是org.apache.shiro.web.filter.authc.LogoutFilter类型的实例，我们可以在shiro.ini配置文件中通过如下配置完成退出：

Java代码  

1. [main]  
2. logout.redirectUrl=/login  
3.   
4. [urls]  
5. /logout2=logout   

通过logout.redirectUrl指定退出后重定向的地址；通过/logout2=logout指定退出url是/logout2。这样当我们登录成功后然后访问/logout2即可退出。

@7@

8.1 拦截器介绍

Shiro使用了与Servlet一样的Filter接口进行扩展；所以如果对Filter不熟悉可以参考《Servlet3.1规范》http://www.iteye.com/blogs/subjects/Servlet-3-1了解Filter的工作原理。首先下图是Shiro拦截器的基础类图：

1、NameableFilter

NameableFilter给Filter起个名字，如果没有设置默认就是FilterName；还记得之前的如authc吗？当我们组装拦截器链时会根据这个名字找到相应的拦截器实例；

 

2、OncePerRequestFilter

OncePerRequestFilter用于防止多次执行Filter的；也就是说一次请求只会走一次拦截器链；另外提供enabled属性，表示是否开启该拦截器实例，默认enabled=true表示开启，如果不想让某个拦截器工作，可以设置为false即可。

 

3、ShiroFilter

ShiroFilter是整个Shiro的入口点，用于拦截需要安全控制的请求进行处理，这个之前已经用过了。

 

4、AdviceFilter

AdviceFilter提供了AOP风格的支持，类似于SpringMVC中的Interceptor：

Java代码  

1. boolean preHandle(ServletRequest request, ServletResponse response) throws Exception  
2. void postHandle(ServletRequest request, ServletResponse response) throws Exception  
3. void afterCompletion(ServletRequest request, ServletResponse response, Exception exception) throws Exception;   

preHandler：类似于AOP中的前置增强；在拦截器链执行之前执行；如果返回true则继续拦截器链；否则中断后续的拦截器链的执行直接返回；进行预处理（如基于表单的身份验证、授权）

postHandle：类似于AOP中的后置返回增强；在拦截器链执行完成后执行；进行后处理（如记录执行时间之类的）；

afterCompletion：类似于AOP中的后置最终增强；即不管有没有异常都会执行；可以进行清理资源（如接触Subject与线程的绑定之类的）；

 

5、PathMatchingFilter

PathMatchingFilter提供了基于Ant风格的请求路径匹配功能及拦截器参数解析的功能，如“roles[admin,user]”自动根据“，”分割解析到一个路径参数配置并绑定到相应的路径：

Java代码  

1. boolean pathsMatch(String path, ServletRequest request)  
2. boolean onPreHandle(ServletRequest request, ServletResponse response, Object mappedValue) throws Exception   

pathsMatch：该方法用于path与请求路径进行匹配的方法；如果匹配返回true；

onPreHandle：在preHandle中，当pathsMatch匹配一个路径后，会调用opPreHandler方法并将路径绑定参数配置传给mappedValue；然后可以在这个方法中进行一些验证（如角色授权），如果验证失败可以返回false中断流程；默认返回true；也就是说子类可以只实现onPreHandle即可，无须实现preHandle。如果没有path与请求路径匹配，默认是通过的（即preHandle返回true）。

 

6、AccessControlFilter

AccessControlFilter提供了访问控制的基础功能；比如是否允许访问/当访问拒绝时如何处理等：

Java代码  

1. abstract boolean isAccessAllowed(ServletRequest request, ServletResponse response, Object mappedValue) throws Exception;  
2. boolean onAccessDenied(ServletRequest request, ServletResponse response, Object mappedValue) throws Exception;  
3. abstract boolean onAccessDenied(ServletRequest request, ServletResponse response) throws Exception;   

isAccessAllowed：表示是否允许访问；mappedValue就是[urls]配置中拦截器参数部分，如果允许访问返回true，否则false；

onAccessDenied：表示当访问拒绝时是否已经处理了；如果返回true表示需要继续处理；如果返回false表示该拦截器实例已经处理了，将直接返回即可。

 

onPreHandle会自动调用这两个方法决定是否继续处理：

Java代码  

1. boolean onPreHandle(ServletRequest request, ServletResponse response, Object mappedValue) throws Exception {  
2.     return isAccessAllowed(request, response, mappedValue) || onAccessDenied(request, response, mappedValue);  
3. }   

另外AccessControlFilter还提供了如下方法用于处理如登录成功后/重定向到上一个请求： 

Java代码  

1. void setLoginUrl(String loginUrl) //身份验证时使用，默认/login.jsp  
2. String getLoginUrl()  
3. Subject getSubject(ServletRequest request, ServletResponse response) //获取Subject实例  
4. boolean isLoginRequest(ServletRequest request, ServletResponse response)//当前请求是否是登录请求  
5. void saveRequestAndRedirectToLogin(ServletRequest request, ServletResponse response) throws IOException //将当前请求保存起来并重定向到登录页面  
6. void saveRequest(ServletRequest request) //将请求保存起来，如登录成功后再重定向回该请求  
7. void redirectToLogin(ServletRequest request, ServletResponse response) //重定向到登录页面   

比如基于表单的身份验证就需要使用这些功能。

 

到此基本的拦截器就完事了，如果我们想进行访问访问的控制就可以继承AccessControlFilter；如果我们要添加一些通用数据我们可以直接继承PathMatchingFilter。

 

8.2 拦截器链

Shiro对Servlet容器的FilterChain进行了代理，即ShiroFilter在继续Servlet容器的Filter链的执行之前，通过ProxiedFilterChain对Servlet容器的FilterChain进行了代理；即先走Shiro自己的Filter体系，然后才会委托给Servlet容器的FilterChain进行Servlet容器级别的Filter链执行；Shiro的ProxiedFilterChain执行流程：1、先执行Shiro自己的Filter链；2、再执行Servlet容器的Filter链（即原始的Filter）。

而ProxiedFilterChain是通过FilterChainResolver根据配置文件中[urls]部分是否与请求的URL是否匹配解析得到的。 

Java代码  

1. FilterChain getChain(ServletRequest request, ServletResponse response, FilterChain originalChain);  

即传入原始的chain得到一个代理的chain。

Shiro内部提供了一个路径匹配的FilterChainResolver实现：PathMatchingFilterChainResolver，其根据[urls]中配置的url模式（默认Ant风格）=拦截器链和请求的url是否匹配来解析得到配置的拦截器链的；而PathMatchingFilterChainResolver内部通过FilterChainManager维护着拦截器链，比如DefaultFilterChainManager实现维护着url模式与拦截器链的关系。因此我们可以通过FilterChainManager进行动态动态增加url模式与拦截器链的关系。

 

DefaultFilterChainManager会默认添加org.apache.shiro.web.filter.mgt.DefaultFilter中声明的拦截器：

Java代码  

1. public enum DefaultFilter {  
2.     anon(AnonymousFilter.class),  
3.     authc(FormAuthenticationFilter.class),  
4.     authcBasic(BasicHttpAuthenticationFilter.class),  
5.     logout(LogoutFilter.class),  
6.     noSessionCreation(NoSessionCreationFilter.class),  
7.     perms(PermissionsAuthorizationFilter.class),  
8.     port(PortFilter.class),  
9.     rest(HttpMethodPermissionFilter.class),  
10.     roles(RolesAuthorizationFilter.class),  
11.     ssl(SslFilter.class),  
12.     user(UserFilter.class);  
13. }   

下一节会介绍这些拦截器的作用。

 

如果要注册自定义拦截器，IniSecurityManagerFactory/WebIniSecurityManagerFactory在启动时会自动扫描ini配置文件中的[filters]/[main]部分并注册这些拦截器到DefaultFilterChainManager；且创建相应的url模式与其拦截器关系链。如果使用Spring后续章节会介绍如果注册自定义拦截器。

 

如果想自定义FilterChainResolver，可以通过实现WebEnvironment接口完成：

Java代码  

1. public class MyIniWebEnvironment extends IniWebEnvironment {  
2.     @Override  
3.     protected FilterChainResolver createFilterChainResolver() {  
4.         //在此处扩展自己的FilterChainResolver  
5.         return super.createFilterChainResolver();  
6.     }  
7. }   

FilterChain之间的关系。如果想动态实现url-拦截器的注册，就可以通过实现此处的FilterChainResolver来完成，比如：

Java代码  

1. //1、创建FilterChainResolver  
2. PathMatchingFilterChainResolver filterChainResolver =  
3.         new PathMatchingFilterChainResolver();  
4. //2、创建FilterChainManager  
5. DefaultFilterChainManager filterChainManager = new DefaultFilterChainManager();  
6. //3、注册Filter  
7. for(DefaultFilter filter : DefaultFilter.values()) {  
8.     filterChainManager.addFilter(  
9.         filter.name(), (Filter) ClassUtils.newInstance(filter.getFilterClass()));  
10. }  
11. //4、注册URL-Filter的映射关系  
12. filterChainManager.addToChain("/login.jsp", "authc");  
13. filterChainManager.addToChain("/unauthorized.jsp", "anon");  
14. filterChainManager.addToChain("/**", "authc");  
15. filterChainManager.addToChain("/**", "roles", "admin");  
16.   
17. //5、设置Filter的属性  
18. FormAuthenticationFilter authcFilter =  
19.          (FormAuthenticationFilter)filterChainManager.getFilter("authc");  
20. authcFilter.setLoginUrl("/login.jsp");  
21. RolesAuthorizationFilter rolesFilter =  
22.           (RolesAuthorizationFilter)filterChainManager.getFilter("roles");  
23. rolesFilter.setUnauthorizedUrl("/unauthorized.jsp");  
24.   
25. filterChainResolver.setFilterChainManager(filterChainManager);  
26. return filterChainResolver;   

此处自己去实现注册filter，及url模式与filter之间的映射关系。可以通过定制FilterChainResolver或FilterChainManager来完成诸如动态URL匹配的实现。

 

然后再web.xml中进行如下配置Environment：  

Java代码  

1. <context-param>  
2. <param-name>shiroEnvironmentClass</param-name> <param-value>com.github.zhangkaitao.shiro.chapter8.web.env.MyIniWebEnvironment</param-value>  
3. </context-param>   

 

8.3 自定义拦截器

通过自定义自己的拦截器可以扩展一些功能，诸如动态url-角色/权限访问控制的实现、根据Subject身份信息获取用户信息绑定到Request（即设置通用数据）、验证码验证、在线用户信息的保存等等，因为其本质就是一个Filter；所以Filter能做的它就能做。

 

对于Filter的介绍请参考《Servlet规范》中的Filter部分：

http://www.iteye.com/blogs/subjects/Servlet-3-1。

 

1、扩展OncePerRequestFilter

OncePerRequestFilter保证一次请求只调用一次doFilterInternal，即如内部的forward不会再多执行一次doFilterInternal： 

Java代码  

1. public class MyOncePerRequestFilter extends OncePerRequestFilter {  
2.     @Override  
3.     protected void doFilterInternal(ServletRequest request, ServletResponse response, FilterChain chain) throws ServletException, IOException {  
4.         System.out.println("=========once per request filter");  
5.         chain.doFilter(request, response);  
6.     }  
7. }   

然后再shiro.ini配置文件中：

Java代码  

1. [main]  
2. myFilter1=com.github.zhangkaitao.shiro.chapter8.web.filter.MyOncePerRequestFilter  
3. #[filters]  
4. #myFilter1=com.github.zhangkaitao.shiro.chapter8.web.filter.MyOncePerRequestFilter  
5. [urls]  
6. /**=myFilter1   

Filter可以在[main]或[filters]部分注册，然后在[urls]部分配置url与filter的映射关系即可。

 

2、扩展AdviceFilter

AdviceFilter提供了AOP的功能，其实现和SpringMVC中的Interceptor思想一样：具体可参考我的SpringMVC教程中的处理器拦截器部分：

http://www.iteye.com/blogs/subjects/kaitao-springmvc

Java代码  

1. public class MyAdviceFilter extends AdviceFilter {  
2.     @Override  
3.     protected boolean preHandle(ServletRequest request, ServletResponse response) throws Exception {  
4.         System.out.println("====预处理/前置处理");  
5.         return true;//返回false将中断后续拦截器链的执行  
6.     }  
7.     @Override  
8.     protected void postHandle(ServletRequest request, ServletResponse response) throws Exception {  
9.         System.out.println("====后处理/后置返回处理");  
10.     }  
11.     @Override  
12.     public void afterCompletion(ServletRequest request, ServletResponse response, Exception exception) throws Exception {  
13.         System.out.println("====完成处理/后置最终处理");  
14.     }  
15. }   

preHandle：进行请求的预处理，然后根据返回值决定是否继续处理（true：继续过滤器链）；可以通过它实现权限控制；

postHandle：执行完拦截器链之后正常返回后执行；

afterCompletion：不管最后有没有异常，afterCompletion都会执行，完成如清理资源功能。

 

然后在shiro.ini中进行如下配置： 

Java代码  

1. [filters]  
2. myFilter1=com.github.zhangkaitao.shiro.chapter8.web.filter.MyOncePerRequestFilter  
3. myFilter2=com.github.zhangkaitao.shiro.chapter8.web.filter.MyAdviceFilter  
4. [urls]  
5. /**=myFilter1,myFilter2   

该过滤器的具体使用可参考我的SpringMVC教程中的处理器拦截器部分。

 

3、PathMatchingFilter

PathMatchingFilter继承了AdviceFilter，提供了url模式过滤的功能，如果需要对指定的请求进行处理，可以扩展PathMatchingFilter： 

Java代码  

1. public class MyPathMatchingFilter extends PathMatchingFilter {  
2.     @Override  
3.     protected boolean onPreHandle(ServletRequest request, ServletResponse response, Object mappedValue) throws Exception {  
4.        System.out.println("url matches,config is " + Arrays.toString((String[])mappedValue));  
5.        return true;  
6.     }  
7. }   

preHandle：会进行url模式与请求url进行匹配，如果匹配会调用onPreHandle；如果没有配置url模式/没有url模式匹配，默认直接返回true；

onPreHandle：如果url模式与请求url匹配，那么会执行onPreHandle，并把该拦截器配置的参数传入。默认什么不处理直接返回true。

 

然后在shiro.ini中进行如下配置：

Java代码  

1. [filters]  
2. myFilter3=com.github.zhangkaitao.shiro.chapter8.web.filter.MyPathMatchingFilter  
3. [urls]  
4. /**= myFilter3[config]   

/**就是注册给PathMatchingFilter的url模式，config就是拦截器的配置参数，多个之间逗号分隔，onPreHandle使用mappedValue接收参数值。

 

4、扩展AccessControlFilter

AccessControlFilter继承了PathMatchingFilter，并扩展了了两个方法：

Java代码  

1. public boolean onPreHandle(ServletRequest request, ServletResponse response, Object mappedValue) throws Exception {  
2.     return isAccessAllowed(request, response, mappedValue)  
3.      || onAccessDenied(request, response, mappedValue);  
4. }   

isAccessAllowed：即是否允许访问，返回true表示允许；

onAccessDenied：表示访问拒绝时是否自己处理，如果返回true表示自己不处理且继续拦截器链执行，返回false表示自己已经处理了（比如重定向到另一个页面）。

   

Java代码  

1. public class MyAccessControlFilter extends AccessControlFilter {  
2.     protected boolean isAccessAllowed(ServletRequest request, ServletResponse response, Object mappedValue) throws Exception {  
3.         System.out.println("access allowed");  
4.         return true;  
5.     }  
6.     protected boolean onAccessDenied(ServletRequest request, ServletResponse response) throws Exception {  
7.         System.out.println("访问拒绝也不自己处理，继续拦截器链的执行");  
8.         return true;  
9.     }  
10. }   

然后在shiro.ini中进行如下配置：

Java代码  

1. [filters]  
2. myFilter4=com.github.zhangkaitao.shiro.chapter8.web.filter.MyAccessControlFilter  
3. [urls]  
4. /**=myFilter4  

  

5、基于表单登录拦截器 

之前我们已经使用过Shiro内置的基于表单登录的拦截器了，此处自己做一个类似的基于表单登录的拦截器。

Java代码  

1. public class FormLoginFilter extends PathMatchingFilter {  
2.     private String loginUrl = "/login.jsp";  
3.     private String successUrl = "/";  
4.     @Override  
5.     protected boolean onPreHandle(ServletRequest request, ServletResponse response, Object mappedValue) throws Exception {  
6.         if(SecurityUtils.getSubject().isAuthenticated()) {  
7.             return true;//已经登录过  
8.         }  
9.         HttpServletRequest req = (HttpServletRequest) request;  
10.         HttpServletResponse resp = (HttpServletResponse) response;  
11.         if(isLoginRequest(req)) {  
12.             if("post".equalsIgnoreCase(req.getMethod())) {//form表单提交  
13.                 boolean loginSuccess = login(req); //登录  
14.                 if(loginSuccess) {  
15.                     return redirectToSuccessUrl(req, resp);  
16.                 }  
17.             }  
18.             return true;//继续过滤器链  
19.         } else {//保存当前地址并重定向到登录界面  
20.             saveRequestAndRedirectToLogin(req, resp);  
21.             return false;  
22.         }  
23.     }  
24.     private boolean redirectToSuccessUrl(HttpServletRequest req, HttpServletResponse resp) throws IOException {  
25.         WebUtils.redirectToSavedRequest(req, resp, successUrl);  
26.         return false;  
27.     }  
28.     private void saveRequestAndRedirectToLogin(HttpServletRequest req, HttpServletResponse resp) throws IOException {  
29.         WebUtils.saveRequest(req);  
30.         WebUtils.issueRedirect(req, resp, loginUrl);  
31.     }  
32.   
33.     private boolean login(HttpServletRequest req) {  
34.         String username = req.getParameter("username");  
35.         String password = req.getParameter("password");  
36.         try {  
37.             SecurityUtils.getSubject().login(new UsernamePasswordToken(username, password));  
38.         } catch (Exception e) {  
39.             req.setAttribute("shiroLoginFailure", e.getClass());  
40.             return false;  
41.         }  
42.         return true;  
43.     }  
44.     private boolean isLoginRequest(HttpServletRequest req) {  
45.         return pathsMatch(loginUrl, WebUtils.getPathWithinApplication(req));  
46.     }  
47. }   

onPreHandle主要流程：

1、首先判断是否已经登录过了，如果已经登录过了继续拦截器链即可；

2、如果没有登录，看看是否是登录请求，如果是get方法的登录页面请求，则继续拦截器链（到请求页面），否则如果是get方法的其他页面请求则保存当前请求并重定向到登录页面；

3、如果是post方法的登录页面表单提交请求，则收集用户名/密码登录即可，如果失败了保存错误消息到“shiroLoginFailure”并返回到登录页面；

4、如果登录成功了，且之前有保存的请求，则重定向到之前的这个请求，否则到默认的成功页面。

 

shiro.ini配置

Java代码  

1. [filters]  
2. formLogin=com.github.zhangkaitao.shiro.chapter8.web.filter.FormLoginFilter  
3. [urls]  
4. /test.jsp=formLogin  
5. /login.jsp=formLogin   

启动服务器输入http://localhost:8080/chapter8/test.jsp测试时，会自动跳转到登录页面，登录成功后又会跳回到test.jsp页面。

 

此处可以通过继承AuthenticatingFilter实现，其提供了很多登录相关的基础代码。另外可以参考Shiro内嵌的FormAuthenticationFilter的源码，思路是一样的。

 

6、任意角色授权拦截器

Shiro提供roles拦截器，其验证用户拥有所有角色，没有提供验证用户拥有任意角色的拦截器。

Java代码  

1. public class AnyRolesFilter extends AccessControlFilter {  
2.     private String unauthorizedUrl = "/unauthorized.jsp";  
3.     private String loginUrl = "/login.jsp";  
4.     protected boolean isAccessAllowed(ServletRequest request, ServletResponse response, Object mappedValue) throws Exception {  
5.         String[] roles = (String[])mappedValue;  
6.         if(roles == null) {  
7.             return true;//如果没有设置角色参数，默认成功  
8.         }  
9.         for(String role : roles) {  
10.             if(getSubject(request, response).hasRole(role)) {  
11.                 return true;  
12.             }  
13.         }  
14.         return false;//跳到onAccessDenied处理  
15.     }  
16.   
17.     @Override  
18.     protected boolean onAccessDenied(ServletRequest request, ServletResponse response) throws Exception {  
19.         Subject subject = getSubject(request, response);  
20.         if (subject.getPrincipal() == null) {//表示没有登录，重定向到登录页面  
21.             saveRequest(request);  
22.             WebUtils.issueRedirect(request, response, loginUrl);  
23.         } else {  
24.             if (StringUtils.hasText(unauthorizedUrl)) {//如果有未授权页面跳转过去  
25.                 WebUtils.issueRedirect(request, response, unauthorizedUrl);  
26.             } else {//否则返回401未授权状态码  
27.                 WebUtils.toHttp(response).sendError(HttpServletResponse.SC_UNAUTHORIZED);  
28.             }  
29.         }  
30.         return false;  
31.     }  
32. }   

流程：

1、首先判断用户有没有任意角色，如果没有返回false，将到onAccessDenied进行处理；

2、如果用户没有角色，接着判断用户有没有登录，如果没有登录先重定向到登录；

3、如果用户没有角色且设置了未授权页面（unauthorizedUrl），那么重定向到未授权页面；否则直接返回401未授权错误码。

 

shiro.ini配置

Java代码  

1. [filters]  
2. anyRoles=com.github.zhangkaitao.shiro.chapter8.web.filter.AnyRolesFilter  
3. [urls]  
4. /test.jsp=formLogin,anyRoles[admin,user]  
5. /login.jsp=formLogin   

此处可以继承AuthorizationFilter实现，其提供了授权相关的基础代码。另外可以参考Shiro内嵌的RolesAuthorizationFilter的源码，只是实现hasAllRoles逻辑。

 

8.4 默认拦截器

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

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

 

另外还提供了一个org.apache.shiro.web.filter.authz.HostFilter，即主机拦截器，比如其提供了属性：authorizedIps：已授权的ip地址，deniedIps：表示拒绝的ip地址；不过目前还没有完全实现，不可用。

 

这些默认的拦截器会自动注册，可以直接在ini配置文件中通过“拦截器名.属性”设置其属性：

Java代码  

1. perms.unauthorizedUrl=/unauthorized  

另外如果某个拦截器不想使用了可以直接通过如下配置直接禁用：

Java代码  

1. perms.enabled=false  

@8@

Shiro提供了JSTL标签用于在JSP/GSP页面进行权限控制，如根据登录用户显示相应的页面按钮。

 

 

导入标签库

Java代码  

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

标签库定义在shiro-web.jar包下的META-INF/shiro.tld中定义。

 

guest标签 

Java代码  

1. <shiro:guest>  
2. 欢迎游客访问，<a href="${pageContext.request.contextPath}/login.jsp">登录</a>  
3. </shiro:guest>   

 

用户没有身份验证时显示相应信息，即游客访问信息。

 

user标签 

Java代码  

1. <shiro:user>  
2. 欢迎[<shiro:principal/>]登录，<a href="${pageContext.request.contextPath}/logout">退出</a>  
3. </shiro:user>   

用户已经身份验证/记住我登录后显示相应的信息。

  

authenticated标签 

Java代码  

1. <shiro:authenticated>  
2.     用户[<shiro:principal/>]已身份验证通过  
3. </shiro:authenticated>   

用户已经身份验证通过，即Subject.login登录成功，不是记住我登录的。    

 

notAuthenticated标签

<shiro:notAuthenticated>    未身份验证（包括记住我）</shiro:notAuthenticated> 

用户已经身份验证通过，即没有调用Subject.login进行登录，包括记住我自动登录的也属于未进行身份验证。 

 

principal标签 

<shiro: principal/>

显示用户身份信息，默认调用Subject.getPrincipal()获取，即Primary Principal。

 

Java代码 

1. <shiro:principal type="java.lang.String"/>  

相当于Subject.getPrincipals().oneByType(String.class)。 

 

Java代码 

1. <shiro:principal type="java.lang.String"/>  

相当于Subject.getPrincipals().oneByType(String.class)。

 

Java代码 

1. <shiro:principal property="username"/>  

相当于((User)Subject.getPrincipals()).getUsername()。   

 

hasRole标签 

Java代码 

1. <shiro:hasRole name="admin">  
2.     用户[<shiro:principal/>]拥有角色admin<br/>  
3. </shiro:hasRole>   

如果当前Subject有角色将显示body体内容。

 

hasAnyRoles标签 

Java代码 

1. <shiro:hasAnyRoles name="admin,user">  
2.     用户[<shiro:principal/>]拥有角色admin或user<br/>  
3. </shiro:hasAnyRoles>   

如果当前Subject有任意一个角色（或的关系）将显示body体内容。 

 

lacksRole标签 

Java代码 

1. <shiro:lacksRole name="abc">  
2.     用户[<shiro:principal/>]没有角色abc<br/>  
3. </shiro:lacksRole>   

如果当前Subject没有角色将显示body体内容。 

  

hasPermission标签

Java代码 

1. <shiro:hasPermission name="user:create">  
2.     用户[<shiro:principal/>]拥有权限user:create<br/>  
3. </shiro:hasPermission>   

如果当前Subject有权限将显示body体内容。 

  

lacksPermission标签

Java代码 

1. <shiro:lacksPermission name="org:create">  
2.     用户[<shiro:principal/>]没有权限org:create<br/>  
3. </shiro:lacksPermission>   

如果当前Subject没有权限将显示body体内容。

 

另外又提供了几个权限控制相关的标签：

 

导入自定义标签库 

Java代码 

1. <%@taglib prefix="zhang" tagdir="/WEB-INF/tags" %>  

 

示例

Java代码 

1. <zhang:hasAllRoles name="admin,user">  
2.     用户[<shiro:principal/>]拥有角色admin和user<br/>  
3. </zhang:hasAllRoles>  
4. <zhang:hasAllPermissions name="user:create,user:update">  
5.     用户[<shiro:principal/>]拥有权限user:create和user:update<br/>  
6. </zhang:hasAllPermissions>  
7. <zhang:hasAnyPermissions name="user:create,abc:update">  
8.     用户[<shiro:principal/>]拥有权限user:create或abc:update<br/>  
9. </zhang:hasAnyPermissions>   

hasAllRoles表示拥有所有相关的角色；hasAllPermissions表示拥有所有相关的权限；hasAnyPermissions表示拥有任意一个相关的权限。

 

另外可以参考我的《简单shiro扩展实现NOT、AND、OR权限验证》实现NOT、AND、OR权限验证：http://jinnianshilongnian.iteye.com/blog/1864800。

@9@

Shiro提供了完整的企业级会话管理功能，不依赖于底层容器（如web容器tomcat），不管JavaSE还是JavaEE环境都可以使用，提供了会话管理、会话事件监听、会话存储/持久化、容器无关的集群、失效/过期支持、对Web的透明支持、SSO单点登录的支持等特性。即直接使用Shiro的会话管理可以直接替换如Web容器的会话管理。

 

会话

所谓会话，即用户访问应用时保持的连接关系，在多次交互中应用能够识别出当前访问的用户是谁，且可以在多次交互中保存一些数据。如访问一些网站时登录成功后，网站可以记住用户，且在退出之前都可以识别当前用户是谁。

 

 

Shiro的会话支持不仅可以在普通的JavaSE应用中使用，也可以在JavaEE应用中使用，如web应用。且使用方式是一致的。 

Java代码  

1. login("classpath:shiro.ini", "zhang", "123");  
2. Subject subject = SecurityUtils.getSubject();  
3. Session session = subject.getSession();   

登录成功后使用Subject.getSession()即可获取会话；其等价于Subject.getSession(true)，即如果当前没有创建Session对象会创建一个；另外Subject.getSession(false)，如果当前没有创建Session则返回null（不过默认情况下如果启用会话存储功能的话在创建Subject时会主动创建一个Session）。

 

Java代码  

1. session.getId();  

获取当前会话的唯一标识。

  

Java代码  

1. session.getHost();  

获取当前Subject的主机地址，该地址是通过HostAuthenticationToken.getHost()提供的。 

 

Java代码  

1. session.getTimeout();  
2. session.setTimeout(毫秒);   

获取/设置当前Session的过期时间；如果不设置默认是会话管理器的全局过期时间。

  

Java代码  

1. session.getStartTimestamp();  
2. session.getLastAccessTime();  

获取会话的启动时间及最后访问时间；如果是JavaSE应用需要自己定期调用session.touch()去更新最后访问时间；如果是Web应用，每次进入ShiroFilter都会自动调用session.touch()来更新最后访问时间。    

 

Java代码  

1. session.touch();  
2. session.stop();   

更新会话最后访问时间及销毁会话；当Subject.logout()时会自动调用stop方法来销毁会话。如果在web中，调用javax.servlet.http.HttpSession. invalidate()也会自动调用Shiro Session.stop方法进行销毁Shiro的会话。 

 

Java代码  

1. session.setAttribute("key", "123");  
2. Assert.assertEquals("123", session.getAttribute("key"));  
3. session.removeAttribute("key");  

设置/获取/删除会话属性；在整个会话范围内都可以对这些属性进行操作。 

 

Shiro提供的会话可以用于JavaSE/JavaEE环境，不依赖于任何底层容器，可以独立使用，是完整的会话模块。

 

会话管理器

会话管理器管理着应用中所有Subject的会话的创建、维护、删除、失效、验证等工作。是Shiro的核心组件，顶层组件SecurityManager直接继承了SessionManager，且提供了SessionsSecurityManager实现直接把会话管理委托给相应的SessionManager，DefaultSecurityManager及DefaultWebSecurityManager默认SecurityManager都继承了SessionsSecurityManager。

 

 

SecurityManager提供了如下接口：

 

Java代码  

1. Session start(SessionContext context); //启动会话  
2. Session getSession(SessionKey key) throws SessionException; //根据会话Key获取会话   

 

另外用于Web环境的WebSessionManager又提供了如下接口：

 

Java代码  

1. boolean isServletContainerSessions();//是否使用Servlet容器的会话  

 

Shiro还提供了ValidatingSessionManager用于验资并过期会话： 

Java代码  

1. void validateSessions();//验证所有会话是否过期  

 

Shiro提供了三个默认实现：

DefaultSessionManager：DefaultSecurityManager使用的默认实现，用于JavaSE环境；

ServletContainerSessionManager：DefaultWebSecurityManager使用的默认实现，用于Web环境，其直接使用Servlet容器的会话；

DefaultWebSessionManager：用于Web环境的实现，可以替代ServletContainerSessionManager，自己维护着会话，直接废弃了Servlet容器的会话管理。

 

替换SecurityManager默认的SessionManager可以在ini中配置（shiro.ini）：

 

Java代码  

1. [main]  
2. sessionManager=org.apache.shiro.session.mgt.DefaultSessionManager  
3. securityManager.sessionManager=$sessionManager   

 

 

Web环境下的ini配置(shiro-web.ini)：

 

<!--EndFragment-->

 

Java代码  

1. [main]  
2. sessionManager=org.apache.shiro.web.session.mgt.ServletContainerSessionManager  
3. securityManager.sessionManager=$sessionManager  

   

 

另外可以设置会话的全局过期时间（毫秒为单位），默认30分钟：

 

Java代码  

1. sessionManager. globalSessionTimeout=1800000   

 

默认情况下globalSessionTimeout将应用给所有Session。可以单独设置每个Session的timeout属性来为每个Session设置其超时时间。

 

另外如果使用ServletContainerSessionManager进行会话管理，Session的超时依赖于底层Servlet容器的超时时间，可以在web.xml中配置其会话的超时时间（分钟为单位）： 

Java代码  

1. <session-config>  
2.   <session-timeout>30</session-timeout>  
3. </session-config>  

  

在Servlet容器中，默认使用JSESSIONID Cookie维护会话，且会话默认是跟容器绑定的；在某些情况下可能需要使用自己的会话机制，此时我们可以使用DefaultWebSessionManager来维护会话：

Java代码  

1. sessionIdCookie=org.apache.shiro.web.servlet.SimpleCookie  
2. sessionManager=org.apache.shiro.web.session.mgt.DefaultWebSessionManager  
3. sessionIdCookie.name=sid  
4. #sessionIdCookie.domain=sishuok.com  
5. #sessionIdCookie.path=  
6. sessionIdCookie.maxAge=1800  
7. sessionIdCookie.httpOnly=true  
8. sessionManager.sessionIdCookie=$sessionIdCookie  
9. sessionManager.sessionIdCookieEnabled=true  
10. securityManager.sessionManager=$sessionManager   

sessionIdCookie是sessionManager创建会话Cookie的模板：

sessionIdCookie.name：设置Cookie名字，默认为JSESSIONID；

sessionIdCookie.domain：设置Cookie的域名，默认空，即当前访问的域名；

sessionIdCookie.path：设置Cookie的路径，默认空，即存储在域名根下；

sessionIdCookie.maxAge：设置Cookie的过期时间，秒为单位，默认-1表示关闭浏览器时过期Cookie；

sessionIdCookie.httpOnly：如果设置为true，则客户端不会暴露给客户端脚本代码，使用HttpOnly cookie有助于减少某些类型的跨站点脚本攻击；此特性需要实现了Servlet 2.5 MR6及以上版本的规范的Servlet容器支持；

sessionManager.sessionIdCookieEnabled：是否启用/禁用Session Id Cookie，默认是启用的；如果禁用后将不会设置Session Id Cookie，即默认使用了Servlet容器的JSESSIONID，且通过URL重写（URL中的“;JSESSIONID=id”部分）保存Session Id。

 

另外我们可以如“sessionManager. sessionIdCookie.name=sid”这种方式操作Cookie模板。

 

会话监听器

会话监听器用于监听会话创建、过期及停止事件： 

Java代码  

1. public class MySessionListener1 implements SessionListener {  
2.     @Override  
3.     public void onStart(Session session) {//会话创建时触发  
4.         System.out.println("会话创建：" + session.getId());  
5.     }  
6.     @Override  
7.     public void onExpiration(Session session) {//会话过期时触发  
8.         System.out.println("会话过期：" + session.getId());  
9.     }  
10.     @Override  
11.     public void onStop(Session session) {//退出/会话过期时触发  
12.         System.out.println("会话停止：" + session.getId());  
13.     }    
14. }  

 

如果只想监听某一个事件，可以继承SessionListenerAdapter实现：

Java代码  

1. public class MySessionListener2 extends SessionListenerAdapter {  
2.     @Override  
3.     public void onStart(Session session) {  
4.         System.out.println("会话创建：" + session.getId());  
5.     }  
6. }  

 

在shiro-web.ini配置文件中可以进行如下配置设置会话监听器：

Java代码  

1. sessionListener1=com.github.zhangkaitao.shiro.chapter10.web.listener.MySessionListener1  
2. sessionListener2=com.github.zhangkaitao.shiro.chapter10.web.listener.MySessionListener2  
3. sessionManager.sessionListeners=$sessionListener1,$sessionListener2  

 

会话存储/持久化 

Shiro提供SessionDAO用于会话的CRUD，即DAO（Data Access Object）模式实现：

Java代码  

1. //如DefaultSessionManager在创建完session后会调用该方法；如保存到关系数据库/文件系统/NoSQL数据库；即可以实现会话的持久化；返回会话ID；主要此处返回的ID.equals(session.getId())；  
2. Serializable create(Session session);  
3. //根据会话ID获取会话  
4. Session readSession(Serializable sessionId) throws UnknownSessionException;  
5. //更新会话；如更新会话最后访问时间/停止会话/设置超时时间/设置移除属性等会调用  
6. void update(Session session) throws UnknownSessionException;  
7. //删除会话；当会话过期/会话停止（如用户退出时）会调用  
8. void delete(Session session);  
9. //获取当前所有活跃用户，如果用户量多此方法影响性能  
10. Collection<Session> getActiveSessions();   

Shiro内嵌了如下SessionDAO实现：

AbstractSessionDAO提供了SessionDAO的基础实现，如生成会话ID等；CachingSessionDAO提供了对开发者透明的会话缓存的功能，只需要设置相应的CacheManager即可；MemorySessionDAO直接在内存中进行会话维护；而EnterpriseCacheSessionDAO提供了缓存功能的会话维护，默认情况下使用MapCache实现，内部使用ConcurrentHashMap保存缓存的会话。

 

可以通过如下配置设置SessionDAO：

Java代码  

1. sessionDAO=org.apache.shiro.session.mgt.eis.EnterpriseCacheSessionDAO  
2. sessionManager.sessionDAO=$sessionDAO   

Shiro提供了使用Ehcache进行会话存储，Ehcache可以配合TerraCotta实现容器无关的分布式集群。

 

首先在pom.xml里添加如下依赖：

Java代码  

1. <dependency>  
2.     <groupId>org.apache.shiro</groupId>  
3.     <artifactId>shiro-ehcache</artifactId>  
4.     <version>1.2.2</version>  
5. </dependency>   

 

接着配置shiro-web.ini文件：    

Java代码  

1. sessionDAO=org.apache.shiro.session.mgt.eis.EnterpriseCacheSessionDAO  
2. sessionDAO. activeSessionsCacheName=shiro-activeSessionCache  
3. sessionManager.sessionDAO=$sessionDAO  
4. cacheManager = org.apache.shiro.cache.ehcache.EhCacheManager  
5. cacheManager.cacheManagerConfigFile=classpath:ehcache.xml  
6. securityManager.cacheManager = $cacheManager   

sessionDAO. activeSessionsCacheName：设置Session缓存名字，默认就是shiro-activeSessionCache；

cacheManager：缓存管理器，用于管理缓存的，此处使用Ehcache实现；

cacheManager.cacheManagerConfigFile：设置ehcache缓存的配置文件；

securityManager.cacheManager：设置SecurityManager的cacheManager，会自动设置实现了CacheManagerAware接口的相应对象，如SessionDAO的cacheManager；

 

然后配置ehcache.xml：

Java代码  

1. <cache name="shiro-activeSessionCache"  
2.        maxEntriesLocalHeap="10000"  
3.        overflowToDisk="false"  
4.        eternal="false"  
5.        diskPersistent="false"  
6.        timeToLiveSeconds="0"  
7.        timeToIdleSeconds="0"  
8.        statistics="true"/>   

Cache的名字为shiro-activeSessionCache，即设置的sessionDAO的activeSessionsCacheName属性值。

 

另外可以通过如下ini配置设置会话ID生成器：

Java代码  

1. sessionIdGenerator=org.apache.shiro.session.mgt.eis.JavaUuidSessionIdGenerator  
2. sessionDAO.sessionIdGenerator=$sessionIdGenerator   

用于生成会话ID，默认就是JavaUuidSessionIdGenerator，使用java.util.UUID生成。

 

如果自定义实现SessionDAO，继承CachingSessionDAO即可：

Java代码  

1. public class MySessionDAO extends CachingSessionDAO {  
2.     private JdbcTemplate jdbcTemplate = JdbcTemplateUtils.jdbcTemplate();  
3.      protected Serializable doCreate(Session session) {  
4.         Serializable sessionId = generateSessionId(session);  
5.         assignSessionId(session, sessionId);  
6.         String sql = "insert into sessions(id, session) values(?,?)";  
7.         jdbcTemplate.update(sql, sessionId, SerializableUtils.serialize(session));  
8.         return session.getId();  
9.     }  
10. protected void doUpdate(Session session) {  
11.     if(session instanceof ValidatingSession && !((ValidatingSession)session).isValid()) {  
12.         return; //如果会话过期/停止 没必要再更新了  
13.     }  
14.         String sql = "update sessions set session=? where id=?";  
15.         jdbcTemplate.update(sql, SerializableUtils.serialize(session), session.getId());  
16.     }  
17.     protected void doDelete(Session session) {  
18.         String sql = "delete from sessions where id=?";  
19.         jdbcTemplate.update(sql, session.getId());  
20.     }  
21.     protected Session doReadSession(Serializable sessionId) {  
22.         String sql = "select session from sessions where id=?";  
23.         List<String> sessionStrList = jdbcTemplate.queryForList(sql, String.class, sessionId);  
24.         if(sessionStrList.size() == 0) return null;  
25.         return SerializableUtils.deserialize(sessionStrList.get(0));  
26.     }  
27. }   

doCreate/doUpdate/doDelete/doReadSession分别代表创建/修改/删除/读取会话；此处通过把会话序列化后存储到数据库实现；接着在shiro-web.ini中配置：

Java代码  

1. sessionDAO=com.github.zhangkaitao.shiro.chapter10.session.dao.MySessionDAO  

其他设置和之前一样，因为继承了CachingSessionDAO；所有在读取时会先查缓存中是否存在，如果找不到才到数据库中查找。

 

会话验证

Shiro提供了会话验证调度器，用于定期的验证会话是否已过期，如果过期将停止会话；出于性能考虑，一般情况下都是获取会话时来验证会话是否过期并停止会话的；但是如在web环境中，如果用户不主动退出是不知道会话是否过期的，因此需要定期的检测会话是否过期，Shiro提供了会话验证调度器SessionValidationScheduler来做这件事情。

 

可以通过如下ini配置开启会话验证：    

Java代码  

1. sessionValidationScheduler=org.apache.shiro.session.mgt.ExecutorServiceSessionValidationScheduler  
2. sessionValidationScheduler.interval = 3600000  
3. sessionValidationScheduler.sessionManager=$sessionManager  
4. sessionManager.globalSessionTimeout=1800000  
5. sessionManager.sessionValidationSchedulerEnabled=true  
6. sessionManager.sessionValidationScheduler=$sessionValidationScheduler   

sessionValidationScheduler：会话验证调度器，sessionManager默认就是使用ExecutorServiceSessionValidationScheduler，其使用JDK的ScheduledExecutorService进行定期调度并验证会话是否过期；

sessionValidationScheduler.interval：设置调度时间间隔，单位毫秒，默认就是1小时；

sessionValidationScheduler.sessionManager：设置会话验证调度器进行会话验证时的会话管理器；

sessionManager.globalSessionTimeout：设置全局会话超时时间，默认30分钟，即如果30分钟内没有访问会话将过期；

sessionManager.sessionValidationSchedulerEnabled：是否开启会话验证器，默认是开启的；

sessionManager.sessionValidationScheduler：设置会话验证调度器，默认就是使用ExecutorServiceSessionValidationScheduler。

 

Shiro也提供了使用Quartz会话验证调度器：

Java代码  

1. sessionValidationScheduler=org.apache.shiro.session.mgt.quartz.QuartzSessionValidationScheduler  
2. sessionValidationScheduler.sessionValidationInterval = 3600000  
3. sessionValidationScheduler.sessionManager=$sessionManager   

使用时需要导入shiro-quartz依赖：

Java代码  

1. <dependency>  
2.      <groupId>org.apache.shiro</groupId>  
3.      <artifactId>shiro-quartz</artifactId>  
4.      <version>1.2.2</version>  
5. </dependency>  

    

如上会话验证调度器实现都是直接调用AbstractValidatingSessionManager 的validateSessions方法进行验证，其直接调用SessionDAO的getActiveSessions方法获取所有会话进行验证，如果会话比较多，会影响性能；可以考虑如分页获取会话并进行验证，如com.github.zhangkaitao.shiro.chapter10.session.scheduler.MySessionValidationScheduler：

Java代码  

1. //分页获取会话并验证  
2. String sql = "select session from sessions limit ?,?";  
3. int start = 0; //起始记录  
4. int size = 20; //每页大小  
5. List<String> sessionList = jdbcTemplate.queryForList(sql, String.class, start, size);  
6. while(sessionList.size() > 0) {  
7.   for(String sessionStr : sessionList) {  
8.     try {  
9.       Session session = SerializableUtils.deserialize(sessionStr);  
10.       Method validateMethod =   
11.         ReflectionUtils.findMethod(AbstractValidatingSessionManager.class,   
12.             "validate", Session.class, SessionKey.class);  
13.       validateMethod.setAccessible(true);  
14.       ReflectionUtils.invokeMethod(validateMethod,   
15.         sessionManager, session, new DefaultSessionKey(session.getId()));  
16.     } catch (Exception e) {  
17.         //ignore  
18.     }  
19.   }  
20.  start = start + size;  
21.   sessionList = jdbcTemplate.queryForList(sql, String.class, start, size);  
22. }   

其直接改造自ExecutorServiceSessionValidationScheduler，如上代码是验证的核心代码，可以根据自己的需求改造此验证调度器器；ini的配置和之前的类似。

 

如果在会话过期时不想删除过期的会话，可以通过如下ini配置进行设置：

Java代码  

1. sessionManager.deleteInvalidSessions=false  

默认是开启的，在会话过期后会调用SessionDAO的delete方法删除会话：如会话时持久化存储的，可以调用此方法进行删除。

 

如果是在获取会话时验证了会话已过期，将抛出InvalidSessionException；因此需要捕获这个异常并跳转到相应的页面告诉用户会话已过期，让其重新登录，如可以在web.xml配置相应的错误页面：

Java代码  

1. <error-page>  
2.     <exception-type>org.apache.shiro.session.InvalidSessionException</exception-type>  
3.     <location>/invalidSession.jsp</location>  
4. </error-page>  

 

sessionFactory

sessionFactory是创建会话的工厂，根据相应的Subject上下文信息来创建会话；默认提供了SimpleSessionFactory用来创建SimpleSession会话。

 

首先自定义一个Session：

Java代码  

1. public class OnlineSession extends SimpleSession {  
2.     public static enum OnlineStatus {  
3.         on_line("在线"), hidden("隐身"), force_logout("强制退出");  
4.         private final String info;  
5.         private OnlineStatus(String info) {  
6.             this.info = info;  
7.         }  
8.         public String getInfo() {  
9.             return info;  
10.         }  
11.     }  
12.     private String userAgent; //用户浏览器类型  
13.     private OnlineStatus status = OnlineStatus.on_line; //在线状态  
14.     private String systemHost; //用户登录时系统IP  
15.     //省略其他  
16. }   

OnlineSession用于保存当前登录用户的在线状态，支持如离线等状态的控制。

 

接着自定义SessionFactory：

Java代码  

1. public class OnlineSessionFactory implements SessionFactory {  
2.   
3.     @Override  
4.     public Session createSession(SessionContext initData) {  
5.         OnlineSession session = new OnlineSession();  
6.         if (initData != null && initData instanceof WebSessionContext) {  
7.             WebSessionContext sessionContext = (WebSessionContext) initData;  
8.             HttpServletRequest request = (HttpServletRequest) sessionContext.getServletRequest();  
9.             if (request != null) {  
10.                 session.setHost(IpUtils.getIpAddr(request));  
11.                 session.setUserAgent(request.getHeader("User-Agent"));  
12.                 session.setSystemHost(request.getLocalAddr() + ":" + request.getLocalPort());  
13.             }  
14.         }  
15.         return session;  
16.     }  
17. }   

根据会话上下文创建相应的OnlineSession。

 

最后在shiro-web.ini配置文件中配置：

Java代码  

1. sessionFactory=org.apache.shiro.session.mgt.OnlineSessionFactory  
2. sessionManager.sessionFactory=$sessionFactory  

@10@

Shiro提供了类似于Spring的Cache抽象，即Shiro本身不实现Cache，但是对Cache进行了又抽象，方便更换不同的底层Cache实现。对于Cache的一些概念可以参考我的《Spring Cache抽象详解》：http://jinnianshilongnian.iteye.com/blog/2001040。

 

Shiro提供的Cache接口： 

Java代码  

1. public interface Cache<K, V> {  
2.     //根据Key获取缓存中的值  
3.     public V get(K key) throws CacheException;  
4.     //往缓存中放入key-value，返回缓存中之前的值  
5.     public V put(K key, V value) throws CacheException;   
6.     //移除缓存中key对应的值，返回该值  
7.     public V remove(K key) throws CacheException;  
8.     //清空整个缓存  
9.     public void clear() throws CacheException;  
10.     //返回缓存大小  
11.     public int size();  
12.     //获取缓存中所有的key  
13.     public Set<K> keys();  
14.     //获取缓存中所有的value  
15.     public Collection<V> values();  
16. }  

  

Shiro提供的CacheManager接口： 

Java代码  

1. public interface CacheManager {  
2.     //根据缓存名字获取一个Cache  
3.     public <K, V> Cache<K, V> getCache(String name) throws CacheException;  
4. }  

  

Shiro还提供了CacheManagerAware用于注入CacheManager： 

Java代码  

1. public interface CacheManagerAware {  
2.     //注入CacheManager  
3.     void setCacheManager(CacheManager cacheManager);  
4. }  

 

Shiro内部相应的组件（DefaultSecurityManager）会自动检测相应的对象（如Realm）是否实现了CacheManagerAware并自动注入相应的CacheManager。

  

本章用例使用了与第六章的代码。

 

Realm缓存

Shiro提供了CachingRealm，其实现了CacheManagerAware接口，提供了缓存的一些基础实现；另外AuthenticatingRealm及AuthorizingRealm分别提供了对AuthenticationInfo 和AuthorizationInfo信息的缓存。

 

ini配置   

Java代码  

1. userRealm=com.github.zhangkaitao.shiro.chapter11.realm.UserRealm  
2. userRealm.credentialsMatcher=$credentialsMatcher  
3. userRealm.cachingEnabled=true  
4. userRealm.authenticationCachingEnabled=true  
5. userRealm.authenticationCacheName=authenticationCache  
6. userRealm.authorizationCachingEnabled=true  
7. userRealm.authorizationCacheName=authorizationCache  
8. securityManager.realms=$userRealm  
9.   
10. cacheManager=org.apache.shiro.cache.ehcache.EhCacheManager  
11. cacheManager.cacheManagerConfigFile=classpath:shiro-ehcache.xml  
12. securityManager.cacheManager=$cacheManager   

userRealm.cachingEnabled：启用缓存，默认false；

userRealm.authenticationCachingEnabled：启用身份验证缓存，即缓存AuthenticationInfo信息，默认false；

userRealm.authenticationCacheName：缓存AuthenticationInfo信息的缓存名称；

userRealm. authorizationCachingEnabled：启用授权缓存，即缓存AuthorizationInfo信息，默认false；

userRealm. authorizationCacheName：缓存AuthorizationInfo信息的缓存名称；

cacheManager：缓存管理器，此处使用EhCacheManager，即Ehcache实现，需要导入相应的Ehcache依赖，请参考pom.xml；

 

因为测试用例的关系，需要将Ehcache的CacheManager改为使用VM单例模式：

this.manager = new net.sf.ehcache.CacheManager(getCacheManagerConfigFileInputStream());

改为

this.manager = net.sf.ehcache.CacheManager.create(getCacheManagerConfigFileInputStream());

 

测试用例 

Java代码  

1. @Test  
2. public void testClearCachedAuthenticationInfo() {  
3.     login(u1.getUsername(), password);  
4.     userService.changePassword(u1.getId(), password + "1");  
5.   
6.     RealmSecurityManager securityManager =  
7.      (RealmSecurityManager) SecurityUtils.getSecurityManager();  
8.     UserRealm userRealm = (UserRealm) securityManager.getRealms().iterator().next();  
9.     userRealm.clearCachedAuthenticationInfo(subject().getPrincipals());  
10.   
11.     login(u1.getUsername(), password + "1");  
12. }   

首先登录成功（此时会缓存相应的AuthenticationInfo），然后修改密码；此时密码就变了；接着需要调用Realm的clearCachedAuthenticationInfo方法清空之前缓存的AuthenticationInfo；否则下次登录时还会获取到修改密码之前的那个AuthenticationInfo；

 

Java代码  

1. @Test  
2. public void testClearCachedAuthorizationInfo() {  
3.     login(u1.getUsername(), password);  
4.     subject().checkRole(r1.getRole());  
5.     userService.correlationRoles(u1.getId(), r2.getId());  
6.   
7.     RealmSecurityManager securityManager =  
8.       (RealmSecurityManager) SecurityUtils.getSecurityManager();  
9.     UserRealm userRealm = (UserRealm)securityManager.getRealms().iterator().next();  
10.     userRealm.clearCachedAuthorizationInfo(subject().getPrincipals());  
11.   
12.     subject().checkRole(r2.getRole());  
13. }   

和之前的用例差不多；此处调用Realm的clearCachedAuthorizationInfo清空之前缓存的AuthorizationInfo；

 

另外还有clearCache，其同时调用clearCachedAuthenticationInfo和clearCachedAuthorizationInfo，清空AuthenticationInfo和AuthorizationInfo。

 

UserRealm还提供了clearAllCachedAuthorizationInfo、clearAllCachedAuthenticationInfo、clearAllCache，用于清空整个缓存。

 

在某些清空下这种方式可能不是最好的选择，可以考虑直接废弃Shiro的缓存，然后自己通过如AOP机制实现自己的缓存；可以参考：

https://github.com/zhangkaitao/es/tree/master/web/src/main/java/com/sishuok/es/extra/aop

 

另外如果和Spring集成时可以考虑直接使用Spring的Cache抽象，可以考虑使用SpringCacheManagerWrapper，其对Spring Cache进行了包装，转换为Shiro的CacheManager实现：

https://github.com/zhangkaitao/es/blob/master/web/src/main/java/org/apache/shiro/cache/spring/SpringCacheManagerWrapper.java 

 

Session缓存

当我们设置了SecurityManager的CacheManager时，如：

Java代码  

1. securityManager.cacheManager=$cacheManager  

 

当我们设置SessionManager时：

Java代码  

1. sessionManager=org.apache.shiro.session.mgt.DefaultSessionManager  
2. securityManager.sessionManager=$sessionManager   

如securityManager实现了SessionsSecurityManager，其会自动判断SessionManager是否实现了CacheManagerAware接口，如果实现了会把CacheManager设置给它。然后sessionManager会判断相应的sessionDAO（如继承自CachingSessionDAO）是否实现了CacheManagerAware，如果实现了会把CacheManager设置给它；如第九章的MySessionDAO就是带缓存的SessionDAO；其会先查缓存，如果找不到才查数据库。

 

对于CachingSessionDAO，可以通过如下配置设置缓存的名称：

Java代码  

1. sessionDAO=com.github.zhangkaitao.shiro.chapter11.session.dao.MySessionDAO  
2. sessionDAO.activeSessionsCacheName=shiro-activeSessionCache   

activeSessionsCacheName默认就是shiro-activeSessionCache。

@11@

Shiro的组件都是JavaBean/POJO式的组件，所以非常容易使用Spring进行组件管理，可以非常方便的从ini配置迁移到Spring进行管理，且支持JavaSE应用及Web应用的集成。

 

在示例之前，需要导入shiro-spring及spring-context依赖，具体请参考pom.xml。

spring-beans.xml配置文件提供了基础组件如DataSource、DAO、Service组件的配置。

 

JavaSE应用

 

spring-shiro.xml提供了普通JavaSE独立应用的Spring配置：

Java代码  

1. <!-- 缓存管理器 使用Ehcache实现 -->  
2. <bean id="cacheManager" class="org.apache.shiro.cache.ehcache.EhCacheManager">  
3.     <property name="cacheManagerConfigFile" value="classpath:ehcache.xml"/>  
4. </bean>  
5.   
6. <!-- 凭证匹配器 -->  
7. <bean id="credentialsMatcher" class="  
8. com.github.zhangkaitao.shiro.chapter12.credentials.RetryLimitHashedCredentialsMatcher">  
9.     <constructor-arg ref="cacheManager"/>  
10.     <property name="hashAlgorithmName" value="md5"/>  
11.     <property name="hashIterations" value="2"/>  
12.     <property name="storedCredentialsHexEncoded" value="true"/>  
13. </bean>  
14.   
15. <!-- Realm实现 -->  
16. <bean id="userRealm" class="com.github.zhangkaitao.shiro.chapter12.realm.UserRealm">  
17.     <property name="userService" ref="userService"/>  
18.     <property name="credentialsMatcher" ref="credentialsMatcher"/>  
19.     <property name="cachingEnabled" value="true"/>  
20.     <property name="authenticationCachingEnabled" value="true"/>  
21.     <property name="authenticationCacheName" value="authenticationCache"/>  
22.     <property name="authorizationCachingEnabled" value="true"/>  
23.     <property name="authorizationCacheName" value="authorizationCache"/>  
24. </bean>  
25. <!-- 会话ID生成器 -->  
26. <bean id="sessionIdGenerator"   
27. class="org.apache.shiro.session.mgt.eis.JavaUuidSessionIdGenerator"/>  
28. <!-- 会话DAO -->  
29. <bean id="sessionDAO"   
30. class="org.apache.shiro.session.mgt.eis.EnterpriseCacheSessionDAO">  
31.     <property name="activeSessionsCacheName" value="shiro-activeSessionCache"/>  
32.     <property name="sessionIdGenerator" ref="sessionIdGenerator"/>  
33. </bean>  
34. <!-- 会话验证调度器 -->  
35. <bean id="sessionValidationScheduler"   
36. class="org.apache.shiro.session.mgt.quartz.QuartzSessionValidationScheduler">  
37.     <property name="sessionValidationInterval" value="1800000"/>  
38.     <property name="sessionManager" ref="sessionManager"/>  
39. </bean>  
40. <!-- 会话管理器 -->  
41. <bean id="sessionManager" class="org.apache.shiro.session.mgt.DefaultSessionManager">  
42.     <property name="globalSessionTimeout" value="1800000"/>  
43.     <property name="deleteInvalidSessions" value="true"/>  
44.     <property name="sessionValidationSchedulerEnabled" value="true"/>  
45.    <property name="sessionValidationScheduler" ref="sessionValidationScheduler"/>  
46.     <property name="sessionDAO" ref="sessionDAO"/>  
47. </bean>  
48. <!-- 安全管理器 -->  
49. <bean id="securityManager" class="org.apache.shiro.mgt.DefaultSecurityManager">  
50.     <property name="realms">  
51.         <list><ref bean="userRealm"/></list>  
52.     </property>  
53.     <property name="sessionManager" ref="sessionManager"/>  
54.     <property name="cacheManager" ref="cacheManager"/>  
55. </bean>  
56. <!-- 相当于调用SecurityUtils.setSecurityManager(securityManager) -->  
57. <bean class="org.springframework.beans.factory.config.MethodInvokingFactoryBean">  
58. <property name="staticMethod"   
59. value="org.apache.shiro.SecurityUtils.setSecurityManager"/>  
60.     <property name="arguments" ref="securityManager"/>  
61. </bean>  
62. <!-- Shiro生命周期处理器-->  
63. <bean id="lifecycleBeanPostProcessor"   
64. class="org.apache.shiro.spring.LifecycleBeanPostProcessor"/>  

可以看出，只要把之前的ini配置翻译为此处的spring xml配置方式即可，无须多解释。LifecycleBeanPostProcessor用于在实现了Initializable接口的Shiro bean初始化时调用Initializable接口回调，在实现了Destroyable接口的Shiro bean销毁时调用 Destroyable接口回调。如UserRealm就实现了Initializable，而DefaultSecurityManager实现了Destroyable。具体可以查看它们的继承关系。

  

测试用例请参考com.github.zhangkaitao.shiro.chapter12.ShiroTest。 

 

Web应用

Web应用和普通JavaSE应用的某些配置是类似的，此处只提供一些不一样的配置，详细配置可以参考spring-shiro-web.xml。 

Java代码  

1. <!-- 会话Cookie模板 -->  
2. <bean id="sessionIdCookie" class="org.apache.shiro.web.servlet.SimpleCookie">  
3.     <constructor-arg value="sid"/>  
4.     <property name="httpOnly" value="true"/>  
5.     <property name="maxAge" value="180000"/>  
6. </bean>  
7. <!-- 会话管理器 -->  
8. <bean id="sessionManager"   
9. class="org.apache.shiro.web.session.mgt.DefaultWebSessionManager">  
10.     <property name="globalSessionTimeout" value="1800000"/>  
11.     <property name="deleteInvalidSessions" value="true"/>  
12.     <property name="sessionValidationSchedulerEnabled" value="true"/>  
13.     <property name="sessionValidationScheduler" ref="sessionValidationScheduler"/>  
14.     <property name="sessionDAO" ref="sessionDAO"/>  
15.     <property name="sessionIdCookieEnabled" value="true"/>  
16.     <property name="sessionIdCookie" ref="sessionIdCookie"/>  
17. </bean>  
18. <!-- 安全管理器 -->  
19. <bean id="securityManager" class="org.apache.shiro.web.mgt.DefaultWebSecurityManager">  
20. <property name="realm" ref="userRealm"/>  
21.     <property name="sessionManager" ref="sessionManager"/>  
22.     <property name="cacheManager" ref="cacheManager"/>  
23. </bean>   

1、sessionIdCookie是用于生产Session ID Cookie的模板；

2、会话管理器使用用于web环境的DefaultWebSessionManager；

3、安全管理器使用用于web环境的DefaultWebSecurityManager。 

 

Java代码  

1. <!-- 基于Form表单的身份验证过滤器 -->  
2. <bean id="formAuthenticationFilter"   
3. class="org.apache.shiro.web.filter.authc.FormAuthenticationFilter">  
4.     <property name="usernameParam" value="username"/>  
5.     <property name="passwordParam" value="password"/>  
6.     <property name="loginUrl" value="/login.jsp"/>  
7. </bean>  
8. <!-- Shiro的Web过滤器 -->  
9. <bean id="shiroFilter" class="org.apache.shiro.spring.web.ShiroFilterFactoryBean">  
10.     <property name="securityManager" ref="securityManager"/>  
11.     <property name="loginUrl" value="/login.jsp"/>  
12.     <property name="unauthorizedUrl" value="/unauthorized.jsp"/>  
13.     <property name="filters">  
14.         <util:map>  
15.             <entry key="authc" value-ref="formAuthenticationFilter"/>  
16.         </util:map>  
17.     </property>  
18.     <property name="filterChainDefinitions">  
19.         <value>  
20.             /index.jsp = anon  
21.             /unauthorized.jsp = anon  
22.             /login.jsp = authc  
23.             /logout = logout  
24.             /** = user  
25.         </value>  
26.     </property>  
27. </bean>   

1、formAuthenticationFilter为基于Form表单的身份验证过滤器；此处可以再添加自己的Filter bean定义；

2、shiroFilter：此处使用ShiroFilterFactoryBean来创建ShiroFilter过滤器；filters属性用于定义自己的过滤器，即ini配置中的[filters]部分；filterChainDefinitions用于声明url和filter的关系，即ini配置中的[urls]部分。

 

接着需要在web.xml中进行如下配置： 

Java代码  

1. <context-param>  
2.     <param-name>contextConfigLocation</param-name>  
3.     <param-value>  
4.         classpath:spring-beans.xml,  
5.         classpath:spring-shiro-web.xml  
6.     </param-value>  
7. </context-param>  
8. <listener>  
9.    <listener-class>  
10. org.springframework.web.context.ContextLoaderListener  
11. </listener-class>  
12. </listener>   

通过ContextLoaderListener加载contextConfigLocation指定的Spring配置文件。

  

Java代码  

1. <filter>  
2.     <filter-name>shiroFilter</filter-name>  
3.     <filter-class>org.springframework.web.filter.DelegatingFilterProxy</filter-class>  
4.     <init-param>  
5.         <param-name>targetFilterLifecycle</param-name>  
6.         <param-value>true</param-value>  
7.     </init-param>  
8. </filter>  
9. <filter-mapping>  
10.     <filter-name>shiroFilter</filter-name>  
11.     <url-pattern>/*</url-pattern>  
12. </filter-mapping>   

DelegatingFilterProxy会自动到Spring容器中查找名字为shiroFilter的bean并把filter请求交给它处理。

 

其他配置请参考源代码。

 

Shiro权限注解

Shiro提供了相应的注解用于权限控制，如果使用这些注解就需要使用AOP的功能来进行判断，如Spring AOP；Shiro提供了Spring AOP集成用于权限注解的解析和验证。

为了测试，此处使用了Spring MVC来测试Shiro注解，当然Shiro注解不仅仅可以在web环境使用，在独立的JavaSE中也是可以用的，此处只是以web为例了。

 

在spring-mvc.xml配置文件添加Shiro Spring AOP权限注解的支持： 

Java代码  

1. <aop:config proxy-target-class="true"></aop:config>  
2. <bean class="  
3. org.apache.shiro.spring.security.interceptor.AuthorizationAttributeSourceAdvisor">  
4.     <property name="securityManager" ref="securityManager"/>  
5. </bean>   

如上配置用于开启Shiro Spring AOP权限注解的支持；<aop:config proxy-target-class="true">表示代理类。

 

接着就可以在相应的控制器（AnnotationController）中使用如下方式进行注解： 

Java代码  

1. @RequiresRoles("admin")  
2. @RequestMapping("/hello2")  
3. public String hello2() {  
4.     return "success";  
5. }   

访问hello2方法的前提是当前用户有admin角色。

 

当验证失败，其会抛出UnauthorizedException异常，此时可以使用Spring的ExceptionHandler（DefaultExceptionHandler）来进行拦截处理：

Java代码  

1. @ExceptionHandler({UnauthorizedException.class})  
2. @ResponseStatus(HttpStatus.UNAUTHORIZED)  
3. public ModelAndView processUnauthenticatedException(NativeWebRequest request, UnauthorizedException e) {  
4.     ModelAndView mv = new ModelAndView();  
5.     mv.addObject("exception", e);  
6.     mv.setViewName("unauthorized");  
7.     return mv;  
8. }   

如果集成Struts2，需要注意《Shiro+Struts2+Spring3 加上@RequiresPermissions 后@Autowired失效》问题：

http://jinnianshilongnian.iteye.com/blog/1850425

 

权限注解      

Java代码  

1. @RequiresAuthentication  

表示当前Subject已经通过login进行了身份验证；即Subject. isAuthenticated()返回true。 

 

Java代码  

1. @RequiresUser  

表示当前Subject已经身份验证或者通过记住我登录的。

 

Java代码  

1. @RequiresGuest  

表示当前Subject没有身份验证或通过记住我登录过，即是游客身份。  

 

Java代码  

1. @RequiresRoles(value={“admin”, “user”}, logical= Logical.AND)  

表示当前Subject需要角色admin和user。

 

Java代码  

1. @RequiresPermissions (value={“user:a”, “user:b”}, logical= Logical.OR)  

表示当前Subject需要权限user:a或user:b。  

@12@

Shiro提供了记住我（RememberMe）的功能，比如访问如淘宝等一些网站时，关闭了浏览器下次再打开时还是能记住你是谁，下次访问时无需再登录即可访问，基本流程如下：

1、首先在登录页面选中RememberMe然后登录成功；如果是浏览器登录，一般会把RememberMe的Cookie写到客户端并保存下来；

2、关闭浏览器再重新打开；会发现浏览器还是记住你的；

3、访问一般的网页服务器端还是知道你是谁，且能正常访问；

 

4、但是比如我们访问淘宝时，如果要查看我的订单或进行支付时，此时还是需要再进行身份认证的，以确保当前用户还是你。

RememberMe配置

 

spring-shiro-web.xml配置：

Java代码  

1. <!-- 会话Cookie模板 -->  
2. <bean id="sessionIdCookie" class="org.apache.shiro.web.servlet.SimpleCookie">  
3.     <constructor-arg value="sid"/>  
4.     <property name="httpOnly" value="true"/>  
5.     <property name="maxAge" value="-1"/>  
6. </bean>  
7. <bean id="rememberMeCookie" class="org.apache.shiro.web.servlet.SimpleCookie">  
8.     <constructor-arg value="rememberMe"/>  
9.     <property name="httpOnly" value="true"/>  
10.     <property name="maxAge" value="2592000"/><!-- 30天 -->  
11. </bean>   

sessionIdCookie：maxAge=-1表示浏览器关闭时失效此Cookie；

rememberMeCookie：即记住我的Cookie，保存时长30天；

  

Java代码  

1. <!-- rememberMe管理器 -->  
2. <bean id="rememberMeManager"   
3. class="org.apache.shiro.web.mgt.CookieRememberMeManager">  
4.     <property name="cipherKey" value="  
5. #{T(org.apache.shiro.codec.Base64).decode('4AvVhmFLUs0KTA3Kprsdag==')}"/>  
6.      <property name="cookie" ref="rememberMeCookie"/>  
7. </bean>   

rememberMe管理器，cipherKey是加密rememberMe Cookie的密钥；默认AES算法；

 

Java代码  

1. <!-- 安全管理器 -->  
2. <bean id="securityManager" class="org.apache.shiro.web.mgt.DefaultWebSecurityManager">  
3. ……  
4.     <property name="rememberMeManager" ref="rememberMeManager"/>  
5. </bean>   

设置securityManager安全管理器的rememberMeManager； 

 

Java代码  

1. <bean id="formAuthenticationFilter"   
2. class="org.apache.shiro.web.filter.authc.FormAuthenticationFilter">  
3.     ……  
4.     <property name="rememberMeParam" value="rememberMe"/>  
5. </bean>   

rememberMeParam，即rememberMe请求参数名，请求参数是boolean类型，true表示rememberMe。 

 

Java代码  

1. <bean id="shiroFilter" class="org.apache.shiro.spring.web.ShiroFilterFactoryBean">  
2.     ……  
3.     <property name="filterChainDefinitions">  
4.         <value>  
5.             /login.jsp = authc  
6.             /logout = logout  
7.             /authenticated.jsp = authc  
8.             /** = user  
9.         </value>  
10.     </property>  
11. </bean>   

“/authenticated.jsp = authc”表示访问该地址用户必须身份验证通过（Subject. isAuthenticated()==true）；而“/** = user”表示访问该地址的用户是身份验证通过或RememberMe登录的都可以。

 

测试：

1、访问http://localhost:8080/chapter13/，会跳转到登录页面，登录成功后会设置会话及rememberMe Cookie；

2、关闭浏览器，此时会话cookie将失效；

3、然后重新打开浏览器访问http://localhost:8080/chapter13/，还是可以访问的；

4、如果此时访问http://localhost:8080/chapter13/authenticated.jsp，会跳转到登录页面重新进行身份验证。

 

如果要自己做RememeberMe，需要在登录之前这样创建Token：UsernamePasswordToken(用户名，密码，是否记住我)，如：

Java代码  

1. Subject subject = SecurityUtils.getSubject();  
2. UsernamePasswordToken token = new UsernamePasswordToken(username, password);  
3. token.setRememberMe(true);  
4. subject.login(token);   

subject.isAuthenticated()表示用户进行了身份验证登录的，即使有Subject.login进行了登录；subject.isRemembered()：表示用户是通过记住我登录的，此时可能并不是真正的你（如你的朋友使用你的电脑，或者你的cookie被窃取）在访问的；且两者二选一，即subject.isAuthenticated()==true，则subject.isRemembered()==false；反之一样。

 

另外对于过滤器，一般这样使用：

访问一般网页，如个人在主页之类的，我们使用user拦截器即可，user拦截器只要用户登录(isRemembered()==true or isAuthenticated()==true)过即可访问成功；

访问特殊网页，如我的订单，提交订单页面，我们使用authc拦截器即可，authc拦截器会判断用户是否是通过Subject.login（isAuthenticated()==true）登录的，如果是才放行，否则会跳转到登录页面叫你重新登录。

 

因此RememberMe使用过程中，需要配合相应的拦截器来实现相应的功能，用错了拦截器可能就不能满足你的需求了。

@13@

对于SSL的支持，Shiro只是判断当前url是否需要SSL登录，如果需要自动重定向到https进行访问。

 

首先生成数字证书，生成证书到D:\localhost.keystore

使用JDK的keytool命令，生成证书（包含证书/公钥/私钥）到D:\localhost.keystore：

keytool -genkey -keystore "D:\localhost.keystore" -alias localhost -keyalg RSA

输入密钥库口令:

再次输入新口令:

您的名字与姓氏是什么?

  [Unknown]:  localhost

您的组织单位名称是什么?

  [Unknown]:  sishuok.com

您的组织名称是什么?

  [Unknown]:  sishuok.com

您所在的城市或区域名称是什么?

  [Unknown]:  beijing

您所在的省/市/自治区名称是什么?

  [Unknown]:  beijing

该单位的双字母国家/地区代码是什么?

  [Unknown]:  cn

CN=localhost, OU=sishuok.com, O=sishuok.com, L=beijing, ST=beijing, C=cn是否正确

?

  [否]:  y

 

输入 <localhost> 的密钥口令

        (如果和密钥库口令相同, 按回车):

再次输入新口令:

 

通过如上步骤，生成证书到D:\ localhost.keystore；

 

然后设置tomcat下的server.xml

此处使用了apache-tomcat-7.0.40版本，打开conf/server.xml，找到：

 

Java代码  

1. <!--  
2. <Connector port="8443" protocol="HTTP/1.1" SSLEnabled="true"  
3.        maxThreads="150" scheme="https" secure="true"  
4.        clientAuth="false" sslProtocol="TLS" />  
5. -->   

替换为  

Java代码  

1. <Connector port="8443" protocol="HTTP/1.1" SSLEnabled="true"  
2.        maxThreads="150" scheme="https" secure="true"  
3.        clientAuth="false" sslProtocol="TLS"   
4.        keystoreFile="D:\localhost.keystore" keystorePass="123456"/>   

keystorePass就是生成keystore时设置的密码。

 

添加SSL到配置文件（spring-shiro-web.xml）

此处使用了和十三章一样的代码：

Java代码  

1. <bean id="sslFilter" class="org.apache.shiro.web.filter.authz.SslFilter">  
2.     <property name="port" value="8443"/>  
3. </bean>  
4. <bean id="shiroFilter" class="org.apache.shiro.spring.web.ShiroFilterFactoryBean">  
5.     ……  
6.     <property name="filters">  
7.         <util:map>  
8.             <entry key="authc" value-ref="formAuthenticationFilter"/>  
9.             <entry key="ssl" value-ref="sslFilter"/>  
10.         </util:map>  
11.     </property>  
12.     <property name="filterChainDefinitions">  
13.         <value>  
14.             /login.jsp = ssl,authc  
15.             /logout = logout  
16.             /authenticated.jsp = authc  
17.             /** = user  
18.         </value>  
19.     </property>  
20. </bean>   

SslFilter默认端口是443，此处使用了8443；“/login.jsp = ssl,authc”表示访问登录页面时需要走SSL。

 

 

测试

最后把shiro-example-chapter14打成war包（mvn:package），放到tomcat下的webapps中，启动服务器测试，如访问localhost:9080/chapter14/，会自动跳转到https://localhost:8443/chapter14/login.jsp。

 

如果使用Maven Jetty插件，可以直接如下插件配置： 

Java代码  

1. <plugin>  
2.    <groupId>org.mortbay.jetty</groupId>  
3.    <artifactId>jetty-maven-plugin</artifactId>  
4.    <version>8.1.8.v20121106</version>  
5.    <configuration>  
6.      <webAppConfig>  
7.        <contextPath>/${project.build.finalName}</contextPath>  
8.      </webAppConfig>  
9.      <connectors>  
10.      <connector implementation="org.eclipse.jetty.server.nio.SelectChannelConnector">  
11.        <port>8080</port>  
12.      </connector>  
13.      <connector implementation="org.eclipse.jetty.server.ssl.SslSocketConnector">  
14.        <port>8443</port>  
15.        <keystore>${project.basedir}/localhost.keystore</keystore>  
16.        <password>123456</password>  
17.        <keyPassword>123456</keyPassword>  
18.      </connector>  
19.      </connectors>  
20.    </configuration>  
21. </plugin>  

@14@

Shiro 1.2开始提供了Jasig CAS单点登录的支持，单点登录主要用于多系统集成，即在多个系统中，用户只需要到一个中央服务器登录一次即可访问这些系统中的任何一个，无须多次登录。此处我们使用Jasig CAS v4.0.0-RC3版本：

https://github.com/Jasig/cas/tree/v4.0.0-RC3

 

Jasig CAS单点登录系统分为服务器端和客户端，服务器端提供单点登录，多个客户端（子系统）将跳转到该服务器进行登录验证，大体流程如下：

1、访问客户端需要登录的页面http://localhost:9080/ client/，此时会跳到单点登录服务器https://localhost:8443/ server/login?service=https://localhost:9443/ client/cas；

2、如果此时单点登录服务器也没有登录的话，会显示登录表单页面，输入用户名/密码进行登录；

3、登录成功后服务器端会回调客户端传入的地址：https://localhost:9443/client/cas?ticket=ST-1-eh2cIo92F9syvoMs5DOg-cas01.example.org，且带着一个ticket；

4、客户端会把ticket提交给服务器来验证ticket是否有效；如果有效服务器端将返回用户身份；

5、客户端可以再根据这个用户身份获取如当前系统用户/角色/权限信息。

 

本章使用了和《第十四章 SSL》一样的数字证书。

 

服务器端

我们使用了Jasig CAS服务器v4.0.0-RC3版本，可以到其官方的github下载：https://github.com/Jasig/cas/tree/v4.0.0-RC3下载，然后将其cas-server-webapp模块封装到shiro-example-chapter15-server模块中，具体请参考源码。

 

1、数字证书使用和《第十四章 SSL》一样的数字证书，即将localhost.keystore拷贝到shiro-example-chapter15-server模块根目录下；

 

2、在pom.xml中添加Jetty Maven插件，并添加SSL支持：

Java代码  

1. <plugin>  
2.   <groupId>org.mortbay.jetty</groupId>  
3.   <artifactId>jetty-maven-plugin</artifactId>  
4.   <version>8.1.8.v20121106</version>  
5.   <configuration>  
6.     <webAppConfig>  
7.       <contextPath>/${project.build.finalName}</contextPath>  
8.     </webAppConfig>  
9.     <connectors>  
10.       <connector implementation="org.eclipse.jetty.server.nio.SelectChannelConnector">  
11.         <port>8080</port>  
12.       </connector>  
13.       <connector implementation="org.eclipse.jetty.server.ssl.SslSocketConnector">  
14.         <port>8443</port>  
15.         <keystore>${project.basedir}/localhost.keystore</keystore>  
16.        <password>123456</password>  
17.         <keyPassword>123456</keyPassword>  
18.       </connector>  
19.     </connectors>  
20.   </configuration>  
21. </plugin>  

 

3、修改src/main/webapp/WEB-INF/deployerConfigContext.xml，找到primaryAuthenticationHandler，然后添加一个账户：

Java代码  

1. <entry key="zhang" value="123"/>  

其也支持如JDBC查询，可以自己定制；具体请参考文档。

 

4、mvn jetty:run启动服务器测试即可：

访问https://localhost:8443/chapter15-server/login将弹出如下登录页面：

 

输入用户名/密码，如zhang/123，将显示登录成功页面：

 

到此服务器端的简单配置就完成了。 

 

 

客户端

1、首先使用localhost.keystore导出数字证书（公钥）到D:\localhost.cer

Java代码  

1. keytool -export -alias localhost -file D:\localhost.cer -keystore D:\localhost.keystore   

 

2、因为CAS client需要使用该证书进行验证，需要将证书导入到JDK中： 

Java代码  

1. cd D:\jdk1.7.0_21\jre\lib\security  
2. keytool -import -alias localhost -file D:\localhost.cer -noprompt -trustcacerts -storetype jks -keystore cacerts -storepass 123456   

如果导入失败，可以先把security 目录下的cacerts删掉； 

 

3、按照服务器端的Jetty Maven插件的配置方式配置Jetty插件；

 

4、在shiro-example-chapter15-client模块中导入shiro-cas依赖，具体请参考其pom.xml； 

 

5、自定义CasRealm：

Java代码  

1. public class MyCasRealm extends CasRealm {  
2.     private UserService userService;  
3.     public void setUserService(UserService userService) {  
4.         this.userService = userService;  
5.     }  
6.     @Override  
7.     protected AuthorizationInfo doGetAuthorizationInfo(PrincipalCollection principals) {  
8.         String username = (String)principals.getPrimaryPrincipal();  
9.         SimpleAuthorizationInfo authorizationInfo = new SimpleAuthorizationInfo();  
10.         authorizationInfo.setRoles(userService.findRoles(username));  
11.         authorizationInfo.setStringPermissions(userService.findPermissions(username));  
12.         return authorizationInfo;  
13.     }  
14. }   

CasRealm根据CAS服务器端返回的用户身份获取相应的角色/权限信息。 

 

 

6、spring-shiro-web.xml配置：

Java代码  

1. <bean id="casRealm" class="com.github.zhangkaitao.shiro.chapter13.realm.MyCasRealm">  
2.     <property name="userService" ref="userService"/>  
3.     ……  
4.     <property name="casServerUrlPrefix" value="https://localhost:8443/chapter14-server"/>  
5.     <property name="casService" value="https://localhost:9443/chapter14-client/cas"/>  
6. </bean>   

casServerUrlPrefix：是CAS Server服务器端地址；

casService：是当前应用CAS服务URL，即用于接收并处理登录成功后的Ticket的；

 

如果角色/权限信息是由服务器端提供的话，我们可以直接使用CasRealm： 

Java代码  

1. <bean id="casRealm" class="org.apache.shiro.cas.CasRealm">  
2.     ……  
3.     <property name="defaultRoles" value="admin,user"/>  
4.     <property name="defaultPermissions" value="user:create,user:update"/>  
5.     <property name="roleAttributeNames" value="roles"/>  
6.     <property name="permissionAttributeNames" value="permissions"/>  
7.     <property name="casServerUrlPrefix" value="https://localhost:8443/chapter14-server"/>  
8.     <property name="casService" value="https://localhost:9443/chapter14-client/cas"/>  
9. </bean>   

defaultRoles/ defaultPermissions：默认添加给所有CAS登录成功用户的角色和权限信息；

roleAttributeNames/ permissionAttributeNames：角色属性/权限属性名称，如果用户的角色/权限信息是从服务器端返回的（即返回的CAS Principal中除了Principal之外还有如一些Attributes），此时可以使用roleAttributeNames/ permissionAttributeNames得到Attributes中的角色/权限数据；请自行查询CAS获取用户更多信息。

 

Java代码  

1. <bean id="casFilter" class="org.apache.shiro.cas.CasFilter">  
2.     <property name="failureUrl" value="/casFailure.jsp"/>  
3. </bean>   

CasFilter类似于FormAuthenticationFilter，只不过其验证服务器端返回的CAS Service Ticket。 

 

Java代码  

1. <bean id="shiroFilter" class="org.apache.shiro.spring.web.ShiroFilterFactoryBean">  
2.     <property name="securityManager" ref="securityManager"/>  
3.     <property name="loginUrl" value="https://localhost:8443/chapter14-server/login?service=https://localhost:9443/chapter14-client/cas"/>  
4.     <property name="successUrl" value="/"/>  
5.     <property name="filters">  
6.         <util:map>  
7.             <entry key="cas" value-ref="casFilter"/>  
8.         </util:map>  
9.     </property>  
10.     <property name="filterChainDefinitions">  
11.         <value>  
12.             /casFailure.jsp = anon  
13.             /cas = cas  
14.             /logout = logout  
15.             /** = user  
16.         </value>  
17.     </property>  
18. </bean>   

loginUrl：https://localhost:8443/chapter15-server/login表示服务端端登录地址，登录成功后跳转到?service参数对于的地址进行客户端验证及登录；

“/cas=cas”：即/cas地址是服务器端回调地址，使用CasFilter获取Ticket进行登录。

 

7、测试，输入http://localhost:9080/chapter15-client地址进行测试即可，可以使用如Chrome开这debug观察网络请求的变化。

 

如果遇到以下异常，一般是证书导入错误造成的，请尝试重新导入，如果还是不行，有可能是运行应用的JDK和安装数字证书的JDK不是同一个造成的：

Caused by: sun.security.validator.ValidatorException: PKIX path building failed: sun.security.provider.certpath.SunCertPathBuilderException: unable to find valid certification path to requested target

       at sun.security.validator.PKIXValidator.doBuild(PKIXValidator.java:385)

       at sun.security.validator.PKIXValidator.engineValidate(PKIXValidator.java:292)

       at sun.security.validator.Validator.validate(Validator.java:260)

       at sun.security.ssl.X509TrustManagerImpl.validate(X509TrustManagerImpl.java:326)

       at sun.security.ssl.X509TrustManagerImpl.checkTrusted(X509TrustManagerImpl.java:231)

       at sun.security.ssl.X509TrustManagerImpl.checkServerTrusted(X509TrustManagerImpl.java:126)

       at sun.security.ssl.ClientHandshaker.serverCertificate(ClientHandshaker.java:1323)

       ... 67 more

Caused by: sun.security.provider.certpath.SunCertPathBuilderException: unable to find valid certification path to requested target

       at sun.security.provider.certpath.SunCertPathBuilder.engineBuild(SunCertPathBuilder.java:196)

       at java.security.cert.CertPathBuilder.build(CertPathBuilder.java:268)

       at sun.security.validator.PKIXValidator.doBuild(PKIXValidator.java:380)

       ... 73 more

@15@

简单的实体关系图

 

简单数据字典

用户(sys_user)

名称	类型	长度	描述
id	bigint		编号 主键
username	varchar	100	用户名
password	varchar	100	密码
salt	varchar	50	盐
role_ids	varchar	100	角色列表
locked	bool		账户是否锁定

组织机构(sys_organization)

名称	类型	长度	描述
id	bigint		编号 主键
name	varchar	100	组织机构名
priority	int		显示顺序
parent_id	bigint		父编号
parent_ids	varchar	100	父编号列表
available	bool		是否可用

资源(sys_resource)

名称	类型	长度	描述
id	bigint		编号 主键
name	varchar	100	资源名称
type	varchar	50	资源类型，
priority	int		显示顺序
parent_id	bigint		父编号
parent_ids	varchar	100	父编号列表
permission	varchar	100	权限字符串
available	bool		是否可用

角色(sys_role)

名称	类型	长度	描述
id	bigint		编号 主键
role	varchar	100	角色名称
description	varchar	100	角色描述
resource_ids	varchar	100	授权的资源
available	bool		是否可用

 

资源：表示菜单元素、页面按钮元素等；菜单元素用来显示界面菜单的，页面按钮是每个页面可进行的操作，如新增、修改、删除按钮；使用type来区分元素类型（如menu表示菜单，button代表按钮），priority是元素的排序，如菜单显示顺序；permission表示权限；如用户菜单使用user:*；也就是把菜单授权给用户后，用户就拥有了user:*权限；如用户新增按钮使用user:create，也就是把用户新增按钮授权给用户后，用户就拥有了user:create权限了；available表示资源是否可用，如菜单显示/不显示。

角色：role表示角色标识符，如admin，用于后台判断使用；description表示角色描述，如超级管理员，用于前端显示给用户使用；resource_ids表示该角色拥有的资源列表，即该角色拥有的权限列表（显示角色），即角色是权限字符串集合；available表示角色是否可用。

组织机构：name表示组织机构名称，priority是组织机构的排序，即显示顺序；available表示组织机构是否可用。

用户：username表示用户名；password表示密码；salt表示加密密码的盐；role_ids表示用户拥有的角色列表，可以通过角色再获取其权限字符串列表；locked表示用户是否锁定。

 

此处如资源、组织机构都是树型结构：

id	name	parent_id	parent_ids
1	总公司	0	0/
2	山东分公司	1	0/1/
3	河北分公司	1	0/1/
4	济南分公司	2	0/1/2/

parent_id表示父编号，parent_ids表示所有祖先编号；如0/1/2/表示其祖先是2、1、0；其中根节点父编号为0。

 

为了简单性，如用户-角色，角色-资源关系直接在实体（用户表中的role_ids，角色表中的resource_ids）里完成的，没有建立多余的关系表，如要查询拥有admin角色的用户时，建议建立关联表，否则就没必要建立了。在存储关系时如role_ids=1,2,3,；多个之间使用逗号分隔。

 

用户组、组织机构组本实例没有实现，即可以把一组权限授权给这些组，组中的用户/组织机构就自动拥有这些角色/权限了；另外对于用户组可以实现一个默认用户组，如论坛，不管匿名/登录用户都有查看帖子的权限。

 

更复杂的权限请参考我的《JavaEE项目开发脚手架》：http://github.com/zhangkaitao/es。

 

表/数据SQL

具体请参考

sql/ shiro-schema.sql （表结构）

sql/ shiro-data.sql  （初始数据）

 

默认用户名/密码是admin/123456。

 

实体

具体请参考com.github.zhangkaitao.shiro.chapter16.entity包下的实体，此处就不列举了。

 

DAO

具体请参考com.github.zhangkaitao.shiro.chapter16.dao包下的DAO接口及实现。

 

Service

具体请参考com.github.zhangkaitao.shiro.chapter16.service包下的Service接口及实现。以下是出了基本CRUD之外的关键接口：

Java代码  

1. public interface ResourceService {  
2.     Set<String> findPermissions(Set<Long> resourceIds); //得到资源对应的权限字符串  
3.     List<Resource> findMenus(Set<String> permissions); //根据用户权限得到菜单  
4. }  

Java代码  

1. public interface RoleService {  
2.     Set<String> findRoles(Long... roleIds); //根据角色编号得到角色标识符列表  
3.     Set<String> findPermissions(Long[] roleIds); //根据角色编号得到权限字符串列表  
4. }  

Java代码  

1. public interface UserService {  
2.     public void changePassword(Long userId, String newPassword); //修改密码  
3.     public User findByUsername(String username); //根据用户名查找用户  
4.     public Set<String> findRoles(String username);// 根据用户名查找其角色  
5.     public Set<String> findPermissions(String username);// 根据用户名查找其权限  
6. }   

Service实现请参考源代码，此处就不列举了。

 

UserRealm实现     

Java代码  

1. public class UserRealm extends AuthorizingRealm {  
2.     @Autowired private UserService userService;  
3.     protected AuthorizationInfo doGetAuthorizationInfo(PrincipalCollection principals) {  
4.         String username = (String)principals.getPrimaryPrincipal();  
5.         SimpleAuthorizationInfo authorizationInfo = new SimpleAuthorizationInfo();  
6.         authorizationInfo.setRoles(userService.findRoles(username));  
7.         authorizationInfo.setStringPermissions(userService.findPermissions(username));  
8.         System.out.println(userService.findPermissions(username));  
9.         return authorizationInfo;  
10.     }  
11.     protected AuthenticationInfo doGetAuthenticationInfo(AuthenticationToken token) throws AuthenticationException {  
12.         String username = (String)token.getPrincipal();  
13.         User user = userService.findByUsername(username);  
14.         if(user == null) {  
15.             throw new UnknownAccountException();//没找到帐号  
16.         }  
17.         if(Boolean.TRUE.equals(user.getLocked())) {  
18.             throw new LockedAccountException(); //帐号锁定  
19.         }  
20.         return new SimpleAuthenticationInfo(  
21.                 user.getUsername(), //用户名  
22.                 user.getPassword(), //密码  
23.                 ByteSource.Util.bytes(user.getCredentialsSalt()),//salt=username+salt  
24.                 getName()  //realm name  
25.         );  
26.     }  
27. }  

此处的UserRealm和《第六章Realm及相关对象》中的UserRealm类似，通过UserService获取帐号及角色/权限信息。

 

Web层控制器 

Java代码  

1. @Controller  
2. public class IndexController {  
3.     @Autowired  
4.     private ResourceService resourceService;  
5.     @Autowired  
6.     private UserService userService;  
7.     @RequestMapping("/")  
8.     public String index(@CurrentUser User loginUser, Model model) {  
9.         Set<String> permissions = userService.findPermissions(loginUser.getUsername());  
10.         List<Resource> menus = resourceService.findMenus(permissions);  
11.         model.addAttribute("menus", menus);  
12.         return "index";  
13.     }  
14. }   

IndexController中查询菜单在前台界面显示，请参考相应的jsp页面；

   

Java代码  

1. @Controller  
2. public class LoginController {  
3.     @RequestMapping(value = "/login")  
4.     public String showLoginForm(HttpServletRequest req, Model model) {  
5.         String exceptionClassName = (String)req.getAttribute("shiroLoginFailure");  
6.         String error = null;  
7.         if(UnknownAccountException.class.getName().equals(exceptionClassName)) {  
8.             error = "用户名/密码错误";  
9.         } else if(IncorrectCredentialsException.class.getName().equals(exceptionClassName)) {  
10.             error = "用户名/密码错误";  
11.         } else if(exceptionClassName != null) {  
12.             error = "其他错误：" + exceptionClassName;  
13.         }  
14.         model.addAttribute("error", error);  
15.         return "login";  
16.     }  
17. }   

LoginController用于显示登录表单页面，其中shiro authc拦截器进行登录，登录失败的话会把错误存到shiroLoginFailure属性中，在该控制器中获取后来显示相应的错误信息。 

 

Java代码  

1. @RequiresPermissions("resource:view")  
2. @RequestMapping(method = RequestMethod.GET)  
3. public String list(Model model) {  
4.     model.addAttribute("resourceList", resourceService.findAll());  
5.     return "resource/list";  
6. }   

在控制器方法上使用@RequiresPermissions指定需要的权限信息，其他的都是类似的，请参考源码。

 

Web层标签库

com.github.zhangkaitao.shiro.chapter16.web.taglib.Functions提供了函数标签实现，有根据编号显示资源/角色/组织机构名称，其定义放在src/main/webapp/tld/zhang-functions.tld。

 

Web层异常处理器 

Java代码  

1. @ControllerAdvice  
2. public class DefaultExceptionHandler {  
3.     @ExceptionHandler({UnauthorizedException.class})  
4.     @ResponseStatus(HttpStatus.UNAUTHORIZED)  
5.     public ModelAndView processUnauthenticatedException(NativeWebRequest request, UnauthorizedException e) {  
6.         ModelAndView mv = new ModelAndView();  
7.         mv.addObject("exception", e);  
8.         mv.setViewName("unauthorized");  
9.         return mv;  
10.     }  
11. }   

如果抛出UnauthorizedException，将被该异常处理器截获来显示没有权限信息。

 

Spring配置——spring-config.xml

定义了context:component-scan来扫描除web层的组件、dataSource（数据源）、事务管理器及事务切面等；具体请参考配置源码。

 

Spring配置——spring-config-cache.xml

定义了spring通用cache，使用ehcache实现；具体请参考配置源码。

 

Spring配置——spring-config-shiro.xml

定义了shiro相关组件。 

Java代码  

1. <bean id="userRealm" class="com.github.zhangkaitao.shiro.chapter16.realm.UserRealm">  
2.     <property name="credentialsMatcher" ref="credentialsMatcher"/>  
3.     <property name="cachingEnabled" value="false"/>  
4. </bean>   

userRealm组件禁用掉了cache，可以参考https://github.com/zhangkaitao/es/tree/master/web/src/main/java/com/sishuok/es/extra/aop实现自己的cache切面；否则需要在修改如资源/角色等信息时清理掉缓存。 

 

Java代码  

1. <bean id="sysUserFilter"   
2. class="com.github.zhangkaitao.shiro.chapter16.web.shiro.filter.SysUserFilter"/>   

sysUserFilter用于根据当前登录用户身份获取User信息放入request；然后就可以通过request获取User。 

  

Java代码  

1. <property name="filterChainDefinitions">  
2.   <value>  
3.     /login = authc  
4.     /logout = logout  
5.     /authenticated = authc  
6.     /** = user,sysUser  
7.   </value>  
8. </property>   

如上是shiroFilter的filterChainDefinitions定义。 

 

Spring MVC配置——spring-mvc.xml

定义了spring mvc相关组件。 

Java代码  

1. <mvc:annotation-driven>  
2.   <mvc:argument-resolvers>  
3.     <bean class="com.github.zhangkaitao.shiro.chapter16  
4.         .web.bind.method.CurrentUserMethodArgumentResolver"/>  
5.   </mvc:argument-resolvers>  
6. </mvc:annotation-driven>   

此处注册了一个@CurrentUser参数解析器。如之前的IndexController，从request获取shiro sysUser拦截器放入的当前登录User对象。

 

 

Spring MVC配置——spring-mvc-shiro.xml

定义了spring mvc相关组件。 

Java代码  

1. <aop:config proxy-target-class="true"></aop:config>  
2. <bean class="org.apache.shiro.spring.security  
3.     .interceptor.AuthorizationAttributeSourceAdvisor">  
4.   <property name="securityManager" ref="securityManager"/>  
5. </bean>   

定义aop切面，用于代理如@RequiresPermissions注解的控制器，进行权限控制。

 

web.xml配置文件

定义Spring ROOT上下文加载器、ShiroFilter、及SpringMVC拦截器。具体请参考源码。

 

JSP页面       

Java代码  

1. <shiro:hasPermission name="user:create">  
2.     <a href="${pageContext.request.contextPath}/user/create">用户新增</a><br/>  
3. </shiro:hasPermission>   

使用shiro标签进行权限控制。具体请参考源码。

 

系统截图

访问http://localhost:8080/chapter16/；

首先进入登录页面，输入用户名/密码（默认admin/123456）登录： 

登录成功后到达整个页面主页，并根据当前用户权限显示相应的菜单，此处菜单比较简单，没有树型结构显示   

然后就可以进行一些操作，如组织机构维护、用户修改、资源维护、角色授权 

 

 

相关资料

《跟我学spring3》

     http://www.iteye.com/blogs/subjects/spring3

《跟开涛学SpringMVC》

     http://www.iteye.com/blogs/subjects/kaitao-springmvc

《简单shiro扩展实现NOT、AND、OR权限验证》

     http://jinnianshilongnian.iteye.com/blog/1864800

《Shiro+Struts2+Spring3 加上@RequiresPermissions 后@Autowired失效》

     http://jinnianshilongnian.iteye.com/blog/1850425

 

更复杂的权限请参考我的《JavaEE项目开发脚手架》：http://github.com/zhangkaitao/es，提供了更加复杂的实现。

@16@

目前很多开放平台如新浪微博开放平台都在使用提供开放API接口供开发者使用，随之带来了第三方应用要到开放平台进行授权的问题，OAuth就是干这个的，OAuth2是OAuth协议的下一个版本，相比OAuth1，OAuth2整个授权流程更简单安全了，但不兼容OAuth1，具体可以到OAuth2官网http://oauth.net/2/查看，OAuth2协议规范可以参考http://tools.ietf.org/html/rfc6749。目前有好多参考实现供选择，可以到其官网查看下载。

 

本文使用Apache Oltu，其之前的名字叫Apache Amber ，是Java版的参考实现。使用文档可参考https://cwiki.apache.org/confluence/display/OLTU/Documentation。

 

OAuth角色

资源拥有者（resource owner）：能授权访问受保护资源的一个实体，可以是一个人，那我们称之为最终用户；如新浪微博用户zhangsan；

资源服务器（resource server）：存储受保护资源，客户端通过access token请求资源，资源服务器响应受保护资源给客户端；存储着用户zhangsan的微博等信息。

授权服务器（authorization server）：成功验证资源拥有者并获取授权之后，授权服务器颁发授权令牌（Access Token）给客户端。

客户端（client）：如新浪微博客户端weico、微格等第三方应用，也可以是它自己的官方应用；其本身不存储资源，而是资源拥有者授权通过后，使用它的授权（授权令牌）访问受保护资源，然后客户端把相应的数据展示出来/提交到服务器。“客户端”术语不代表任何特定实现（如应用运行在一台服务器、桌面、手机或其他设备）。 

 

OAuth2协议流程

 

1、客户端从资源拥有者那请求授权。授权请求可以直接发给资源拥有者，或间接的通过授权服务器这种中介，后者更可取。

2、客户端收到一个授权许可，代表资源服务器提供的授权。

3、客户端使用它自己的私有证书及授权许可到授权服务器验证。

4、如果验证成功，则下发一个访问令牌。

5、客户端使用访问令牌向资源服务器请求受保护资源。

6、资源服务器会验证访问令牌的有效性，如果成功则下发受保护资源。

 

更多流程的解释请参考OAuth2的协议规范http://tools.ietf.org/html/rfc6749。

 

服务器端

本文把授权服务器和资源服务器整合在一起实现。

 

POM依赖

此处我们使用apache oltu oauth2服务端实现，需要引入authzserver（授权服务器依赖）和resourceserver（资源服务器依赖）。 

Java代码  

1. <dependency>  
2.     <groupId>org.apache.oltu.oauth2</groupId>  
3.     <artifactId>org.apache.oltu.oauth2.authzserver</artifactId>  
4.     <version>0.31</version>  
5. </dependency>  
6. <dependency>  
7.     <groupId>org.apache.oltu.oauth2</groupId>  
8.     <artifactId>org.apache.oltu.oauth2.resourceserver</artifactId>  
9.     <version>0.31</version>  
10. </dependency>   

其他的请参考pom.xml。

 

数据字典

用户(oauth2_user)

名称	类型	长度	描述
id	bigint	10	编号 主键
username	varchar	100	用户名
password	varchar	100	密码
salt	varchar	50	盐

客户端(oauth2_client)

名称	类型	长度	描述
id	bigint	10	编号 主键
client_name	varchar	100	客户端名称
client_id	varchar	100	客户端id
client_secret	varchar	100	客户端安全key

 

用户表存储着认证/资源服务器的用户信息，即资源拥有者；比如用户名/密码；客户端表存储客户端的的客户端id及客户端安全key；在进行授权时使用。

 

表及数据SQL

具体请参考

sql/ shiro-schema.sql （表结构）

sql/ shiro-data.sql  （初始数据）

 

默认用户名/密码是admin/123456。

 

实体

具体请参考com.github.zhangkaitao.shiro.chapter17.entity包下的实体，此处就不列举了。

 

DAO

具体请参考com.github.zhangkaitao.shiro.chapter17.dao包下的DAO接口及实现。

 

Service

具体请参考com.github.zhangkaitao.shiro.chapter17.service包下的Service接口及实现。以下是出了基本CRUD之外的关键接口： 

Java代码  

1. public interface UserService {  
2.     public User createUser(User user);// 创建用户  
3.     public User updateUser(User user);// 更新用户  
4.     public void deleteUser(Long userId);// 删除用户  
5.     public void changePassword(Long userId, String newPassword); //修改密码  
6.     User findOne(Long userId);// 根据id查找用户  
7.     List<User> findAll();// 得到所有用户  
8.     public User findByUsername(String username);// 根据用户名查找用户  
9. }  

Java代码  

1. public interface ClientService {  
2.     public Client createClient(Client client);// 创建客户端  
3.     public Client updateClient(Client client);// 更新客户端  
4.     public void deleteClient(Long clientId);// 删除客户端  
5.     Client findOne(Long clientId);// 根据id查找客户端  
6.     List<Client> findAll();// 查找所有  
7.     Client findByClientId(String clientId);// 根据客户端id查找客户端  
8.     Client findByClientSecret(String clientSecret);//根据客户端安全KEY查找客户端  
9. }  

Java代码  

1. public interface OAuthService {  
2.    public void addAuthCode(String authCode, String username);// 添加 auth code  
3.    public void addAccessToken(String accessToken, String username); // 添加 access token  
4.    boolean checkAuthCode(String authCode); // 验证auth code是否有效  
5.    boolean checkAccessToken(String accessToken); // 验证access token是否有效  
6.    String getUsernameByAuthCode(String authCode);// 根据auth code获取用户名  
7.    String getUsernameByAccessToken(String accessToken);// 根据access token获取用户名  
8.    long getExpireIn();//auth code / access token 过期时间  
9.    public boolean checkClientId(String clientId);// 检查客户端id是否存在  
10.    public boolean checkClientSecret(String clientSecret);// 坚持客户端安全KEY是否存在  
11. }   

此处通过OAuthService实现进行auth code和access token的维护。

 

后端数据维护控制器

具体请参考com.github.zhangkaitao.shiro.chapter17.web.controller包下的IndexController、LoginController、UserController和ClientController，其用于维护后端的数据，如用户及客户端数据；即相当于后台管理。

 

授权控制器AuthorizeController      

Java代码  

1. @Controller  
2. public class AuthorizeController {  
3.   @Autowired  
4.   private OAuthService oAuthService;  
5.   @Autowired  
6.   private ClientService clientService;  
7.   @RequestMapping("/authorize")  
8.   public Object authorize(Model model,  HttpServletRequest request)  
9.         throws URISyntaxException, OAuthSystemException {  
10.     try {  
11.       //构建OAuth 授权请求  
12.       OAuthAuthzRequest oauthRequest = new OAuthAuthzRequest(request);  
13.       //检查传入的客户端id是否正确  
14.       if (!oAuthService.checkClientId(oauthRequest.getClientId())) {  
15.         OAuthResponse response = OAuthASResponse  
16.              .errorResponse(HttpServletResponse.SC_BAD_REQUEST)  
17.              .setError(OAuthError.TokenResponse.INVALID_CLIENT)  
18.              .setErrorDescription(Constants.INVALID_CLIENT_DESCRIPTION)  
19.              .buildJSONMessage();  
20.         return new ResponseEntity(  
21.            response.getBody(), HttpStatus.valueOf(response.getResponseStatus()));  
22.       }  
23.   
24.       Subject subject = SecurityUtils.getSubject();  
25.       //如果用户没有登录，跳转到登陆页面  
26.       if(!subject.isAuthenticated()) {  
27.         if(!login(subject, request)) {//登录失败时跳转到登陆页面  
28.           model.addAttribute("client",      
29.               clientService.findByClientId(oauthRequest.getClientId()));  
30.           return "oauth2login";  
31.         }  
32.       }  
33.   
34.       String username = (String)subject.getPrincipal();  
35.       //生成授权码  
36.       String authorizationCode = null;  
37.       //responseType目前仅支持CODE，另外还有TOKEN  
38.       String responseType = oauthRequest.getParam(OAuth.OAUTH_RESPONSE_TYPE);  
39.       if (responseType.equals(ResponseType.CODE.toString())) {  
40.         OAuthIssuerImpl oauthIssuerImpl = new OAuthIssuerImpl(new MD5Generator());  
41.         authorizationCode = oauthIssuerImpl.authorizationCode();  
42.         oAuthService.addAuthCode(authorizationCode, username);  
43.       }  
44.       //进行OAuth响应构建  
45.       OAuthASResponse.OAuthAuthorizationResponseBuilder builder =  
46.         OAuthASResponse.authorizationResponse(request,   
47.                                            HttpServletResponse.SC_FOUND);  
48.       //设置授权码  
49.       builder.setCode(authorizationCode);  
50.       //得到到客户端重定向地址  
51.       String redirectURI = oauthRequest.getParam(OAuth.OAUTH_REDIRECT_URI);  
52.   
53.       //构建响应  
54.       final OAuthResponse response = builder.location(redirectURI).buildQueryMessage();  
55.       //根据OAuthResponse返回ResponseEntity响应  
56.       HttpHeaders headers = new HttpHeaders();  
57.       headers.setLocation(new URI(response.getLocationUri()));  
58.       return new ResponseEntity(headers, HttpStatus.valueOf(response.getResponseStatus()));  
59.     } catch (OAuthProblemException e) {  
60.       //出错处理  
61.       String redirectUri = e.getRedirectUri();  
62.       if (OAuthUtils.isEmpty(redirectUri)) {  
63.         //告诉客户端没有传入redirectUri直接报错  
64.         return new ResponseEntity(  
65.           "OAuth callback url needs to be provided by client!!!", HttpStatus.NOT_FOUND);  
66.       }  
67.       //返回错误消息（如?error=）  
68.       final OAuthResponse response =  
69.               OAuthASResponse.errorResponse(HttpServletResponse.SC_FOUND)  
70.                       .error(e).location(redirectUri).buildQueryMessage();  
71.       HttpHeaders headers = new HttpHeaders();  
72.       headers.setLocation(new URI(response.getLocationUri()));  
73.       return new ResponseEntity(headers, HttpStatus.valueOf(response.getResponseStatus()));  
74.     }  
75.   }  
76.   
77.   private boolean login(Subject subject, HttpServletRequest request) {  
78.     if("get".equalsIgnoreCase(request.getMethod())) {  
79.       return false;  
80.     }  
81.     String username = request.getParameter("username");  
82.     String password = request.getParameter("password");  
83.   
84.     if(StringUtils.isEmpty(username) || StringUtils.isEmpty(password)) {  
85.       return false;  
86.     }  
87.   
88.     UsernamePasswordToken token = new UsernamePasswordToken(username, password);  
89.     try {  
90.       subject.login(token);  
91.       return true;  
92.     } catch (Exception e) {  
93.       request.setAttribute("error", "登录失败:" + e.getClass().getName());  
94.       return false;  
95.     }  
96.   }  
97. }   

如上代码的作用：

1、首先通过如http://localhost:8080/chapter17-server/authorize

?client_id=c1ebe466-1cdc-4bd3-ab69-77c3561b9dee&response_type=code&redirect_uri=http://localhost:9080/chapter17-client/oauth2-login访问授权页面；

2、该控制器首先检查clientId是否正确；如果错误将返回相应的错误信息；

3、然后判断用户是否登录了，如果没有登录首先到登录页面登录；

4、登录成功后生成相应的auth code即授权码，然后重定向到客户端地址，如http://localhost:9080/chapter17-client/oauth2-login?code=52b1832f5dff68122f4f00ae995da0ed；在重定向到的地址中会带上code参数（授权码），接着客户端可以根据授权码去换取access token。

 

访问令牌控制器AccessTokenController  

Java代码  

1. @RestController  
2. public class AccessTokenController {  
3.   @Autowired  
4.   private OAuthService oAuthService;  
5.   @Autowired  
6.   private UserService userService;  
7.   @RequestMapping("/accessToken")  
8.   public HttpEntity token(HttpServletRequest request)  
9.           throws URISyntaxException, OAuthSystemException {  
10.     try {  
11.       //构建OAuth请求  
12.       OAuthTokenRequest oauthRequest = new OAuthTokenRequest(request);  
13.   
14.       //检查提交的客户端id是否正确  
15.       if (!oAuthService.checkClientId(oauthRequest.getClientId())) {  
16.         OAuthResponse response = OAuthASResponse  
17.                 .errorResponse(HttpServletResponse.SC_BAD_REQUEST)  
18.                 .setError(OAuthError.TokenResponse.INVALID_CLIENT)  
19.                 .setErrorDescription(Constants.INVALID_CLIENT_DESCRIPTION)  
20.                 .buildJSONMessage();  
21.        return new ResponseEntity(  
22.          response.getBody(), HttpStatus.valueOf(response.getResponseStatus()));  
23.       }  
24.   
25.     // 检查客户端安全KEY是否正确  
26.       if (!oAuthService.checkClientSecret(oauthRequest.getClientSecret())) {  
27.         OAuthResponse response = OAuthASResponse  
28.               .errorResponse(HttpServletResponse.SC_UNAUTHORIZED)  
29.               .setError(OAuthError.TokenResponse.UNAUTHORIZED_CLIENT)  
30.               .setErrorDescription(Constants.INVALID_CLIENT_DESCRIPTION)  
31.               .buildJSONMessage();  
32.       return new ResponseEntity(  
33.           response.getBody(), HttpStatus.valueOf(response.getResponseStatus()));  
34.       }  
35.     
36.       String authCode = oauthRequest.getParam(OAuth.OAUTH_CODE);  
37.       // 检查验证类型，此处只检查AUTHORIZATION_CODE类型，其他的还有PASSWORD或REFRESH_TOKEN  
38.       if (oauthRequest.getParam(OAuth.OAUTH_GRANT_TYPE).equals(  
39.          GrantType.AUTHORIZATION_CODE.toString())) {  
40.          if (!oAuthService.checkAuthCode(authCode)) {  
41.             OAuthResponse response = OAuthASResponse  
42.                 .errorResponse(HttpServletResponse.SC_BAD_REQUEST)  
43.                 .setError(OAuthError.TokenResponse.INVALID_GRANT)  
44.                 .setErrorDescription("错误的授权码")  
45.               .buildJSONMessage();  
46.            return new ResponseEntity(  
47.              response.getBody(), HttpStatus.valueOf(response.getResponseStatus()));  
48.          }  
49.       }  
50.   
51.       //生成Access Token  
52.       OAuthIssuer oauthIssuerImpl = new OAuthIssuerImpl(new MD5Generator());  
53.       final String accessToken = oauthIssuerImpl.accessToken();  
54.       oAuthService.addAccessToken(accessToken,  
55.           oAuthService.getUsernameByAuthCode(authCode));  
56.   
57.       //生成OAuth响应  
58.       OAuthResponse response = OAuthASResponse  
59.               .tokenResponse(HttpServletResponse.SC_OK)  
60.               .setAccessToken(accessToken)  
61.               .setExpiresIn(String.valueOf(oAuthService.getExpireIn()))  
62.               .buildJSONMessage();  
63.   
64.       //根据OAuthResponse生成ResponseEntity  
65.       return new ResponseEntity(  
66.           response.getBody(), HttpStatus.valueOf(response.getResponseStatus()));  
67.     } catch (OAuthProblemException e) {  
68.       //构建错误响应  
69.       OAuthResponse res = OAuthASResponse  
70.               .errorResponse(HttpServletResponse.SC_BAD_REQUEST).error(e)  
71.               .buildJSONMessage();  
72.      return new ResponseEntity(res.getBody(), HttpStatus.valueOf(res.getResponseStatus()));  
73.    }  
74.  }  
75. }   

如上代码的作用：

1、首先通过如http://localhost:8080/chapter17-server/accessToken，POST提交如下数据：client_id= c1ebe466-1cdc-4bd3-ab69-77c3561b9dee& client_secret= d8346ea2-6017-43ed-ad68-19c0f971738b&grant_type=authorization_code&code=828beda907066d058584f37bcfd597b6&redirect_uri=http://localhost:9080/chapter17-client/oauth2-login访问；

2、该控制器会验证client_id、client_secret、auth code的正确性，如果错误会返回相应的错误；

3、如果验证通过会生成并返回相应的访问令牌access token。

 

资源控制器UserInfoController  

Java代码  

1. @RestController  
2. public class UserInfoController {  
3.   @Autowired  
4.   private OAuthService oAuthService;  
5.   
6.   @RequestMapping("/userInfo")  
7.   public HttpEntity userInfo(HttpServletRequest request) throws OAuthSystemException {  
8.     try {  
9.       //构建OAuth资源请求  
10.       OAuthAccessResourceRequest oauthRequest =   
11.             new OAuthAccessResourceRequest(request, ParameterStyle.QUERY);  
12.       //获取Access Token  
13.       String accessToken = oauthRequest.getAccessToken();  
14.   
15.       //验证Access Token  
16.       if (!oAuthService.checkAccessToken(accessToken)) {  
17.         // 如果不存在/过期了，返回未验证错误，需重新验证  
18.       OAuthResponse oauthResponse = OAuthRSResponse  
19.               .errorResponse(HttpServletResponse.SC_UNAUTHORIZED)  
20.               .setRealm(Constants.RESOURCE_SERVER_NAME)  
21.               .setError(OAuthError.ResourceResponse.INVALID_TOKEN)  
22.               .buildHeaderMessage();  
23.   
24.         HttpHeaders headers = new HttpHeaders();  
25.         headers.add(OAuth.HeaderType.WWW_AUTHENTICATE,   
26.           oauthResponse.getHeader(OAuth.HeaderType.WWW_AUTHENTICATE));  
27.       return new ResponseEntity(headers, HttpStatus.UNAUTHORIZED);  
28.       }  
29.       //返回用户名  
30.       String username = oAuthService.getUsernameByAccessToken(accessToken);  
31.       return new ResponseEntity(username, HttpStatus.OK);  
32.     } catch (OAuthProblemException e) {  
33.       //检查是否设置了错误码  
34.       String errorCode = e.getError();  
35.       if (OAuthUtils.isEmpty(errorCode)) {  
36.         OAuthResponse oauthResponse = OAuthRSResponse  
37.                .errorResponse(HttpServletResponse.SC_UNAUTHORIZED)  
38.                .setRealm(Constants.RESOURCE_SERVER_NAME)  
39.                .buildHeaderMessage();  
40.   
41.         HttpHeaders headers = new HttpHeaders();  
42.         headers.add(OAuth.HeaderType.WWW_AUTHENTICATE,   
43.           oauthResponse.getHeader(OAuth.HeaderType.WWW_AUTHENTICATE));  
44.         return new ResponseEntity(headers, HttpStatus.UNAUTHORIZED);  
45.       }  
46.   
47.       OAuthResponse oauthResponse = OAuthRSResponse  
48.                .errorResponse(HttpServletResponse.SC_UNAUTHORIZED)  
49.                .setRealm(Constants.RESOURCE_SERVER_NAME)  
50.                .setError(e.getError())  
51.                .setErrorDescription(e.getDescription())  
52.                .setErrorUri(e.getUri())  
53.                .buildHeaderMessage();  
54.   
55.       HttpHeaders headers = new HttpHeaders();  
56.       headers.add(OAuth.HeaderType.WWW_AUTHENTICATE, 、  
57.         oauthResponse.getHeader(OAuth.HeaderType.WWW_AUTHENTICATE));  
58.       return new ResponseEntity(HttpStatus.BAD_REQUEST);  
59.     }  
60.   }  
61. }   

如上代码的作用：

1、首先通过如http://localhost:8080/chapter17-server/userInfo? access_token=828beda907066d058584f37bcfd597b6进行访问；

2、该控制器会验证access token的有效性；如果无效了将返回相应的错误，客户端再重新进行授权；

3、如果有效，则返回当前登录用户的用户名。

 

Spring配置文件

具体请参考resources/spring*.xml，此处只列举spring-config-shiro.xml中的shiroFilter的filterChainDefinitions属性：  

Java代码  

1. <property name="filterChainDefinitions">  
2.     <value>  
3.       / = anon  
4.       /login = authc  
5.       /logout = logout  
6.   
7.       /authorize=anon  
8.       /accessToken=anon  
9.       /userInfo=anon  
10.   
11.       /** = user  
12.     </value>  
13. </property>   

对于oauth2的几个地址/authorize、/accessToken、/userInfo都是匿名可访问的。

 

其他源码请直接下载文档查看。

 

服务器维护

访问localhost:8080/chapter17-server/，登录后进行客户端管理和用户管理。

客户端管理就是进行客户端的注册，如新浪微博的第三方应用就需要到新浪微博开发平台进行注册；用户管理就是进行如新浪微博用户的管理。

 

对于授权服务和资源服务的实现可以参考新浪微博开发平台的实现：

http://open.weibo.com/wiki/授权机制说明 

http://open.weibo.com/wiki/微博API 

 

客户端

客户端流程：如果需要登录首先跳到oauth2服务端进行登录授权，成功后服务端返回auth code，然后客户端使用auth code去服务器端换取access token，最好根据access token获取用户信息进行客户端的登录绑定。这个可以参照如很多网站的新浪微博登录功能，或其他的第三方帐号登录功能。

POM依赖

此处我们使用apache oltu oauth2客户端实现。     

Java代码  

1. <dependency>  
2.   <groupId>org.apache.oltu.oauth2</groupId>  
3.   <artifactId>org.apache.oltu.oauth2.client</artifactId>  
4.   <version>0.31</version>  
5. </dependency>   

其他的请参考pom.xml。

 

OAuth2Token

类似于UsernamePasswordToken和CasToken；用于存储oauth2服务端返回的auth code。  

Java代码  

1. public class OAuth2Token implements AuthenticationToken {  
2.     private String authCode;  
3.     private String principal;  
4.     public OAuth2Token(String authCode) {  
5.         this.authCode = authCode;  
6.     }  
7.     //省略getter/setter  
8. }   

  

OAuth2AuthenticationFilter

该filter的作用类似于FormAuthenticationFilter用于oauth2客户端的身份验证控制；如果当前用户还没有身份验证，首先会判断url中是否有code（服务端返回的auth code），如果没有则重定向到服务端进行登录并授权，然后返回auth code；接着OAuth2AuthenticationFilter会用auth code创建OAuth2Token，然后提交给Subject.login进行登录；接着OAuth2Realm会根据OAuth2Token进行相应的登录逻辑。  

Java代码  

1. public class OAuth2AuthenticationFilter extends AuthenticatingFilter {  
2.     //oauth2 authc code参数名  
3.     private String authcCodeParam = "code";  
4.     //客户端id  
5.     private String clientId;  
6.     //服务器端登录成功/失败后重定向到的客户端地址  
7.     private String redirectUrl;  
8.     //oauth2服务器响应类型  
9.     private String responseType = "code";  
10.     private String failureUrl;  
11.     //省略setter  
12.     protected AuthenticationToken createToken(ServletRequest request, ServletResponse response) throws Exception {  
13.         HttpServletRequest httpRequest = (HttpServletRequest) request;  
14.         String code = httpRequest.getParameter(authcCodeParam);  
15.         return new OAuth2Token(code);  
16.     }  
17.     protected boolean isAccessAllowed(ServletRequest request, ServletResponse response, Object mappedValue) {  
18.         return false;  
19.     }  
20.     protected boolean onAccessDenied(ServletRequest request, ServletResponse response) throws Exception {  
21.         String error = request.getParameter("error");  
22.         String errorDescription = request.getParameter("error_description");  
23.         if(!StringUtils.isEmpty(error)) {//如果服务端返回了错误  
24.             WebUtils.issueRedirect(request, response, failureUrl + "?error=" + error + "error_description=" + errorDescription);  
25.             return false;  
26.         }  
27.         Subject subject = getSubject(request, response);  
28.         if(!subject.isAuthenticated()) {  
29.             if(StringUtils.isEmpty(request.getParameter(authcCodeParam))) {  
30.                 //如果用户没有身份验证，且没有auth code，则重定向到服务端授权  
31.                 saveRequestAndRedirectToLogin(request, response);  
32.                 return false;  
33.             }  
34.         }  
35.         //执行父类里的登录逻辑，调用Subject.login登录  
36.         return executeLogin(request, response);  
37.     }  
38.   
39.     //登录成功后的回调方法 重定向到成功页面  
40.     protected boolean onLoginSuccess(AuthenticationToken token, Subject subject, ServletRequest request,  ServletResponse response) throws Exception {  
41.         issueSuccessRedirect(request, response);  
42.         return false;  
43.     }  
44.   
45.     //登录失败后的回调   
46.     protected boolean onLoginFailure(AuthenticationToken token, AuthenticationException ae, ServletRequest request,  
47.                                      ServletResponse response) {  
48.         Subject subject = getSubject(request, response);  
49.         if (subject.isAuthenticated() || subject.isRemembered()) {  
50.             try { //如果身份验证成功了 则也重定向到成功页面  
51.                 issueSuccessRedirect(request, response);  
52.             } catch (Exception e) {  
53.                 e.printStackTrace();  
54.             }  
55.         } else {  
56.             try { //登录失败时重定向到失败页面  
57.                 WebUtils.issueRedirect(request, response, failureUrl);  
58.             } catch (IOException e) {  
59.                 e.printStackTrace();  
60.             }  
61.         }  
62.         return false;  
63.     }  
64. }   

该拦截器的作用：

1、首先判断有没有服务端返回的error参数，如果有则直接重定向到失败页面；

2、接着如果用户还没有身份验证，判断是否有auth code参数（即是不是服务端授权之后返回的），如果没有则重定向到服务端进行授权；

3、否则调用executeLogin进行登录，通过auth code创建OAuth2Token提交给Subject进行登录；

4、登录成功将回调onLoginSuccess方法重定向到成功页面；

5、登录失败则回调onLoginFailure重定向到失败页面。

 

OAuth2Realm  

Java代码  

1. public class OAuth2Realm extends AuthorizingRealm {  
2.     private String clientId;  
3.     private String clientSecret;  
4.     private String accessTokenUrl;  
5.     private String userInfoUrl;  
6.     private String redirectUrl;  
7.     //省略setter  
8.     public boolean supports(AuthenticationToken token) {  
9.         return token instanceof OAuth2Token; //表示此Realm只支持OAuth2Token类型  
10.     }  
11.     protected AuthorizationInfo doGetAuthorizationInfo(PrincipalCollection principals) {  
12.         SimpleAuthorizationInfo authorizationInfo = new SimpleAuthorizationInfo();  
13.         return authorizationInfo;  
14.     }  
15.     protected AuthenticationInfo doGetAuthenticationInfo(AuthenticationToken token) throws AuthenticationException {  
16.         OAuth2Token oAuth2Token = (OAuth2Token) token;  
17.         String code = oAuth2Token.getAuthCode(); //获取 auth code  
18.         String username = extractUsername(code); // 提取用户名  
19.         SimpleAuthenticationInfo authenticationInfo =  
20.                 new SimpleAuthenticationInfo(username, code, getName());  
21.         return authenticationInfo;  
22.     }  
23.     private String extractUsername(String code) {  
24.         try {  
25.             OAuthClient oAuthClient = new OAuthClient(new URLConnectionClient());  
26.             OAuthClientRequest accessTokenRequest = OAuthClientRequest  
27.                     .tokenLocation(accessTokenUrl)  
28.                     .setGrantType(GrantType.AUTHORIZATION_CODE)  
29.                     .setClientId(clientId).setClientSecret(clientSecret)  
30.                     .setCode(code).setRedirectURI(redirectUrl)  
31.                     .buildQueryMessage();  
32.             //获取access token  
33.             OAuthAccessTokenResponse oAuthResponse =   
34.                 oAuthClient.accessToken(accessTokenRequest, OAuth.HttpMethod.POST);  
35.             String accessToken = oAuthResponse.getAccessToken();  
36.             Long expiresIn = oAuthResponse.getExpiresIn();  
37.             //获取user info  
38.             OAuthClientRequest userInfoRequest =   
39.                 new OAuthBearerClientRequest(userInfoUrl)  
40.                     .setAccessToken(accessToken).buildQueryMessage();  
41.             OAuthResourceResponse resourceResponse = oAuthClient.resource(  
42.                 userInfoRequest, OAuth.HttpMethod.GET, OAuthResourceResponse.class);  
43.             String username = resourceResponse.getBody();  
44.             return username;  
45.         } catch (Exception e) {  
46.             throw new OAuth2AuthenticationException(e);  
47.         }  
48.     }  
49. }  

此Realm首先只支持OAuth2Token类型的Token；然后通过传入的auth code去换取access token；再根据access token去获取用户信息（用户名），然后根据此信息创建AuthenticationInfo；如果需要AuthorizationInfo信息，可以根据此处获取的用户名再根据自己的业务规则去获取。

 

Spring shiro配置（spring-config-shiro.xml）  

Java代码  

1. <bean id="oAuth2Realm"   
2.     class="com.github.zhangkaitao.shiro.chapter18.oauth2.OAuth2Realm">  
3.   <property name="cachingEnabled" value="true"/>  
4.   <property name="authenticationCachingEnabled" value="true"/>  
5.   <property name="authenticationCacheName" value="authenticationCache"/>  
6.   <property name="authorizationCachingEnabled" value="true"/>  
7.   <property name="authorizationCacheName" value="authorizationCache"/>  
8.   <property name="clientId" value="c1ebe466-1cdc-4bd3-ab69-77c3561b9dee"/>  
9.   <property name="clientSecret" value="d8346ea2-6017-43ed-ad68-19c0f971738b"/>  
10.   <property name="accessTokenUrl"   
11.      value="http://localhost:8080/chapter17-server/accessToken"/>  
12.   <property name="userInfoUrl" value="http://localhost:8080/chapter17-server/userInfo"/>  
13.   <property name="redirectUrl" value="http://localhost:9080/chapter17-client/oauth2-login"/>  
14. </bean>   

此OAuth2Realm需要配置在服务端申请的clientId和clientSecret；及用于根据auth code换取access token的accessTokenUrl地址；及用于根据access token换取用户信息（受保护资源）的userInfoUrl地址。 

 

Java代码  

1. <bean id="oAuth2AuthenticationFilter"   
2.     class="com.github.zhangkaitao.shiro.chapter18.oauth2.OAuth2AuthenticationFilter">  
3.   <property name="authcCodeParam" value="code"/>  
4.   <property name="failureUrl" value="/oauth2Failure.jsp"/>  
5. </bean>   

此OAuth2AuthenticationFilter用于拦截服务端重定向回来的auth code。  

 

Java代码  

1. <bean id="shiroFilter" class="org.apache.shiro.spring.web.ShiroFilterFactoryBean">  
2.   <property name="securityManager" ref="securityManager"/>  
3.   <property name="loginUrl" value="http://localhost:8080/chapter17-server/authorize?client_id=c1ebe466-1cdc-4bd3-ab69-77c3561b9dee&amp;response_type=code&amp;redirect_uri=http://localhost:9080/chapter17-client/oauth2-login"/>  
4.   <property name="successUrl" value="/"/>  
5.   <property name="filters">  
6.       <util:map>  
7.          <entry key="oauth2Authc" value-ref="oAuth2AuthenticationFilter"/>  
8.       </util:map>  
9.   </property>  
10.   <property name="filterChainDefinitions">  
11.       <value>  
12.           / = anon  
13.           /oauth2Failure.jsp = anon  
14.           /oauth2-login = oauth2Authc  
15.           /logout = logout  
16.           /** = user  
17.       </value>  
18.   </property>  
19. </bean>  

此处设置loginUrl为http://localhost:8080/chapter17-server/authorize

?client_id=c1ebe466-1cdc-4bd3-ab69-77c3561b9dee&amp;response_type=code&amp;redirect_uri=http://localhost:9080/chapter17-client/oauth2-login"；其会自动设置到所有的AccessControlFilter，如oAuth2AuthenticationFilter；另外/oauth2-login = oauth2Authc表示/oauth2-login地址使用oauth2Authc拦截器拦截并进行oauth2客户端授权。

 

测试

1、首先访问http://localhost:9080/chapter17-client/，然后点击登录按钮进行登录，会跳到如下页面： 

 

2、输入用户名进行登录并授权；

3、如果登录成功，服务端会重定向到客户端，即之前客户端提供的地址http://localhost:9080/chapter17-client/oauth2-login?code=473d56015bcf576f2ca03eac1a5bcc11，并带着auth code过去；

4、客户端的OAuth2AuthenticationFilter会收集此auth code，并创建OAuth2Token提交给Subject进行客户端登录；

5、客户端的Subject会委托给OAuth2Realm进行身份验证；此时OAuth2Realm会根据auth code换取access token，再根据access token获取受保护的用户信息；然后进行客户端登录。

 

到此OAuth2的集成就完成了，此处的服务端和客户端相对比较简单，没有进行一些异常检测，请参考如新浪微博进行相应API及异常错误码的设计。   

@17@

在某些项目中可能会遇到如每个账户同时只能有一个人登录或几个人同时登录，如果同时有多人登录：要么不让后者登录；要么踢出前者登录（强制退出）。比如spring security就直接提供了相应的功能；Shiro的话没有提供默认实现，不过可以很容易的在Shiro中加入这个功能。

 

示例代码基于《第十六章 综合实例》完成，通过Shiro Filter机制扩展KickoutSessionControlFilter完成。

 

首先来看看如何配置使用（spring-config-shiro.xml）

  

kickoutSessionControlFilter用于控制并发登录人数的 

Java代码  

1. <bean id="kickoutSessionControlFilter"   
2. class="com.github.zhangkaitao.shiro.chapter18.web.shiro.filter.KickoutSessionControlFilter">  
3.     <property name="cacheManager" ref="cacheManager"/>  
4.     <property name="sessionManager" ref="sessionManager"/>  
5.   
6.     <property name="kickoutAfter" value="false"/>  
7.     <property name="maxSession" value="2"/>  
8.     <property name="kickoutUrl" value="/login?kickout=1"/>  
9. </bean>   

cacheManager：使用cacheManager获取相应的cache来缓存用户登录的会话；用于保存用户—会话之间的关系的；

sessionManager：用于根据会话ID，获取会话进行踢出操作的；

kickoutAfter：是否踢出后来登录的，默认是false；即后者登录的用户踢出前者登录的用户；

maxSession：同一个用户最大的会话数，默认1；比如2的意思是同一个用户允许最多同时两个人登录；

kickoutUrl：被踢出后重定向到的地址；

 

shiroFilter配置 

Java代码  

1. <bean id="shiroFilter" class="org.apache.shiro.spring.web.ShiroFilterFactoryBean">  
2.      <property name="securityManager" ref="securityManager"/>  
3.      <property name="loginUrl" value="/login"/>  
4.      <property name="filters">  
5.          <util:map>  
6.              <entry key="authc" value-ref="formAuthenticationFilter"/>  
7.              <entry key="sysUser" value-ref="sysUserFilter"/>  
8.              <entry key="kickout" value-ref="kickoutSessionControlFilter"/>  
9.          </util:map>  
10.      </property>  
11.      <property name="filterChainDefinitions">  
12.          <value>  
13.              /login = authc  
14.              /logout = logout  
15.              /authenticated = authc  
16.              /** = kickout,user,sysUser  
17.          </value>  
18.      </property>  
19.  </bean>   

此处配置除了登录等之外的地址都走kickout拦截器进行并发登录控制。

 

测试

此处因为maxSession=2，所以需要打开3个浏览器（需要不同的浏览器，如IE、Chrome、Firefox），分别访问http://localhost:8080/chapter18/进行登录；然后刷新第一次打开的浏览器，将会被强制退出，如显示下图： 

KickoutSessionControlFilter核心代码： 

Java代码  

1. protected boolean onAccessDenied(ServletRequest request, ServletResponse response) throws Exception {  
2.     Subject subject = getSubject(request, response);  
3.     if(!subject.isAuthenticated() && !subject.isRemembered()) {  
4.         //如果没有登录，直接进行之后的流程  
5.         return true;  
6.     }  
7.   
8.     Session session = subject.getSession();  
9.     String username = (String) subject.getPrincipal();  
10.     Serializable sessionId = session.getId();  
11.   
12.     //TODO 同步控制  
13.     Deque<Serializable> deque = cache.get(username);  
14.     if(deque == null) {  
15.         deque = new LinkedList<Serializable>();  
16.         cache.put(username, deque);  
17.     }  
18.   
19.     //如果队列里没有此sessionId，且用户没有被踢出；放入队列  
20.     if(!deque.contains(sessionId) && session.getAttribute("kickout") == null) {  
21.         deque.push(sessionId);  
22.     }  
23.   
24.     //如果队列里的sessionId数超出最大会话数，开始踢人  
25.     while(deque.size() > maxSession) {  
26.         Serializable kickoutSessionId = null;  
27.         if(kickoutAfter) { //如果踢出后者  
28.             kickoutSessionId = deque.removeFirst();  
29.         } else { //否则踢出前者  
30.             kickoutSessionId = deque.removeLast();  
31.         }  
32.         try {  
33.             Session kickoutSession =  
34.                 sessionManager.getSession(new DefaultSessionKey(kickoutSessionId));  
35.             if(kickoutSession != null) {  
36.                 //设置会话的kickout属性表示踢出了  
37.                 kickoutSession.setAttribute("kickout", true);  
38.             }  
39.         } catch (Exception e) {//ignore exception  
40.         }  
41.     }  
42.   
43.     //如果被踢出了，直接退出，重定向到踢出后的地址  
44.     if (session.getAttribute("kickout") != null) {  
45.         //会话被踢出了  
46.         try {  
47.             subject.logout();  
48.         } catch (Exception e) { //ignore  
49.         }  
50.         saveRequest(request);  
51.         WebUtils.issueRedirect(request, response, kickoutUrl);  
52.         return false;  
53.     }  
54.     return true;  
55. }   

此处使用了Cache缓存用户名—会话id之间的关系；如果量比较大可以考虑如持久化到数据库/其他带持久化的Cache中；另外此处没有并发控制的同步实现，可以考虑根据用户名获取锁来控制，减少锁的粒度。

@18@

用过Spring Security的朋友应该比较熟悉对URL进行全局的权限控制，即访问URL时进行权限匹配；如果没有权限直接跳到相应的错误页面。Shiro也支持类似的机制，不过需要稍微改造下来满足实际需求。不过在Shiro中，更多的是通过AOP进行分散的权限控制，即方法级别的；而通过URL进行权限控制是一种集中的权限控制。本章将介绍如何在Shiro中完成动态URL权限控制。

 

本章代码基于《第十六章 综合实例》，请先了解相关数据模型及基本流程后再学习本章。

 

表及数据SQL

请运行shiro-example-chapter19/sql/ shiro-schema.sql 表结构

请运行shiro-example-chapter19/sql/ shiro-schema.sql 数据

 

实体

具体请参考com.github.zhangkaitao.shiro.chapter19包下的实体。 

Java代码  

1. public class UrlFilter implements Serializable {  
2.     private Long id;  
3.     private String name; //url名称/描述  
4.     private String url; //地址  
5.     private String roles; //所需要的角色，可省略  
6.     private String permissions; //所需要的权限，可省略  
7. }   

表示拦截的URL和角色/权限之间的关系，多个角色/权限之间通过逗号分隔，此处还可以扩展其他的关系，另外可以加如available属性表示是否开启该拦截。

 

DAO

具体请参考com.github.zhangkaitao.shiro.chapter19.dao包下的DAO接口及实现。

 

Service

具体请参考com.github.zhangkaitao.shiro.chapter19.service包下的Service接口及实现。  

Java代码  

1. public interface UrlFilterService {  
2.     public UrlFilter createUrlFilter(UrlFilter urlFilter);  
3.     public UrlFilter updateUrlFilter(UrlFilter urlFilter);  
4.     public void deleteUrlFilter(Long urlFilterId);  
5.     public UrlFilter findOne(Long urlFilterId);  
6.     public List<UrlFilter> findAll();  
7. }  

基本的URL拦截的增删改查实现。 

 

Java代码  

1. @Service  
2. public class UrlFilterServiceImpl implements UrlFilterService {  
3.     @Autowired  
4. private ShiroFilerChainManager shiroFilerChainManager;  
5.   
6.     @Override  
7.     public UrlFilter createUrlFilter(UrlFilter urlFilter) {  
8.         urlFilterDao.createUrlFilter(urlFilter);  
9.         initFilterChain();  
10.         return urlFilter;  
11.     }  
12.     //其他方法请参考源码  
13.     @PostConstruct  
14.     public void initFilterChain() {  
15.         shiroFilerChainManager.initFilterChains(findAll());  
16.     }  
17. }   

UrlFilterServiceImpl在进行新增、修改、删除时会调用initFilterChain来重新初始化Shiro的URL拦截器链，即同步数据库中的URL拦截器定义到Shiro中。此处也要注意如果直接修改数据库是不会起作用的，因为只要调用这几个Service方法时才同步。另外当容器启动时会自动回调initFilterChain来完成容器启动后的URL拦截器的注册。

  

ShiroFilerChainManager 

Java代码  

1. @Service  
2. public class ShiroFilerChainManager {  
3.     @Autowired private DefaultFilterChainManager filterChainManager;  
4.     private Map<String, NamedFilterList> defaultFilterChains;  
5.     @PostConstruct  
6.     public void init() {  
7.         defaultFilterChains =   
8.           new HashMap<String, NamedFilterList>(filterChainManager.getFilterChains());  
9.     }  
10.     public void initFilterChains(List<UrlFilter> urlFilters) {  
11.         //1、首先删除以前老的filter chain并注册默认的  
12.         filterChainManager.getFilterChains().clear();  
13.         if(defaultFilterChains != null) {  
14.             filterChainManager.getFilterChains().putAll(defaultFilterChains);  
15.         }  
16.         //2、循环URL Filter 注册filter chain  
17.         for (UrlFilter urlFilter : urlFilters) {  
18.             String url = urlFilter.getUrl();  
19.             //注册roles filter  
20.             if (!StringUtils.isEmpty(urlFilter.getRoles())) {  
21.                 filterChainManager.addToChain(url, "roles", urlFilter.getRoles());  
22.             }  
23.             //注册perms filter  
24.             if (!StringUtils.isEmpty(urlFilter.getPermissions())) {  
25.                 filterChainManager.addToChain(url, "perms", urlFilter.getPermissions());  
26.             }  
27.         }  
28.     }  
29. }   

1、init：Spring容器启动时会调用init方法把在spring配置文件中配置的默认拦截器保存下来，之后会自动与数据库中的配置进行合并。

2、initFilterChains：UrlFilterServiceImpl会在Spring容器启动或进行增删改UrlFilter时进行注册URL拦截器到Shiro。

 

拦截器及拦截器链知识请参考《第八章 拦截器机制》，此处再介绍下Shiro拦截器的流程：

AbstractShiroFilter //如ShiroFilter/ SpringShiroFilter都继承该Filter

   doFilter //Filter的doFilter

     doFilterInternal //转调doFilterInternal

       executeChain(request, response, chain) //执行拦截器链

         FilterChain chain = getExecutionChain(request, response, origChain) //使用原始拦截器链获取新的拦截器链

           chain.doFilter(request, response) //执行新组装的拦截器链

 

getExecutionChain(request, response, origChain) //获取拦截器链流程

       FilterChainResolver resolver = getFilterChainResolver(); //获取相应的FilterChainResolver

       FilterChain resolved = resolver.getChain(request, response, origChain); //通过FilterChainResolver根据当前请求解析到新的FilterChain拦截器链

 

默认情况下如使用ShiroFilterFactoryBean创建shiroFilter时，默认使用PathMatchingFilterChainResolver进行解析，而它默认是根据当前请求的URL获取相应的拦截器链，使用Ant模式进行URL匹配；默认使用DefaultFilterChainManager进行拦截器链的管理。

 

PathMatchingFilterChainResolver默认流程：

Java代码  

1. public FilterChain getChain(ServletRequest request, ServletResponse response, FilterChain originalChain) {  
2.     //1、首先获取拦截器链管理器  
3.     FilterChainManager filterChainManager = getFilterChainManager();  
4.     if (!filterChainManager.hasChains()) {  
5.         return null;  
6.     }  
7.     //2、接着获取当前请求的URL（不带上下文）  
8.     String requestURI = getPathWithinApplication(request);  
9.     //3、循环拦截器管理器中的拦截器定义（拦截器链的名字就是URL模式）  
10.     for (String pathPattern : filterChainManager.getChainNames()) {  
11.         //4、如当前URL匹配拦截器名字（URL模式）  
12.         if (pathMatches(pathPattern, requestURI)) {  
13.             //5、返回该URL模式定义的拦截器链  
14.             return filterChainManager.proxy(originalChain, pathPattern);  
15.         }  
16.     }  
17.     return null;  
18. }   

默认实现有点小问题：

如果多个拦截器链都匹配了当前请求URL，那么只返回第一个找到的拦截器链；后续我们可以修改此处的代码，将多个匹配的拦截器链合并返回。

 

DefaultFilterChainManager内部使用Map来管理URL模式-拦截器链的关系；也就是说相同的URL模式只能定义一个拦截器链，不能重复定义；而且如果多个拦截器链都匹配时是无序的（因为使用map.keySet()获取拦截器链的名字，即URL模式）。

 

FilterChainManager接口： 

Java代码  

1. public interface FilterChainManager {  
2.     Map<String, Filter> getFilters(); //得到注册的拦截器  
3.     void addFilter(String name, Filter filter); //注册拦截器  
4.     void addFilter(String name, Filter filter, boolean init); //注册拦截器  
5.     void createChain(String chainName, String chainDefinition); //根据拦截器链定义创建拦截器链  
6.     void addToChain(String chainName, String filterName); //添加拦截器到指定的拦截器链  
7.     void addToChain(String chainName, String filterName, String chainSpecificFilterConfig) throws ConfigurationException; //添加拦截器（带有配置的）到指定的拦截器链  
8.     NamedFilterList getChain(String chainName); //获取拦截器链  
9.     boolean hasChains(); //是否有拦截器链  
10.     Set<String> getChainNames(); //得到所有拦截器链的名字  
11.     FilterChain proxy(FilterChain original, String chainName); //使用指定的拦截器链代理原始拦截器链  
12. }   

此接口主要三个功能：注册拦截器，注册拦截器链，对原始拦截器链生成代理之后的拦截器链，比如  

Java代码  

1. <bean id="shiroFilter" class="org.apache.shiro.spring.web.ShiroFilterFactoryBean">  
2. ……  
3.     <property name="filters">  
4.         <util:map>  
5.             <entry key="authc" value-ref="formAuthenticationFilter"/>  
6.             <entry key="sysUser" value-ref="sysUserFilter"/>  
7.         </util:map>  
8.     </property>  
9.     <property name="filterChainDefinitions">  
10.         <value>  
11.             /login = authc  
12.             /logout = logout  
13.             /authenticated = authc  
14.             /** = user,sysUser  
15.         </value>  
16.     </property>  
17. </bean>   

filters属性定义了拦截器；filterChainDefinitions定义了拦截器链；如/**就是拦截器链的名字；而user,sysUser就是拦截器名字列表。

 

之前说过默认的PathMatchingFilterChainResolver和DefaultFilterChainManager不能满足我们的需求，我们稍微扩展了一下：

  

CustomPathMatchingFilterChainResolver 

Java代码  

1. public class CustomPathMatchingFilterChainResolver  
2.              extends PathMatchingFilterChainResolver {  
3.   private CustomDefaultFilterChainManager customDefaultFilterChainManager;  
4.   public void setCustomDefaultFilterChainManager(  
5.         CustomDefaultFilterChainManager customDefaultFilterChainManager) {  
6.       this.customDefaultFilterChainManager = customDefaultFilterChainManager;  
7.       setFilterChainManager(customDefaultFilterChainManager);  
8.   }  
9.   
10.   public FilterChain getChain(ServletRequest request, ServletResponse response, FilterChain originalChain) {  
11.       FilterChainManager filterChainManager = getFilterChainManager();  
12.       if (!filterChainManager.hasChains()) {  
13.           return null;  
14.       }  
15.       String requestURI = getPathWithinApplication(request);  
16.       List<String> chainNames = new ArrayList<String>();  
17.       for (String pathPattern : filterChainManager.getChainNames()) {  
18.         if (pathMatches(pathPattern, requestURI)) {  
19.         chainNames.add(pathPattern);  
20.         }  
21.       }  
22.       if(chainNames.size() == 0) {  
23.         return null;  
24.       }  
25.       return customDefaultFilterChainManager.proxy(originalChain, chainNames);  
26.   }  
27. }   

和默认的PathMatchingFilterChainResolver区别是，此处得到所有匹配的拦截器链，然后通过调用CustomDefaultFilterChainManager.proxy(originalChain, chainNames)进行合并后代理。

 

CustomDefaultFilterChainManager    

Java代码  

1. public class CustomDefaultFilterChainManager extends DefaultFilterChainManager {  
2.     private Map<String, String> filterChainDefinitionMap = null;  
3.     private String loginUrl;  
4.     private String successUrl;  
5.     private String unauthorizedUrl;  
6.     public CustomDefaultFilterChainManager() {  
7.         setFilters(new LinkedHashMap<String, Filter>());  
8.         setFilterChains(new LinkedHashMap<String, NamedFilterList>());  
9.         addDefaultFilters(true);  
10.     }  
11.     public Map<String, String> getFilterChainDefinitionMap() {  
12.         return filterChainDefinitionMap;  
13.     }  
14.     public void setFilterChainDefinitionMap(Map<String, String> filterChainDefinitionMap) {  
15.         this.filterChainDefinitionMap = filterChainDefinitionMap;  
16.     }  
17.     public void setCustomFilters(Map<String, Filter> customFilters) {  
18.         for(Map.Entry<String, Filter> entry : customFilters.entrySet()) {  
19.             addFilter(entry.getKey(), entry.getValue(), false);  
20.         }  
21. }  
22.     public void setDefaultFilterChainDefinitions(String definitions) {  
23.         Ini ini = new Ini();  
24.         ini.load(definitions);  
25.         Ini.Section section = ini.getSection(IniFilterChainResolverFactory.URLS);  
26.         if (CollectionUtils.isEmpty(section)) {  
27.             section = ini.getSection(Ini.DEFAULT_SECTION_NAME);  
28.         }  
29.         setFilterChainDefinitionMap(section);  
30.     }  
31.     public String getLoginUrl() {  
32.         return loginUrl;  
33.     }  
34.     public void setLoginUrl(String loginUrl) {  
35.         this.loginUrl = loginUrl;  
36.     }  
37.     public String getSuccessUrl() {  
38.         return successUrl;  
39.     }  
40.     public void setSuccessUrl(String successUrl) {  
41.         this.successUrl = successUrl;  
42.     }  
43.     public String getUnauthorizedUrl() {  
44.         return unauthorizedUrl;  
45.     }  
46.     public void setUnauthorizedUrl(String unauthorizedUrl) {  
47.         this.unauthorizedUrl = unauthorizedUrl;  
48.     }  
49.     @PostConstruct  
50.     public void init() {  
51.         Map<String, Filter> filters = getFilters();  
52.         if (!CollectionUtils.isEmpty(filters)) {  
53.             for (Map.Entry<String, Filter> entry : filters.entrySet()) {  
54.                 String name = entry.getKey();  
55.                 Filter filter = entry.getValue();  
56.                 applyGlobalPropertiesIfNecessary(filter);  
57.                 if (filter instanceof Nameable) {  
58.                     ((Nameable) filter).setName(name);  
59.                 }  
60.                 addFilter(name, filter, false);  
61.             }  
62.         }  
63.         Map<String, String> chains = getFilterChainDefinitionMap();  
64.         if (!CollectionUtils.isEmpty(chains)) {  
65.             for (Map.Entry<String, String> entry : chains.entrySet()) {  
66.                 String url = entry.getKey();  
67.                 String chainDefinition = entry.getValue();  
68.                 createChain(url, chainDefinition);  
69.             }  
70.         }  
71.     }  
72.     protected void initFilter(Filter filter) {  
73.         //ignore   
74.     }  
75.   
76.     public FilterChain proxy(FilterChain original, List<String> chainNames) {  
77.         NamedFilterList configured = new SimpleNamedFilterList(chainNames.toString());  
78.         for(String chainName : chainNames) {  
79.             configured.addAll(getChain(chainName));  
80.         }  
81.         return configured.proxy(original);  
82.     }  
83.     private void applyGlobalPropertiesIfNecessary(Filter filter) {  
84.         applyLoginUrlIfNecessary(filter);  
85.         applySuccessUrlIfNecessary(filter);  
86.         applyUnauthorizedUrlIfNecessary(filter);  
87.     }  
88.     private void applyLoginUrlIfNecessary(Filter filter) {  
89.         //请参考源码  
90.     }  
91.     private void applySuccessUrlIfNecessary(Filter filter) {  
92.         //请参考源码  
93.     }  
94.     private void applyUnauthorizedUrlIfNecessary(Filter filter) {  
95.         //请参考源码  
96.     }  
97. }   

1、CustomDefaultFilterChainManager：调用其构造器时，会自动注册默认的拦截器；

2、loginUrl、successUrl、unauthorizedUrl：分别对应登录地址、登录成功后默认跳转地址、未授权跳转地址，用于给相应拦截器的；

3、filterChainDefinitionMap：用于存储如ShiroFilterFactoryBean在配置文件中配置的拦截器链定义，即可以认为是默认的静态拦截器链；会自动与数据库中加载的合并；

4、setDefaultFilterChainDefinitions：解析配置文件中传入的字符串拦截器链配置，解析为相应的拦截器链；

5、setCustomFilters：注册我们自定义的拦截器；如ShiroFilterFactoryBean的filters属性；

6、init：初始化方法，Spring容器启动时会调用，首先其会自动给相应的拦截器设置如loginUrl、successUrl、unauthorizedUrl；其次根据filterChainDefinitionMap构建默认的拦截器链；

7、initFilter：此处我们忽略实现initFilter，因为交给spring管理了，所以Filter的相关配置会在Spring配置中完成；

8、proxy：组合多个拦截器链为一个生成一个新的FilterChain代理。

 

Web层控制器 

请参考com.github.zhangkaitao.shiro.chapter19.web.controller包，相对于第十六章添加了UrlFilterController用于UrlFilter的维护。另外，移除了控制器方法上的权限注解，而是使用动态URL拦截进行控制。

 

Spring配置——spring-config-shiro.xml   

Java代码  

1. <bean id="filterChainManager"   
2.     class="com.github.zhangkaitao.shiro.spring.CustomDefaultFilterChainManager">  
3.     <property name="loginUrl" value="/login"/>  
4.     <property name="successUrl" value="/"/>  
5.     <property name="unauthorizedUrl" value="/unauthorized.jsp"/>  
6.     <property name="customFilters">  
7.         <util:map>  
8.             <entry key="authc" value-ref="formAuthenticationFilter"/>  
9.             <entry key="sysUser" value-ref="sysUserFilter"/>  
10.         </util:map>  
11.     </property>  
12.     <property name="defaultFilterChainDefinitions">  
13.         <value>  
14.             /login = authc  
15.             /logout = logout  
16.             /unauthorized.jsp = authc  
17.             /** = user,sysUser  
18.         </value>  
19.     </property>  
20. </bean>   

filterChainManager是我们自定义的CustomDefaultFilterChainManager，注册相应的拦截器及默认的拦截器链。 

Java代码  

1. <bean id="filterChainResolver"   
2.     class="com.github.zhangkaitao.shiro.spring.CustomPathMatchingFilterChainResolver">  
3.     <property name="customDefaultFilterChainManager" ref="filterChainManager"/>  
4. </bean>   

filterChainResolver是自定义的CustomPathMatchingFilterChainResolver，使用上边的filterChainManager进行拦截器链的管理。 

Java代码  

1. <bean id="shiroFilter" class="org.apache.shiro.spring.web.ShiroFilterFactoryBean">  
2.     <property name="securityManager" ref="securityManager"/>  
3. </bean>   

shiroFilter不再定义filters及filterChainDefinitions，而是交给了filterChainManager进行完成。 

Java代码  

1. <bean class="org.springframework.beans.factory.config.MethodInvokingFactoryBean">  
2.     <property name="targetObject" ref="shiroFilter"/>  
3.     <property name="targetMethod" value="setFilterChainResolver"/>  
4.     <property name="arguments" ref="filterChainResolver"/>  
5. </bean>   

最后把filterChainResolver注册给shiroFilter，其使用它进行动态URL权限控制。

 

其他配置和第十六章一样，请参考第十六章。

 

测试

1、首先执行shiro-data.sql初始化数据。

2、然后再URL管理中新增如下数据： 

3、访问http://localhost:8080/chapter19/user时要求用户拥有aa角色，此时是没有的所以会跳转到未授权页面；

4、添加aa角色然后授权给用户，此时就有权限访问http://localhost:8080/chapter19/user。

 

实际项目可以在此基础上进行扩展。

@19@

在一些环境中，可能需要把Web应用做成无状态的，即服务器端无状态，就是说服务器端不会存储像会话这种东西，而是每次请求时带上相应的用户名进行登录。如一些REST风格的API，如果不使用OAuth2协议，就可以使用如REST+HMAC认证进行访问。HMAC（Hash-based Message Authentication Code）：基于散列的消息认证码，使用一个密钥和一个消息作为输入，生成它们的消息摘要。注意该密钥只有客户端和服务端知道，其他第三方是不知道的。访问时使用该消息摘要进行传播，服务端然后对该消息摘要进行验证。如果只传递用户名+密码的消息摘要，一旦被别人捕获可能会重复使用该摘要进行认证。解决办法如：

1、每次客户端申请一个Token，然后使用该Token进行加密，而该Token是一次性的，即只能用一次；有点类似于OAuth2的Token机制，但是简单些；

2、客户端每次生成一个唯一的Token，然后使用该Token加密，这样服务器端记录下这些Token，如果之前用过就认为是非法请求。

 

为了简单，本文直接对请求的数据（即全部请求的参数）生成消息摘要，即无法篡改数据，但是可能被别人窃取而能多次调用。解决办法如上所示。

  

服务器端

对于服务器端，不生成会话，而是每次请求时带上用户身份进行认证。

  

服务控制器

Java代码  

1. @RestController  
2. public class ServiceController {  
3.     @RequestMapping("/hello")  
4.     public String hello1(String[] param1, String param2) {  
5.         return "hello" + param1[0] + param1[1] + param2;  
6.     }  
7. }   

当访问/hello服务时，需要传入param1、param2两个请求参数。

 

加密工具类

com.github.zhangkaitao.shiro.chapter20.codec.HmacSHA256Utils： 

Java代码  

1. //使用指定的密码对内容生成消息摘要（散列值）  
2. public static String digest(String key, String content);  
3. //使用指定的密码对整个Map的内容生成消息摘要（散列值）  
4. public static String digest(String key, Map<String, ?> map)   

对Map生成消息摘要主要用于对客户端/服务器端来回传递的参数生成消息摘要。

  

Subject工厂  

Java代码  

1. public class StatelessDefaultSubjectFactory extends DefaultWebSubjectFactory {  
2.     public Subject createSubject(SubjectContext context) {  
3.         //不创建session  
4.         context.setSessionCreationEnabled(false);  
5.         return super.createSubject(context);  
6.     }  
7. }   

通过调用context.setSessionCreationEnabled(false)表示不创建会话；如果之后调用Subject.getSession()将抛出DisabledSessionException异常。

 

StatelessAuthcFilter

类似于FormAuthenticationFilter，但是根据当前请求上下文信息每次请求时都要登录的认证过滤器。

Java代码  

1. public class StatelessAuthcFilter extends AccessControlFilter {  
2.   protected boolean isAccessAllowed(ServletRequest request, ServletResponse response, Object mappedValue) throws Exception {  
3.       return false;  
4.   }  
5.   protected boolean onAccessDenied(ServletRequest request, ServletResponse response) throws Exception {  
6.     //1、客户端生成的消息摘要  
7.     String clientDigest = request.getParameter(Constants.PARAM_DIGEST);  
8.     //2、客户端传入的用户身份  
9. String username = request.getParameter(Constants.PARAM_USERNAME);  
10.     //3、客户端请求的参数列表  
11.     Map<String, String[]> params =   
12.       new HashMap<String, String[]>(request.getParameterMap());  
13.     params.remove(Constants.PARAM_DIGEST);  
14.     //4、生成无状态Token  
15.     StatelessToken token = new StatelessToken(username, params, clientDigest);  
16.     try {  
17.       //5、委托给Realm进行登录  
18.       getSubject(request, response).login(token);  
19.     } catch (Exception e) {  
20.       e.printStackTrace();  
21.       onLoginFail(response); //6、登录失败  
22.       return false;  
23.     }  
24.     return true;  
25.   }  
26.   //登录失败时默认返回401状态码  
27.   private void onLoginFail(ServletResponse response) throws IOException {  
28.     HttpServletResponse httpResponse = (HttpServletResponse) response;  
29.     httpResponse.setStatus(HttpServletResponse.SC_UNAUTHORIZED);  
30.     httpResponse.getWriter().write("login error");  
31.   }  
32. }  
33.    

获取客户端传入的用户名、请求参数、消息摘要，生成StatelessToken；然后交给相应的Realm进行认证。

 

StatelessToken   

Java代码  

1. public class StatelessToken implements AuthenticationToken {  
2.     private String username;  
3.     private Map<String, ?> params;  
4.     private String clientDigest;  
5.     //省略部分代码  
6.     public Object getPrincipal() {  return username;}  
7.     public Object getCredentials() {  return clientDigest;}  
8. }   

用户身份即用户名；凭证即客户端传入的消息摘要。

 

StatelessRealm 

用于认证的Realm。

Java代码  

1. public class StatelessRealm extends AuthorizingRealm {  
2.     public boolean supports(AuthenticationToken token) {  
3.         //仅支持StatelessToken类型的Token  
4.         return token instanceof StatelessToken;  
5.     }  
6.     protected AuthorizationInfo doGetAuthorizationInfo(PrincipalCollection principals) {  
7.         //根据用户名查找角色，请根据需求实现  
8.         String username = (String) principals.getPrimaryPrincipal();  
9.         SimpleAuthorizationInfo authorizationInfo =  new SimpleAuthorizationInfo();  
10.         authorizationInfo.addRole("admin");  
11.         return authorizationInfo;  
12.     }  
13.     protected AuthenticationInfo doGetAuthenticationInfo(AuthenticationToken token) throws AuthenticationException {  
14.         StatelessToken statelessToken = (StatelessToken) token;  
15.         String username = statelessToken.getUsername();  
16.         String key = getKey(username);//根据用户名获取密钥（和客户端的一样）  
17.         //在服务器端生成客户端参数消息摘要  
18.         String serverDigest = HmacSHA256Utils.digest(key, statelessToken.getParams());  
19.         //然后进行客户端消息摘要和服务器端消息摘要的匹配  
20.         return new SimpleAuthenticationInfo(  
21.                 username,  
22.                 serverDigest,  
23.                 getName());  
24.     }  
25.       
26.     private String getKey(String username) {//得到密钥，此处硬编码一个  
27.         if("admin".equals(username)) {  
28.             return "dadadswdewq2ewdwqdwadsadasd";  
29.         }  
30.         return null;  
31.     }  
32. }   

此处首先根据客户端传入的用户名获取相应的密钥，然后使用密钥对请求参数生成服务器端的消息摘要；然后与客户端的消息摘要进行匹配；如果匹配说明是合法客户端传入的；否则是非法的。这种方式是有漏洞的，一旦别人获取到该请求，可以重复请求；可以考虑之前介绍的解决方案。

 

Spring配置——spring-config-shiro.xml 

Java代码  

1. <!-- Realm实现 -->  
2. <bean id="statelessRealm"   
3.   class="com.github.zhangkaitao.shiro.chapter20.realm.StatelessRealm">  
4.     <property name="cachingEnabled" value="false"/>  
5. </bean>  
6. <!-- Subject工厂 -->  
7. <bean id="subjectFactory"   
8.   class="com.github.zhangkaitao.shiro.chapter20.mgt.StatelessDefaultSubjectFactory"/>  
9. <!-- 会话管理器 -->  
10. <bean id="sessionManager" class="org.apache.shiro.session.mgt.DefaultSessionManager">  
11.     <property name="sessionValidationSchedulerEnabled" value="false"/>  
12. </bean>  
13. <!-- 安全管理器 -->  
14. <bean id="securityManager" class="org.apache.shiro.web.mgt.DefaultWebSecurityManager">  
15.     <property name="realm" ref="statelessRealm"/>  
16.     <property name="subjectDAO.sessionStorageEvaluator.sessionStorageEnabled"  
17.       value="false"/>  
18.     <property name="subjectFactory" ref="subjectFactory"/>  
19.     <property name="sessionManager" ref="sessionManager"/>  
20. </bean>  
21. <!-- 相当于调用SecurityUtils.setSecurityManager(securityManager) -->  
22. <bean class="org.springframework.beans.factory.config.MethodInvokingFactoryBean">  
23.     <property name="staticMethod"   
24.       value="org.apache.shiro.SecurityUtils.setSecurityManager"/>  
25.     <property name="arguments" ref="securityManager"/>  
26. </bean>   

sessionManager通过sessionValidationSchedulerEnabled禁用掉会话调度器，因为我们禁用掉了会话，所以没必要再定期过期会话了。 

 

Java代码  

1. <bean id="statelessAuthcFilter"   
2.     class="com.github.zhangkaitao.shiro.chapter20.filter.StatelessAuthcFilter"/>   

每次请求进行认证的拦截器。 

 

Java代码  

1. <!-- Shiro的Web过滤器 -->  
2. <bean id="shiroFilter" class="org.apache.shiro.spring.web.ShiroFilterFactoryBean">  
3.     <property name="securityManager" ref="securityManager"/>  
4.     <property name="filters">  
5.         <util:map>  
6.             <entry key="statelessAuthc" value-ref="statelessAuthcFilter"/>  
7.         </util:map>  
8.     </property>  
9.     <property name="filterChainDefinitions">  
10.         <value>  
11.             /**=statelessAuthc  
12.         </value>  
13.     </property>  
14. </bean>   

所有请求都将走statelessAuthc拦截器进行认证。

 

其他配置请参考源代码。

 

SpringMVC学习请参考：

5分钟构建spring web mvc REST风格HelloWorld

  http://jinnianshilongnian.iteye.com/blog/1996071

跟我学SpringMVC

  http://www.iteye.com/blogs/subjects/kaitao-springmvc

 

客户端

此处使用SpringMVC提供的RestTemplate进行测试。请参考如下文章进行学习：

Spring MVC测试框架详解——客户端测试

   http://jinnianshilongnian.iteye.com/blog/2007180

Spring MVC测试框架详解——服务端测试 

   http://jinnianshilongnian.iteye.com/blog/2004660

 

此处为了方便，使用内嵌jetty服务器启动服务端： 

Java代码  

1. public class ClientTest {  
2.     private static Server server;  
3.     private RestTemplate restTemplate = new RestTemplate();  
4.     @BeforeClass  
5.     public static void beforeClass() throws Exception {  
6.         //创建一个server  
7.         server = new Server(8080);  
8.         WebAppContext context = new WebAppContext();  
9.         String webapp = "shiro-example-chapter20/src/main/webapp";  
10.         context.setDescriptor(webapp + "/WEB-INF/web.xml");  //指定web.xml配置文件  
11.         context.setResourceBase(webapp);  //指定webapp目录  
12.         context.setContextPath("/");  
13.         context.setParentLoaderPriority(true);  
14.         server.setHandler(context);  
15.         server.start();  
16.     }  
17.     @AfterClass  
18.     public static void afterClass() throws Exception {  
19.         server.stop(); //当测试结束时停止服务器  
20.     }  
21. }   

在整个测试开始之前开启服务器，整个测试结束时关闭服务器。

 

测试成功情况 

Java代码  

1. @Test  
2. public void testServiceHelloSuccess() {  
3.     String username = "admin";  
4.     String param11 = "param11";  
5.     String param12 = "param12";  
6.     String param2 = "param2";  
7.     String key = "dadadswdewq2ewdwqdwadsadasd";  
8.     MultiValueMap<String, String> params = new LinkedMultiValueMap<String, String>();  
9.     params.add(Constants.PARAM_USERNAME, username);  
10.     params.add("param1", param11);  
11.     params.add("param1", param12);  
12.     params.add("param2", param2);  
13.     params.add(Constants.PARAM_DIGEST, HmacSHA256Utils.digest(key, params));  
14.     String url = UriComponentsBuilder  
15.             .fromHttpUrl("http://localhost:8080/hello")  
16.             .queryParams(params).build().toUriString();  
17.      ResponseEntity responseEntity = restTemplate.getForEntity(url, String.class);  
18.     Assert.assertEquals("hello" + param11 + param12 + param2, responseEntity.getBody());  
19. }   

对请求参数生成消息摘要后带到参数中传递给服务器端，服务器端验证通过后访问相应服务，然后返回数据。

 

测试失败情况 

Java代码  

1. @Test  
2. public void testServiceHelloFail() {  
3.     String username = "admin";  
4.     String param11 = "param11";  
5.     String param12 = "param12";  
6.     String param2 = "param2";  
7.     String key = "dadadswdewq2ewdwqdwadsadasd";  
8.     MultiValueMap<String, String> params = new LinkedMultiValueMap<String, String>();  
9.     params.add(Constants.PARAM_USERNAME, username);  
10.     params.add("param1", param11);  
11.     params.add("param1", param12);  
12.     params.add("param2", param2);  
13.     params.add(Constants.PARAM_DIGEST, HmacSHA256Utils.digest(key, params));  
14.     params.set("param2", param2 + "1");  
15.   
16.     String url = UriComponentsBuilder  
17.             .fromHttpUrl("http://localhost:8080/hello")  
18.             .queryParams(params).build().toUriString();  
19.     try {  
20.         ResponseEntity responseEntity = restTemplate.getForEntity(url, String.class);  
21.     } catch (HttpClientErrorException e) {  
22.         Assert.assertEquals(HttpStatus.UNAUTHORIZED, e.getStatusCode());  
23.         Assert.assertEquals("login error", e.getResponseBodyAsString());  
24.     }  
25. }   

在生成请求参数消息摘要后，篡改了参数内容，服务器端接收后进行重新生成消息摘要发现不一样，报401错误状态码。

 

到此，整个测试完成了，需要注意的是，为了安全性，请考虑本文开始介绍的相应解决方案。

 

 

SpringMVC相关知识请参考

5分钟构建spring web mvc REST风格HelloWorld

  http://jinnianshilongnian.iteye.com/blog/1996071

跟我学SpringMVC

  http://www.iteye.com/blogs/subjects/kaitao-springmvc

Spring MVC测试框架详解——客户端测试

   http://jinnianshilongnian.iteye.com/blog/2007180

Spring MVC测试框架详解——服务端测试 

   http://jinnianshilongnian.iteye.com/blog/2004660

@20@

在一些场景中，比如某个领导因为一些原因不能进行登录网站进行一些操作，他想把他网站上的工作委托给他的秘书，但是他不想把帐号/密码告诉他秘书，只是想把工作委托给他；此时和我们可以使用Shiro的RunAs功能，即允许一个用户假装为另一个用户（如果他们允许）的身份进行访问。

 

本章代码基于《第十六章 综合实例》，请先了解相关数据模型及基本流程后再学习本章。

 

表及数据SQL

请运行shiro-example-chapter21/sql/ shiro-schema.sql 表结构

请运行shiro-example-chapter21/sql/ shiro-schema.sql 数据

 

实体

 

具体请参考com.github.zhangkaitao.shiro.chapter21包下的实体。

Java代码  

1. public class UserRunAs implements Serializable {  
2.     private Long fromUserId;//授予身份帐号  
3.     private Long toUserId;//被授予身份帐号  
4. }   

该实体定义了授予身份帐号（A）与被授予身份帐号（B）的关系，意思是B帐号将可以假装为A帐号的身份进行访问。

 

DAO

具体请参考com.github.zhangkaitao.shiro.chapter21.dao包下的DAO接口及实现。

 

Service

具体请参考com.github.zhangkaitao.shiro.chapter21.service包下的Service接口及实现。 

Java代码  

1. public interface UserRunAsService {  
2.     public void grantRunAs(Long fromUserId, Long toUserId);  
3.     public void revokeRunAs(Long fromUserId, Long toUserId);  
4.     public boolean exists(Long fromUserId, Long toUserId);  
5.     public List<Long> findFromUserIds(Long toUserId);  
6.     public List<Long> findToUserIds(Long fromUserId);  
7. }   

提供授予身份、回收身份、关系存在判断及查找API。

 

Web控制器RunAsController

该控制器完成：授予身份/回收身份/切换身份功能。

 

展示当前用户能切换到身份列表，及授予给其他人的身份列表：

Java代码  

1. @RequestMapping  
2. public String runasList(@CurrentUser User loginUser, Model model) {  
3.     model.addAttribute("fromUserIds",   
4.         userRunAsService.findFromUserIds(loginUser.getId()));  
5.     model.addAttribute("toUserIds", userRunAsService.findToUserIds(loginUser.getId()));  
6.     List<User> allUsers = userService.findAll();  
7.     allUsers.remove(loginUser);  
8.     model.addAttribute("allUsers", allUsers);  
9.   
10.     Subject subject = SecurityUtils.getSubject();  
11.     model.addAttribute("isRunas", subject.isRunAs());  
12.     if(subject.isRunAs()) {  
13.         String previousUsername =  
14.                 (String)subject.getPreviousPrincipals().getPrimaryPrincipal();  
15.         model.addAttribute("previousUsername", previousUsername);  
16.     }  
17.     return "runas";  
18. }   

1、Subject.isRunAs()：表示当前用户是否是RunAs用户，即已经切换身份了；

2、Subject.getPreviousPrincipals()：得到切换身份之前的身份，一个用户可以切换很多次身份，之前的身份使用栈数据结构来存储；

 

授予身份

把当前用户身份授予给另一个用户，这样另一个用户可以切换身份到该用户。

Java代码  

1. @RequestMapping("/grant/{toUserId}")  
2. public String grant(  
3.         @CurrentUser User loginUser,  
4.         @PathVariable("toUserId") Long toUserId,  
5.         RedirectAttributes redirectAttributes) {  
6.     if(loginUser.getId().equals(toUserId)) {  
7.         redirectAttributes.addFlashAttribute("msg", "自己不能切换到自己的身份");  
8.         return "redirect:/runas";  
9.     }  
10.     userRunAsService.grantRunAs(loginUser.getId(), toUserId);  
11.     redirectAttributes.addFlashAttribute("msg", "操作成功");  
12.     return "redirect:/runas";  
13. }   

1、自己不能授予身份给自己；

2、调用UserRunAsService. grantRunAs把当前登录用户的身份授予给相应的用户；

 

回收身份

把授予给某个用户的身份回收回来。 

Java代码  

1. @RequestMapping("/revoke/{toUserId}")  
2. public String revoke(  
3.         @CurrentUser User loginUser,  
4.         @PathVariable("toUserId") Long toUserId,  
5.         RedirectAttributes redirectAttributes) {  
6.     userRunAsService.revokeRunAs(loginUser.getId(), toUserId);  
7.     redirectAttributes.addFlashAttribute("msg", "操作成功");  
8.     return "redirect:/runas";  
9. }  

  

 

切换身份

Java代码  

1. @RequestMapping("/switchTo/{switchToUserId}")  
2. public String switchTo(  
3.         @CurrentUser User loginUser,  
4.         @PathVariable("switchToUserId") Long switchToUserId,  
5.         RedirectAttributes redirectAttributes) {  
6.     Subject subject = SecurityUtils.getSubject();  
7.     User switchToUser = userService.findOne(switchToUserId);  
8.     if(loginUser.equals(switchToUser)) {  
9.         redirectAttributes.addFlashAttribute("msg", "自己不能切换到自己的身份");  
10.         return "redirect:/runas";  
11.     }  
12.     if(switchToUser == null || !userRunAsService.exists(switchToUserId, loginUser.getId())) {  
13.         redirectAttributes.addFlashAttribute("msg", "对方没有授予您身份，不能切换");  
14.         return "redirect:/runas";  
15.     }  
16.     subject.runAs(new SimplePrincipalCollection(switchToUser.getUsername(), ""));  
17.     redirectAttributes.addFlashAttribute("msg", "操作成功");  
18.     redirectAttributes.addFlashAttribute("needRefresh", "true");  
19.     return "redirect:/runas";  
20. }  
21.    

1、首先根据switchToUserId查找到要切换到的身份；

2、然后通过UserRunAsService. exists()判断当前登录用户是否可以切换到该身份；

3、通过Subject.runAs()切换到该身份；

 

切换到上一个身份 

Java代码  

1. @RequestMapping("/switchBack")  
2. public String switchBack(RedirectAttributes redirectAttributes) {  
3.     Subject subject = SecurityUtils.getSubject();  
4.     if(subject.isRunAs()) {  
5.        subject.releaseRunAs();  
6.     }  
7.     redirectAttributes.addFlashAttribute("msg", "操作成功");  
8.     redirectAttributes.addFlashAttribute("needRefresh", "true");  
9.     return "redirect:/runas";  
10. }   

1、通过Subject.releaseRunAs()切换会上一个身份；

 

 

此处注意的是我们可以切换多次身份，如A切换到B，然后再切换到C；那么需要调用两次Subject. releaseRunAs()才能切换会A；即内部使用栈数据结构存储着切换过的用户；Subject. getPreviousPrincipals()得到上一次切换到的身份，比如当前是C；那么调用该API将得到B的身份。

 

其他代码和配置和《第十六章 综合实例》一样，请参考该章。

 

测试

1、首先访问http://localhost:8080/chapter21/，输入admin/123456进行登录；会看到如下界面： 

 

2、点击切换身份按钮，跳到如下界面：   

在该界面可以授权身份给其他人（点击授权身份可以把自己的身份授权给其他人/点击回收身份可以把之前授予的身份撤回）、或切换到其他身份（即假装为其他身份运行）；

 

3、点击切换到该身份按钮，切换到相应的身份运行，如： 

此时zhang用户切换到admin身份；如果点击切换回该身份，会把当前身份切换会zhang。

@21@

在做用户登录功能时，很多时候都需要验证码支持，验证码的目的是为了防止机器人模拟真实用户登录而恶意访问，如暴力破解用户密码/恶意评论等。目前也有一些验证码比较简单，通过一些OCR工具就可以解析出来；另外还有一些验证码比较复杂（一般通过如扭曲、加线条/噪点等干扰）防止OCR工具识别；但是在中国就是人多，机器干不了的可以交给人来完成，所以在中国就有很多打码平台，人工识别验证码；因此即使比较复杂的如填字、算数等类型的验证码还是能识别的。所以验证码也不是绝对可靠的，目前比较可靠还是手机验证码，但是对于用户来说相对于验证码还是比较麻烦的。

 

对于验证码图片的生成，可以自己通过如Java提供的图像API自己去生成，也可以借助如JCaptcha这种开源Java类库生成验证码图片；JCaptcha提供了常见的如扭曲、加噪点等干扰支持。本章代码基于《第十六章 综合实例》。

 

一、添加JCaptcha依赖 

Java代码  

1. <dependency>  
2.     <groupId>com.octo.captcha</groupId>  
3.     <artifactId>jcaptcha</artifactId>  
4.     <version>2.0-alpha-1</version>  
5. </dependency>  
6. <dependency>  
7.     <groupId>com.octo.captcha</groupId>  
8.     <artifactId>jcaptcha-integration-simple-servlet</artifactId>  
9.     <version>2.0-alpha-1</version>  
10.     <exclusions>  
11.         <exclusion>  
12.             <artifactId>servlet-api</artifactId>  
13.             <groupId>javax.servlet</groupId>  
14.         </exclusion>  
15.     </exclusions>  
16. </dependency>   

com.octo.captcha . jcaptcha 提供了jcaptcha 核心；而jcaptcha-integration-simple-servlet提供了与Servlet集成。

 

二、GMailEngine

来自https://code.google.com/p/musicvalley/source/browse/trunk/musicvalley/doc/springSecurity/springSecurityIII/src/main/java/com/spring/security/jcaptcha/GMailEngine.java?spec=svn447&r=447（目前无法访问了），仿照JCaptcha2.0编写类似GMail验证码的样式；具体请参考com.github.zhangkaitao.shiro.chapter22.jcaptcha.GMailEngine。

 

三、MyManageableImageCaptchaService

提供了判断仓库中是否有相应的验证码存在。 

Java代码  

1. public class MyManageableImageCaptchaService extends   
2.   DefaultManageableImageCaptchaService {   
3.     public MyManageableImageCaptchaService(  
4.       com.octo.captcha.service.captchastore.CaptchaStore captchaStore,        
5.       com.octo.captcha.engine.CaptchaEngine captchaEngine,  
6.       int minGuarantedStorageDelayInSeconds,   
7.       int maxCaptchaStoreSize,   
8.       int captchaStoreLoadBeforeGarbageCollection) {  
9.         super(captchaStore, captchaEngine, minGuarantedStorageDelayInSeconds,   
10.             maxCaptchaStoreSize, captchaStoreLoadBeforeGarbageCollection);  
11.     }  
12.     public boolean hasCapcha(String id, String userCaptchaResponse) {  
13.         return store.getCaptcha(id).validateResponse(userCaptchaResponse);  
14.     }  
15. }  

  

 

四、JCaptcha工具类

提供相应的API来验证当前请求输入的验证码是否正确。  

Java代码  

1. public class JCaptcha {  
2.     public static final MyManageableImageCaptchaService captchaService  
3.             = new MyManageableImageCaptchaService(new FastHashMapCaptchaStore(),   
4.                             new GMailEngine(), 180, 100000, 75000);  
5.     public static boolean validateResponse(  
6.         HttpServletRequest request, String userCaptchaResponse) {  
7.         if (request.getSession(false) == null) return false;  
8.         boolean validated = false;  
9.         try {  
10.             String id = request.getSession().getId();  
11.             validated =   
12.                 captchaService.validateResponseForID(id, userCaptchaResponse)  
13.                             .booleanValue();  
14.         } catch (CaptchaServiceException e) {  
15.             e.printStackTrace();  
16.         }  
17.         return validated;  
18.     }   
19.     public static boolean hasCaptcha(  
20.         HttpServletRequest request, String userCaptchaResponse) {  
21.         if (request.getSession(false) == null) return false;  
22.         boolean validated = false;  
23.         try {  
24.             String id = request.getSession().getId();  
25.             validated = captchaService.hasCapcha(id, userCaptchaResponse);  
26.         } catch (CaptchaServiceException e) {  
27.             e.printStackTrace();  
28.         }  
29.         return validated;  
30.     }  
31. }   

validateResponse()：验证当前请求输入的验证码否正确；并从CaptchaService中删除已经生成的验证码；

hasCaptcha()：验证当前请求输入的验证码是否正确；但不从CaptchaService中删除已经生成的验证码（比如Ajax验证时可以使用，防止多次生成验证码）；

 

五、JCaptchaFilter

用于生成验证码图片的过滤器。  

Java代码  

1. public class JCaptchaFilter extends OncePerRequestFilter {  
2.     protected void doFilterInternal(HttpServletRequest request, HttpServletResponse response, FilterChain filterChain) throws ServletException, IOException {  
3.   
4.         response.setDateHeader("Expires", 0L);  
5.         response.setHeader("Cache-Control", "no-store, no-cache, must-revalidate");  
6.         response.addHeader("Cache-Control", "post-check=0, pre-check=0");  
7.         response.setHeader("Pragma", "no-cache");  
8.         response.setContentType("image/jpeg");  
9.         String id = request.getRequestedSessionId();  
10.         BufferedImage bi = JCaptcha.captchaService.getImageChallengeForID(id);  
11.         ServletOutputStream out = response.getOutputStream();  
12.         ImageIO.write(bi, "jpg", out);  
13.         try {  
14.             out.flush();  
15.         } finally {  
16.             out.close();  
17.         }  
18.     }  
19. }   

CaptchaService使用当前会话ID当作key获取相应的验证码图片；另外需要设置响应内容不进行浏览器端缓存。 

 

Java代码  

1. <!-- 验证码过滤器需要放到Shiro之后 因为Shiro将包装HttpSession 如果不，可能造成两次的sesison id 不一样 -->  
2. <filter>  
3.   <filter-name>JCaptchaFilter</filter-name>  
4.   <filter-class>   
5.     com.github.zhangkaitao.shiro.chapter22.jcaptcha.JCaptchaFilter  
6.   </filter-class>  
7.   </filter>  
8.   <filter-mapping>  
9.     <filter-name>JCaptchaFilter</filter-name>  
10.     <url-pattern>/jcaptcha.jpg</url-pattern>  
11. </filter-mapping>   

这样就可以在页面使用/jcaptcha.jpg地址显示验证码图片。

 

六、JCaptchaValidateFilter

用于验证码验证的Shiro过滤器。  

Java代码  

1. public class JCaptchaValidateFilter extends AccessControlFilter {  
2.     private boolean jcaptchaEbabled = true;//是否开启验证码支持  
3.     private String jcaptchaParam = "jcaptchaCode";//前台提交的验证码参数名  
4.     private String failureKeyAttribute = "shiroLoginFailure"; //验证失败后存储到的属性名  
5.     public void setJcaptchaEbabled(boolean jcaptchaEbabled) {  
6.         this.jcaptchaEbabled = jcaptchaEbabled;  
7.     }  
8.     public void setJcaptchaParam(String jcaptchaParam) {  
9.         this.jcaptchaParam = jcaptchaParam;  
10.     }  
11.     public void setFailureKeyAttribute(String failureKeyAttribute) {  
12.         this.failureKeyAttribute = failureKeyAttribute;  
13.     }  
14.     protected boolean isAccessAllowed(ServletRequest request, ServletResponse response, Object mappedValue) throws Exception {  
15.         //1、设置验证码是否开启属性，页面可以根据该属性来决定是否显示验证码  
16.         request.setAttribute("jcaptchaEbabled", jcaptchaEbabled);  
17.   
18.         HttpServletRequest httpServletRequest = WebUtils.toHttp(request);  
19.         //2、判断验证码是否禁用 或不是表单提交（允许访问）  
20.         if (jcaptchaEbabled == false || !"post".equalsIgnoreCase(httpServletRequest.getMethod())) {  
21.             return true;  
22.         }  
23.         //3、此时是表单提交，验证验证码是否正确  
24.         return JCaptcha.validateResponse(httpServletRequest, httpServletRequest.getParameter(jcaptchaParam));  
25.     }  
26.     protected boolean onAccessDenied(ServletRequest request, ServletResponse response) throws Exception {  
27.         //如果验证码失败了，存储失败key属性  
28.         request.setAttribute(failureKeyAttribute, "jCaptcha.error");  
29.         return true;  
30.     }  
31. }  

 

七、MyFormAuthenticationFilter

用于验证码验证的Shiro拦截器在用于身份认证的拦截器之前运行；但是如果验证码验证拦截器失败了，就不需要进行身份认证拦截器流程了；所以需要修改下如FormAuthenticationFilter身份认证拦截器，当验证码验证失败时不再走身份认证拦截器。 

Java代码  

1. public class MyFormAuthenticationFilter extends FormAuthenticationFilter {  
2.     protected boolean onAccessDenied(ServletRequest request, ServletResponse response, Object mappedValue) throws Exception {  
3.         if(request.getAttribute(getFailureKeyAttribute()) != null) {  
4.             return true;  
5.         }  
6.         return super.onAccessDenied(request, response, mappedValue);  
7.     }  
8. }   

即如果之前已经错了，那直接跳过即可。

 

八、spring-config-shiro.xml       

Java代码  

1. <!-- 基于Form表单的身份验证过滤器 -->  
2. <bean id="authcFilter"   
3.   class="com.github.zhangkaitao.shiro.chapter22.jcaptcha.MyFormAuthenticationFilter">  
4.     <property name="usernameParam" value="username"/>  
5.     <property name="passwordParam" value="password"/>  
6.     <property name="rememberMeParam" value="rememberMe"/>  
7.     <property name="failureKeyAttribute" value="shiroLoginFailure"/>  
8. </bean>  
9. <bean id="jCaptchaValidateFilter"   
10.   class="com.github.zhangkaitao.shiro.chapter22.jcaptcha.JCaptchaValidateFilter">  
11.     <property name="jcaptchaEbabled" value="true"/>  
12.     <property name="jcaptchaParam" value="jcaptchaCode"/>  
13.     <property name="failureKeyAttribute" value="shiroLoginFailure"/>  
14. </bean>  
15. <!-- Shiro的Web过滤器 -->  
16. <bean id="shiroFilter" class="org.apache.shiro.spring.web.ShiroFilterFactoryBean">  
17.     <property name="securityManager" ref="securityManager"/>  
18.     <property name="loginUrl" value="/login"/>  
19.     <property name="filters">  
20.         <util:map>  
21.             <entry key="authc" value-ref="authcFilter"/>  
22.             <entry key="sysUser" value-ref="sysUserFilter"/>  
23.             <entry key="jCaptchaValidate" value-ref="jCaptchaValidateFilter"/>  
24.         </util:map>  
25.     </property>  
26.     <property name="filterChainDefinitions">  
27.         <value>  
28.             /static/** = anon  
29.             /jcaptcha* = anon  
30.             /login = jCaptchaValidate,authc  
31.             /logout = logout  
32.             /authenticated = authc  
33.             /** = user,sysUser  
34.         </value>  
35.     </property>  
36. </bean>  

 

九、login.jsp登录页面

Java代码  

1. <c:if test="${jcaptchaEbabled}">  
2.     验证码：  
3.     <input type="text" name="jcaptchaCode">  
4. <img class="jcaptcha-btn jcaptcha-img"   
5. src="${pageContext.request.contextPath}/jcaptcha.jpg" title="点击更换验证码">  
6.     <a class="jcaptcha-btn" href="javascript:;">换一张</a>  
7.     <br/>  
8. </c:if>   

根据jcaptchaEbabled来显示验证码图片。

 

十、测试

输入http://localhost:8080/chapter22将重定向到登录页面；输入正确的用户名/密码/验证码即可成功登录，如果输入错误的验证码，将显示验证码错误页面： 

@22@

在做一些企业内部项目时或一些互联网后台时；可能会涉及到集中权限管理，统一进行多项目的权限管理；另外也需要统一的会话管理，即实现单点身份认证和授权控制。

 

学习本章之前，请务必先学习《第十章 会话管理》和《第十六章 综合实例》，本章代码都是基于这两章的代码基础上完成的。

 

本章示例是同域名的场景下完成的，如果跨域请参考《第十五章 单点登录》和《第十七章 OAuth2集成》了解使用CAS或OAuth2实现跨域的身份验证和授权。另外比如客户端/服务器端的安全校验可参考《第二十章 无状态Web应用集成》。

 

 

部署架构 

1、有三个应用：用于用户/权限控制的Server（端口：8080）；两个应用App1（端口9080）和App2（端口10080）；

2、使用Nginx反向代理这三个应用，nginx.conf的server配置部分如下：  

Java代码  

1. server {  
2.     listen 80;  
3.     server_name  localhost;  
4.     charset utf-8;  
5.     location ~ ^/(chapter23-server)/ {  
6.         proxy_pass http://127.0.0.1:8080;   
7.         index /;  
8.             proxy_set_header Host $host;  
9.     }  
10.     location ~ ^/(chapter23-app1)/ {  
11.         proxy_pass http://127.0.0.1:9080;   
12.         index /;  
13.             proxy_set_header Host $host;  
14.     }  
15.     location ~ ^/(chapter23-app2)/ {  
16.         proxy_pass http://127.0.0.1:10080;   
17.         index /;  
18.             proxy_set_header Host $host;  
19.     }  
20. }   

如访问http://localhost/chapter23-server会自动转发到http://localhost:8080/chapter23-server；

访问http://localhost/chapter23-app1会自动转发到http://localhost:9080/chapter23-app1；访问http://localhost/chapter23-app3会自动转发到http://localhost:10080/chapter23-app3；

 

Nginx的安装及使用请自行搜索学习，本文不再阐述。 

 

项目架构 

1、首先通过用户/权限Server维护用户、应用、权限信息；数据都持久化到MySQL数据库中；

2、应用App1/应用App2使用客户端Client远程调用用户/权限Server获取会话及权限信息。

 

此处使用Mysql存储会话，而不是使用如Memcached/Redis之类的，主要目的是降低学习成本；如果换成如Redis也不会很难；如： 

使用如Redis还一个好处就是无需在用户/权限Server中开会话过期调度器，可以借助Redis自身的过期策略来完成。

 

模块关系依赖

  

1、shiro-example-chapter23-pom模块：提供了其他所有模块的依赖；这样其他模块直接继承它即可，简化依赖配置，如shiro-example-chapter23-server：  

Java代码  

1. <parent>  
2.     <artifactId>shiro-example-chapter23-pom</artifactId>  
3.     <groupId>com.github.zhangkaitao</groupId>  
4.     <version>1.0-SNAPSHOT</version>  
5. </parent>  

2、shiro-example-chapter23-core模块：提供给shiro-example-chapter23-server、shiro-example-chapter23-client、shiro-example-chapter23-app*模块的核心依赖，比如远程调用接口等；

  

3、shiro-example-chapter23-server模块：提供了用户、应用、权限管理功能；

 

4、shiro-example-chapter23-client模块：提供给应用模块获取会话及应用对应的权限信息；

 

5、shiro-example-chapter23-app*模块：各个子应用，如一些内部管理系统应用；其登录都跳到shiro-example-chapter23-server登录；另外权限都从shiro-example-chapter23-server获取（如通过远程调用）。  

  

shiro-example-chapter23-pom模块

 

其pom.xml的packaging类型为pom，并且在该pom中加入其他模块需要的依赖，然后其他模块只需要把该模块设置为parent即可自动继承这些依赖，如shiro-example-chapter23-server模块： 

Java代码  

1. <parent>  
2.     <artifactId>shiro-example-chapter23-pom</artifactId>  
3.     <groupId>com.github.zhangkaitao</groupId>  
4.     <version>1.0-SNAPSHOT</version>  
5. </parent>   

简化其他模块的依赖配置等。 

 

shiro-example-chapter23-core模块

 

提供了其他模块共有的依赖，如远程调用接口：  

Java代码  

1. public interface RemoteServiceInterface {  
2.     public Session getSession(String appKey, Serializable sessionId);  
3.     Serializable createSession(Session session);  
4.     public void updateSession(String appKey, Session session);  
5.     public void deleteSession(String appKey, Session session);  
6.     public PermissionContext getPermissions(String appKey, String username);  
7. }   

提供了会话的CRUD，及根据应用key和用户名获取权限上下文（包括角色和权限字符串）；shiro-example-chapter23-server模块服务端实现；shiro-example-chapter23-client模块客户端调用。

 

另外提供了com.github.zhangkaitao.shiro.chapter23.core.ClientSavedRequest，其扩展了org.apache.shiro.web.util.SavedRequest；用于shiro-example-chapter23-app*模块当访问一些需要登录的请求时，自动把请求保存下来，然后重定向到shiro-example-chapter23-server模块登录；登录成功后再重定向回来；因为SavedRequest不保存URL中的schema://domain:port部分；所以才需要扩展SavedRequest；使得ClientSavedRequest能保存schema://domain:port；这样才能从一个应用重定向另一个（要不然只能在一个应用内重定向）：  

Java代码  

1.     public String getRequestUrl() {  
2.         String requestURI = getRequestURI();  
3.         if(backUrl != null) {//1  
4.             if(backUrl.toLowerCase().startsWith("http://") || backUrl.toLowerCase().startsWith("https://")) {  
5.                 return backUrl;  
6.             } else if(!backUrl.startsWith(contextPath)) {//2  
7.                 requestURI = contextPath + backUrl;  
8.             } else {//3  
9.                 requestURI = backUrl;  
10.             }  
11.         }  
12.         StringBuilder requestUrl = new StringBuilder(scheme);//4  
13.         requestUrl.append("://");  
14.         requestUrl.append(domain);//5  
15.         //6  
16.         if("http".equalsIgnoreCase(scheme) && port != 80) {  
17.             requestUrl.append(":").append(String.valueOf(port));  
18.         } else if("https".equalsIgnoreCase(scheme) && port != 443) {  
19.             requestUrl.append(":").append(String.valueOf(port));  
20.         }  
21.         //7  
22.         requestUrl.append(requestURI);  
23.         //8  
24.         if (backUrl == null && getQueryString() != null) {  
25.             requestUrl.append("?").append(getQueryString());  
26.         }  
27.         return requestUrl.toString();  
28.     }  
29.    

1、如果从外部传入了successUrl（登录成功之后重定向的地址），且以http://或https://开头那么直接返回（相应的拦截器直接重定向到它即可）；

2、如果successUrl有值但没有上下文，拼上上下文；

3、否则，如果successUrl有值，直接赋值给requestUrl即可；否则，如果successUrl没值，那么requestUrl就是当前请求的地址；

5、拼上url前边的schema，如http或https；

6、拼上域名；

7、拼上重定向到的地址（带上下文）；

8、如果successUrl没值，且有查询参数，拼上；

9返回该地址，相应的拦截器直接重定向到它即可。

 

shiro-example-chapter23-server模块

简单的实体关系图  

简单数据字典

用户(sys_user)

名称	类型	长度	描述
id	bigint		编号 主键
username	varchar	100	用户名
password	varchar	100	密码
salt	varchar	50	盐
locked	bool		账户是否锁定

应用(sys_app)

名称	类型	长度	描述
id	bigint		编号 主键
name	varchar	100	应用名称
app_key	varchar	100	应用key（唯一）
app_secret	varchar	100	应用安全码
available	bool		是否锁定

授权(sys_authorization)

名称	类型	长度	描述
id	bigint		编号 主键
user_id	bigint		所属用户
app_id	bigint		所属应用
role_ids	varchar	100	角色列表

用户：比《第十六章 综合实例》少了role_ids，因为本章是多项目集中权限管理；所以授权时需要指定相应的应用；而不是直接给用户授权；所以不能在用户中出现role_ids了；

应用：所有集中权限的应用；在此处需要指定应用key(app_key)和应用安全码（app_secret），app在访问server时需要指定自己的app_key和用户名来获取该app对应用户权限信息；另外app_secret可以认为app的密码，比如需要安全访问时可以考虑使用它，可参考《第二十章 无状态Web应用集成》。另外available属性表示该应用当前是否开启；如果false表示该应用当前不可用，即不能获取到相应的权限信息。

授权：给指定的用户在指定的app下授权，即角色是与用户和app存在关联关系。

 

因为本章使用了《第十六章 综合实例》代码，所以还有其他相应的表结构（本章未使用到）。

 

表/数据SQL

具体请参考

sql/ shiro-schema.sql （表结构）

sql/ shiro-data.sql  （初始数据）

 

实体

具体请参考com.github.zhangkaitao.shiro.chapter23.entity包下的实体，此处就不列举了。

 

DAO

具体请参考com.github.zhangkaitao.shiro.chapter23.dao包下的DAO接口及实现。

 

Service

具体请参考com.github.zhangkaitao.shiro.chapter23.service包下的Service接口及实现。以下是出了基本CRUD之外的关键接口： 

Java代码  

1. public interface AppService {  
2.     public Long findAppIdByAppKey(String appKey);// 根据appKey查找AppId   
3. }  

Java代码  

1. public interface AuthorizationService {  
2.     //根据AppKey和用户名查找其角色  
3.     public Set<String> findRoles(String appKey, String username);  
4.     //根据AppKey和用户名查找权限字符串  
5.     public Set<String> findPermissions(String appKey, String username);  
6. }   

根据AppKey和用户名查找用户在指定应用中对于的角色和权限字符串。

 

UserRealm  

Java代码  

1. protected AuthorizationInfo doGetAuthorizationInfo(PrincipalCollection principals) {  
2.     String username = (String)principals.getPrimaryPrincipal();  
3.     SimpleAuthorizationInfo authorizationInfo = new SimpleAuthorizationInfo();  
4.     authorizationInfo.setRoles(  
5.         authorizationService.findRoles(Constants.SERVER_APP_KEY, username));  
6.     authorizationInfo.setStringPermissions(  
7.     authorizationService.findPermissions(Constants.SERVER_APP_KEY, username));  
8.     return authorizationInfo;  
9. }   

此处需要调用AuthorizationService的findRoles/findPermissions方法传入AppKey和用户名来获取用户的角色和权限字符串集合。其他的和《第十六章 综合实例》代码一样。

 

ServerFormAuthenticationFilter 

Java代码  

1. public class ServerFormAuthenticationFilter extends FormAuthenticationFilter {  
2.     protected void issueSuccessRedirect(ServletRequest request, ServletResponse response) throws Exception {  
3.         String fallbackUrl = (String) getSubject(request, response)  
4.                 .getSession().getAttribute("authc.fallbackUrl");  
5.         if(StringUtils.isEmpty(fallbackUrl)) {  
6.             fallbackUrl = getSuccessUrl();  
7.         }  
8.         WebUtils.redirectToSavedRequest(request, response, fallbackUrl);  
9.     }  
10. }   

因为是多项目登录，比如如果是从其他应用中重定向过来的，首先检查Session中是否有“authc.fallbackUrl”属性，如果有就认为它是默认的重定向地址；否则使用Server自己的successUrl作为登录成功后重定向到的地址。

 

MySqlSessionDAO

将会话持久化到Mysql数据库；此处大家可以将其实现为如存储到Redis/Memcached等，实现策略请参考《第十章 会话管理》中的会话存储/持久化章节的MySessionDAO，完全一样。

 

MySqlSessionValidationScheduler

和《第十章 会话管理》中的会话验证章节部分中的MySessionValidationScheduler完全一样。如果使用如Redis之类的有自动过期策略的DB，完全可以不用实现SessionValidationScheduler，直接借助于这些DB的过期策略即可。

 

RemoteService  

Java代码  

1. public class RemoteService implements RemoteServiceInterface {  
2.     @Autowired  private AuthorizationService authorizationService;  
3.     @Autowired  private SessionDAO sessionDAO;  
4.   
5.     public Session getSession(String appKey, Serializable sessionId) {  
6.         return sessionDAO.readSession(sessionId);  
7.     }  
8.     public Serializable createSession(Session session) {  
9.         return sessionDAO.create(session);  
10.     }  
11.     public void updateSession(String appKey, Session session) {  
12.         sessionDAO.update(session);  
13.     }  
14.     public void deleteSession(String appKey, Session session) {  
15.         sessionDAO.delete(session);  
16.     }  
17.     public PermissionContext getPermissions(String appKey, String username) {  
18.         PermissionContext permissionContext = new PermissionContext();  
19.         permissionContext.setRoles(authorizationService.findRoles(appKey, username));  
20.         permissionContext.setPermissions(authorizationService.findPermissions(appKey, username));  
21.         return permissionContext;  
22.     }  
23. }   

将会使用HTTP调用器暴露为远程服务，这样其他应用就可以使用相应的客户端调用这些接口进行Session的集中维护及根据AppKey和用户名获取角色/权限字符串集合。此处没有实现安全校验功能，如果是局域网内使用可以通过限定IP完成；否则需要使用如《第二十章 无状态Web应用集成》中的技术完成安全校验。

 

然后在spring-mvc-remote-service.xml配置文件把服务暴露出去：  

Java代码  

1. <bean id="remoteService"  
2.   class="com.github.zhangkaitao.shiro.chapter23.remote.RemoteService"/>  
3. <bean name="/remoteService"   
4.   class="org.springframework.remoting.httpinvoker.HttpInvokerServiceExporter">  
5.     <property name="service" ref="remoteService"/>  
6.     <property name="serviceInterface"   
7.       value="com.github.zhangkaitao.shiro.chapter23.remote.RemoteServiceInterface"/>  
8. </bean>  

   

Shiro配置文件spring-config-shiro.xml 

和《第十六章 综合实例》配置类似，但是需要在shiroFilter中的filterChainDefinitions中添加如下配置，即远程调用不需要身份认证：  

Java代码  

1. /remoteService = anon  

对于userRealm的缓存配置直接禁用；因为如果开启，修改了用户权限不会自动同步到缓存；另外请参考《第十一章 缓存机制》进行缓存的正确配置。

 

服务器端数据维护

1、首先开启ngnix反向代理；然后就可以直接访问http://localhost/chapter23-server/；

2、输入默认的用户名密码：admin/123456登录

3、应用管理，进行应用的CRUD，主要维护应用KEY（必须唯一）及应用安全码；客户端就可以使用应用KEY获取用户对应应用的权限了。 

4、授权管理，维护在哪个应用中用户的角色列表。这样客户端就可以根据应用KEY及用户名获取到对应的角色/权限字符串列表了。 

 

shiro-example-chapter23-client模块

Client模块提供给其他应用模块依赖，这样其他应用模块只需要依赖Client模块，然后再在相应的配置文件中配置如登录地址、远程接口地址、拦截器链等等即可，简化其他应用模块的配置。

 

配置远程服务spring-client-remote-service.xml      

Java代码  

1. <bean id="remoteService"   
2.   class="org.springframework.remoting.httpinvoker.HttpInvokerProxyFactoryBean">  
3.     <property name="serviceUrl" value="${client.remote.service.url}"/>  
4.     <property name="serviceInterface"   
5.       value="com.github.zhangkaitao.shiro.chapter23.remote.RemoteServiceInterface"/>  
6. </bean>   

client.remote.service.url是远程服务暴露的地址；通过相应的properties配置文件配置，后续介绍。然后就可以通过remoteService获取会话及角色/权限字符串集合了。

 

ClientRealm  

Java代码  

1. public class ClientRealm extends AuthorizingRealm {  
2.     private RemoteServiceInterface remoteService;  
3.     private String appKey;  
4.     public void setRemoteService(RemoteServiceInterface remoteService) {  
5.         this.remoteService = remoteService;  
6.     }  
7.     public void setAppKey(String appKey) {  
8.         this.appKey = appKey;  
9.     }  
10.     protected AuthorizationInfo doGetAuthorizationInfo(PrincipalCollection principals) {  
11.         String username = (String) principals.getPrimaryPrincipal();  
12.         SimpleAuthorizationInfo authorizationInfo = new SimpleAuthorizationInfo();  
13.         PermissionContext context = remoteService.getPermissions(appKey, username);  
14.         authorizationInfo.setRoles(context.getRoles());  
15.         authorizationInfo.setStringPermissions(context.getPermissions());  
16.         return authorizationInfo;  
17.     }  
18.     protected AuthenticationInfo doGetAuthenticationInfo(AuthenticationToken token) throws AuthenticationException {  
19.         //永远不会被调用  
20.         throw new UnsupportedOperationException("永远不会被调用");  
21.     }  
22. }   

ClientRealm提供身份认证信息和授权信息，此处因为是其他应用依赖客户端，而这些应用不会实现身份认证，所以doGetAuthenticationInfo获取身份认证信息直接无须实现。另外获取授权信息，是通过远程暴露的服务RemoteServiceInterface获取，提供appKey和用户名获取即可。

 

ClientSessionDAO 

Java代码  

1. public class ClientSessionDAO extends CachingSessionDAO {  
2.     private RemoteServiceInterface remoteService;  
3.     private String appKey;  
4.     public void setRemoteService(RemoteServiceInterface remoteService) {  
5.         this.remoteService = remoteService;  
6.     }  
7.     public void setAppKey(String appKey) {  
8.         this.appKey = appKey;  
9.     }  
10.     protected void doDelete(Session session) {  
11.         remoteService.deleteSession(appKey, session);  
12.     }  
13.     protected void doUpdate(Session session) {  
14.         remoteService.updateSession(appKey, session);  
15. }  
16. protected Serializable doCreate(Session session) {  
17.         Serializable sessionId = remoteService.createSession(session);  
18.         assignSessionId(session, sessionId);  
19.         return sessionId;  
20.     }  
21.     protected Session doReadSession(Serializable sessionId) {  
22.         return remoteService.getSession(appKey, sessionId);  
23.     }  
24. }   

Session的维护通过远程暴露接口实现，即本地不维护会话。

 

ClientAuthenticationFilter  

Java代码  

1. public class ClientAuthenticationFilter extends AuthenticationFilter {  
2.     protected boolean isAccessAllowed(ServletRequest request, ServletResponse response, Object mappedValue) {  
3.         Subject subject = getSubject(request, response);  
4.         return subject.isAuthenticated();  
5.     }  
6.     protected boolean onAccessDenied(ServletRequest request, ServletResponse response) throws Exception {  
7.         String backUrl = request.getParameter("backUrl");  
8.         saveRequest(request, backUrl, getDefaultBackUrl(WebUtils.toHttp(request)));  
9.         return false;  
10.     }  
11.     protected void saveRequest(ServletRequest request, String backUrl, String fallbackUrl) {  
12.         Subject subject = SecurityUtils.getSubject();  
13.         Session session = subject.getSession();  
14.         HttpServletRequest httpRequest = WebUtils.toHttp(request);  
15.         session.setAttribute("authc.fallbackUrl", fallbackUrl);  
16.         SavedRequest savedRequest = new ClientSavedRequest(httpRequest, backUrl);  
17.         session.setAttribute(WebUtils.SAVED_REQUEST_KEY, savedRequest);  
18. }  
19.     private String getDefaultBackUrl(HttpServletRequest request) {  
20.         String scheme = request.getScheme();  
21.         String domain = request.getServerName();  
22.         int port = request.getServerPort();  
23.         String contextPath = request.getContextPath();  
24.         StringBuilder backUrl = new StringBuilder(scheme);  
25.         backUrl.append("://");  
26.         backUrl.append(domain);  
27.         if("http".equalsIgnoreCase(scheme) && port != 80) {  
28.             backUrl.append(":").append(String.valueOf(port));  
29.         } else if("https".equalsIgnoreCase(scheme) && port != 443) {  
30.             backUrl.append(":").append(String.valueOf(port));  
31.         }  
32.         backUrl.append(contextPath);  
33.         backUrl.append(getSuccessUrl());  
34.         return backUrl.toString();  
35.     }  
36. }   

ClientAuthenticationFilter是用于实现身份认证的拦截器（authc），当用户没有身份认证时；

1、首先得到请求参数backUrl，即登录成功重定向到的地址；

2、然后保存保存请求到会话，并重定向到登录地址（server模块）；

3、登录成功后，返回地址按照如下顺序获取：backUrl、保存的当前请求地址、defaultBackUrl（即设置的successUrl）；

 

ClientShiroFilterFactoryBean  

Java代码  

1. public class ClientShiroFilterFactoryBean extends ShiroFilterFactoryBean implements ApplicationContextAware {  
2.     private ApplicationContext applicationContext;  
3.     public void setApplicationContext(ApplicationContext applicationContext) {  
4.         this.applicationContext = applicationContext;  
5.     }  
6.     public void setFiltersStr(String filters) {  
7.         if(StringUtils.isEmpty(filters)) {  
8.             return;  
9.         }  
10.         String[] filterArray = filters.split(";");  
11.         for(String filter : filterArray) {  
12.             String[] o = filter.split("=");  
13.             getFilters().put(o[0], (Filter)applicationContext.getBean(o[1]));  
14.         }  
15.     }  
16.     public void setFilterChainDefinitionsStr(String filterChainDefinitions) {  
17.         if(StringUtils.isEmpty(filterChainDefinitions)) {  
18.             return;  
19.         }  
20.         String[] chainDefinitionsArray = filterChainDefinitions.split(";");  
21.         for(String filter : chainDefinitionsArray) {  
22.             String[] o = filter.split("=");  
23.             getFilterChainDefinitionMap().put(o[0], o[1]);  
24.         }  
25.     }  
26. }   

1、setFiltersStr：设置拦截器，设置格式如“filterName=filterBeanName; filterName=filterBeanName”；多个之间分号分隔；然后通过applicationContext获取filterBeanName对应的Bean注册到拦截器Map中；

2、setFilterChainDefinitionsStr：设置拦截器链，设置格式如“url=filterName1[config],filterName2; url=filterName1[config],filterName2”；多个之间分号分隔；

 

Shiro客户端配置spring-client.xml

提供了各应用通用的Shiro客户端配置；这样应用只需要导入相应该配置即可完成Shiro的配置，简化了整个配置过程。  

Java代码  

1. <context:property-placeholder location=   
2.     "classpath:client/shiro-client-default.properties,classpath:client/shiro-client.properties"/>   

提供给客户端配置的properties属性文件，client/shiro-client-default.properties是客户端提供的默认的配置；classpath:client/shiro-client.properties是用于覆盖客户端默认配置，各应用应该提供该配置文件，然后提供各应用个性配置。

 

Java代码  

1. <bean id="remoteRealm" class="com.github.zhangkaitao.shiro.chapter23.client.ClientRealm">  
2.     <property name="cachingEnabled" value="false"/>  
3.     <property name="appKey" value="${client.app.key}"/>  
4.     <property name="remoteService" ref="remoteService"/>  
5. </bean>   

appKey：使用${client.app.key}占位符替换，即需要在之前的properties文件中配置。 

 

Java代码  

1. <bean id="sessionIdCookie" class="org.apache.shiro.web.servlet.SimpleCookie">  
2.     <constructor-arg value="${client.session.id}"/>  
3.     <property name="httpOnly" value="true"/>  
4.     <property name="maxAge" value="-1"/>  
5.     <property name="domain" value="${client.cookie.domain}"/>  
6.     <property name="path" value="${client.cookie.path}"/>  
7. </bean>   

Session Id Cookie，cookie名字、域名、路径等都是通过配置文件配置。  

 

Java代码  

1. <bean id="sessionDAO"   
2.   class="com.github.zhangkaitao.shiro.chapter23.client.ClientSessionDAO">  
3.     <property name="sessionIdGenerator" ref="sessionIdGenerator"/>  
4.     <property name="appKey" value="${client.app.key}"/>  
5.     <property name="remoteService" ref="remoteService"/>  
6. </bean>   

SessionDAO的appKey，也是通过${ client.app.key }占位符替换，需要在配置文件配置。

 

Java代码  

1. <bean id="sessionManager"   
2.   class="org.apache.shiro.web.session.mgt.DefaultWebSessionManager">  
3.         <property name="sessionValidationSchedulerEnabled" value="false"/>//省略其他  
4. </bean>   

其他应用无须进行会话过期调度，所以sessionValidationSchedulerEnabled=false。  

 

Java代码  

1. <bean id="clientAuthenticationFilter"   
2.   class="com.github.zhangkaitao.shiro.chapter23.client.ClientAuthenticationFilter"/>   

应用的身份认证使用ClientAuthenticationFilter，即如果没有身份认证，则会重定向到Server模块完成身份认证，身份认证成功后再重定向回来。 

 

Java代码  

1. <bean id="shiroFilter"   
2.   class="com.github.zhangkaitao.shiro.chapter23.client.ClientShiroFilterFactoryBean">  
3.     <property name="securityManager" ref="securityManager"/>  
4.     <property name="loginUrl" value="${client.login.url}"/>  
5.     <property name="successUrl" value="${client.success.url}"/>  
6.     <property name="unauthorizedUrl" value="${client.unauthorized.url}"/>  
7.     <property name="filters">  
8.         <util:map>  
9.             <entry key="authc" value-ref="clientAuthenticationFilter"/>  
10.         </util:map>  
11.     </property>  
12.     <property name="filtersStr" value="${client.filters}"/>  
13.     <property name="filterChainDefinitionsStr" value="${client.filter.chain.definitions}"/>  
14. </bean>   

ShiroFilter使用我们自定义的ClientShiroFilterFactoryBean，然后loginUrl（登录地址）、successUrl（登录成功后默认的重定向地址）、unauthorizedUrl（未授权重定向到的地址）通过占位符替换方式配置；另外filtersStr和filterChainDefinitionsStr也是使用占位符替换方式配置；这样就可以在各应用进行自定义了。

 

默认配置client/ shiro-client-default.properties 

Java代码  

1. #各应用的appKey  
2. client.app.key=  
3. #远程服务URL地址  
4. client.remote.service.url=http://localhost/chapter23-server/remoteService  
5. #登录地址  
6. client.login.url=http://localhost/chapter23-server/login  
7. #登录成功后，默认重定向到的地址  
8. client.success.url=/  
9. #未授权重定向到的地址  
10. client.unauthorized.url=http://localhost/chapter23-server/unauthorized  
11. #session id 域名  
12. client.cookie.domain=  
13. #session id 路径  
14. client.cookie.path=/  
15. #cookie中的session id名称  
16. client.session.id=sid  
17. #cookie中的remember me名称  
18. client.rememberMe.id=rememberMe  
19. #过滤器 name=filter-ref;name=filter-ref  
20. client.filters=  
21. #过滤器链 格式 url=filters;url=filters  
22. client.filter.chain.definitions=/**=anon   

在各应用中主要配置client.app.key、client.filters、client.filter.chain.definitions。

 

 

shiro-example-chapter23-app*模块

继承shiro-example-chapter23-pom模块 

Java代码  

1. <parent>  
2.     <artifactId>shiro-example-chapter23-pom</artifactId>  
3.     <groupId>com.github.zhangkaitao</groupId>  
4.     <version>1.0-SNAPSHOT</version>  
5. </parent>  

  

依赖shiro-example-chapter23-client模块

<dependency>    <groupId>com.github.zhangkaitao</groupId>    <artifactId>shiro-example-chapter23-client</artifactId>    <version>1.0-SNAPSHOT</version></dependency> 

 

客户端配置client/shiro-client.properties

 

配置shiro-example-chapter23-app1  

Java代码 

1. client.app.key=645ba612-370a-43a8-a8e0-993e7a590cf0  
2. client.success.url=/hello  
3. client.filter.chain.definitions=/hello=anon;/login=authc;/**=authc   

client.app.key是server模块维护的，直接拷贝过来即可；client.filter.chain.definitions定义了拦截器链；比如访问/hello，匿名即可。

 

配置shiro-example-chapter23-app2 

Java代码 

1. client.app.key=645ba613-370a-43a8-a8e0-993e7a590cf0  
2. client.success.url=/hello  
3. client.filter.chain.definitions=/hello=anon;/login=authc;/**=authc   

和app1类似，client.app.key是server模块维护的，直接拷贝过来即可；client.filter.chain.definitions定义了拦截器链；比如访问/hello，匿名即可。

 

web.xml 

Java代码 

1. <context-param>  
2.     <param-name>contextConfigLocation</param-name>  
3.     <param-value>  
4.         classpath:client/spring-client.xml  
5.     </param-value>  
6. </context-param>  
7. <listener>  
8.     <listener-class>  
9.         org.springframework.web.context.ContextLoaderListener  
10.     </listener-class>  
11. </listener>   

指定加载客户端Shiro配置，client/spring-client.xml。 

 

Java代码 

1. <filter>  
2.     <filter-name>shiroFilter</filter-name>  
3.     <filter-class>org.springframework.web.filter.DelegatingFilterProxy</filter-class>  
4.     <init-param>  
5.         <param-name>targetFilterLifecycle</param-name>  
6.         <param-value>true</param-value>  
7.     </init-param>  
8. </filter>  
9. <filter-mapping>  
10.     <filter-name>shiroFilter</filter-name>  
11.     <url-pattern>/*</url-pattern>  
12. </filter-mapping>  

 配置ShiroFilter拦截器。

 

控制器

shiro-example-chapter23-app1

Java代码 

1. @Controller  
2. public class HelloController {  
3.     @RequestMapping("/hello")  
4.     public String hello() {  
5.         return "success";  
6.     }  
7.     @RequestMapping(value = "/attr", method = RequestMethod.POST)  
8.     public String setAttr(  
9.             @RequestParam("key") String key, @RequestParam("value") String value) {  
10.         SecurityUtils.getSubject().getSession().setAttribute(key, value);  
11.         return "success";  
12.     }  
13.     @RequestMapping(value = "/attr", method = RequestMethod.GET)  
14.     public String getAttr(  
15.             @RequestParam("key") String key, Model model) {  
16.         model.addAttribute("value",   
17.             SecurityUtils.getSubject().getSession().getAttribute(key));  
18.         return "success";  
19.     }  
20.     @RequestMapping("/role1")  
21.     @RequiresRoles("role1")  
22.     public String role1() {  
23.         return "success";  
24.     }  
25. }   

shiro-example-chapter23-app2的控制器类似，role2方法使用@RequiresRoles("role2")注解，即需要角色2。

 

其他配置请参考源码。 

 

 

测试

1、安装配置启动nginx

1、首先到http://nginx.org/en/download.html下载，比如我下载的是windows版本的；

 

2、然后编辑conf/nginx.conf配置文件，在server部分添加如下部分：

Java代码 

1. location ~ ^/(chapter23-server)/ {  
2.  proxy_pass http://127.0.0.1:8080;   
3.  index /;  
4.         proxy_set_header Host $host;  
5. }  
6. location ~ ^/(chapter23-app1)/ {  
7.  proxy_pass http://127.0.0.1:9080;   
8.  index /;  
9.         proxy_set_header Host $host;  
10. }  
11. location ~ ^/(chapter23-app2)/ {  
12.  proxy_pass http://127.0.0.1:10080;   
13.  index /;  
14.         proxy_set_header Host $host;  
15. }  

  

3、最后双击nginx.exe启动Nginx即可。

 

已经配置好的nginx请到shiro-example-chapter23-nginx模块下下周nginx-1.5.11.rar即可。

 

2、安装依赖

1、首先安装shiro-example-chapter23-core依赖，到shiro-example-chapter23-core模块下运行mvn install安装core模块。

2、接着到shiro-example-chapter23-client模块下运行mvn install安装客户端模块。

 

3、启动Server模块

到shiro-example-chapter23-server模块下运行mvn jetty:run启动该模块；使用http://localhost:8080/chapter23-server/即可访问，因为启动了nginx，那么可以直接访问http://localhost/chapter23-server/。

 

4、启动App*模块

到shiro-example-chapter23-app1和shiro-example-chapter23-app2模块下分别运行mvn jetty:run启动该模块；使用http://localhost:9080/chapter23-app1/和http://localhost:10080/chapter23-app2/即可访问，因为启动了nginx，那么可以直接访问http://localhost/chapter23-app1/和http://localhost/chapter23-app2/。

5、服务器端维护

1、访问http://localhost/chapter23-server/；

2、输入默认的用户名密码：admin/123456登录

 

3、应用管理，进行应用的CRUD，主要维护应用KEY（必须唯一）及应用安全码；客户端就可以使用应用KEY获取用户对应应用的权限了。

4、授权管理，维护在哪个应用中用户的角色列表。这样客户端就可以根据应用KEY及用户名获取到对应的角色/权限字符串列表了。


  

6、App*模块身份认证及授权

1、在未登录情况下访问http://localhost/chapter23-app1/hello，看到下图：

 2、登录地址是http://localhost/chapter23-app1/login?backUrl=/chapter23-app1，即登录成功后重定向回http://localhost/chapter23-app1（这是个错误地址，为了测试登录成功后重定向地址），点击登录按钮后重定向到Server模块的登录界面： 

3、登录成功后，会重定向到相应的登录成功地址；接着访问http://localhost/chapter23-app1/hello，看到如下图：

4、可以看到admin登录，及其是否拥有role1/role2角色；可以在server模块移除role1角色或添加role2角色看看页面变化；

 

5、可以在http://localhost/chapter23-app1/hello页面设置属性，如key=123；接着访问http://localhost/chapter23-app2/attr?key=key就可以看到刚才设置的属性，如下图：

另外在app2，用户默认拥有role2角色，而没有role1角色。

 

到此整个测试就完成了，可以看出本示例实现了：会话的分布式及权限的集中管理。

 

本示例缺点

1、没有加缓存；

2、客户端每次获取会话/权限都需要通过客户端访问服务端；造成服务端单点和请求压力大；单点可以考虑使用集群来解决；请求压力大需要考虑配合缓存服务器（如Redis）来解决；即每次会话/权限获取时首先查询缓存中是否存在，如果有直接获取即可；否则再查服务端；降低请求压力；

3、会话的每次更新（比如设置属性/更新最后访问时间戳）都需要同步到服务端；也造成了请求压力过大；可以考虑在请求的最后只同步一次会话（需要对Shiro会话进行改造，通过如拦截器在执行完请求后完成同步，这样每次请求只同步一次）；

4、只能同域名才能使用，即会话ID是从同一个域名下获取，如果跨域请考虑使用CAS/OAuth2之实现。

 

所以实际应用时可能还是需要改造的，但大体思路是差不多的。

@23@

有时候需要显示当前在线人数、当前在线用户，有时候可能需要强制某个用户下线等；此时就需要获取相应的在线用户并进行一些操作。

 

本章基于《第十六章 综合实例》代码构建。 

 

会话控制器

Java代码  

1. @RequiresPermissions("session:*")  
2. @Controller  
3. @RequestMapping("/sessions")  
4. public class SessionController {  
5.     @Autowired  
6.     private SessionDAO sessionDAO;  
7.     @RequestMapping()  
8.     public String list(Model model) {  
9.         Collection<Session> sessions =  sessionDAO.getActiveSessions();  
10.         model.addAttribute("sessions", sessions);  
11.         model.addAttribute("sesessionCount", sessions.size());  
12.         return "sessions/list";  
13.     }  
14.     @RequestMapping("/{sessionId}/forceLogout")  
15.     public String forceLogout(@PathVariable("sessionId") String sessionId,   
16.         RedirectAttributes redirectAttributes) {  
17.         try {  
18.             Session session = sessionDAO.readSession(sessionId);  
19.             if(session != null) {  
20.                 session.setAttribute(  
21.                     Constants.SESSION_FORCE_LOGOUT_KEY, Boolean.TRUE);  
22.             }  
23.         } catch (Exception e) {/*ignore*/}  
24.         redirectAttributes.addFlashAttribute("msg", "强制退出成功！");  
25.         return "redirect:/sessions";  
26.     }  
27. }   

1、list方法：提供了展示所有在线会话列表，通过sessionDAO.getActiveSessions()获取所有在线的会话。

2、forceLogout方法：强制退出某一个会话，此处只在指定会话中设置Constants.SESSION_FORCE_LOGOUT_KEY属性，之后通过ForceLogoutFilter判断并进行强制退出。

 

此处展示会话列表的缺点是：sessionDAO.getActiveSessions()提供了获取所有活跃会话集合，如果做一般企业级应用问题不大，因为在线用户不多；但是如果应用的在线用户非常多，此种方法就不适合了，解决方案就是分页获取： 

Java代码  

1. Page<Session> getActiveSessions(int pageNumber, int pageSize);  

Page对象除了包含pageNumber、pageSize属性之外，还包含totalSessions（总会话数）、Collection<Session> （当前页的会话）。

 

分页获取时，如果是MySQL这种关系数据库存储会话比较好办，如果使用Redis这种数据库可以考虑这样存储：

Java代码  

1. session.id=会话序列化数据  
2. session.ids=会话id Set列表（接着可以使用LLEN获取长度，LRANGE分页获取）   

 

会话创建时（如sessionId=123），那么redis命令如下所示：   

Java代码  

1. SET session.123 "Session序列化数据"  
2. LPUSH session.ids 123      

 

会话删除时（如sessionId=123），那么redis命令如下所示： 

Java代码  

1. DEL session.123  
2. LREM session.ids 123      

 

获取总活跃会话：

Java代码  

1. LLEN session.ids  

 

分页获取活跃会话： 

Java代码  

1. LRANGE key 0 10 #获取到会话ID  
2. MGET session.1 session.2……  #根据第一条命令获取的会话ID获取会话数据   

 

ForceLogoutFilter

Java代码  

1. public class ForceLogoutFilter extends AccessControlFilter {  
2.     protected boolean isAccessAllowed(ServletRequest request, ServletResponse response, Object mappedValue) throws Exception {  
3.         Session session = getSubject(request, response).getSession(false);  
4.         if(session == null) {  
5.             return true;  
6.         }  
7.         return session.getAttribute(Constants.SESSION_FORCE_LOGOUT_KEY) == null;  
8.     }  
9.     protected boolean onAccessDenied(ServletRequest request, ServletResponse response) throws Exception {  
10.         try {  
11.             getSubject(request, response).logout();//强制退出  
12.         } catch (Exception e) {/*ignore exception*/}  
13.         String loginUrl = getLoginUrl() + (getLoginUrl().contains("?") ? "&" : "?") + "forceLogout=1";  
14.         WebUtils.issueRedirect(request, response, loginUrl);  
15.         return false;  
16.     }  
17. }   

强制退出拦截器，如果用户会话中存在Constants.SESSION_FORCE_LOGOUT_KEY属性，表示被管理员强制退出了；然后调用Subject.logout()退出，且重定向到登录页面（自动拼上fourceLogout请求参数）。

 

登录控制器

在LoginController类的showLoginForm方法中最后添加如下代码： 

Java代码  

1. if(req.getParameter("forceLogout") != null) {  
2.     model.addAttribute("error", "您已经被管理员强制退出，请重新登录");  
3. }   

即如果有请求参数forceLogout表示是管理员强制退出的，在界面上显示相应的信息。

 

Shiro配置spring-config-shiro.xml

和之前的唯一区别是在shiroFilter中的filterChainDefinitions拦截器链定义中添加了forceLogout拦截器： 

Java代码  

1. /** = forceLogout,user,sysUser  

测试

1、首先输入http://localhost:8080/chapter24/跳转到登录页面输入admin/123456登录；

2、登录成功后，点击菜单的“会话管理”，可以看到当前在线会话列表： 

3、点击“强制退出”按钮，会话相应的用户再点击界面的话会看到如下界面，表示已经被强制退出了： 

 

另外可参考我的ES中的在线会话管理功能：UserOnlineController.java，其使用数据库存储会话，并分页获取在线会话。