u013378306
u013378306

Shiro

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的组件吧。


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

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

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

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

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

 

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

 

2.2  环境准备

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

Java代码   收藏代码
  1.   
  2.       
  3.         junit  
  4.         junit  
  5.         4.9  
  6.       
  7.       
  8.         commons-logging  
  9.         commons-logging  
  10.         1.1.3  
  11.       
  12.       
  13.         org.apache.shiro  
  14.         shiro-core  
  15.         1.2.2  
  16.       
  17.    

添加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 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.   
  2.     mysql  
  3.     mysql-connector-java  
  4.     5.1.25  
  5.   
  6.   
  7.     com.alibaba  
  8.     druid  
  9.     0.2.23  
  10.    

本文将使用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时成功，且返回身份/凭据为[email protected]/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 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和[email protected]身份信息。

 

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. Collectionextends 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。


授权，也叫访问控制，即在应用中控制谁能访问哪些资源（如访问页面/编辑数据/页面操作等）。在授权中需了解的几个关键对象：主体（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. "admin">  
  2.   
  3.    

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

 

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 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里的验证逻辑实现的。       

之前章节我们已经接触过一些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 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相关章节。 


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次那么抛出异常表示超出重试次数了。



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 findRoles(String username);// 根据用户名查找其角色  
  8.     public Set 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

Shiro_第1张图片

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

Shiro_第2张图片

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_第3张图片

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

