程序博客网 > 数据的存储过程

shiro权限管理入门

来源：互联网 发布：数据的存储过程 编辑：程序博客网 时间：2024/06/07 16:26

shiro介绍

什么是shiro

shiro是Apache的一个开源框架，它将软件系统的安全认证相关的功能抽取出来，实现用户身份认证，权限授权、加密、会话管理等功能，组成了一个通用的安全认证框架。它可以实现如下的功能：
1.验证用户
2.对用户执行访问控制，如：判断用户是否具有角色admin，判断用户是否拥有访问的资源权限。
3.在任何环境下使用SessionAPI。例如C/S程序
4.可以使用多个用户数据源。例如一个是Oracle数据库，另外一个是MySQL数据库。
5.单点登录(SSO)功能
6."Remember Me"服务，类似于购物车的功能，shiro官方建议开启。

为何使用shiro?

因为shiro将安全认证相关的功能抽取出来组成了一个框架，因此使用shiro就可以非常快速的完成认证、授权等功能的开发，降低系统成本。
shiro使用广泛，shiro可以运行在web应用，非web应用，集群分布式应用中越来越多的用户开始使用shiro.
Spring中有Spring security(原名Acegi), 是一个权限框架，它和Spring的依赖过于紧密，没有shiro使用简单。shiro不依赖于Spring，而shiro就相对独立最主要是因为shiro使用简单‘灵活，所以现在越来越多的用户选择shiro。

shiro核心组成部分


shiro的4大组成部分——身份认证，授权，会话管理和加密
Authentication：身份验证(身份认证)，简称"登录"。
Authorization：授权，给用户给用户分配角色或者权限资源。
Session Manager：用户Session管理器，可以让C/S程序也使用Session来控制权限。
Cryptography：将JDK中复杂的密码加密方式进行封装。
除了以上功能，shiro还提供很多扩展功能：
Web Support：主要针对web应用提供一些常用功能。
Caching：缓存可以使程序运行更有效率。
Concurrency：多线程相关功能。
Testing：帮助我们进行测试相关的功能。
"Run As"：一个允许用户假设为另一个用户身份(如果允许)的功能，有时候在管理脚本时很有用。
"Remember  Me"：记住用户身份，提供类似购物车的功能。

shiro运行大致流程：


Subject——主体，是与程序进行交互的对象，可以是人也可以是服务或其他程序，通常理解为用户。所有的Subject实例都必须绑定到一个SecurityManager上。我们与Subject交互，运行时shiro会自动转化为与SecurityManager交互的特定的subject的交互。
SecurityManager——SecurityManager是shiro的核心，初始化时协调各个模块运行。然而，一旦SecurityManager协调完毕，SecurityManager会被单独留下，且我们只需要去操作Subject即可，无需操作SecurityManager。但是需要了解的是当我们与一个Subject进行交互时，实质上是SecurityManager在处理Subject的安全操作。
Realms——Realms在shiro中作为程序和安全数据之间的"桥梁"或"连接器"。它用于获取安全数据来判断subject是否能够登录，subject拥有什么权限。有点类似于DAO。在配置realms时，需要至少一个realm。而且shiro提供了一些常用的Realms来连接数据源，如LDAP数据源的JndiLdapRealm，JDBC数据源的JdbcRealm，ini文件数据源的iniRealm，Properties文件数据源的PropertiesRealm，等等，我们也可以插入自己的Realm实现来代表自定义的数据源。像其他组件一样，Realms也是由SecurityManager控制。

shiro架构


Subject：(org.apache.shiro.subject.Subject)  即主体，简称用户，主体既可以是用户也可以是程序，主体访问系统，系统需要对主体进行认证、授权。外部应用与subject进行交互，Subject记录了当前操作用户，将用户的概念理解为当前操作的主体，可能是一个通过浏览器请求的用户，也可能是一个运行的程序。Subject在shiro中是一个接口，接口中定义了很多认证授权相关的方法，外部程序通过subject进行认证授权，而Subject是通过SecurityManager安全管理器进行认证授权。
SecurityManager：(org.apache.shiro.mgt.SecurityManager)如上所述，SecurityManager是shiro的核心，协调shiro的各个组件。SecurityManager就是安全管理器，负责对全部的subject进行安全管理。通过SecurityManager可以完成Subject的认证、授权等，实质上SecurityManager是通过Authenticator对主体进行认证，通过Authorizer对主体进行授权，通过SessionManager进行会话管理等等。SecurityManager是一个接口，继承了Authenticator，Authorizer，SessionManager这三个接口。
Authenticator：(org.apache.shiro.authc.Authenticator) 即认证器，对用户身份进行认证，Authenticator是一个接口，shiro提供ModularRealmAuthenticator实现类，通过ModularRealmAuthenticator基本上可以满足大多数需求，也可以自定义认证器。
Authorizer：(org.apache.shiro.authz.Authorizer)即授权器，用户在通过认证器认证通过后，在访问时需要通过授权器判断用户是否有此功能的操作权限。最终是通过认证器对主体进行授权的。
Realm：(org.apache.shiro.realm.Realm)Realm即领域，相当于DataSource数据源，通过Realm存取认证、授权相关数据。SecurityManager通过认证器对主体进行安全认证需要通过Realm获取用户身份数据，比如：如果用户身份数据在数据库，那么Realm就需要从数据库获取用户的身份信息。授权也是如此，也需要通过Realm取出授权相关信息。注意：不要将Realm理解成只是从数据源获取数据，在Realm中还有认证授权校验的相关代码
SessionManager：(org.apache.shiro.session.SessionManager)会话管理。web应用中一般是web容器对Session进行管理，shiro框架定义了一套会话管理，它不依赖于web容器的Session，所以shiro可以使用在非web应用上，也可以将分布式应用的会话集中在一点进行管理，此特性可使它实现单点登录。
SessionDAO：SessionDAO即会话dao，是对Session会话操作的一套接口，比如要将Session存储到数据库，可以通过JDBC将会话存储到数据库。针对个性化的Session数据存储(存到数据库)需要使用SessionDAO。
CacheManager：(org.apahce.shiro.cache.CacheManager)缓存管理器，主要对Session和授权数据进行缓存，比如将授权数据通过cachemanager进行缓存管理，和ehcache整合对缓存数据进行管理，可以减少不必要的后台访问，提高应用效率，增加用户体验。
Cryptography：(org.apache.shiro.crypto.*)密码管理，提供了一套加密/解密组件，对JDK中的加密解密算法进行了封装，方便开发。比如提供常用的散列、加/解密等功能，比如MD5散列算法。

shiro相关jar

