-de8bd8f33c3e44a59907dafe1884f228.png)
介绍
授权，也叫访问控制，即在应用中控制谁能访问哪些资源（如访问页面、编辑数据、页面操作等）。在授权中需了解的几个关键对象：主体（Subject）、资源（Resource）、权限（Permission）、角色（Role）。
- 主体（Subject）：访问应用的用户，在 Shiro 中使用 Subject 代表该用户。用户只有授权后才允许访问相应的资源。
- 资源（Resource）：在应用中用户可以访问的 URL，比如访问 JSP 页面、查看/编辑某些数据、访问某个业务方法、打印文本等等都是资源。用户只有授权后才能访问。
- 权限（Permission）：安全策略中的原子授权单位，通过权限我们可以表示在应用中用户有没有操作某个资源的权力。即权限表示在应用中用户能不能访问某个资源。如：访问用户列表页面查看、新增、修改、删除用户数据（即很多时候都是 CRUD 式权限控制）等。权限代表了用户有没有操作某个资源的权力，即反映了在某个资源上的操作允不允许。
- 角色（Role）：角色实际上就是权限的集合，一般情况下会赋予用户角色而不是权限，即这样用户可以拥有一组权限，赋予权限时比较方便。典型的如：项目经理、技术总监、CTO、开发工程师等都是角色，不同的角色拥有一组不同的权限。
Shiro 支持粗粒度权限（如用户模块的所有权限）和细粒度权限（如操作某个用户的权限，实例级别）。
授权方式
Shiro 中支持如下三种方式的授权：
1、编程式：通过写 if/else 授权代码块完成。
// 例：
if(subject.hasRole("admin")){
// 有权限
}else{
// 无权限
}
2、注解式：通过在执行的 Java 方法上放置相应的注解完成，没有权限将抛出相应的异常。
// 例：
@RequiresRoles("admin") // 有权限时才进入方法，无权限时抛出异常
public void hello(){
// 有权限
}
3、JSP 标签：在 JSP 页面通过相应的标签完成。
<shiro:hasRole name="admin">
// 有权限
</shiro:hasRole>
授权配置示例
有两个页面 admin.jsp 和 user.jsp，如果我们需要控制访问 admin.jsp 需要用户拥有 admin 角色、访问 user.jsp 拥有 user 角色，则可如下配置：
<bean id="shiroFilter" class="org.apache.shiro.spring.web.ShiroFilterFactoryBean">
<property name="securityManager" ref="securityManager"/>
<property name="loginUrl" value="/login.jsp"/>
<property name="successUrl" value="/list.jsp"/>
<property name="unauthorizedUrl" value="/unauthorized.jsp"/>
<!--
配置哪些页面需要受保护 以及 访问这些页面需要的权限
a、anon 可以匿名访问
b、authc 必须认证（登陆）后才可以访问
-->
<property name="filterChainDefinitions">
<value>
/admin.jsp=roles[admin]
/user.jsp=roles[user]
/logout=logout
/login*=anon
/** = authc
</value>
</property>
</bean>
配置后即便我们已经登录，访问 admin.jsp 和 user.jsp 都会跳转到 unauthorized.jsp，因为当前登录用户并没有 admin 和 user 这两个角色。
授权 Realm
授权 Realm 需要继承 org.apache.shiro.realm.AuthorizingRealm 类，并实现其 doGetAuthorizationInfo 方法。
AuthorizingRealm 类继承自 org.apache.shiro.realm.AuthenticatingRealm ，但没有实现 AuthenticatingRealm 中的 doGetAuthenticationInfo 方法，所以要完成认证和授权只需要继承 AuthorizingRealm 类，同时实现它的两个抽象方法即可。
源码分析授权流程
在最初的快速开始 Demo 中我们已经知道，校验当前用户是否拥有某个角色是通过 Subject.hasRole 方法：
// org.apache.shiro.subject.support.DelegatingSubject#hasRole
public boolean hasRole(String roleIdentifier) {
return hasPrincipals() && securityManager.hasRole(getPrincipals(), roleIdentifier);
}
接着看到 securityManager.hasRole(getPrincipals(), roleIdentifier) 方法：
// org.apache.shiro.mgt.AuthorizingSecurityManager#hasRole
public boolean hasRole(PrincipalCollection principals, String roleIdentifier) {
return this.authorizer.hasRole(principals, roleIdentifier);
}
接着是 this.authorizer.hasRole(principals, roleIdentifier) 方法，当是单个授权 Realm 时：
// org.apache.shiro.realm.AuthorizingRealm#hasRole(org.apache.shiro.subject.PrincipalCollection, java.lang.String)
public boolean hasRole(PrincipalCollection principal, String roleIdentifier) {
AuthorizationInfo info = getAuthorizationInfo(principal);
return hasRole(roleIdentifier, info);
}
重点就在 getAuthorizationInfo(principal) ：
// org.apache.shiro.realm.AuthorizingRealm#getAuthorizationInfo
protected AuthorizationInfo getAuthorizationInfo(PrincipalCollection principals) {
if (principals == null) {
return null;
}
AuthorizationInfo info = null;
if (log.isTraceEnabled()) {
log.trace("Retrieving AuthorizationInfo for principals [" + principals + "]");
}
Cache<Object, AuthorizationInfo> cache = getAvailableAuthorizationCache();
if (cache != null) {
if (log.isTraceEnabled()) {
log.trace("Attempting to retrieve the AuthorizationInfo from cache.");
}
Object key = getAuthorizationCacheKey(principals);
info = cache.get(key);
if (log.isTraceEnabled()) {
if (info == null) {
log.trace("No AuthorizationInfo found in cache for principals [" + principals + "]");
} else {
log.trace("AuthorizationInfo found in cache for principals [" + principals + "]");
}
}
}
if (info == null) {
// Call template method if the info was not found in a cache
// <1>
info = doGetAuthorizationInfo(principals);
// If the info is not null and the cache has been created, then cache the authorization info.
if (info != null && cache != null) {
if (log.isTraceEnabled()) {
log.trace("Caching authorization info for principals: [" + principals + "].");
}
Object key = getAuthorizationCacheKey(principals);
cache.put(key, info);
}
}
return info;
}
看到第 <1> 处，我们自定义的授权 Realm 继承了 AuthorizingRealm ，所以这里调的 doGetAuthorizationInfo 方法实际上就是需要我们自己实现的 doGetAuthorizationInfo 方法，最后返回该方法的返回值。回到 org.apache.shiro.realm.AuthorizingRealm#hasRole(org.apache.shiro.subject.PrincipalCollection, java.lang.String) 方法，通过 hasRole(roleIdentifier, info) 方法来检验用户是否拥有某角色：
// org.apache.shiro.realm.AuthorizingRealm#hasRole(java.lang.String, org.apache.shiro.authz.AuthorizationInfo)
protected boolean hasRole(String roleIdentifier, AuthorizationInfo info) {
return info != null && info.getRoles() != null && info.getRoles().contains(roleIdentifier);
}
而如果是多授权 Realm 的情况下，在 org.apache.shiro.mgt.AuthorizingSecurityManager#hasRole 方法的第二行的 this.authorizer.hasRole(principals, roleIdentifier) 方法就会走这个方法：
// org.apache.shiro.authz.ModularRealmAuthorizer#hasRole
public boolean hasRole(PrincipalCollection principals, String roleIdentifier) {
assertRealmsConfigured();
for (Realm realm : getRealms()) {
if (!(realm instanceof Authorizer)) continue;
if (((Authorizer) realm).hasRole(principals, roleIdentifier)) {
return true;
}
}
return false;
}
可以看到，只要有一个授权 Realm 返回的信息包含了指定角色，校验就通过了。
所以示例中的 LoginRealm 就可以修改如下：
// com.zze.shiro.realms.LoginRealm
import org.apache.shiro.authc.*;
import org.apache.shiro.authz.AuthorizationInfo;
import org.apache.shiro.authz.SimpleAuthorizationInfo;
import org.apache.shiro.realm.AuthorizingRealm;
import org.apache.shiro.subject.PrincipalCollection;
import java.util.HashSet;
import java.util.Set;
public class LoginRealm extends AuthorizingRealm {
protected AuthenticationInfo doGetAuthenticationInfo(AuthenticationToken authenticationToken) throws AuthenticationException {
// authenticationToken 实际就是 Controller 中通过 Subject.Login 方法传入的 token，保存了前台输入的密码
UsernamePasswordToken usernamePasswordToken = (UsernamePasswordToken) authenticationToken;
// 获取页面传入的用户名
String username = usernamePasswordToken.getUsername();
// 根据用户名从数据库获取密码，假如获取到的是 123456
String dbPassword = "123456";
// 假如 unknown 用户名不存在
if ("unknown".equals(username)) {
throw new UnknownAccountException("用户名不存在");
}
// 假如 monster 用户名已经被锁定
if ("monster".equals(username)) {
throw new LockedAccountException("用户已被锁定");
}
// 根据用户情况，构建 AuthenticationInfo 对象返回，通常使用的实现类为 SimpleAuthenticationInfo
// a. principal : 认证的实体信息，可以是 username，也可以是用户对应的实体对象
Object principal = username;
// b. credentials : 密码
Object credentials = dbPassword;
// c. realmName : 当前 realm 对象的 name，调用父类的 getName() 方法获得
String realmName = getName();
SimpleAuthenticationInfo simpleAuthenticationInfo = new SimpleAuthenticationInfo(principal, credentials, realmName);
return simpleAuthenticationInfo; // 返回认证信息，交给 Shiro 完成比对
}
protected AuthorizationInfo doGetAuthorizationInfo(PrincipalCollection principals) {
// 1、获取登录用户的信息
Object primaryPrincipal = principals.getPrimaryPrincipal();
// 2、利用登录用户信息来获取当前用户的角色或权限（可能需要查询数据库）
Set<String> roles = new HashSet<String>();
roles.add("user");
if ("admin".equals(primaryPrincipal)) {
roles.add("admin");
}
// 3、创建 SimpleAuthorizationInfo 实例，并设置其 reles 属性
SimpleAuthorizationInfo simpleAuthorizationInfo = new SimpleAuthorizationInfo();
simpleAuthorizationInfo.setRoles(roles);
return simpleAuthorizationInfo;
}
}
上述代码中给任何已认证的用户都分配了 user 角色，给 admin 用户分配了 admin 角色。此时以 user 用户登录就可以访问 user.jsp ，但不可以访问 admin.jsp ，以 admin 用户登录就可以访问 user.jsp 和 admin.jsp 。
评论区