原文地址：https://www.jianshu.com/p/35b89d5502b8?from=singlemessage
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授权过程
“基于角色的访问控制逻辑”和“基于资源的访问控制逻辑”内部过程基本是一样的
使用者调用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方法。
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-MzyOckIT-1618564414405)(E:\笔记整合\shiro\shiro核心逻辑类.png)]
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.
//追溯源码 WildcardPermission中的setParts(String wildcardString, boolean caseSensitive)方法中
// protected static final String PART_DIVIDER_TOKEN = ":";
List<String> parts = CollectionUtils.asList(wildcardString.split(PART_DIVIDER_TOKEN));
上面这句代码首先将权限按 " : "进行分割成数组。然后对这个数组中的每个元素再按照 ”，“ 分割。
// protected static final String SUBPART_DIVIDER_TOKEN = ",";
Set<String> subparts = CollectionUtils.asSet(part.split(SUBPART_DIVIDER_TOKEN));
最终返回形式为List<Set>
那么转化后怎么用了，看看WildcardPermission的继承关系：
public class WildcardPermission implements Permission, Serializable{
......
}
而Permission的定义如下：
public interface Permission {
boolean implies(Permission p);
}
WildcardPermission的implices方法实现如下：
public boolean implies(Permission p) {
// By default only supports comparisons with other WildcardPermissions
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 this permission has less parts than the other permission, everything after the number of parts contained
// in this permission is automatically implied, so return true
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，然后自定义实现其授权方法即可！
总结
权限校验流程如下：
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-wU0uMVpO-1618564414407)(E:\笔记整合\shiro\权限校验流程如下.webp)]
具体流程为：
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。
相关注解
@RequiresPermissions
//只有当用户拥有这个system:dept:view字符串时才能访问此方法。那怎么知道用户拥有这个字符串呢？
//必须自己定义一个方法继承抽象方法 org.apache.shiro.realm.AuthorizingRealm
// 实现其抽象类doGetAuthorizationInfo方法即可；这样框架就会取到用户权限列表
@RequiresPermissions("system:dept:view")
@GetMapping()
public String dept()
{
return prefix + "/dept";
}
public class UserRealm extends AuthorizingRealm
{
/**
* 授权
*/
@Override
protected AuthorizationInfo doGetAuthorizationInfo(PrincipalCollection arg0)
{
SysUser user = ShiroUtils.getSysUser();
// 角色列表
Set<String> roles = new HashSet<String>();
// 功能列表
Set<String> menus = new HashSet<String>();
SimpleAuthorizationInfo info = new SimpleAuthorizationInfo();
// 管理员拥有所有权限
if (user.isAdmin())
{
info.addRole("admin");
info.addStringPermission("*:*:*");
}
else
{
roles = roleService.selectRoleKeys(user.getUserId());
menus = menuService.selectPermsByUserId(user.getUserId());
// 角色加入AuthorizationInfo认证对象
info.setRoles(roles);
// 权限加入AuthorizationInfo认证对象
info.setStringPermissions(menus);
}
return info;
}
}
634
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