与其他Java开源框架类似，将shiro的jar包加入项目就可以使用shiro提供的功能了。shiro-core时核心包必须选用，还提供了与web整合的shiro-web、与Spring整合的shiro-spring、与任务调度quartz整合的shiro-quartz、与ehcache整合的shiro-ehcache。下边是shiro各个jar包的Maven坐标。
[html] view plain copy
print?
  1. <dependency>  
  2.     <groupId>org.apache.shiro</groupId>  
  3.     <artifactId>shiro-core</artifactId>  
  4.     <version>1.2.3</version>  
  5. </dependency>  
  6. <dependency>  
  7.     <groupId>org.apache.shiro</groupId>  
  8.     <artifactId>shiro-web</artifactId>  
  9.     <version>1.2.3</version>  
  10. </dependency>  
  11. <dependency>  
  12.     <groupId>org.apache.shiro</groupId>  
  13.     <artifactId>shiro-spring</artifactId>  
  14.     <version>1.2.3</version>  
  15. </dependency>  
  16. <dependency>  
  17.     <groupId>org.apache.shiro</groupId>  
  18.     <artifactId>shiro-ehcache</artifactId>  
  19.     <version>1.2.3</version>  
  20. </dependency>  
  21. <dependency>  
  22.     <groupId>org.apache.shiro</groupId>  
  23.     <artifactId>shiro-quartz</artifactId>  
  24.     <version>1.2.3</version>  
  25. </dependency>  
也可以通过引入shiro-all包括shiro所有的包
[html] view plain copy
print?
  1. <dependency>  
  2.     <groupId>org.apache.shiro</groupId>  
  3.     <artifactId>shiro-all</artifactId>  
  4.     <version>1.2.3</version>  
  5. </dependency>  
相关jar包如下所示：

shiro认证

shiro认证过程


1.应用程序构建了一个终端用户认证信息AuthenticationToken实例后，调用Subject.login方法。
2.Subject的实例通常是DelegatingSubject类(或子类)的实例对象，在认证开始时，会委托应用程序设置的SecurityManager实例调用securityManager.login(token)方法。
3.SecurityManager接受到token(令牌)信息后会委托内置的Authenticator的实例(通常是ModularRealmAuthenticator类的实例)调用authenticator.authenticate(token)。ModularRealmAuthenticator在认证过程中会对设置的一个或多个Realm实例进行适配，它实际上为shiro提供了一个可插拔的认证机制。
4.如果在应用程序中配置类多个Realm，ModularRealmAuthenticator会根据配置的AuthenticationStrategy(认证策略)来进行多Realm的认证过程。在Realm被调用后，AuthenticationStrategy将对每一个Realm的结果做出响应。注意：如果应用程序中仅配置了一个Realm，Realm将被直接调用而无需再配置认证策略。
5.判断每一个Realm是否支持提交的token，如果支持，Realm将调用getAuthenticationInfo(token)；getAuthenticationInfo方法就是实际认证处理，我们通过覆盖Realm的doGetAuthenticationInfo方法来编写我们自定义的认证处理。
shiro的认证流程图如下：

shiro入门程序(用户登录和退出)

创建Java工程

加入shiro-core的jar包以及依赖包


工程结构如下：

log4j.properties日志配置文件

[plain] view plain copy
print?
  1. log4j.rootLogger=debug, stdout  
  2.   
  3. log4j.appender.stdout=org.apache.log4j.ConsoleAppender  
  4. log4j.appender.stdout.layout=org.apache.log4j.PatternLayout  
  5. log4j.appender.stdout.layout.ConversionPattern=%d %p [%c] - %m %n  

shiro-first.ini

通过shiro-first.ini配置文件初始化SecurityManager环境，创建SecurityManager工厂。
配置MyEclipse支持ini，添加中文支持插件Properties Editor 地址是http://propedit.sourceforge.jp/eclipse/updates/

在MyEclipse配置后，在classpath创建shiro.ini配置文件，为了方便测试将用户名和密码配置在shiro-first.ini文件中

[plain] view plain copy
print?
  1. #对用户信息进行配置  
  2. [users]  
  3. #用户账号和密码  
  4. zhangsan=123456  
  5. lisi=654321  

入门程序认证代码

[java] view plain copy
print?
  1. // 用户登录和退出  
  2.     @Test  
  3.     public void testLoginAndLogout() {  
  4.   
  5.         // 创建SecurityManager工厂。通过ini配置文件创建securityManager  
  6.         Factory<SecurityManager> factory = new IniSecurityManagerFactory("classpath:shiro-first.ini");  
  7.   
  8.         // 创建SecurityManager  
  9.         SecurityManager securityManager = factory.getInstance();  
  10.   
  11.         // 将securityManager设置到当前的运行环境中  
  12.         SecurityUtils.setSecurityManager(securityManager);  
  13.   
  14.         // 从SecurityUtils中创建一个subject  
  15.         Subject subject = SecurityUtils.getSubject();  
  16.   
  17.         // 在认证提交前准备token(令牌)  
  18.         // 这里的账号和密码 将来是由用户输入进去的  
  19.         UsernamePasswordToken token = new UsernamePasswordToken("zhangsan", "123456");  
  20.          
  21.         //执行认证提交  
  22.         try {  
  23.             //执行认证提交  
  24.             subject.login(token);  
  25.         } catch (AuthenticationException e) {  
  26.             e.printStackTrace();  
  27.         }  
  28.           
  29.         // 是否认证通过  
  30.         boolean isAuthenticated = subject.isAuthenticated();  
  31.         System.out.println("是否认证通过："+isAuthenticated);  
  32.           
  33.         //退出操作  
  34.         subject.logout();  
  35.           
  36.         // 是否认证通过  
  37.         isAuthenticated = subject.isAuthenticated();  
  38.         System.out.println("是否认证通过："+isAuthenticated);  
  39.     }  

认证执行流程

1.通过ini配置文件创建SecurityManager
2.创建token令牌，token中有用户提交的认证信息即用户名和密码
3.执行subject.login(token)方法提交认证，最终由securityManager通过Authenticator进行认证
4.Authenticator的实现ModularRealmAuthenticator调用realm从ini配置文件取出用户真实的账号和密码，这里使用的是iniRealm(shiro自带)
5.initRealm先根据先根据token中的账号去ini中查找账号，如果查找不到则给ModularRealmAuthenticator返回null，如果查到用户信息，就给ModularRealmAuthenticator返回用户信息(账号和密码)
6.ModularRealmAuthenticator接收IniRealm返回Authentication认证信息，如果返回的认证信息是null，ModularRealmAuthenticator抛出异常（org.apache.shiro.authc.UnknownAccountException）如果返回的认证信息不是null（说明inirealm找到了用户），对IniRealm返回用户密码 （在ini文件中存在）和 token中的密码 进行对比，如果不一致抛出异常（org.apache.shiro.authc.IncorrectCredentialsException）

常见的认证异常

