权限控制可以描述为：“谁”对“什么”进行什么”操作"。通过权限控制，我们可以有效控制用户的行为操作，进而做到对资源的有效保护。
一、SHIRO授权示例
shiro支持两种两种访问控制方式，分别为：基于角色的访问控制、基于资源的访问控制。
基于角色的访问控制:
Subject subject = SecurityUtils.getSubject();
subject.hasRole("tole1");
subject.hasAllRoles("role1","role2");
基于资源的访问控制:
Subject subject = SecurityUtils.getSubject();
subject.isPermitted("user:create");
subject.isPermittedAll("user:update","user:delete");
下面本文将对shiro的内部授权逻辑过程进行详细分析。
二、SHIRO授权过程
“基于角色的访问控制逻辑”和“基于资源的访问控制逻辑”内部过程基本是一样的，因此本文分析只分析下“基于资源的访问控制逻辑”的过程。
使用者调用Subject.isPermitted方法进行授权，isPermitted接口实现是在DelegatingSubject中，代码如下：
public class DelegatingSubject implements Subject {
public boolean isPermitted(String permission) {
return hasPrincipals() && securityManager.isPermitted(getPrincipals(), permission);
}
public boolean isPermitted(Permission permission) {
return hasPrincipals() && securityManager.isPermitted(getPrincipals(), permission);
}
public boolean[] isPermitted(String... permissions) {
if (hasPrincipals()) {
return securityManager.isPermitted(getPrincipals(), permissions);
} else {
return new boolean[permissions.length];
}
}
...
}
从代码可以发现，DelegatingSubject又委托给了SecurityManager，调用SecurityManager中的isPermitted方法。下面看看SecurityManager的授权处理。
首先看看shiro核心逻辑类图。
SecurityManager其实是一个代理，SecurityManager代理了Authorizer，SecurityManager子类AuthorizingSecuritymanager为具体代理子类，看看类中相应方法定义：
public boolean isPermitted(PrincipalCollection principals, String permissionString) {
return this.authorizer.isPermitted(principals, permissionString);
}
public boolean isPermitted(PrincipalCollection principals, Permission permission) {
return this.authorizer.isPermitted(principals, permission);
}
public boolean[] isPermitted(PrincipalCollection principals, String... permissions) {
return this.authorizer.isPermitted(principals, permissions);
}
...
确实是代理模式，类中真正校验是Authorizer做的，具体Authorizer为ModularRealmAuthorizer，ModularRealmAuthorizer中方法定义如下：
public boolean isPermitted(PrincipalCollection principals, String permission) {
assertRealmsConfigured();
for (Realm realm : getRealms()) {
if (!(realm instanceof Authorizer)) continue;
if (((Authorizer) realm).isPermitted(principals, permission)) {
return true;
}
}
return false;
}
public boolean isPermitted(PrincipalCollection principals, Permission permission) {
assertRealmsConfigured();
for (Realm realm : getRealms()) {
if (!(realm instanceof Authorizer)) continue;
if (((Authorizer) realm).isPermitted(principals, permission)) {
return true;
}
}
return false;
}
从上面代码又可以看出，ModularRealmAuthorizer又把校验的工作交给了Realm,授权的Realm为AuthorizingRealm，AuthorizingRealm中实现了isPermitted方法，方法定义如下：
public boolean isPermitted(PrincipalCollection principals, String permission) {
Permission p = getPermissionResolver().resolvePermission(permission);
return isPermitted(principals, p);
}
public boolean isPermitted(PrincipalCollection principals, Permission permission) {
AuthorizationInfo info = getAuthorizationInfo(principals);
return isPermitted(permission, info);
}
如果是字符串Permission，首先要进行处理，处理过程如下：
PermissionResolver对字符串权限进行转化处理，其继承类为WildcardPermissionResolver.
List<String> parts = CollectionUtils.asList(wildcardString.split(PART_DIVIDER_TOKEN));
上面这句代码首先将权限按 " : "进行分割成数组。然后对这个数组中的每个元素再按照 ”，“ 分割。
Set<String> subparts = CollectionUtils.asSet(part.split(SUBPART_DIVIDER_TOKEN));
最终返回形式为List<Set<String>>。
那么转化后怎么用了，看看WildcardPermission的继承关系：
public class WildcardPermission implements Permission, Serializable{
......
}
而Permission的定义如下：
public interface Permission {
boolean implies(Permission p);
}
WildcardPermission的implices方法实现如下：
public boolean implies(Permission p) {
if (!(p instanceof WildcardPermission)) {
return false;
}
WildcardPermission wp = (WildcardPermission) p;
List<Set<String>> otherParts = wp.getParts();
int i = 0;
for (Set<String> otherPart : otherParts) {
if (getParts().size() - 1 < i) {
return true;
} else {
Set<String> part = getParts().get(i);
if (!part.contains(WILDCARD_TOKEN) && !part.containsAll(otherPart)) {
return false;
}
i++;
}
}
// If this permission has more parts than the other parts, only imply it if all of the other parts are wildcards
for (; i < getParts().size(); i++) {
Set<String> part = getParts().get(i);
if (!part.contains(WILDCARD_TOKEN)) {
return false;
}
}
return true;
}
这个代码的意思就是instance的权限是否包含目标权限，如果包含，那么就鉴权成功，返回True，否则鉴权不通过，这样就完成了权限校验。
我们需要自定义授权逻辑时，继承AuthorizingRealm，然后自定义实现其授权方法即可！
三、总结
总结一下，权限校验流程如下：
具体流程为：
1）首先调用Subject.isPermitted/hasRole接口，其会委托给SecurityManager，而SecurityManager接着会委托给Authorizer(SecurityManager继承了Authorizer接口，其真正业务逻辑还是委托给相应的Authorizer实例。ModularRealmAuthenticator是Authenticator的一个实现类，一般主要用这个实现类)。
2）Authorizer是真正的授权者，如果我们调用如isPermitted(“user:view”)，其首先会通过PermissionResolver把字符串转换成相应的Permission实例；
3）在进行授权之前，其会调用相应的Realm获取Subject相应的角色/权限用于匹配传入的角色/权限；
4）Authorizer会判断Realm的角色/权限是否和传入的匹配，如果有多个Realm，会委托给ModularRealmAuthorizer进行循环判断，如果匹配如isPermitted/hasRole会返回true，否则返回false表示授权失败。
一般是使用Realm进行授权，此时继承AuthorizingRealm，其流程是：
1.如果调用hasRole，则直接获取AuthorizationInfo.getRoles()与传入的角色比较即可；
2、如果调用isPermitted(“user:view”)，首先通过PermissionResolver将权限字符串转换成相应的Permission实例，默认使用WildcardPermissionResolver，即转换为通配符的WildcardPermission；
3、通过AuthorizationInfo.getObjectPermissions()得到Permission实例集合；通过AuthorizationInfo. getStringPermissions()得到字符串集合并通过PermissionResolver解析为Permission实例；然后获取用户的角色，并通过RolePermissionResolver解析角色对应的权限集合（默认没有实现，可以自己提供）；
4、接着调用Permission. implies(Permission p)逐个与传入的权限比较，如果有匹配的则返回true，否则false。
ModularRealmAuthorizer进行多Realm匹配流程：
1）首先检查相应的Realm是否实现了实现了Authorizer；
2）如果实现了Authorizer，那么接着调用其相应的isPermitted/hasRole接口进行匹配；
3）如果有一个Realm匹配那么将返回true，否则返回false。
SHIRO授权分析到此为止，祝工作顺利，天天开心！
