浏览了许多发现这篇写的不错，比较详细：参考文档，其中我觉得原理图，这个可能更清楚一些。整理以下：
1，授权：给身份认证通过的人，授予他可以访问某些资源的权限。
2，权限粒度：分为粗粒度和细粒度。
粗粒度：例如对 user 的 crud，也就是通常所说的对表的操作。
细粒度：对表中记录的操作。如 只允许查询id为1的user的工资。Shiro一般管理的是粗粒度的权限。比如，菜单，按钮，url。一般细粒度的权限是通过业务来控制的。
3，角色：权限的集合。
角色有两个概念：
隐式角色，好像就是说传统的基于角色的访问控制。但是如果想添加或删除一个角色，或者重新定义一个角色的行为，需要修改大量代码，维护麻烦。
显式角色，基于资源的访问控制。
Shiro 团队提倡使用权限和显式角色，两者区别看这个家伙的文章：rbac新解
4，权限表示规则：资源：操作：实例。可以用通配符表示。
如：user:add 表示对user有添加的权限；user:* 表示对user有所有操作的权限；user:delete:100表示对user标识为100的记录有删除的权限。
5，shiro中的权限流程：
=======================================================================
6，例子程序：
（认证使用ini配置）
新建maven项目，项目结构：
maven配置：
<dependencies>
<dependency>
<groupId>org.apache.shiro</groupId>
<artifactId>shiro-core</artifactId>
<version>1.3.2</version>
</dependency>
<dependency>
<groupId>commons-logging</groupId>
<artifactId>commons-logging</artifactId>
<version>1.2</version>
</dependency>
<dependency>
<groupId>log4j</groupId>
<artifactId>log4j</artifactId>
<version>1.2.17</version>
</dependency>
<dependency>
<groupId>org.slf4j</groupId>
<artifactId>slf4j-log4j12</artifactId>
<version>1.7.5</version>
</dependency>
</dependencies> log4j:
log4j.rootLogger=info, stdout log4j.appender.stdout=org.apache.log4j.ConsoleAppender log4j.appender.stdout.layout=org.apache.log4j.PatternLayout log4j.appender.stdout.layout.ConversionPattern=%d %p [%c] - %m %n
shiro.ini配置：
定义了两个用户： zhangsan/1111，lisi/1111,两个角色：role1，role2，role1有对user的add、update、delete权限，role2有对user的所有权限
[users] zhangsan=1111,role1 lisi=1111,role2 [roles] role1=user:add,user:update,user:delete role2=user:*
测试代码：
package com.lhy.shiro;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.HashSet;
import java.util.Set;
import org.apache.shiro.SecurityUtils;
import org.apache.shiro.authc.IncorrectCredentialsException;
import org.apache.shiro.authc.UnknownAccountException;
import org.apache.shiro.authc.UsernamePasswordToken;
import org.apache.shiro.authz.Permission;
import org.apache.shiro.config.IniSecurityManagerFactory;
import org.apache.shiro.mgt.SecurityManager;
import org.apache.shiro.subject.Subject;
import org.apache.shiro.util.Factory;
public class AuthorizationDemo {
public static void main(String[] args) {
//1,创建SecurityManager工厂 读取shiro配置文件
Factory<SecurityManager> factory = new IniSecurityManagerFactory("classpath:shiro.ini");
//2 通过securityManager工厂获取SecurityManager实例
SecurityManager securityManager = factory.getInstance();
//3 将SecurityManager 对象设置到运行环境
SecurityUtils.setSecurityManager(securityManager);
//4 通过SecurityUtils获取主体subject
Subject subject = SecurityUtils.getSubject();
try {
//5.假设登录名是zhangsan 密码是1111
UsernamePasswordToken token = new UsernamePasswordToken("zhangsan","1111");
//6，登录，进行用户身验证
subject.login(token);
//通过subject判断用户是否通过验证
if(subject.isAuthenticated()){
System.out.println("用户登录成功！");
}
} catch (UnknownAccountException e) {
e.printStackTrace();
System.out.println("用户名或密码错误！");
}catch (IncorrectCredentialsException e) {
System.out.println("用户名或密码错误！");
}
//****************基于【角色】的授权 *********************
//hasRole判断一个权限
boolean flag = subject.hasRole("role1");
System.out.println(flag);
/**
* hasAllRoles:判断是否有给定的【全部角色】
* 参数类型：Collection<String>
* 返回 boolean
*/
flag = subject.hasAllRoles(Arrays.asList("role1","role2","role3"));
System.out.println("授权-hasAllRoles方法-是否有 role1,role2，role3全部角色---"+flag);
/**
* hasRoles方法，逐个判断有给定【角色中的哪些】，返回boolean[]
* 参数类型：List<String>
*/
boolean[] flags = subject.hasRoles(Arrays.asList("role1","role2"));
for (int i = 0; i < flags.length; i++) {
System.out.println("授权--hasRoles--判断有给定角色中的哪些："+flags[i]);
}
/**
* hasRole 方法没有权限会返回false，不会抛异常，checkRole方法会抛异常
* 检查权限，没有相应角色会抛异常UnauthorizedException
*/
//检查一个权限
subject.checkRole("role2");
/**
* 检查多个权限
* 参数类型：1，可变参数String... ，2, Collection<String>
*/
subject.checkRoles("role1","role2");
subject.checkRoles(Arrays.asList("role1","role2"));
//****************基于【资源】的授权 *********************
//isPermitted：判断单个权限：
boolean permitted = subject.isPermitted("user:add");
System.out.println("基于资源的权限--subject是否有-user:add权限-"+permitted);
/**
* isPermitted:判断是否有多个角色中的某些
* 参数类型：String... 可变参数
* 返回：boolean[]
*/
flags = subject.isPermitted("user:add","user:update","user:read");
for (int i = 0; i < flags.length; i++) {
System.out.println(flags[i]);
}
/**
* isPermittedAll:判断是否有给定的【全部权限】
* 参数类型：String... permissions可变参数
* 返回：boolean
*/
flag = subject.isPermittedAll("user:add","user:update");
System.out.println(flag);
/**
* 判断一个权限，会抛异常UnauthorizedException
*/
subject.checkPermission("user:read");
/**
* 判断多个权限：checkPermissions
* 参数类型：String... permissions
*/
subject.checkPermissions("user:add","user:update");
//7 退出
subject.logout();
}
}
shiro中的权限检查有三种方式：
a)编程式：
if(subject.hasRole("管理员")){ //操作某个资源 }
b)注解式：
@RequiresRoles("管理员")
public void list(){
//查询数据
}
c) 标签式：
<shiro:hasPermission name="user:update">
<a href="#">更新</a>
</shiro>
授权流程：
查看subject.isPermitted 源代码：
其实调用的是DelegatingSubject类的isPermitted，DelegatingSubject 又交给了securityManager
ctrl+t,查看类关系，可知，securityManager是SecurityManager接口的实现类DefaultSecurityManager，而DefaultSecurityManager类继承了好多个父类
具体的是DefaultSecurityManager的父类 AuthorizingSecurityManager里有个Authorizer，
其具体调用的是ModularRealmAuthorizer 的方法，最终交给了realm
ModularRealmAuthorizer中有一个PermissionResolver，ctro+t 查看该Realm：它其实调用的是AuthorizingRealm，
而AuthorizingRealm里，有PermissionResolver，而实际调用的是其实现类 WildcardPermissionResolver
查看WildcardPermission：里边出现了熟悉的字符：就是来解析 shiro的权限的字符的。
总结：
a) 获取subject主体
b)判断主体是否通过认证
c)调用subject.isPermitted*/hasRole*进行授权的判断
i）subject是由其实现类DelegatingSubject 来调用方法的，该类将处理交给了SecurityManager。
ii)securityManager 是由其实现类 DefaultSecurityManager 来进行处理的，该类的isPermitted 来处理，其本质是父类AuthorizingSecurityManager来处理的。该类将处理交给了authorizer（授权器）
iii）Authorizer 由其实现类 ModularRealmAuthorizer 来处理，该类可以调用对应的Realm来获取数据，在该类有PermissionResolver 对权限字符串进行解析，在对应的Realm中也有对应的 PermissionResolver 交给 WildcardPermissionResolver 该类调用WildPermission 来进行权限字符串的解析。
iv) 返回处理结果