UnknownAccountException
账号不存在异常如下：org.apache.shiro.authc.UnknownAccountException: No account found for user…
IncorrectCredentialsException
当输入密码错误会抛此异常，如下：org.apache.shiro.authc.IncorrectCredentialsException: Submitted credentials for token [org.apache.shiro.authc.UsernamePasswordToken - zhangsan, rememberMe=false] did not match the expected credentials.
更多如下：
DisabledAccountException（帐号被禁用）
LockedAccountException（帐号被锁定）
ExcessiveAttemptsException（登录失败次数过多）
ExpiredCredentialsException（凭证过期）等

小结

ModularRealmAuthenticator作用进行认证，需要调用realm查询用户信息（在数据库中存在用户信息）
ModularRealmAuthenticator进行密码对比（认证过程）。
realm：需要根据token中的身份信息去查询数据库（入门程序使用ini配置文件），如果查到用户返回认证信息，如果查询不到返回null。

自定义Realm

上边的程序中使用的是Shiro自带的iniRealm。iniRealm从配置文件中读取用户的信息，大部分情况下需要从系统的数据库中读取用户信息，所以需要自定义Realm。

shiro中提供的Realm接口的实现


实现自定义Realm

[java] view plain copy
print?
  1. public class CustomRealm extends AuthorizingRealm {  
  2.     // 设置Realm的名称  
  3.     @Override  
  4.     public String getName() {  
  5.         return super.getName();  
  6.     }  
  7.   
  8.     // 支持UsernamePasswordToken  
  9.     @Override  
  10.     public boolean supports(AuthenticationToken token) {  
  11.         return token instanceof UsernamePasswordToken;  
  12.     }  
  13.   
  14.     // 用于认证  
  15.     @Override  
  16.     protected AuthenticationInfo doGetAuthenticationInfo(AuthenticationToken token) throws AuthenticationException {  
  17.   
  18.         // token是用户输入的  
  19.         // 第一步从token中取出身份信息  
  20.         String usercode = (String) token.getPrincipal();  
  21.   
  22.         // 第二步：根据用户输入的usercode从数据库查询  
  23.         // ......  
  24.   
  25.         // 如果查询不到返回null  
  26.         // 数据库中用户账号是zhangsan  
  27.         if (!usercode.equals("zhangsan")) {  
  28.             return null;  
  29.         }  
  30.   
  31.         // 模拟从数据库中查询到密码  
  32.         String password = "123456";  
  33.   
  34.         // 如果查询到返回认证信息AuthenticationInfo  
  35.         SimpleAuthenticationInfo simpleAuthenticationInfo = new SimpleAuthenticationInfo(usercode, password,  
  36.                 this.getName());  
  37.   
  38.         return simpleAuthenticationInfo;  
  39.     }  
  40.   
  41.     // 用于授权  
  42.     @Override  
  43.     protected AuthorizationInfo doGetAuthorizationInfo(PrincipalCollection principals) {  
  44.   
  45.         return null;  
  46.     }  
  47. }  

shiro-realm.ini

需要在shiro-realm.ini配置realm注入到securityManager

[plain] view plain copy
print?
  1. [main]  
  2. #自定义realm  
  3. customRealm=liuxun.test.shiro.realm.CustomRealm  
  4. #将realm设置到SecurityManager，相当于Spring中的注入  
  5. securityManager.realms=$customRealm  

测试代码

测试代码同入门程序，将ini的地址修改为shiro-realm.ini
分别模拟账号不存在、密码错误、账号和密码正确进行测试

散列算法

散列算法一般用于生成一段文本的摘要信息，散列算法不可逆，将内容可以生成摘要，无法将摘要转成原始内容。散列算法常用于对密码进行散列，常用的散列算法有MD5、SHA。
一般散列算法需要提供一个salt（盐）与原始内容生成摘要信息，这样做的目的是为了安全性，比如：111111的md5值是：96e79218965eb72c92a549dd5a330112，拿着“96e79218965eb72c92a549dd5a330112”去md5破解网站很容易进行破解，如果要是对111111和salt（盐，一个随机数）进行散列，这样虽然密码都是111111加不同的盐会生成不同的散列值。

md5散列测试程序

[java] view plain copy
print?
  1. package liuxun.test.shiro.authentication;  
  2.   
  3. import org.apache.shiro.crypto.hash.Md5Hash;  
  4. import org.apache.shiro.crypto.hash.SimpleHash;  
  5.   
  6. public class MD5Test {  
  7.     public static void main(String[] args) {  
  8.         //原始密码  
  9.         String source = "123456";  
  10.         //盐  
  11.         String salt = "qwerty";  
  12.         //散列次数  
  13.         int hashIterations = 2;  
  14.         //上边散列1次：48474f975022f960bc2afbe49be581e8  
  15.         //上边散列2次：13f79dafcbbedc313273e2b891ac84d3  
  16.           
  17.         //构造方法中：  
  18.         //第一个参数：明文，原始密码  
  19.         //第二个参数：盐，通过使用随机字符串  
  20.         //第三个参数：散列的次数，比如散列两次，相当于md5(md5(''))  
  21.         Md5Hash md5Hash = new Md5Hash(source, salt, hashIterations);  
  22.           
  23.         String password_md5 = md5Hash.toString();  
  24.         System.out.println(password_md5);  
  25.           
  26.         //使用后SimpleHash  
  27.         //第一个参数：散列算法  
  28.         SimpleHash simpleHash = new SimpleHash("md5", source, salt, hashIterations);  
  29.         System.out.println(simpleHash.toString());  
  30.     }  
  31. }  
建议对MD5进行散列时加salt(盐)，相当于对原始密码+盐进行散列
正常使用时散列算法：
在程序中对"原始密码+盐"进行散列，将散列值存储到数据库中，并且还要将盐存储在数据库中，如果进行密码比对时，使用相同方法，将原始密码+盐进行散列，进行比对。

自定义Realm支持散列算法

实际应用中是将盐和散列后的值存在数据库中，自动Realm从数据库中取出盐和加密后的值，由shiro完成密码校验。

新建Realm(CustomRealmMd5)

[java] view plain copy
print?
  1. // 用于认证  
  2.     @Override  
  3.     protected AuthenticationInfo doGetAuthenticationInfo(AuthenticationToken token) throws AuthenticationException {  
  4.   
  5.         // token保存了用户输入的身份信息userName和password  
  6.         // 第一步：从token中取出身份信息  
  7.         String userCode = (String) token.getPrincipal();  
  8.   
  9.         // 第二步：根据用户输入的userCode从数据库查询  
  10.         // ....  
  11.         // 如果查询不到返回null 假设用户输入的账号是zhansgan  
  12.         // 模拟从数据库中查询账号是zhangsan的用户  
  13.         if (!userCode.equals("zhangsan")) {  
  14.             return null;  
  15.         }  
  16.   
  17.         // 模拟从数据库中查询到密码(散列值)  
  18.         // 按照固定规则加密的结果，此密码是在数据库中存储的，原始密码是123456 盐是qwerty  
  19.         String password = "48474f975022f960bc2afbe49be581e8";  
  20.         // 盐，随机字符串，此随机字符串也是在数据库中存储的,模拟从数据库中获取  
  21.         String salt = "qwerty";  
  22.   
  23.         // 如果查询到则返回认证信息AuthenticationInfo  
  24.         SimpleAuthenticationInfo simpleAuthenticationInfo = new SimpleAuthenticationInfo(userCode, password,  
  25.                 ByteSource.Util.bytes(salt), this.getName());  
  26.           
  27.         return simpleAuthenticationInfo;  
  28.     }  