Java代码   收藏代码
  1. public interface PrincipalCollection extends Iterable, Serializable {  
  2.     Object getPrimaryPrincipal(); //得到主要的身份  
  3.      T oneByType(Class type); //根据身份类型获取第一个  
  4.      Collection byType(Class type); //根据身份类型获取一组  
  5.     List asList(); //转换为List  
  6.     Set asSet(); //转换为Set  
  7.     Collection fromRealm(String realmName); //根据Realm名字获取  
  8.     Set 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 realmNames = princialCollection.getRealmNames();  

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

 

Java代码   收藏代码
  1. Set principals = princialCollection.asSet(); //asList和asSet的结果一样  

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

     

    Java代码   收藏代码
    1. Collection users = princialCollection.fromRealm("c");  

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

     

    6.4 AuthorizationInfo

    Shiro_第4张图片

    AuthorizationInfo用于聚合授权信息的：

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

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

     

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

     

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

     

    6.5 Subject

    Shiro_第5张图片

    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 roleIdentifiers);  
    3. boolean hasAllRoles(Collection roleIdentifiers);  
    4. void checkRole(String roleIdentifier) throws AuthorizationException;  
    5. void checkRoles(Collection 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 permissions);  
    5. boolean isPermittedAll(String... permissions);  
    6. boolean isPermittedAll(Collection 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 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 execute(Callable callable) throws ExecutionException;  
    2. void execute(Runnable runnable);  
    3.  Callable associateWith(Callable 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方法验证等的一些简化实现。    


    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.   
    2.     javax.servlet  
    3.     javax.servlet-api  
    4.     3.0.1  
    5.     provided  
    6.    

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

     

    shiro-web

    Java代码   收藏代码
    1.   
    2.     org.apache.shiro  
    3.     shiro-web  
    4.     1.2.2  
    5.    

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

     

    7.2 ShiroFilter入口

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

    Java代码   收藏代码
    1.   
    2.     iniShiroFilter  
    3.     class>org.apache.shiro.web.servlet.IniShiroFilterclass>  
    4.       
    5.         configPath  
    6.         classpath:shiro.ini  
    7.       
    8.   
    9.   
    10.     iniShiroFilter  
    11.     /*  
    12.    

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

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

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

    Java代码   收藏代码
    1.   
    2.     config  
    3.       
    4.         ini配置文件贴在这  
    5.       
    6.   

     

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

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

    Java代码   收藏代码
    1.   
    2.    class>org.apache.shiro.web.env.EnvironmentLoaderListenerclass>  
    3.    

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

     

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

    Java代码   收藏代码
    1.   
    2.    shiroEnvironmentClass  
    3.    org.apache.shiro.web.env.IniWebEnvironment  
    4.   
    5.       
    6.         shiroConfigLocations  
    7.         classpath:shiro.ini  
    8.        

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

     

    3、与Spring集成

    Java代码   收藏代码
    1.   
    2.     shiroFilter  
    3.     class>org.springframework.web.filter.DelegatingFilterProxyclass>  
    4.       
    5.         targetFilterLifecycle  
    6.         true  
    7.       
    8.   
    9.   
    10.     shiroFilter  
    11.     /*  
    12.    

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

    Java代码   收藏代码
    1. "shiroFilter" class="org.apache.shiro.spring.web.ShiroFilterFactoryBean">  
    2. "securityManager" ref="securityManager"/>  
    3.   
    4.    

    最后不要忘了使用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用于弹出的登录框显示信息使用，如图：

    Shiro_第6张图片

    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即可退出。




    8.1 拦截器介绍

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

    Shiro_第7张图片

    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.   
    2. shiroEnvironmentClass com.github.zhangkaitao.shiro.chapter8.web.env.MyIniWebEnvironment  
    3.    

     

    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  

    9.1 jsp标签

    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.   
    2. 欢迎游客访问，"${pageContext.request.contextPath}/login.jsp">登录  
    3.    

     

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

     

    user标签 

    Java代码   收藏代码
    1.   
    2. 欢迎[]登录，"${pageContext.request.contextPath}/logout">退出  
    3.    

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

      

    authenticated标签 

    Java代码   收藏代码
    1.   
    2.     用户[]已身份验证通过  
    3.    

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

     

    notAuthenticated标签

        未身份验证（包括记住我） 

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

     

    principal标签 

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

     

    Java代码 
    1. "java.lang.String"/>  

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

     

    Java代码 
    1. "java.lang.String"/>  

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

     

    Java代码 
    1. "username"/>  

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

     

    hasRole标签 

    Java代码 
    1. "admin">  
    2.     用户[]拥有角色admin
        
    3.    

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

     

    hasAnyRoles标签 

    Java代码 
    1. "admin,user">  
    2.     用户[]拥有角色admin或user
        
    3.    

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

     

    lacksRole标签 

    Java代码 
    1. "abc">  
    2.     用户[]没有角色abc
        
    3.    

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

      

    hasPermission标签

    Java代码 
    1. "user:create">  
    2.     用户[]拥有权限user:create
        
    3.    

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

      

    lacksPermission标签

    Java代码 
    1. "org:create">  
    2.     用户[]没有权限org:create
        
    3.    

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

     

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

     

    导入自定义标签库 

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

     

    示例

    Java代码 
    1. "admin,user">  
    2.     用户[]拥有角色admin和user
        
    3.   
    4. "user:create,user:update">  
    5.     用户[]拥有权限user:create和user:update
        
    6.   
    7. "user:create,abc:update">  
    8.     用户[]拥有权限user:create或abc:update
        
    9.    

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



    10.1 会话管理

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

     

     

    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.   
    2.   30  
    3.   

      

    在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 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.   
    2.     org.apache.shiro  
    3.     shiro-ehcache  
    4.     1.2.2  
    5.    

     

    接着配置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. "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 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.   
    2.      org.apache.shiro  
    3.      shiro-quartz  
    4.      1.2.2  
    5.   

        

    如上会话验证调度器实现都是直接调用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 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.   
    2.     org.apache.shiro.session.InvalidSessionException  
    3.     /invalidSession.jsp  
    4.   

     

    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  
      


    11.1 缓存



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

     

    Shiro提供的Cache接口： 

    Java代码   收藏代码
    1. public interface Cache {  
    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 keys();  
    14.     //获取缓存中所有的value  
    15.     public Collection values();  
    16. }  

      

    Shiro提供的CacheManager接口： 

    Java代码   收藏代码
    1. public interface CacheManager {  
    2.     //根据缓存名字获取一个Cache  
    3.     public  Cache 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。

     

    12.1 与spring 集成

    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.   
    2. "cacheManager" class="org.apache.shiro.cache.ehcache.EhCacheManager">  
    3.     "cacheManagerConfigFile" value="classpath:ehcache.xml"/>  
    4.   
    5.   
    6.   
    7. "credentialsMatcher" class="  
    8. com.github.zhangkaitao.shiro.chapter12.credentials.RetryLimitHashedCredentialsMatcher">  
    9.     "cacheManager"/>  
    10.     "hashAlgorithmName" value="md5"/>  
    11.     "hashIterations" value="2"/>  
    12.     "storedCredentialsHexEncoded" value="true"/>  
    13.   
    14.   
    15.   
    16. "userRealm" class="com.github.zhangkaitao.shiro.chapter12.realm.UserRealm">  
    17.     "userService" ref="userService"/>  
    18.     "credentialsMatcher" ref="credentialsMatcher"/>  
    19.     "cachingEnabled" value="true"/>  
    20.     "authenticationCachingEnabled" value="true"/>  
    21.     "authenticationCacheName" value="authenticationCache"/>  
    22.     "authorizationCachingEnabled" value="true"/>  
    23.     "authorizationCacheName" value="authorizationCache"/>  
    24.   
    25.   
    26. "sessionIdGenerator"   
    27. class="org.apache.shiro.session.mgt.eis.JavaUuidSessionIdGenerator"/>  
    28.   
    29. "sessionDAO"   
    30. class="org.apache.shiro.session.mgt.eis.EnterpriseCacheSessionDAO">  
    31.     "activeSessionsCacheName" value="shiro-activeSessionCache"/>  
    32.     "sessionIdGenerator" ref="sessionIdGenerator"/>  
    33.   
    34.   
    35. "sessionValidationScheduler"   
    36. class="org.apache.shiro.session.mgt.quartz.QuartzSessionValidationScheduler">  
    37.     "sessionValidationInterval" value="1800000"/>  
    38.     "sessionManager" ref="sessionManager"/>  
    39.   
    40.   
    41. "sessionManager" class="org.apache.shiro.session.mgt.DefaultSessionManager">  
    42.     "globalSessionTimeout" value="1800000"/>  
    43.     "deleteInvalidSessions" value="true"/>  
    44.     "sessionValidationSchedulerEnabled" value="true"/>  
    45.    "sessionValidationScheduler" ref="sessionValidationScheduler"/>  
    46.     "sessionDAO" ref="sessionDAO"/>  
    47.   
    48.   
    49. "securityManager" class="org.apache.shiro.mgt.DefaultSecurityManager">  
    50.     "realms">  
    51.         "userRealm"/>  
    52.       
    53.     "sessionManager" ref="sessionManager"/>  
    54.     "cacheManager" ref="cacheManager"/>  
    55.   
    56.   
    57. class="org.springframework.beans.factory.config.MethodInvokingFactoryBean">  
    58. "staticMethod"   
    59. value="org.apache.shiro.SecurityUtils.setSecurityManager"/>  
    60.     "arguments" ref="securityManager"/>  
    61.   
    62.   
    63. "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.   
    2. "sessionIdCookie" class="org.apache.shiro.web.servlet.SimpleCookie">  
    3.     "sid"/>  
    4.     "httpOnly" value="true"/>  
    5.     "maxAge" value="180000"/>  
    6.   
    7.   
    8. "sessionManager"   
    9. class="org.apache.shiro.web.session.mgt.DefaultWebSessionManager">  
    10.     "globalSessionTimeout" value="1800000"/>  
    11.     "deleteInvalidSessions" value="true"/>  
    12.     "sessionValidationSchedulerEnabled" value="true"/>  
    13.     "sessionValidationScheduler" ref="sessionValidationScheduler"/>  
    14.     "sessionDAO" ref="sessionDAO"/>  
    15.     "sessionIdCookieEnabled" value="true"/>  
    16.     "sessionIdCookie" ref="sessionIdCookie"/>  
    17.   
    18.   
    19. "securityManager" class="org.apache.shiro.web.mgt.DefaultWebSecurityManager">  
    20. "realm" ref="userRealm"/>  
    21.     "sessionManager" ref="sessionManager"/>  
    22.     "cacheManager" ref="cacheManager"/>  
    23.    

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

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

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

     

    Java代码   收藏代码
    1.   
    2. "formAuthenticationFilter"   
    3. class="org.apache.shiro.web.filter.authc.FormAuthenticationFilter">  
    4.     "usernameParam" value="username"/>  
    5.     "passwordParam" value="password"/>  
    6.     "loginUrl" value="/login.jsp"/>  
    7.   
    8.   
    9. "shiroFilter" class="org.apache.shiro.spring.web.ShiroFilterFactoryBean">  
    10.     "securityManager" ref="securityManager"/>  
    11.     "loginUrl" value="/login.jsp"/>  
    12.     "unauthorizedUrl" value="/unauthorized.jsp"/>  
    13.     "filters">  
    14.           
    15.             "authc" value-ref="formAuthenticationFilter"/>  
    16.           
    17.       
    18.     "filterChainDefinitions">  
    19.           
    20.             /index.jsp = anon  
    21.             /unauthorized.jsp = anon  
    22.             /login.jsp = authc  
    23.             /logout = logout  
    24.             /** = user  
    25.           
    26.       
    27.    

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

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

     

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

    Java代码   收藏代码
    1.   
    2.     contextConfigLocation  
    3.       
    4.         classpath:spring-beans.xml,  
    5.         classpath:spring-shiro-web.xml  
    6.       
    7.   
    8.   
    9.    class>  
    10. org.springframework.web.context.ContextLoaderListener  
    11. class>  
    12.    

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

      

    Java代码   收藏代码
    1.   
    2.     shiroFilter  
    3.     class>org.springframework.web.filter.DelegatingFilterProxyclass>  
    4.       
    5.         targetFilterLifecycle  
    6.         true  
    7.       
    8.   
    9.   
    10.     shiroFilter  
    11.     /*  
    12.    

    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. class="true">  
    2. class="  
    3. org.apache.shiro.spring.security.interceptor.AuthorizationAttributeSourceAdvisor">  
    4.     "securityManager" ref="securityManager"/>  
    5.    

    如上配置用于开启Shiro Spring AOP权限注解的支持；表示代理类。

     

    接着就可以在相应的控制器（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。  


    13.1 remberME 记住我


    Shiro提供了记住我（RememberMe）的功能，比如访问如淘宝等一些网站时，关闭了浏览器下次再打开时还是能记住你是谁，下次访问时无需再登录即可访问，基本流程如下：

    1、首先在登录页面选中RememberMe然后登录成功；如果是浏览器登录，一般会把RememberMe的Cookie写到客户端并保存下来；

    2、关闭浏览器再重新打开；会发现浏览器还是记住你的；

    3、访问一般的网页服务器端还是知道你是谁，且能正常访问；

     

    4、但是比如我们访问淘宝时，如果要查看我的订单或进行支付时，此时还是需要再进行身份认证的，以确保当前用户还是你。

    RememberMe配置

     

    spring-shiro-web.xml配置：

    Java代码   收藏代码
    1.   
    2. "sessionIdCookie" class="org.apache.shiro.web.servlet.SimpleCookie">  
    3.     "sid"/>  
    4.     "httpOnly" value="true"/>  
    5.     "maxAge" value="-1"/>  
    6.   
    7. "rememberMeCookie" class="org.apache.shiro.web.servlet.SimpleCookie">  
    8.     "rememberMe"/>  
    9.     "httpOnly" value="true"/>  
    10.     "maxAge" value="2592000"/>  
    11.    

    sessionIdCookie：maxAge=-1表示浏览器关闭时失效此Cookie；

    rememberMeCookie：即记住我的Cookie，保存时长30天；

      

    Java代码   收藏代码
    1.   
    2. "rememberMeManager"   
    3. class="org.apache.shiro.web.mgt.CookieRememberMeManager">  
    4.     "cipherKey" value="  
    5. #{T(org.apache.shiro.codec.Base64).decode('4AvVhmFLUs0KTA3Kprsdag==')}"/>  
    6.      "cookie" ref="rememberMeCookie"/>  
    7.    

    rememberMe管理器，cipherKey是加密rememberMe Cookie的密钥；默认AES算法；

     

    Java代码   收藏代码
    1.   
    2. "securityManager" class="org.apache.shiro.web.mgt.DefaultWebSecurityManager">  
    3. ……  
    4.     "rememberMeManager" ref="rememberMeManager"/>  
    5.    

    设置securityManager安全管理器的rememberMeManager； 

     

    Java代码   收藏代码
    1. "formAuthenticationFilter"   
    2. class="org.apache.shiro.web.filter.authc.FormAuthenticationFilter">  
    3.     ……  
    4.     "rememberMeParam" value="rememberMe"/>  
    5.    

    rememberMeParam，即rememberMe请求参数名，请求参数是boolean类型，true表示rememberMe。 

     

    Java代码   收藏代码
    1. "shiroFilter" class="org.apache.shiro.spring.web.ShiroFilterFactoryBean">  
    2.     ……  
    3.     "filterChainDefinitions">  
    4.           
    5.             /login.jsp = authc  
    6.             /logout = logout  
    7.             /authenticated.jsp = authc  
    8.             /** = user  
    9.           
    10.       
    11.    

    “/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使用过程中，需要配合相应的拦截器来实现相应的功能，用错了拦截器可能就不能满足你的需求了。


    14.1 SSL

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

     

    输入  的密钥口令

            (如果和密钥库口令相同, 按回车):

    再次输入新口令:

     

    通过如上步骤，生成证书到D:\ localhost.keystore；

     

    然后设置tomcat下的server.xml

    此处使用了apache-tomcat-7.0.40版本，打开conf/server.xml，找到：

     

    Java代码   收藏代码
    1.    

    替换为  

    Java代码   收藏代码
    1. "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. "sslFilter" class="org.apache.shiro.web.filter.authz.SslFilter">  
    2.     "port" value="8443"/>  
    3.   
    4. "shiroFilter" class="org.apache.shiro.spring.web.ShiroFilterFactoryBean">  
    5.     ……  
    6.     "filters">  
    7.           
    8.             "authc" value-ref="formAuthenticationFilter"/>  
    9.             "ssl" value-ref="sslFilter"/>  
    10.           
    11.       
    12.     "filterChainDefinitions">  
    13.           
    14.             /login.jsp = ssl,authc  
    15.             /logout = logout  
    16.             /authenticated.jsp = authc  
    17.             /** = user  
    18.           
    19.       
    20.    

    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.   
    2.    org.mortbay.jetty  
    3.    jetty-maven-plugin  
    4.    8.1.8.v20121106  
    5.      
    6.        
    7.        /${project.build.finalName}  
    8.        
    9.        
    10.      "org.eclipse.jetty.server.nio.SelectChannelConnector">  
    11.        8080  
    12.        
    13.      "org.eclipse.jetty.server.ssl.SslSocketConnector">  
    14.        8443  
    15.        ${project.basedir}/localhost.keystore  
    16.        123456  
    17.        123456  
    18.        
    19.        
    20.      
    21.   

     

    15.1 单点登录

    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.   
    2.   org.mortbay.jetty  
    3.   jetty-maven-plugin  
    4.   8.1.8.v20121106  
    5.     
    6.       
    7.       /${project.build.finalName}  
    8.       
    9.       
    10.       "org.eclipse.jetty.server.nio.SelectChannelConnector">  
    11.         8080  
    12.         
    13.       "org.eclipse.jetty.server.ssl.SslSocketConnector">  
    14.         8443  
    15.         ${project.basedir}/localhost.keystore  
    16.        123456  
    17.         123456  
    18.         
    19.       
    20.     
    21.   

     

    3、修改src/main/webapp/WEB-INF/deployerConfigContext.xml，找到primaryAuthenticationHandler，然后添加一个账户：

    Java代码   收藏代码
    1. "zhang" value="123"/>  

    其也支持如JDBC查询，可以自己定制；具体请参考文档。

     

    4、mvn jetty:run启动服务器测试即可：

    访问https://localhost:8443/chapter15-server/login将弹出如下登录页面：

    Shiro_第8张图片
     

    输入用户名/密码，如zhang/123，将显示登录成功页面：

    Shiro_第9张图片

     

    到此服务器端的简单配置就完成了。 

     

     

    客户端

    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. "casRealm" class="com.github.zhangkaitao.shiro.chapter13.realm.MyCasRealm">  
    2.     "userService" ref="userService"/>  
    3.     ……  
    4.     "casServerUrlPrefix" value="https://localhost:8443/chapter14-server"/>  
    5.     "casService" value="https://localhost:9443/chapter14-client/cas"/>  
    6.    

    casServerUrlPrefix：是CAS Server服务器端地址；

    casService：是当前应用CAS服务URL，即用于接收并处理登录成功后的Ticket的；

     

    如果角色/权限信息是由服务器端提供的话，我们可以直接使用CasRealm： 

    Java代码   收藏代码
    1. "casRealm" class="org.apache.shiro.cas.CasRealm">  
    2.     ……  
    3.     "defaultRoles" value="admin,user"/>  
    4.     "defaultPermissions" value="user:create,user:update"/>  
    5.     "roleAttributeNames" value="roles"/>  
    6.     "permissionAttributeNames" value="permissions"/>  
    7.     "casServerUrlPrefix" value="https://localhost:8443/chapter14-server"/>  
    8.     "casService" value="https://localhost:9443/chapter14-client/cas"/>  
    9.    

    defaultRoles/ defaultPermissions：默认添加给所有CAS登录成功用户的角色和权限信息；

    roleAttributeNames/ permissionAttributeNames：角色属性/权限属性名称，如果用户的角色/权限信息是从服务器端返回的（即返回的CAS Principal中除了Principal之外还有如一些Attributes），此时可以使用roleAttributeNames/ permissionAttributeNames得到Attributes中的角色/权限数据；请自行查询CAS获取用户更多信息。

     

    Java代码   收藏代码
    1. "casFilter" class="org.apache.shiro.cas.CasFilter">  
    2.     "failureUrl" value="/casFailure.jsp"/>  
    3.    

    CasFilter类似于FormAuthenticationFilter，只不过其验证服务器端返回的CAS Service Ticket。 

     

    Java代码   收藏代码
    1. "shiroFilter" class="org.apache.shiro.spring.web.ShiroFilterFactoryBean">  
    2.     "securityManager" ref="securityManager"/>  
    3.     "loginUrl" value="https://localhost:8443/chapter14-server/login?service=https://localhost:9443/chapter14-client/cas"/>  
    4.     "successUrl" value="/"/>  
    5.     "filters">  
    6.           
    7.             "cas" value-ref="casFilter"/>  
    8.           
    9.       
    10.     "filterChainDefinitions">  
    11.           
    12.             /casFailure.jsp = anon  
    13.             /cas = cas  
    14.             /logout = logout  
    15.             /** = user  
    16.           
    17.       
    18.    

    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



    16.1 综合实例


    简单的实体关系图


     

    简单数据字典

    用户(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 findPermissions(Set resourceIds); //得到资源对应的权限字符串  
    3.     List findMenus(Set permissions); //根据用户权限得到菜单  
    4. }  
    Java代码   收藏代码
    1. public interface RoleService {  
    2.     Set findRoles(Long... roleIds); //根据角色编号得到角色标识符列表  
    3.     Set 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 findRoles(String username);// 根据用户名查找其角色  
    5.     public Set 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 permissions = userService.findPermissions(loginUser.getUsername());  
    10.         List 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. "userRealm" class="com.github.zhangkaitao.shiro.chapter16.realm.UserRealm">  
    2.     "credentialsMatcher" ref="credentialsMatcher"/>  
    3.     "cachingEnabled" value="false"/>  
    4.    

    userRealm组件禁用掉了cache，可以参考https://github.com/zhangkaitao/es/tree/master/web/src/main/java/com/sishuok/es/extra/aop实现自己的cache切面；否则需要在修改如资源/角色等信息时清理掉缓存。 

     

    Java代码   收藏代码
    1. "sysUserFilter"   
    2. class="com.github.zhangkaitao.shiro.chapter16.web.shiro.filter.SysUserFilter"/>   

    sysUserFilter用于根据当前登录用户身份获取User信息放入request；然后就可以通过request获取User。 

      

    Java代码   收藏代码
    1. "filterChainDefinitions">  
    2.     
    3.     /login = authc  
    4.     /logout = logout  
    5.     /authenticated = authc  
    6.     /** = user,sysUser  
    7.     
    8.    

    如上是shiroFilter的filterChainDefinitions定义。 

     

    Spring MVC配置——spring-mvc.xml

    定义了spring mvc相关组件。 

    Java代码   收藏代码
    1.   
    2.     
    3.     class="com.github.zhangkaitao.shiro.chapter16  
    4.         .web.bind.method.CurrentUserMethodArgumentResolver"/>  
    5.     
    6.    

    此处注册了一个@CurrentUser参数解析器。如之前的IndexController，从request获取shiro sysUser拦截器放入的当前登录User对象。

     

     

    Spring MVC配置——spring-mvc-shiro.xml

    定义了spring mvc相关组件。 

    Java代码   收藏代码
    1. class="true">  
    2. class="org.apache.shiro.spring.security  
    3.     .interceptor.AuthorizationAttributeSourceAdvisor">  
    4.   "securityManager" ref="securityManager"/>  
    5.    

    定义aop切面，用于代理如@RequiresPermissions注解的控制器，进行权限控制。

     

    web.xml配置文件

    定义Spring ROOT上下文加载器、ShiroFilter、及SpringMVC拦截器。具体请参考源码。

     

    JSP页面       

    Java代码   收藏代码
    1. "user:create">  
    2.     "${pageContext.request.contextPath}/user/create">用户新增
        
    3.    

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


    17.1 auth2集成

    目前很多开放平台如新浪微博开放平台都在使用提供开放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协议流程

    Shiro_第10张图片
     

    1、客户端从资源拥有者那请求授权。授权请求可以直接发给资源拥有者，或间接的通过授权服务器这种中介，后者更可取。

    2、客户端收到一个授权许可，代表资源服务器提供的授权。

    3、客户端使用它自己的私有证书及授权许可到授权服务器验证。

    4、如果验证成功，则下发一个访问令牌。

    5、客户端使用访问令牌向资源服务器请求受保护资源。

    6、资源服务器会验证访问令牌的有效性，如果成功则下发受保护资源。

     

    更多流程的解释请参考OAuth2的协议规范http://tools.ietf.org/html/rfc6749。

     

    服务器端

    本文把授权服务器和资源服务器整合在一起实现。

     

    POM依赖

    此处我们使用apache oltu oauth2服务端实现，需要引入authzserver（授权服务器依赖）和resourceserver（资源服务器依赖）。 

    Java代码   收藏代码
    1.   
    2.     org.apache.oltu.oauth2  
    3.     org.apache.oltu.oauth2.authzserver  
    4.     0.31  
    5.   
    6.   
    7.     org.apache.oltu.oauth2  
    8.     org.apache.oltu.oauth2.resourceserver  
    9.     0.31  
    10.    

    其他的请参考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 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 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. "filterChainDefinitions">  
    2.       
    3.       / = anon  
    4.       /login = authc  
    5.       /logout = logout  
    6.   
    7.       /authorize=anon  
    8.       /accessToken=anon  
    9.       /userInfo=anon  
    10.   
    11.       /** = user  
    12.       
    13.    

    对于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.   
    2.   org.apache.oltu.oauth2  
    3.   org.apache.oltu.oauth2.client  
    4.   0.31  
    5.    

    其他的请参考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. "oAuth2Realm"   
    2.     class="com.github.zhangkaitao.shiro.chapter18.oauth2.OAuth2Realm">  
    3.   "cachingEnabled" value="true"/>  
    4.   "authenticationCachingEnabled" value="true"/>  
    5.   "authenticationCacheName" value="authenticationCache"/>  
    6.   "authorizationCachingEnabled" value="true"/>  
    7.   "authorizationCacheName" value="authorizationCache"/>  
    8.   "clientId" value="c1ebe466-1cdc-4bd3-ab69-77c3561b9dee"/>  
    9.   "clientSecret" value="d8346ea2-6017-43ed-ad68-19c0f971738b"/>  
    10.   "accessTokenUrl"   
    11.      value="http://localhost:8080/chapter17-server/accessToken"/>  
    12.   "userInfoUrl" value="http://localhost:8080/chapter17-server/userInfo"/>  
    13.   "redirectUrl" value="http://localhost:9080/chapter17-client/oauth2-login"/>  
    14.    

    此OAuth2Realm需要配置在服务端申请的clientId和clientSecret；及用于根据auth code换取access token的accessTokenUrl地址；及用于根据access token换取用户信息（受保护资源）的userInfoUrl地址。 

     

    Java代码   收藏代码
    1. "oAuth2AuthenticationFilter"   
    2.     class="com.github.zhangkaitao.shiro.chapter18.oauth2.OAuth2AuthenticationFilter">  
    3.   "authcCodeParam" value="code"/>  
    4.   "failureUrl" value="/oauth2Failure.jsp"/>  
    5.    

    此OAuth2AuthenticationFilter用于拦截服务端重定向回来的auth code。  

     

    Java代码   收藏代码
    1. "shiroFilter" class="org.apache.shiro.spring.web.ShiroFilterFactoryBean">  
    2.   "securityManager" ref="securityManager"/>  
    3.   "loginUrl" value="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"/>  
    4.   "successUrl" value="/"/>  
    5.   "filters">  
    6.         
    7.          "oauth2Authc" value-ref="oAuth2AuthenticationFilter"/>  
    8.         
    9.     
    10.   "filterChainDefinitions">  
    11.         
    12.           / = anon  
    13.           /oauth2Failure.jsp = anon  
    14.           /oauth2-login = oauth2Authc  
    15.           /logout = logout  
    16.           /** = user  
    17.         
    18.     
    19.   

    此处设置loginUrl为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"；其会自动设置到所有的AccessControlFilter，如oAuth2AuthenticationFilter；另外/oauth2-login = oauth2Authc表示/oauth2-login地址使用oauth2Authc拦截器拦截并进行oauth2客户端授权。

     

    测试

    1、首先访问http://localhost:9080/chapter17-client/，然后点击登录按钮进行登录，会跳到如下页面： 

    Shiro_第11张图片

     

    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及异常错误码的设计。   


    18.1 登录并发人数控制

    在某些项目中可能会遇到如每个账户同时只能有一个人登录或几个人同时登录，如果同时有多人登录：要么不让后者登录；要么踢出前者登录（强制退出）。比如spring security就直接提供了相应的功能；Shiro的话没有提供默认实现，不过可以很容易的在Shiro中加入这个功能。

     

    示例代码基于《第十六章 综合实例》完成，通过Shiro Filter机制扩展KickoutSessionControlFilter完成。

     

    首先来看看如何配置使用（spring-config-shiro.xml）

      

    kickoutSessionControlFilter用于控制并发登录人数的 

    Java代码   收藏代码
    1. "kickoutSessionControlFilter"   
    2. class="com.github.zhangkaitao.shiro.chapter18.web.shiro.filter.KickoutSessionControlFilter">  
    3.     "cacheManager" ref="cacheManager"/>  
    4.     "sessionManager" ref="sessionManager"/>  
    5.   
    6.     "kickoutAfter" value="false"/>  
    7.     "maxSession" value="2"/>  
    8.     "kickoutUrl" value="/login?kickout=1"/>  
    9.    

    cacheManager：使用cacheManager获取相应的cache来缓存用户登录的会话；用于保存用户—会话之间的关系的；

    sessionManager：用于根据会话ID，获取会话进行踢出操作的；

    kickoutAfter：是否踢出后来登录的，默认是false；即后者登录的用户踢出前者登录的用户；

    maxSession：同一个用户最大的会话数，默认1；比如2的意思是同一个用户允许最多同时两个人登录；

    kickoutUrl：被踢出后重定向到的地址；

     

    shiroFilter配置 

    Java代码   收藏代码
    1. "shiroFilter" class="org.apache.shiro.spring.web.ShiroFilterFactoryBean">  
    2.      "securityManager" ref="securityManager"/>  
    3.      "loginUrl" value="/login"/>  
    4.      "filters">  
    5.            
    6.              "authc" value-ref="formAuthenticationFilter"/>  
    7.              "sysUser" value-ref="sysUserFilter"/>  
    8.              "kickout" value-ref="kickoutSessionControlFilter"/>  
    9.            
    10.        
    11.      "filterChainDefinitions">  
    12.            
    13.              /login = authc  
    14.              /logout = logout  
    15.              /authenticated = authc  
    16.              /** = kickout,user,sysUser  
    17.            
    18.        
    19.     

    此处配置除了登录等之外的地址都走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 deque = cache.get(username);  
    14.     if(deque == null) {  
    15.         deque = new LinkedList();  
    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中；另外此处没有并发控制的同步实现，可以考虑根据用户名获取锁来控制，减少锁的粒度。

    19.1 动态url权限控制

    用过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 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 defaultFilterChains;  
    5.     @PostConstruct  
    6.     public void init() {  
    7.         defaultFilterChains =   
    8.           new HashMap(filterChainManager.getFilterChains());  
    9.     }  
    10.     public void initFilterChains(List 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 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 getChainNames(); //得到所有拦截器链的名字  
    11.     FilterChain proxy(FilterChain original, String chainName); //使用指定的拦截器链代理原始拦截器链  
    12. }   

    此接口主要三个功能：注册拦截器，注册拦截器链，对原始拦截器链生成代理之后的拦截器链，比如  

    Java代码   收藏代码
    1. "shiroFilter" class="org.apache.shiro.spring.web.ShiroFilterFactoryBean">  
    2. ……  
    3.     "filters">  
    4.           
    5.             "authc" value-ref="formAuthenticationFilter"/>  
    6.             "sysUser" value-ref="sysUserFilter"/>  
    7.           
    8.       
    9.     "filterChainDefinitions">  
    10.           
    11.             /login = authc  
    12.             /logout = logout  
    13.             /authenticated = authc  
    14.             /** = user,sysUser  
    15.           
    16.       
    17.    

    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 chainNames = new ArrayList();  
    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 filterChainDefinitionMap = null;  
    3.     private String loginUrl;  
    4.     private String successUrl;  
    5.     private String unauthorizedUrl;  
    6.     public CustomDefaultFilterChainManager() {  
    7.         setFilters(new LinkedHashMap());  
    8.         setFilterChains(new LinkedHashMap());  
    9.         addDefaultFilters(true);  
    10.     }  
    11.     public Map getFilterChainDefinitionMap() {  
    12.         return filterChainDefinitionMap;  
    13.     }  
    14.     public void setFilterChainDefinitionMap(Map filterChainDefinitionMap) {  
    15.         this.filterChainDefinitionMap = filterChainDefinitionMap;  
    16.     }  
    17.     public void setCustomFilters(Map customFilters) {  
    18.         for(Map.Entry 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 filters = getFilters();  
    52.         if (!CollectionUtils.isEmpty(filters)) {  
    53.             for (Map.Entry 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 chains = getFilterChainDefinitionMap();  
    64.         if (!CollectionUtils.isEmpty(chains)) {  
    65.             for (Map.Entry 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 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. "filterChainManager"   
    2.     class="com.github.zhangkaitao.shiro.spring.CustomDefaultFilterChainManager">  
    3.     "loginUrl" value="/login"/>  
    4.     "successUrl" value="/"/>  
    5.     "unauthorizedUrl" value="/unauthorized.jsp"/>  
    6.     "customFilters">  
    7.           
    8.             "authc" value-ref="formAuthenticationFilter"/>  
    9.             "sysUser" value-ref="sysUserFilter"/>  
    10.           
    11.       
    12.     "defaultFilterChainDefinitions">  
    13.           
    14.             /login = authc  
    15.             /logout = logout  
    16.             /unauthorized.jsp = authc  
    17.             /** = user,sysUser  
    18.           
    19.       
    20.    

    filterChainManager是我们自定义的CustomDefaultFilterChainManager，注册相应的拦截器及默认的拦截器链。 

    Java代码   收藏代码
    1. "filterChainResolver"   
    2.     class="com.github.zhangkaitao.shiro.spring.CustomPathMatchingFilterChainResolver">  
    3.     "customDefaultFilterChainManager" ref="filterChainManager"/>  
    4.    

    filterChainResolver是自定义的CustomPathMatchingFilterChainResolver，使用上边的filterChainManager进行拦截器链的管理。 

    Java代码   收藏代码
    1. "shiroFilter" class="org.apache.shiro.spring.web.ShiroFilterFactoryBean">  
    2.     "securityManager" ref="securityManager"/>  
    3.    

    shiroFilter不再定义filters及filterChainDefinitions，而是交给了filterChainManager进行完成。 

    Java代码   收藏代码
    1. class="org.springframework.beans.factory.config.MethodInvokingFactoryBean">  
    2.     "targetObject" ref="shiroFilter"/>  
    3.     "targetMethod" value="setFilterChainResolver"/>  
    4.     "arguments" ref="filterChainResolver"/>  
    5.    

    最后把filterChainResolver注册给shiroFilter，其使用它进行动态URL权限控制。

     

    其他配置和第十六章一样，请参考第十六章。

     

    测试

    1、首先执行shiro-data.sql初始化数据。

    2、然后再URL管理中新增如下数据： 

    Shiro_第12张图片

    3、访问http://localhost:8080/chapter19/user时要求用户拥有aa角色，此时是没有的所以会跳转到未授权页面；

    4、添加aa角色然后授权给用户，此时就有权限访问http://localhost:8080/chapter19/user。

     

    实际项目可以在此基础上进行扩展。


    20.1 无状态web应用集成

    在一些环境中，可能需要把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 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 params =   
    12.       new HashMap(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 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.   
    2. "statelessRealm"   
    3.   class="com.github.zhangkaitao.shiro.chapter20.realm.StatelessRealm">  
    4.     "cachingEnabled" value="false"/>  
    5.   
    6.   
    7. "subjectFactory"   
    8.   class="com.github.zhangkaitao.shiro.chapter20.mgt.StatelessDefaultSubjectFactory"/>  
    9.   
    10. "sessionManager" class="org.apache.shiro.session.mgt.DefaultSessionManager">  
    11.     "sessionValidationSchedulerEnabled" value="false"/>  
    12.   
    13.   
    14. "securityManager" class="org.apache.shiro.web.mgt.DefaultWebSecurityManager">  
    15.     "realm" ref="statelessRealm"/>  
    16.     "subjectDAO.sessionStorageEvaluator.sessionStorageEnabled"  
    17.       value="false"/>  
    18.     "subjectFactory" ref="subjectFactory"/>  
    19.     "sessionManager" ref="sessionManager"/>  
    20.   
    21.   
    22. class="org.springframework.beans.factory.config.MethodInvokingFactoryBean">  
    23.     "staticMethod"   
    24.       value="org.apache.shiro.SecurityUtils.setSecurityManager"/>  
    25.     "arguments" ref="securityManager"/>  
    26.    

    sessionManager通过sessionValidationSchedulerEnabled禁用掉会话调度器，因为我们禁用掉了会话，所以没必要再定期过期会话了。 

     

    Java代码   收藏代码
    1. "statelessAuthcFilter"   
    2.     class="com.github.zhangkaitao.shiro.chapter20.filter.StatelessAuthcFilter"/>   

    每次请求进行认证的拦截器。 

     

    Java代码   收藏代码
    1.   
    2. "shiroFilter" class="org.apache.shiro.spring.web.ShiroFilterFactoryBean">  
    3.     "securityManager" ref="securityManager"/>  
    4.     "filters">  
    5.           
    6.             "statelessAuthc" value-ref="statelessAuthcFilter"/>  
    7.           
    8.       
    9.     "filterChainDefinitions">  
    10.           
    11.             /**=statelessAuthc  
    12.           
    13.       
    14.    

    所有请求都将走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 params = new LinkedMultiValueMap();  
    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 params = new LinkedMultiValueMap();  
    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



    21.1授予身份及确认身份

    在一些场景中，比如某个领导因为一些原因不能进行登录网站进行一些操作，他想把他网站上的工作委托给他的秘书，但是他不想把帐号/密码告诉他秘书，只是想把工作委托给他；此时和我们可以使用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 findFromUserIds(Long toUserId);  
    6.     public List 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 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、点击切换身份按钮，跳到如下界面：   

    Shiro_第13张图片

    在该界面可以授权身份给其他人（点击授权身份可以把自己的身份授权给其他人/点击回收身份可以把之前授予的身份撤回）、或切换到其他身份（即假装为其他身份运行）；

     

    3、点击切换到该身份按钮，切换到相应的身份运行，如： 

    Shiro_第14张图片

    此时zhang用户切换到admin身份；如果点击切换回该身份，会把当前身份切换会zhang。



    22.1 集成验证码

    在做用户登录功能时，很多时候都需要验证码支持，验证码的目的是为了防止机器人模拟真实用户登录而恶意访问，如暴力破解用户密码/恶意评论等。目前也有一些验证码比较简单，通过一些OCR工具就可以解析出来；另外还有一些验证码比较复杂（一般通过如扭曲、加线条/噪点等干扰）防止OCR工具识别；但是在中国就是人多，机器干不了的可以交给人来完成，所以在中国就有很多打码平台，人工识别验证码；因此即使比较复杂的如填字、算数等类型的验证码还是能识别的。所以验证码也不是绝对可靠的，目前比较可靠还是手机验证码，但是对于用户来说相对于验证码还是比较麻烦的。

     

    对于验证码图片的生成，可以自己通过如Java提供的图像API自己去生成，也可以借助如JCaptcha这种开源Java类库生成验证码图片；JCaptcha提供了常见的如扭曲、加噪点等干扰支持。本章代码基于《第十六章 综合实例》。

     

    一、添加JCaptcha依赖 

    Java代码   收藏代码
    1.   
    2.     com.octo.captcha  
    3.     jcaptcha  
    4.     2.0-alpha-1  
    5.   
    6.   
    7.     com.octo.captcha  
    8.     jcaptcha-integration-simple-servlet  
    9.     2.0-alpha-1  
    10.       
    11.           
    12.             servlet-api  
    13.             javax.servlet  
    14.           
    15.       
    16.    

    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.   
    2.   
    3.   JCaptchaFilter  
    4.   class>   
    5.     com.github.zhangkaitao.shiro.chapter22.jcaptcha.JCaptchaFilter  
    6.   class>  
    7.     
    8.     
    9.     JCaptchaFilter  
    10.     /jcaptcha.jpg  
    11.    

    这样就可以在页面使用/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.   
    2. "authcFilter"   
    3.   class="com.github.zhangkaitao.shiro.chapter22.jcaptcha.MyFormAuthenticationFilter">  
    4.     "usernameParam" value="username"/>  
    5.     "passwordParam" value="password"/>  
    6.     "rememberMeParam" value="rememberMe"/>  
    7.     "failureKeyAttribute" value="shiroLoginFailure"/>  
    8.   
    9. "jCaptchaValidateFilter"   
    10.   class="com.github.zhangkaitao.shiro.chapter22.jcaptcha.JCaptchaValidateFilter">  
    11.     "jcaptchaEbabled" value="true"/>  
    12.     "jcaptchaParam" value="jcaptchaCode"/>  
    13.     "failureKeyAttribute" value="shiroLoginFailure"/>  
    14.   
    15.   
    16. "shiroFilter" class="org.apache.shiro.spring.web.ShiroFilterFactoryBean">  
    17.     "securityManager" ref="securityManager"/>  
    18.     "loginUrl" value="/login"/>  
    19.     "filters">  
    20.           
    21.             "authc" value-ref="authcFilter"/>  
    22.             "sysUser" value-ref="sysUserFilter"/>  
    23.             "jCaptchaValidate" value-ref="jCaptchaValidateFilter"/>  
    24.           
    25.       
    26.     "filterChainDefinitions">  
    27.           
    28.             /static/** = anon  
    29.             /jcaptcha* = anon  
    30.             /login = jCaptchaValidate,authc  
    31.             /logout = logout  
    32.             /authenticated = authc  
    33.             /** = user,sysUser  
    34.           
    35.       
    36.   

     

    九、login.jsp登录页面

    Java代码   收藏代码
    1. if test="${jcaptchaEbabled}">  
    2.     验证码：  
    3.     "text" name="jcaptchaCode">  
    4. class="jcaptcha-btn jcaptcha-img"   
    5. src="${pageContext.request.contextPath}/jcaptcha.jpg" title="点击更换验证码">  
    6.     class="jcaptcha-btn" href="javascript:;">换一张  
    7.     
        
    8. if>   

    根据jcaptchaEbabled来显示验证码图片。

     

    十、测试

    输入http://localhost:8080/chapter22将重定向到登录页面；输入正确的用户名/密码/验证码即可成功登录，如果输入错误的验证码，将显示验证码错误页面： 

    Shiro_第15张图片

    23.1多项目集中授权管理及分布式会话

    在一些场景中，比如某个领导因为一些原因不能进行登录网站进行一些操作，他想把他网站上的工作委托给他的秘书，但是他不想把帐号/密码告诉他秘书，只是想把工作委托给他；此时和我们可以使用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 findFromUserIds(Long toUserId);  
    6.     public List 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 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. }  

      

    &n

    你可能感兴趣的:(shiro)

    • SpringSecurity初学总结 weixin_66442229 spring
      springSecurity安全框架基于Java的安全框架主要有:SpringSecurity和Shiro介绍基础概念安全框架是对用户访问权限的控制,保证应用的安全性。其主要的工作是用户认证和用户授权|鉴权主要应用于Spring的企业应用系统,提供声明式的安全访问控制解决方案。它提供了一组可以在Spring应用上下文中配置的Bean能很好的结合Spring的DI依赖注入和AOP面向切面编程功能应用
    • 关于项目中使用shiro进行安全管理的总结 一颗大青柠 JavaShirojavaspring
      关于项目中使用shiro进行安全管理的总结关于SpringBoot下使用shiro进行用户认证与权限管理对于安全框架有一定了解的开发者一定对于shiro这款安全框架有一定的了解，这里我们不再对该框架进行其设计与知识的介绍，仅对于我的个人项目中所使用到的进行一个总结，并放上代码。使用该框架的第一步，进行配置：packagecom.libvirtjava.demo.vm.util.config;imp
    • Apache Shiro安全框架(2)-用户认证 heyrian Javashiro
      身份认证在shiro中用户需要提供用户的principals（身份）和credentials（证明）来证明该用户属于当前系统用户。常见的认证方式即用户名/密码。在解释身份认证之前，我们先来看看shiro中的Subject和Realm,这是身份认证的两个关键的概念。Subjectsubject代表当前用户，内部主要维护当前用户信息。shiro中所有的subject都交给SecurityManager
    • 毕设/私活/bigold必备项目，一个挣钱的免费的全开源标准前后端分离后台管理权限系统【springboot+vue+redis+Spring Security】脚手架搭建：若依Ruo框架具体使用教程 南北极之间 前端开发springbootvuespringboot+vue免费后台管理系统毕业私活后台权限系统
      【建议收藏】毕设/私活/大佬必备，一个挣钱的标准开源前后端分离【springboot+vue+redis+SpringSecurity】脚手架一个免费的开源后台管理系统：若依框架（具体使用教程：具体怎样下载？怎样使用？怎样配置后台接口地址？超详细）简介RuoYi是一个JavaEE企业级快速开发平台，基于经典技术组合（SpringBoot、ApacheShiro、MyBatis、Thymeleaf、
    • 解锁Apache Shiro：新手友好的安全框架指南(一)——整体架构与身份认证_apache shiro的配置包括安全管理器(2) 2401_84281748 程序员apache安全架构
      ApacheShiro是一个功能强大且易于使用的Java安全框架，它执行身份验证、授权、加密和会话管理，可用于保护任何应用程序——从命令行应用程序、移动应用程序到最大的web和企业应用程序。Shiro提供了应用程序安全API来执行以下方面：Authentication（认证）：验证用户身份，即用户登录。Authorization（授权）：访问控制Cryptography（密码学）：保护或隐藏私密数
    • springmvc用配置类替换xml配置 码里法 其他javamvcspring
      ssm基础项目整合前言xml配置mybatis.xmlspingmvc.xmlweb.xml配置类jdbc配置类mybatis配置SpringConfig配置SpringMvcConfig配置shiro配置WebInit前言其实这中间用配置类，发现问题还挺多的，所以记录一下，尤其是针对shiro的配置。xml配置mybatis.xmlArchetypeCreatedWebApplicationdi
    • （shiro加密）2019-03-27 _麻辣香锅不要辣
      参考：spring-shiro的密码加密配置凭证匹配器@BeanpublicHashedCredentialsMatcherhashedCredentialsMatcher(){HashedCredentialsMatcherhashedCredentialsMatcher=newHashedCredentialsMatcher();hashedCredentialsMatcher.setHash
    • shiro 采用redis共享session，出现反序列化错误的排查过程 nightseventhunit redisjava数据库
      这是一个老系统改造的过程，该老系统采用的框架是#jfinal#shiroredis,采用outh2协议的方式，对多个子系统之间进行单点登录，以实现系统之间的session，由于速度方面的影响，现在要改造成多个系统之间共享session，并采用redis集群的方式。说明一下当前项目的整体运行环境，此项目的多个子系统都在同一个域名下，通过上下文不同来区分子系统。以下将记录整个改造过程，采用jfinal
    • springboot+shiro前后端分离过程中跨域问题、sessionId问题、302鉴权失败问题 DN金猿 springboot后端javashiro前后端分离
      近期项目需要前后端分离，由于前后端分离后原来的适用的shiro配置无法满足现有系统要求。同时在前后端项目分离的项目中存在的跨域问题，cookies不再使用，通过token方式实现用户登陆鉴权。下面记录在整个过程中涉及的几个大问题：1、跨域问题2、sessionId问题3、302鉴权问题1、springboot跨域问题解决packagenet.sinorock.aj.common.config;im
    • Shiro实现登录认证以及整合到Springboot3 LIPAH web安全springboot
      一、概念介绍ApacheShiro是一个强大灵活的开源安全框架，提供授权、会话管理以及密码加密等功能。与SpringSecurity对比劣势：SpringSecurity基于Spring开发，项目若使用Spring作为基础，配合SpringSecurity做权限更加方便，而Shiro需要和Spring进行整合开发SpringSecurity功能比Shiro更加丰富些，例如安全维护方面SpringS
    • springboot整合shiro安全框架 heromps Springboot安全apache
      shiro快速开始1.导入依赖org.apache.shiroshiro-core1.8.0org.slf4jjcl-over-slf4j1.7.21org.slf4jslf4j-log4j121.7.21log4jlog4j1.2.17org.apache.shiroshiro-core1.8.02.配置文件shiro.ini[users]#user'root'withpassword'secr
    • mac解决mysql 1055问题 nitricoxide
      首遇报错mac本地安装的mysql执行带groupby的语句时，出现了如下报错1055-Expression#1ofSELECTlistisnotinGROUPBYclauseandcontainsnonaggregatedcolumn'yyhd_shiro.ar.roleName'whichisnotfunctionallydependentoncolumnsinGROUPBYclause;th
    • Spring Boot + Mybatis + Shiro 后台权限管理系统 chuxia_vlog
      平台简介一直想做一款后台管理系统，看了很多优秀的开源项目但是发现没有合适的。于是利用空闲休息时间开始自己写了一套后台系统。如此有了若依。她可以用于所有的Web应用程序，如网站管理后台，网站会员中心，CMS，CRM，OA。所有前端后台代码封装过后十分精简易上手，出错概率低。同时支持移动客户端访问。系统会陆续更新一些实用功能。性别男，若依是给还没有出生女儿取的名字（寓意：你若不离不弃，我必生死相依）若
    • 00后会自动化就想拿20K？不，你还差点远呢··· v_648374 自动化运维
      等你搭建好公司的自动化生态，你还是不满足，我为什么不把这些东西可视化管理呢？做个平台？管理用例，管理任务，管理测试报告？我还可以把公司的一些部署任务也集成过来？想法很好！此时的你已经不仅仅是一名优秀的自动化工程师了，已经迈向了测试开发的道路！开始学习，了解了测试框架httprunner，开发框架django/flask/springboot，懂得了接口开发的流程，了解了mybatis,shiro,
    • Spring Security与Apache Shiro：Java安全框架的比较 Lill_bin javajavaspringapache分布式安全后端开发语言
      引言在Java企业级应用开发中，安全性是一个不可忽视的重要方面。随着Web应用的复杂性日益增加，选择合适的安全框架对于保护应用免受未授权访问和其他安全威胁至关重要。SpringSecurity和ApacheShiro是两个广泛使用的Java安全框架，它们提供了认证(Authentication)和授权(Authorization)的功能。本文将对这两个框架进行比较，探讨它们的设计理念、核心特性以及
    • 【Apache】漏洞 B1ackMa9ic apache网络安全web安全网络攻击模型
      文章目录Apache漏洞1.ApacheHTTPD多后缀解析漏洞2.ApacheSSI远程命令执行漏洞3.ApacheHTTP路径穿越漏洞4.ApacheHTTPSSRF漏洞5.Apachelog4j26.ApacheshiroApache漏洞1.ApacheHTTPD多后缀解析漏洞主要利用方式：文件类型欺骗：构造example.php.jpg的文件（只要一个文件含有.php后缀的文件即将被识别成
    • 请简单介绍一下Shiro框架是什么？Shiro在Java安全领域的主要作用是什么？Shiro主要提供了哪些安全功能？ AaronWang94 shirojavajava安全开发语言
      请简单介绍一下Shiro框架是什么？Shiro框架是一个强大且灵活的开源安全框架，为Java应用程序提供了全面的安全解决方案。它主要用于身份验证、授权、加密和会话管理等功能，可以轻松地集成到任何JavaWeb应用程序中，并提供了易于理解和使用的API，使开发人员能够快速实现安全特性。Shiro的核心组件包括Subject、SecurityManager和Realms。Subject代表了当前与应用
    • shiro 整合 spring 实战及源码详解 老马啸西风 java
      序言前面我们学习了如下内容：5分钟入门shiro安全框架实战笔记shiro整合spring实战及源码详解相信大家对于shiro已经有了最基本的认识，这一节我们一起来学习写如何将shiro与spring进行整合。spring整合maven依赖org.apache.shiroshiro-spring1.7.0org.springframeworkspring-context4.3.13.RELEASE
    • shrio跳转操作 + ajax 月1.2.3 springbootajax
      使用shiro框架的时候，在session过期之后实现跳转到登录界面，ajax操作不会直接跳转而是返回一个登录页面的html，并且不会进入controller逻辑，需要找到对应的方法进行重写，对ajax进行处理（FormAuthenticationFilter中的redirectToLogin方法重写）。
    • XMall 开源商城 SQL注入漏洞复现(CVE-2024-24112) OidBoy_G 漏洞复现web安全安全sql
      0x01产品简介XMall开源电商商城是开发者Exrick的一款基于SOA架构的分布式电商购物商城前后端分离前台商城:Vue全家桶后台管理:Dubbo/SSM/Elasticsearch/Redis/MySQL/ActiveMQ/Shiro/Zookeeper等。0x02漏洞概述XMall开源商城/item/list、/item/listSearch、/sys/log、/order/list、/m
    • shiro入门实战笔记（1）--理论篇 y-yg Shiroshiro入门javaapache权限控制
      从这篇文章开始，将学习Apacheshiro的相关内容。由于博主也是刚刚开始学习相关的基本内容，网上已经有系列文章讲解shiro，这里博主推荐一个：开涛的博客，《跟我学shiro》。博主也是跟着这个系列的文章学习shiro的相关内容。以下的文章，各位读者请权当是学习笔记，因此对于想了解更多内容的读者，请移步到上面的文章中，在参考资料里，博主也会附上链接。第一篇，我们参考官方文档，以及上面文章的翻译
    • Shiro-05-5 分钟入门 shiro 安全框架实战笔记 老马啸西风 web安全java安全架构开发语言哈希算法
      序言大家好，我是老马。前面我们学习了web安全之SpringSecurity入门教程这次我们来一起学习下另一款java安全框架shiro。什么是ApacheShiro？ApacheShiro是一个功能强大且易于使用的Java安全框架，它为开发人员提供了一种直观而全面的解决方案，用于身份验证，授权，加密和会话管理。实际上，它可以管理应用程序安全性的所有方面，同时尽可能避免干扰。它建立在可靠的界面驱动
    • 使用shiro进行登录密码安全验证 Asparrow Shiro安全框架学shiro安全springboot
      使用shiro进行登录密码安全验证使用框架版本SpringBoot1.5.3.RELEASEshiro-spring1.2.5shiro-ehcache1.2.5Shiro配置ShiroConfig中shiroFilter/***ShiroFilter*注意这里参数中的StudentService和IScoreDao只是一个例子，因为我们在这里可以用这样的方式获取到相关访问数据库的对象，*然后读取
    • JAVA后端主流开发框架 理查德.克莱德曼 JavaWebSpringBootjava后端开发语言
      项目介绍一款Java语言基于SpringBoot2.x、Layui、Thymeleaf、MybatisPlus、Shiro、MySQL等框架精心打造的一款模块化、插件化、高性能的前后端分离架构敏捷开发框架，可用于快速搭建后台管理系统，本着简化开发、提升开发效率的初衷，框架自研了一套个性化的组件，实现了可插拔的组件式开发方式：单图上传、多图上传、下拉选择、开关按钮、单选按钮、多选按钮、图片裁剪、富文
    • shiro登陆时密码加盐哈希实现和简单原理 ignoHH javashirospringbootjavashiro密码学
      shiro登陆时密码加盐哈希实现版权声明：本文为博主原创文章，遵循CC4.0BY-SA版权协议，转载请附上原文出处链接和本声明。本文链接：https://blog.csdn.net/wy862740672/article/details/109818314实现废话不多说，开搞。此篇采用SHA-256哈希算法，采用其他算法只需要更改算法名字段。1.在shiro配置中添加对于HashedCredent
    • 详解Springboot整合Shiro加盐加散列实现登陆注册小案例 鱼小洲 技术杂谈shiromybatishashspringbootboot-shiro
      前言Springboot和Shiro的基本介绍我就不多说了，能看到这篇文章的相信也都会用。这篇文章主要是分享一下我在学习Shiro和Springboot的整合的小阶段。目前是复习，很感谢B站的up主——编程不良人的视频让我有了一个学习Shiro的基本方向。目前是实现了用户认证的功能。依赖整合的时候使用的是jsp，其实和thymeleaf一个道理，而且不涉及到作用域传值。我们需要导入的依赖有：mys
    • Shiro-09-Session Management 会话管理 老马啸西风 web安全哈希算法密码学算法java安全
      会话管理ApacheShiro在安全性框架世界中提供了一些独特的功能：适用于任何应用程序的完整的企业级Session解决方案，从最简单的命令行和智能手机应用程序到最大的群集企业Web应用程序。这对许多应用程序都有很大的影响-在Shiro之前，如果需要会话支持，则需要将应用程序部署在Web容器中或使用EJB状态会话Bean。Shiro的Session支持比这两种机制中的任何一种都更易于使用和管理，并
    • Shiro-10-Cryptography 编码加密 老马啸西风 web安全java安全架构开发语言哈希算法
      编码/加密在涉及到密码存储问题上，应该加密/生成密码摘要存储，而不是存储明文密码。比如之前的600wcsdn账号泄露对用户可能造成很大损失，因此应加密/生成不可逆的摘要方式存储。编码/解码Shiro提供了base64和16进制字符串编码/解码的API支持，方便一些编码解码操作。Shiro内部的一些数据的存储/表示都使用了base64和16进制字符串。Stringstr="hello";String
    • Shiro学习（三）之MD5+随机盐salt+Hash散列认证 Solitude_dong Shiroshiro
      MD5:加密算法不可逆（只能根据明文生成密文；如果内容相同，不论执行多少次md5生成结果始终一致），通常和随机盐配合使用一般用来加密或签名签名：也称为校验和，就是用来判断两个内容是否一致eg:tomcat.ziptomcat.md5.fdfd…看是否下载完整，就可以点击tomcat.md5.看生成的签名和tomcat生成的是否一致两个文件是否一致？a.txt和bb.txt分别md5看签名是否一致破
    • [开发框架]-shiro-入门 Pacifica_ java数据库web安全shiro
      权限管理概述权限管理实现对用户访问系统的控制，以及按照安全规则或安全策略控制用户可以访问而且只能访问自己被授权的资源。也就是说，权限管理包括用户身份认证(登录)和授权(资源的访问权限)两部分shiro中的详细架构：shiro中的认证认证过程中的关键对象1.Subject，主体。访问系统的用户，主体可以是用户，程序等，进行认证的都称为主体2.Principal，身份信息，是主体进行身份认证的标识，标
    • PHP，安卓，UI，java，linux视频教程合集 cocos2d-x小菜 javaUIlinuxPHPandroid
      ╔-----------------------------------╗┆                           
    • zookeeper admin 笔记 braveCS zookeeper
        Required Software 1) JDK>=1.6 2)推荐使用ensemble的ZooKeeper(至少3台)，并run on separate machines 3)在Yahoo!，zk配置在特定的RHEL boxes里，2个cpu，2G内存，80G硬盘   数据和日志目录 1)数据目录里的文件是zk节点的持久化备份，包括快照和事务日
    • Spring配置多个连接池 easterfly spring
      项目中需要同时连接多个数据库的时候，如何才能在需要用到哪个数据库就连接哪个数据库呢？ Spring中有关于dataSource的配置：     <bean id="dataSource" class="com.mchange.v2.c3p0.ComboPooledDataSource"   &nb
    • Mysql 171815164 mysql
      例如，你想myuser使用mypassword从任何主机连接到mysql服务器的话。 GRANT ALL PRIVILEGES ON *.* TO 'myuser'@'%'IDENTIFIED BY 'mypassword' WI TH GRANT OPTION; 如果你想允许用户myuser从ip为192.168.1.6的主机连接到mysql服务器，并使用mypassword作
    • CommonDAO（公共/基础DAO） g21121 DAO
              好久没有更新博客了，最近一段时间工作比较忙，所以请见谅，无论你是爱看呢还是爱看呢还是爱看呢，总之或许对你有些帮助。         DAO(Data Access Object)是一个数据访问（顾名思义就是与数据库打交道）接口，DAO一般在业
    • 直言有讳 永夜-极光 感悟随笔
        1.转载地址:http://blog.csdn.net/jasonblog/article/details/10813313   精华: “直言有讳”是阿里巴巴提倡的一种观念，而我在此之前并没有很深刻的认识。为什么呢？就好比是读书时候做阅读理解，我喜欢我自己的解读，并不喜欢老师给的意思。在这里也是。我自己坚持的原则是互相尊重，我觉得阿里巴巴很多价值观其实是基本的做人
    • 安装CentOS 7 和Win 7后，Win7 引导丢失 随便小屋 centos
      一般安装双系统的顺序是先装Win7，然后在安装CentOS，这样CentOS可以引导WIN 7启动。但安装CentOS7后，却找不到Win7 的引导，稍微修改一点东西即可。 一、首先具有root 的权限。      即进入Terminal后输入命令su，然后输入密码即可 二、利用vim编辑器打开/boot/grub2/grub.cfg文件进行修改 v
    • Oracle备份与恢复案例 aijuans oracle
      Oracle备份与恢复案例 一. 理解什么是数据库恢复当我们使用一个数据库时，总希望数据库的内容是可靠的、正确的，但由于计算机系统的故障（硬件故障、软件故障、网络故障、进程故障和系统故障）影响数据库系统的操作，影响数据库中数据的正确性，甚至破坏数据库，使数据库中全部或部分数据丢失。因此当发生上述故障后，希望能重构这个完整的数据库，该处理称为数据库恢复。恢复过程大致可以分为复原(Restore)与
    • JavaEE开源快速开发平台G4Studio v5.0发布 無為子
        我非常高兴地宣布,今天我们最新的JavaEE开源快速开发平台G4Studio_V5.0版本已经正式发布。   访问G4Studio网站 http://www.g4it.org   2013-04-06 发布G4Studio_V5.0版本 功能新增 (1). 新增了调用Oracle存储过程返回游标，并将游标映射为Java List集合对象的标
    • Oracle显示根据高考分数模拟录取 百合不是茶 PL/SQL编程oracle例子模拟高考录取学习交流
      题目要求: 1,创建student表和result表 2,pl/sql对学生的成绩数据进行处理 3,处理的逻辑是根据每门专业课的最低分线和总分的最低分数线自动的将录取和落选     1,创建student表,和result表 学生信息表; create table student( student_id number primary key,--学生id
    • 优秀的领导与差劲的领导 bijian1013 领导管理团队
      责任 优秀的领导：优秀的领导总是对他所负责的项目担负起责任。如果项目不幸失败了，那么他知道该受责备的人是他自己，并且敢于承认错误。 差劲的领导：差劲的领导觉得这不是他的问题，因此他会想方设法证明是他的团队不行，或是将责任归咎于团队中他不喜欢的那几个成员身上。 努力工作 优秀的领导：团队领导应该是团队成员的榜样。至少，他应该与团队中的其他成员一样努力工作。这仅仅因为他
    • js函数在浏览器下的兼容 Bill_chen jquery浏览器IEDWRext
        做前端开发的工程师，少不了要用FF进行测试，纯js函数在不同浏览器下，名称也可能不同。对于IE6和FF，取得下一结点的函数就不尽相同：   IE6：node.nextSibling,对于FF是不能识别的；   FF：node.nextElementSibling,对于IE是不能识别的； 兼容解决方式：var Div = node.nextSibl
    • 【JVM四】老年代垃圾回收：吞吐量垃圾收集器(Throughput GC) bit1129 垃圾回收
      吞吐量与用户线程暂停时间   衡量垃圾回收算法优劣的指标有两个： 吞吐量越高，则算法越好 暂停时间越短，则算法越好 首先说明吞吐量和暂停时间的含义。   垃圾回收时，JVM会启动几个特定的GC线程来完成垃圾回收的任务，这些GC线程与应用的用户线程产生竞争关系，共同竞争处理器资源以及CPU的执行时间。GC线程不会对用户带来的任何价值，因此，好的GC应该占
    • J2EE监听器和过滤器基础 白糖_ J2EE
      Servlet程序由Servlet，Filter和Listener组成，其中监听器用来监听Servlet容器上下文。 监听器通常分三类：基于Servlet上下文的ServletContex监听，基于会话的HttpSession监听和基于请求的ServletRequest监听。   ServletContex监听器 ServletContex又叫application
    • 博弈AngularJS讲义(16) - 提供者 boyitech jsAngularJSapiAngularProvider
        Angular框架提供了强大的依赖注入机制，这一切都是有注入器(injector)完成. 注入器会自动实例化服务组件和符合Angular API规则的特殊对象，例如控制器，指令，过滤器动画等。   那注入器怎么知道如何去创建这些特殊的对象呢？ Angular提供了5种方式让注入器创建对象，其中最基础的方式就是提供者(provider), 其余四种方式(Value, Fac
    • java-写一函数f(a,b)，它带有两个字符串参数并返回一串字符，该字符串只包含在两个串中都有的并按照在a中的顺序。 bylijinnan java
      public class CommonSubSequence { /** * 题目：写一函数f(a,b)，它带有两个字符串参数并返回一串字符，该字符串只包含在两个串中都有的并按照在a中的顺序。 * 写一个版本算法复杂度O(N^2)和一个O(N) 。 * * O(N^2)：对于a中的每个字符，遍历b中的每个字符，如果相同，则拷贝到新字符串中。 * O(
    • sqlserver 2000 无法验证产品密钥 Chen.H sqlwindowsSQL ServerMicrosoft
      在 Service Pack 4 (SP 4), 是运行 Microsoft Windows Server 2003、 Microsoft Windows Storage Server 2003 或 Microsoft Windows 2000 服务器上您尝试安装 Microsoft SQL Server 2000 通过卷许可协议 (VLA) 媒体。 这样做, 收到以下错误信息CD KEY的 SQ
    • [新概念武器]气象战争 comsci
             气象战争的发动者必须是拥有发射深空航天器能力的国家或者组织....        原因如下:        地球上的气候变化和大气层中的云层涡旋场有密切的关系,而维持一个在大气层某个层次
    • oracle 中 rollup、cube、grouping 使用详解 daizj oraclegroupingrollupcube
      oracle 中 rollup、cube、grouping 使用详解 -- 使用oracle 样例表演示 转自namesliu -- 使用oracle 的样列库，演示 rollup, cube, grouping 的用法与使用场景    --- ROLLUP ， 为了理解分组的成员数量，我增加了 分组的计数  COUNT(SAL)   
    • 技术资料汇总分享 Dead_knight 技术资料汇总 分享
      本人汇总的技术资料，分享出来，希望对大家有用。 http://pan.baidu.com/s/1jGr56uE 资料主要包含： Workflow->工作流相关理论、框架(OSWorkflow、JBPM、Activiti、fireflow...) Security->java安全相关资料(SSL、SSO、SpringSecurity、Shiro、JAAS...) Ser
    • 初一下学期难记忆单词背诵第一课 dcj3sjt126com englishword
      could 能够 minute 分钟 Tuesday 星期二 February 二月 eighteenth 第十八 listen 听 careful 小心的，仔细的 short 短的 heavy 重的 empty 空的 certainly 当然 carry 携带；搬运 tape 磁带 basket 蓝子 bottle 瓶 juice 汁，果汁 head 头；头部
    • 截取视图的图片, 然后分享出去 dcj3sjt126com OSObjective-C
      OS 7 has a new method that allows you to draw a view hierarchy into the current graphics context. This can be used to get an UIImage very fast. I implemented a category method on UIView to get the vi
    • MySql重置密码 fanxiaolong MySql重置密码
      方法一:  在my.ini的[mysqld]字段加入： skip-grant-tables 重启mysql服务，这时的mysql不需要密码即可登录数据库  然后进入mysql mysql>use mysql;  mysql>更新 user set password=password('新密码') WHERE User='root'; mysq
    • Ehcache（03）——Ehcache中储存缓存的方式 234390216 ehcacheMemoryStoreDiskStore存储驱除策略
      Ehcache中储存缓存的方式   目录 1     堆内存（MemoryStore） 1.1     指定可用内存 1.2     驱除策略 1.3     元素过期 2   &nbs
    • spring mvc中的@propertysource jackyrong spring mvc
        在spring mvc中，在配置文件中的东西，可以在java代码中通过注解进行读取了： @PropertySource  在spring 3.1中开始引入 比如有配置文件 config.properties mongodb.url=1.2.3.4 mongodb.db=hello 则代码中   @PropertySource(&
    • 重学单例模式 lanqiu17 单例Singleton模式
      最近在重新学习设计模式，感觉对模式理解更加深刻。觉得有必要记下来。 第一个学的就是单例模式，单例模式估计是最好理解的模式了。它的作用就是防止外部创建实例，保证只有一个实例。 单例模式的常用实现方式有两种，就人们熟知的饱汉式与饥汉式，具体就不多说了。这里说下其他的实现方式 静态内部类方式: package test.pattern.singleton.statics; publ
    • .NET开源核心运行时，且行且珍惜 netcome java.net开源
      背景 2014年11月12日，ASP.NET之父、微软云计算与企业级产品工程部执行副总裁Scott Guthrie，在Connect全球开发者在线会议上宣布，微软将开源全部.NET核心运行时，并将.NET 扩展为可在 Linux 和 Mac OS 平台上运行。.NET核心运行时将基于MIT开源许可协议发布，其中将包括执行.NET代码所需的一切项目——CLR、JIT编译器、垃圾收集器（GC）和核心
    • 使用oscahe缓存技术减少与数据库的频繁交互 Everyday都不同 Web高并发oscahe缓存
      此前一直不知道缓存的具体实现，只知道是把数据存储在内存中，以便下次直接从内存中读取。对于缓存的使用也没有概念，觉得缓存技术是一个比较”神秘陌生“的领域。但最近要用到缓存技术，发现还是很有必要一探究竟的。   缓存技术使用背景：一般来说，对于web项目，如果我们要什么数据直接jdbc查库好了，但是在遇到高并发的情形下，不可能每一次都是去查数据库，因为这样在高并发的情形下显得不太合理——
    • Spring+Mybatis 手动控制事务 toknowme mybatis
      @Override    public boolean testDelete(String jobCode) throws Exception {       boolean flag = false;  &nbs
    • 菜鸟级的android程序员面试时候需要掌握的知识点 xp9802 android
      熟悉Android开发架构和API调用 掌握APP适应不同型号手机屏幕开发技巧 熟悉Android下的数据存储  熟练Android Debug Bridge Tool 熟练Eclipse/ADT及相关工具  熟悉Android框架原理及Activity生命周期 熟练进行Android UI布局 熟练使用SQLite数据库； 熟悉Android下网络通信机制，S