配置散列Realm

在classpath下配置shiro-realm-md5.ini

[plain] view plain copy
print?
  1. [main]  
  2. #定义凭证匹配器  
  3. credentialsMatcher=org.apache.shiro.authc.credential.HashedCredentialsMatcher  
  4. #散列算法  
  5. credentialsMatcher.hashAlgorithmName=md5  
  6. #散列次数  
  7. credentialsMatcher.hashIterations=1  
  8.   
  9. #将凭证匹配器设置到Realm  
  10. customRealm=liuxun.test.shiro.realm.CustomRealmMd5  
  11. customRealm.credentialsMatcher=$credentialsMatcher  
  12. #将Realm设置到securityManager  
  13. securityManager.realms=$customRealm  

测试代码同上，修改ini文件路径即可

shiro授权

授权有三个核心元素：权限、角色和用户。
shiro权限声明通常是使用冒号分隔的表达式，权限表达式示例如下：
user:view         可查询用户数据
user:view,edit  可查询或编辑用户数据
user:*或user    可对用户数据进行所有操作
user:edit:123   可编辑id为123的用户数据。
Shiro支持两种角色模式：
  1、传统角色：一个角色代表着一系列的操作，当需要对某一操作进行授权验证时，只需判断是否是该角色即可。这种角色权限相对简单、模糊，不利于扩展。 
2、权限角色：一个角色拥有一个权限的集合。授权验证时，需要判断当前角色是否拥有该权限。这种角色权限可以对该角色进行详细的权限描述，适合更复杂的权限设计。

shiro内部授权处理机制



1.在应用程序中调用授权验证方法(Subject的isPermitted*或hasRole*等)
2.Subject的实例通常是DelegatingSubject(或子类)的实例对象，在认证开始时，会委托应用程序设置的securityManager实例调用相应的isPermitted*或hasRole*方法。
3.接下来SecurityManager会委托内置的Authorizer的实例(默认是ModularRealmAuthorizer类的实例，类似于认证实例，它同样支持一个或多个Realm实例认证)调用相应的授权方法。
4.每一个Realm将检查是否实现了相同的Authorizer接口。然后，将调用Realm自己相应的授权验证方法。
注意：
当使用多个Realm时，不同于认证策略处理方式，在授权处理过程中：
(1) 当调用Realm出现异常时，将立即抛出异常，结束授权验证。
(2) 只要有一个Realm验证成功，那么将认为授权成功，立即返回，结束认证。
Shiro有3中认证策略的具体实现：
(1) AtLeastOneSuccessfulStrategy  只要有一个（或更多）的Realm验证成功，那么认证将被视为成功                       (2) FirstSuccessfulStrategy  第一个Realm验证成功，整体认证将被视为成功，且后续Realm将被忽略                         (3) AllSuccessfulStrategy  所有Realm成功，认证才视为成功

shiro授权流程


shiro授权方式

shiro支持三种方式的授权：编程式、注解式、标签式
方式一：编程式，通过写if/else授权代码块完成
Subject subject = SecurityUtils.getSubject();
if(subject.hasRole("admin")){
   //有权限
}else{
   // 无权限
}
方式二：注解式，通过在执行的Java方法上放置相应的注解完成。
@RequiresRoles("admin")
public void hello(){
   //有权限
}
方式三：JSP/GSP标签，页面通过相应的标签完成
<shiro:hasRole  name="admin">
  <!--  有权限   -->
</shiro:hasole>

授权测试

shiro-permission.ini

创建存放权限的配置文件shiro-permission.ini 如下：
[plain] view plain copy
print?
  1. #用户  
  2. [users]  
  3. #用户zhang的密码是123，此用户具有role1和role2两个角色  
  4. zhang=123,role1,role2  
  5. wang=123,role2  
  6.   
  7. #权限  
  8. [roles]  
  9. #角色role1对资源user拥有create、update权限  
  10. role1=user:create,user:update  
  11. #角色role2对资源user拥有create、delete权限  
  12. role2=user:create,user:delete  
  13. #role3对资源user拥有create权限  
  14. role3=user:create  
在ini文件中用户、角色、权限的配置规则是：
" 用户名=密码,角色1,角色2 .... "
“ 角色=权限1,权限2...... ”
首先根据用户名查找角色，再根据角色查找权限，角色是权限的集合

权限字符串规则

权限字符串的规则是：“资源标识符：操作：资源实例标识符”，意思是对哪个资源的哪个实例具有什么操作，“:”是资源/操作/实例的分割符，权限字符串也可以使用*通配符。
例子：
用户创建权限：user:create，或user:create:*
用户修改实例001的权限：user:update:001
用户实例001的所有权限：user：*：001  

权限测试代码

测试代码同认证代码，注意ini地址改为shiro-permission.ini，主要掌握其授权方法
注意：在用户认证通过后才能执行下边的授权
[java] view plain copy
print?
  1. // 角色授权、资源授权测试  
  2.     @Test  
  3.     public void testAuthorization() {  
  4.   
  5.         // 创建SecurityManager工厂  
  6.         Factory<SecurityManager> factory = new IniSecurityManagerFactory("classpath:shiro-permission.ini");  
  7.   
  8.         // 创建SecurityManager  
  9.         SecurityManager securityManager = factory.getInstance();  
  10.   
  11.         // 将SecurityManager设置到系统运行环境，和Spring整合后将SecurityManager配置在Spring容器中，一般单例管理  
  12.         SecurityUtils.setSecurityManager(securityManager);  
  13.   
  14.         // 创建subject  
  15.         Subject subject = SecurityUtils.getSubject();  
  16.   
  17.         // 创建token令牌  
  18.         UsernamePasswordToken token = new UsernamePasswordToken("zhangsan", "123");  
  19.   
  20.         // 执行认证  
  21.         try {  
  22.             subject.login(token);  
  23.         } catch (AuthenticationException e) {  
  24.             e.printStackTrace();  
  25.         }  
  26.   
  27.         System.out.println("认证状态：" + subject.isAuthenticated());  
  28.   
  29.         // 认证通过后执行授权  
  30.   
  31.         // 基于角色的授权  
  32.         // hasRole传入角色标识  
  33.         boolean ishasRole = subject.hasRole("role1");  
  34.         System.out.println("单个角色判断 " + ishasRole);  
  35.         // hasAllRoles 是否拥有多个角色  
  36.         boolean hasAllRoles = subject.hasAllRoles(Arrays.asList("role1", "role2", "role3"));  
  37.         System.out.println("多个角色判断 " + hasAllRoles);  
  38.           
  39.         //使用check方法进行授权，如果授权不通过会抛出异常,用于断言  
  40.         subject.checkRole("role2");  
  41.           
  42.         //基于资源的权限  
  43.         //isPermitted传入权限标识符  
  44.         boolean isPermitted = subject.isPermitted("user:create:1");  
  45.         System.out.println("单个权限判断 "+isPermitted);  
  46.           
  47.         boolean isPermittedAll = subject.isPermittedAll("user:create:1","user:delete");  
  48.         System.out.println("多个权限判断 "+isPermittedAll);  
  49.           
  50.         //使用check方法进行授权测试，如果授权不通过会抛出异常  
  51.         subject.checkPermission("item:delete");  
  52.     }  
使用check方法测试授权失败会抛出异常：org.apache.shiro.authz.UnauthorizedException

自定义Realm授权

上边的程序通过shiro-permission.ini对权限信息进行静态配置，实际开发中从数据库中获取权限数据。就需要自定义Realm，由Realm从数据库查询权限数据。Realm根据用户身份信息查询权限数据，将权限数据返回给authorizer(授权器)

自定义Realm授权代码

在原来自定义的Realm类中完善doGetAuthorizationInfo方法，此方法需要完成以下功能：根据用户身份信息从数据库中查询权限字符串，由shiro进行授权。
[java] view plain copy
print?
  1. // 用于授权  
  2.     @Override  
  3.     protected AuthorizationInfo doGetAuthorizationInfo(PrincipalCollection principals) {  
  4.   
  5.         //从principals获取身份信息  
  6.         //将getPrimaryPrincipal方法返回值转为真实类型  
  7.         //(在上边的doGetAuthenticationInfo认证通过后填充到SimpleAuthenticationInfo中身份类型)  
  8.         String userCode = (String) principals.getPrimaryPrincipal();  
  9.           
  10.         //根据身份信息从数据库中获取权限信息  
  11.         //模拟从数据库中取到的数据  
  12.         List<String>  permissions = new ArrayList<String>();  
  13.         permissions.add("user:create");//用户创建  
  14.         permissions.add("items:add");//商品添加权限  
  15.         //....  
  16.           
  17.         //查询到权限数据，返回授权信息(要包括上边的permissions)  
  18.         SimpleAuthorizationInfo simpleAuthorizationInfo = new SimpleAuthorizationInfo();  
  19.         //将上边查询到的授权信息填充到simpleAuthorizationInfo对象中  
  20.         simpleAuthorizationInfo.addStringPermissions(permissions);  
  21.           
  22.         return simpleAuthorizationInfo;  
  23.     }  

shiro-realm.ini

ini配置文件还使用认证阶段用的，不用改变(即在shiro-realm.ini中配置自定义realm，将realm设置到securityManager)。注意：shiro-realm是配置自定义的Realm，是从数据库中获取权限数据，所以不需要再配置[roles]了。
[plain] view plain copy
print?
  1. [main]  
  2. #自定义realm  
  3. customRealm=liuxun.test.shiro.realm.CustomRealm  
  4. #将realm设置到SecurityManager，相当于Spring中的注入  
  5. securityManager.realms=$customRealm  

测试代码

同上边的授权测试代码，注意ini地址为shiro-realm.ini

授权执行流程总结

1.对subject进行授权，调用isPermitted("permission串")
2.SecurityManager执行授权，通过ModularRealmAuthorizer执行授权
3.ModularRealmAuthorizer执行realm(自定义的CustomRealm)从数据库查询权限数据(调用realm的授权方法doGetAuthorizationInfo)
4.realm从数据库查询权限数据，返回给ModularRealmAuthorizer
5.ModularRealmAuthorizer调用PermissionResolver进行权限串比对
6.如果比对后，isPermitted中"permission串" 在realm查询到的权限数据中，说明用户访问permission串有权限，否则没有权限，抛出异常。

shiro认证和授权入门Demo

项目结构如下：


此Demo已经上传GitHub(https://github.com/LX1993728/permission_java_shiro)
其代码具体如下：
AuthenticationTest.java 测试认证
[java] view plain copy
print?
  1. package liuxun.test.shiro.authentication;  
  2.   
  3. import org.apache.shiro.SecurityUtils;  
  4. import org.apache.shiro.authc.AuthenticationException;  
  5. import org.apache.shiro.authc.UsernamePasswordToken;  
  6. import org.apache.shiro.config.IniSecurityManagerFactory;  
  7. import org.apache.shiro.mgt.SecurityManager;  
  8. import org.apache.shiro.subject.Subject;  
  9. import org.apache.shiro.util.Factory;  
  10. import org.junit.Test;  
  11.   
  12. /** 
  13.  * 认证测试 
  14.  *  
  15.  * @author liuxun 
  16.  * 
  17.  */  
  18. public class AuthenticationTest {  
  19.   
  20.     // 用户登录和退出  
  21.     @Test  
  22.     public void testLoginAndLogout() {  
  23.   
  24.         // 创建SecurityManager工厂。通过ini配置文件创建securityManager  
  25.         Factory<SecurityManager> factory = new IniSecurityManagerFactory("classpath:shiro-first.ini");  
  26.   
  27.         // 创建SecurityManager  
  28.         SecurityManager securityManager = factory.getInstance();  
  29.   
  30.         // 将securityManager设置到当前的运行环境中  
  31.         SecurityUtils.setSecurityManager(securityManager);  
  32.   
  33.         // 从SecurityUtils中创建一个subject  
  34.         Subject subject = SecurityUtils.getSubject();  
  35.   
  36.         // 在认证提交前准备token(令牌)  
  37.         // 这里的账号和密码 将来是由用户输入进去的  
  38.         UsernamePasswordToken token = new UsernamePasswordToken("zhangsan", "123456");  
  39.          
  40.         //执行认证提交  
  41.         try {  
  42.             //执行认证提交  
  43.             subject.login(token);  
  44.         } catch (AuthenticationException e) {  
  45.             e.printStackTrace();  
  46.         }  
  47.           
  48.         // 是否认证通过  
  49.         boolean isAuthenticated = subject.isAuthenticated();  
  50.         System.out.println("是否认证通过："+isAuthenticated);  
  51.           
  52.         //退出操作  
  53.         subject.logout();  
  54.           
  55.         // 是否认证通过  
  56.         isAuthenticated = subject.isAuthenticated();  
  57.         System.out.println("是否认证通过："+isAuthenticated);  
  58.     }  
  59.       
  60.     //自定义Realm  
  61.     @Test  
  62.     public void testCustomRealm() {  
  63.           
  64.         // 创建SecurityManager工厂。通过ini配置文件创建securityManager  
  65.         Factory<SecurityManager> factory = new IniSecurityManagerFactory("classpath:shiro-realm.ini");  
  66.           
  67.         // 创建SecurityManager  
  68.         SecurityManager securityManager = factory.getInstance();  
  69.           
  70.         // 将securityManager设置到当前的运行环境中  
  71.         SecurityUtils.setSecurityManager(securityManager);  
  72.           
  73.         // 从SecurityUtils中创建一个subject  
  74.         Subject subject = SecurityUtils.getSubject();  
  75.           
  76.         // 在认证提交前准备token(令牌)  
  77.         // 这里的账号和密码 将来是由用户输入进去的  
  78.         UsernamePasswordToken token = new UsernamePasswordToken("zhangsan", "123456");  
  79.           
  80.         //执行认证提交  
  81.         try {  
  82.             //执行认证提交  
  83.             subject.login(token);  
  84.         } catch (AuthenticationException e) {  
  85.             e.printStackTrace();  
  86.         }  
  87.           
  88.         // 是否认证通过  
  89.         boolean isAuthenticated = subject.isAuthenticated();  
  90.         System.out.println("是否认证通过："+isAuthenticated);  
  91.           
  92.     }  
  93.     //自定义Realm实现散列值匹配  
  94.     @Test  
  95.     public void testCustomRealmMd5() {  
  96.           
  97.         // 创建SecurityManager工厂。通过ini配置文件创建securityManager  
  98.         Factory<SecurityManager> factory = new IniSecurityManagerFactory("classpath:shiro-realm-md5.ini");  
  99.           
  100.         // 创建SecurityManager  
  101.         SecurityManager securityManager = factory.getInstance();  
  102.           
  103.         // 将securityManager设置到当前的运行环境中  
  104.         SecurityUtils.setSecurityManager(securityManager);  
  105.           
  106.         // 从SecurityUtils中创建一个subject  
  107.         Subject subject = SecurityUtils.getSubject();  
  108.           
  109.         // 在认证提交前准备token(令牌)  
  110.         // 这里的账号和密码 将来是由用户输入进去的  
  111.         UsernamePasswordToken token = new UsernamePasswordToken("zhangsan", "123456");  
  112.           
  113.         //执行认证提交  
  114.         try {  
  115.             //执行认证提交  
  116.             subject.login(token);  
  117.         } catch (AuthenticationException e) {  
  118.             e.printStackTrace();  
  119.         }  
  120.           
  121.         // 是否认证通过  
  122.         boolean isAuthenticated = subject.isAuthenticated();  
  123.         System.out.println("是否认证通过："+isAuthenticated);  
  124.           
  125.     }  
  126. }  
MD5Test.java  测试shiro散列算法
[java] view plain copy
print?
  1. package liuxun.test.shiro.authentication;  
  2.   
  3. import org.apache.shiro.crypto.hash.Md5Hash;  
  4. import org.apache.shiro.crypto.hash.SimpleHash;  
  5.   
  6. public class MD5Test {  
  7.     public static void main(String[] args) {  
  8.         //原始密码  
  9.         String source = "123456";  
  10.         //盐  
  11.         String salt = "qwerty";  
  12.         //散列次数  
  13.         int hashIterations = 2;  
  14.         //上边散列1次：48474f975022f960bc2afbe49be581e8  
  15.         //上边散列2次：13f79dafcbbedc313273e2b891ac84d3  
  16.           
  17.         //构造方法中：  
  18.         //第一个参数：明文，原始密码  
  19.         //第二个参数：盐，通过使用随机字符串  
  20.         //第三个参数：散列的次数，比如散列两次，相当于md5(md5(''))  
  21.         Md5Hash md5Hash = new Md5Hash(source, salt, hashIterations);  
  22.           
  23.         String password_md5 = md5Hash.toString();  
  24.         System.out.println(password_md5);  
  25.           
  26.         //使用后SimpleHash  
  27.         //第一个参数：散列算法  
  28.         SimpleHash simpleHash = new SimpleHash("md5", source, salt, hashIterations);  
  29.         System.out.println(simpleHash.toString());  
  30.     }  
  31. }  
AuthorizationTest  测试授权
[java] view plain copy
print?
  1. package liuxun.test.shiro.authorization;  
  2.   
  3. import java.util.Arrays;  
  4.   
  5. import org.apache.shiro.SecurityUtils;  
  6. import org.apache.shiro.authc.AuthenticationException;  
  7. import org.apache.shiro.authc.UsernamePasswordToken;  
  8. import org.apache.shiro.config.IniSecurityManagerFactory;  
  9. import org.apache.shiro.mgt.SecurityManager;  
  10. import org.apache.shiro.subject.Subject;  
  11. import org.apache.shiro.util.Factory;  
  12. import org.junit.Test;  
  13.   
  14. /** 
  15.  * 授权测试 
  16.  *  
  17.  * @author liuxun 
  18.  * 
  19.  */  
  20. public class AuthorizationTest {  
  21.   
  22.     // 角色授权、资源授权测试  
  23.     @Test  
  24.     public void testAuthorization() {  
  25.   
  26.         // 创建SecurityManager工厂  
  27.         Factory<SecurityManager> factory = new IniSecurityManagerFactory("classpath:shiro-permission.ini");  
  28.   
  29.         // 创建SecurityManager  
  30.         SecurityManager securityManager = factory.getInstance();  
  31.   
  32.         // 将SecurityManager设置到系统运行环境，和Spring整合后将SecurityManager配置在Spring容器中，一般单例管理  
  33.         SecurityUtils.setSecurityManager(securityManager);  
  34.   
  35.         // 创建subject  
  36.         Subject subject = SecurityUtils.getSubject();  
  37.   
  38.         // 创建token令牌  
  39.         UsernamePasswordToken token = new UsernamePasswordToken("zhangsan", "123");  
  40.   
  41.         // 执行认证  
  42.         try {  
  43.             subject.login(token);  
  44.         } catch (AuthenticationException e) {  
  45.             e.printStackTrace();  
  46.         }  
  47.   
  48.         System.out.println("认证状态：" + subject.isAuthenticated());  
  49.   
  50.         // 认证通过后执行授权  
  51.   
  52.         // 基于角色的授权  
  53.         // hasRole传入角色标识  
  54.         boolean ishasRole = subject.hasRole("role1");  
  55.         System.out.println("单个角色判断 " + ishasRole);  
  56.         // hasAllRoles 是否拥有多个角色  
  57.         boolean hasAllRoles = subject.hasAllRoles(Arrays.asList("role1", "role2", "role3"));  
  58.         System.out.println("多个角色判断 " + hasAllRoles);  
  59.   
  60.         // 使用check方法进行授权，如果授权不通过会抛出异常,用于断言  
  61.         subject.checkRole("role2");  
  62.   
  63.         // 基于资源的权限  
  64.         // isPermitted传入权限标识符  
  65.         boolean isPermitted = subject.isPermitted("user:create:1");  
  66.         System.out.println("单个权限判断 " + isPermitted);  
  67.   
  68.         boolean isPermittedAll = subject.isPermittedAll("user:create:1", "user:delete");  
  69.         System.out.println("多个权限判断 " + isPermittedAll);  
  70.   
  71.         // 使用check方法进行授权测试，如果授权不通过会抛出异常  
  72.         subject.checkPermission("item:delete");  
  73.     }  
  74.   
  75.     // 自定义Realm进行资源授权测试  
  76.     @Test  
  77.     public void testAuthorizationCustomRealm() {  
  78.   
  79.         // 创建SecurityManager工厂  
  80.         Factory<SecurityManager> factory = new IniSecurityManagerFactory("classpath:shiro-realm.ini");  
  81.   
  82.         // 创建SecurityManager  
  83.         SecurityManager securityManager = factory.getInstance();  
  84.   
  85.         // 将SecurityManager设置到系统运行环境，和Spring整合后将SecurityManager配置在Spring容器中，一般单例管理  
  86.         SecurityUtils.setSecurityManager(securityManager);  
  87.   
  88.         // 创建subject  
  89.         Subject subject = SecurityUtils.getSubject();  
  90.   
  91.         // 创建token令牌  
  92.         UsernamePasswordToken token = new UsernamePasswordToken("zhangsan", "123");  
  93.   
  94.         // 执行认证  
  95.         try {  
  96.             subject.login(token);  
  97.         } catch (AuthenticationException e) {  
  98.             e.printStackTrace();  
  99.         }  
  100.   
  101.         System.out.println("认证状态：" + subject.isAuthenticated());  
  102.   
  103.         // 认证通过后执行授权  
  104.   
  105.         // 基于资源的授权，调用isPermitted方法会调用CustomRealm从数据库中查询正确权限数据  
  106.         // isPermitted传入权限标识符，判断user:create:1是否在CustomRealm查询到的权限数据之内  
  107.         boolean isPermitted = subject.isPermitted("user:create:1");  
  108.         System.out.println("单个权限判断 " + isPermitted);  
  109.   
  110.         boolean isPermittedAll = subject.isPermittedAll("user:create:1", "user:delete");  
  111.         System.out.println("多个权限判断 " + isPermittedAll);  
  112.   
  113.         // 使用check方法进行授权测试，如果授权不通过会抛出异常  
  114.         subject.checkPermission("item:add:1");  
  115.     }  
  116.   
  117. }  
CustomRealm.java  自定义Realm
[java] view plain copy
print?
  1. package liuxun.test.shiro.realm;  
  2.   
  3. import java.util.ArrayList;  
  4. import java.util.List;  
  5.   
  6. import org.apache.shiro.authc.AuthenticationException;  
  7. import org.apache.shiro.authc.AuthenticationInfo;  
  8. import org.apache.shiro.authc.AuthenticationToken;  
  9. import org.apache.shiro.authc.SimpleAuthenticationInfo;  
  10. import org.apache.shiro.authc.UsernamePasswordToken;  
  11. import org.apache.shiro.authz.AuthorizationInfo;  
  12. import org.apache.shiro.authz.SimpleAuthorizationInfo;  
  13. import org.apache.shiro.realm.AuthorizingRealm;  
  14. import org.apache.shiro.subject.PrincipalCollection;  
  15.   
  16. public class CustomRealm extends AuthorizingRealm {  
  17.     // 设置Realm的名称  
  18.     @Override  
  19.     public String getName() {  
  20.         return "CustomRealm";  
  21.     }  
  22.   
  23.     // 支持UsernamePasswordToken  
  24.     @Override  
  25.     public boolean supports(AuthenticationToken token) {  
  26.         return token instanceof UsernamePasswordToken;  
  27.     }  
  28.   
  29.     // 用于认证  
  30.     @Override  
  31.     protected AuthenticationInfo doGetAuthenticationInfo(AuthenticationToken token) throws AuthenticationException {  
  32.   
  33.         // token是用户输入的  
  34.         // 第一步从token中取出身份信息  
  35.         String usercode = (String) token.getPrincipal();  
  36.   
  37.         // 第二步：根据用户输入的usercode从数据库查询  
  38.         // ......  
  39.   
  40.         // 如果查询不到返回null  
  41.         // 数据库中用户账号是zhangsan  
  42.         if (!usercode.equals("zhangsan")) {  
  43.             return null;  
  44.         }  
  45.   
  46.         // 模拟从数据库中查询到密码  
  47.         String password = "123456";  
  48.   
  49.         // 如果查询到返回认证信息AuthenticationInfo  
  50.         SimpleAuthenticationInfo simpleAuthenticationInfo = new SimpleAuthenticationInfo(usercode, password,  
  51.                 this.getName());  
  52.   
  53.         return simpleAuthenticationInfo;  
  54.     }  
  55.   
  56.     // 用于授权  
  57.     @Override  
  58.     protected AuthorizationInfo doGetAuthorizationInfo(PrincipalCollection principals) {  
  59.   
  60.         //从principals获取身份信息  
  61.         //将getPrimaryPrincipal方法返回值转为真实类型  
  62.         //(在上边的doGetAuthenticationInfo认证通过后填充到SimpleAuthenticationInfo中身份类型)  
  63.         String userCode = (String) principals.getPrimaryPrincipal();  
  64.           
  65.         //根据身份信息从数据库中获取权限信息  
  66.         //模拟从数据库中取到的数据  
  67.         List<String>  permissions = new ArrayList<String>();  
  68.         permissions.add("user:create");//用户创建  
  69.         permissions.add("items:add");//商品添加权限  
  70.         //....  
  71.           
  72.         //查询到权限数据，返回授权信息(要包括上边的permissions)  
  73.         SimpleAuthorizationInfo simpleAuthorizationInfo = new SimpleAuthorizationInfo();  
  74.         //将上边查询到的授权信息填充到simpleAuthorizationInfo对象中  
  75.         simpleAuthorizationInfo.addStringPermissions(permissions);  
  76.           
  77.         return simpleAuthorizationInfo;  
  78.     }  
  79. }  
CustomRealmMd5.java  自定义Realm处理散列算法
[java] view plain copy
print?
  1. package liuxun.test.shiro.realm;  
  2.   
  3. import org.apache.shiro.authc.AuthenticationException;  
  4. import org.apache.shiro.authc.AuthenticationInfo;  
  5. import org.apache.shiro.authc.AuthenticationToken;  
  6. import org.apache.shiro.authc.SimpleAuthenticationInfo;  
  7. import org.apache.shiro.authc.UsernamePasswordToken;  
  8. import org.apache.shiro.authz.AuthorizationInfo;  
  9. import org.apache.shiro.realm.AuthorizingRealm;  
  10. import org.apache.shiro.subject.PrincipalCollection;  
  11. import org.apache.shiro.util.ByteSource;  
  12.   
  13. public class CustomRealmMd5 extends AuthorizingRealm {  
  14.     // 设置Realm名称  
  15.     @Override  
  16.     public void setName(String name) {  
  17.         super.setName("CustomRealmMd5");  
  18.     }  
  19.   
  20.     // 支持UsernamePasswordToken  
  21.     @Override  
  22.     public boolean supports(AuthenticationToken token) {  
  23.         return token instanceof UsernamePasswordToken;  
  24.     }  
  25.   
  26.     // 用于认证  
  27.     @Override  
  28.     protected AuthenticationInfo doGetAuthenticationInfo(AuthenticationToken token) throws AuthenticationException {  
  29.   
  30.         // token保存了用户输入的身份信息userName和password  
  31.         // 第一步：从token中取出身份信息  
  32.         String userCode = (String) token.getPrincipal();  
  33.   
  34.         // 第二步：根据用户输入的userCode从数据库查询  
  35.         // ....  
  36.         // 如果查询不到返回null 假设用户输入的账号是zhansgan  
  37.         // 模拟从数据库中查询账号是zhangsan的用户  
  38.         if (!userCode.equals("zhangsan")) {  
  39.             return null;  
  40.         }  
  41.   
  42.         // 模拟从数据库中查询到密码(散列值)  
  43.         // 按照固定规则加密的结果，此密码是在数据库中存储的，原始密码是123456 盐是qwerty  
  44.         String password = "48474f975022f960bc2afbe49be581e8";  
  45.         // 盐，随机字符串，此随机字符串也是在数据库中存储的,模拟从数据库中获取  
  46.         String salt = "qwerty";  
  47.   
  48.         // 如果查询到则返回认证信息AuthenticationInfo  
  49.         SimpleAuthenticationInfo simpleAuthenticationInfo = new SimpleAuthenticationInfo(userCode, password,  
  50.                 ByteSource.Util.bytes(salt), this.getName());  
  51.           
  52.         return simpleAuthenticationInfo;  
  53.     }  
  54.   
  55.     // 用于授权  
  56.     @Override  
  57.     protected AuthorizationInfo doGetAuthorizationInfo(PrincipalCollection principals) {  
  58.         return null;  
  59.     }  
  60.   
  61. }  
log4j.properties
[plain] view plain copy
print?
  1. log4j.rootLogger=debug, stdout  
  2.   
  3. log4j.appender.stdout=org.apache.log4j.ConsoleAppender  
  4. log4j.appender.stdout.layout=org.apache.log4j.PatternLayout  
  5. log4j.appender.stdout.layout.ConversionPattern=%d %p [%c] - %m %n  
shiro-first.ini  用于用户身份信息从配置文件中取
[plain] view plain copy
print?
  1. #对用户信息进行配置  
  2. [users]  
  3. #用户账号和密码  
  4. zhangsan=123456  
  5. lisi=654321  
shiro-permission.ini  用于用户权限和身份信息从配置文件中取
[plain] view plain copy
print?
  1. #用户  
  2. [users]  
  3. #用户zhang的密码是123，此用户具有role1和role2两个角色  
  4. zhangsan=123,role1,role2  
  5. wang=123,role2  
  6.   
  7. #权限  
  8. [roles]  
  9. #角色role1对资源user拥有create、update权限  
  10. role1=user:create,user:update  
  11. #角色role2对资源user拥有create、delete权限  
  12. role2=user:create,user:delete  
  13. #role3对资源user拥有create权限  
  14. role3=user:create  
shiro-realm.ini  用于配置自定义Realm 从数据库中获取身份和权限以及角色信息
[plain] view plain copy
print?
  1. [main]  
  2. #自定义realm  
  3. customRealm=liuxun.test.shiro.realm.CustomRealm  
  4. #将realm设置到SecurityManager，相当于Spring中的注入  
  5. securityManager.realms=$customRealm  
shiro-realm-md5.ini 用于配置自定义Realm 从数据库中获取身份和权限以及角色信息 以及散列配置
[plain] view plain copy
print?
  1. [main]  
  2. #定义凭证匹配器  
  3. credentialsMatcher=org.apache.shiro.authc.credential.HashedCredentialsMatcher  
  4. #散列算法  
  5. credentialsMatcher.hashAlgorithmName=md5  
  6. #散列次数  
  7. credentialsMatcher.hashIterations=1  
  8.   
  9. #将凭证匹配器设置到Realm  
  10. customRealm=liuxun.test.shiro.realm.CustomRealmMd5  
  11. customRealm.credentialsMatcher=$credentialsMatcher  
  12. #将Realm设置到securityManager  
  13. securityManager.realms=$customRealm  
阅读全文
0 0
数据的存储过程 数据的存储过程
原创粉丝点击
热门IT博客
全知视角全知视角
广州亚信数据有限公司广州亚信数据有限公司
淘宝小y代购levis真吗
淘宝万圣节男孩童服装
win10安装2000数据库
php正则表达式邮箱详解
社交网络观后感500字
知止而定
mac os怎么安装软件
狐谓狼曰羊肉其鲜乎ppt
java 语法解析器
淘宝广告法投诉处理
重庆商品房交易数据
火狐 谷歌 知乎
简述java异常处理机制
足球周刊淘宝店的网址
剑网3数据互通查询
htri换热软件
ios音乐软件海外
东方财富软件快捷键
热门问题 老师的惩罚 人脸识别 我在镇武司摸鱼那些年 重生之率土为王 我在大康的咸鱼生活 盘龙之生命进化 天生仙种 凡人之先天五行 春回大明朝 姑娘不必设防，我是瞎子 妇女卫生带 美丽妇女 妇女痛经丸 妇女英文 妇女新知 妇女树林不湛入目图片 国产中年妇女拍拍拍 睡30岁已婚妇女水特别多 妇女躺在树林里卖 毒妇女配求生存 妇女树林不湛入目视 老人树林弄妇女图片 老年妇女的松紧 留守妇女公爹睡 中年妇女赤体照片 妇女是什么意思 中年妇女痛经怎么办 农村妇女创业 妇女上环疼吗 纳米银妇女外用抗菌凝胶 妇女盆腔炎的症状 妇女全身检查 布列根和妇女医院 妇女什么时候绝经 妇女月经推迟的原因 妇女月经量少是什么原因 妇女绝经年龄 纳米银妇女外用抗菌器 妇女干部学校 妇女用品有哪些 我与留守妇女 中国孕妇 funv 少年满足留守妇女 结扎输卵管的妇女 40岁至50岁中年妇女发型 妇好 农门悍妇好霸道 妇好简介 百草妇炎清栓效果好吗 悍妇当家娶个相公好种田

程序博客网，程序员的互联网技术博客家园。csdn论坛精品 msdn技术资料都在这里