好久没有更新了，最近一段时间不是因为太忙，就是不想写了，shiro虽然仅仅写了三篇，但是感觉核心也已经差不多就这些了，这篇可能是最后一篇了，之前的过滤器和认证这块主要的也已经讲完了，现在主要是来看下shiro的授权是怎么实现的。

四、授权

现在主流的权限模型就是基于角色的权限控制（RBAC），在一些对权限要求不是很严格的时候，我们仅仅需要知道当前用户所拥有的角色，并确定角色的所拥有的资源的时候就可以了。当我们需要更加细腻的控制的时候，就需要进一步将资源进行细化，从整体上说，我们每一个资源都应该对应着增删改查这四种操作。

在第二，第三篇的时候我们已经看了整个过滤器和整个验证的流程，在验证的过程中还有一步是授权问题。最后就是整个验证的实际实现部分是交由isAccessAllowed这个方法进行实现的。而这一方法的具体实现每一个都不同，这一块主要就是检测是否拥有权限。我们在实际开发中可以根据自己的需要进行重写这个方法。下面是我的一个项目的具体实现。

    @Override
    protected boolean isAccessAllowed(ServletRequest request, ServletResponse response
                       , Object mappedValue) throws Exception {
        Subject subject = getSubject(request, response);
        String URL = getPathWithinApplication(request);
        // 返回false会执行onAccessDenied这个方法
        return subject.isPermitted(URL);
    }

我这边的设计是，每一个资源的操作与URL进行一一对应，这样一来，我只要检验我当前状态是否拥有此次请求的路径的权限。
上面的方法也不是我自己写的，这都是shiro已经提供的一些算是工具类和方法获取的，我觉得这点shiro做的很不错，既解决了很多繁琐的问题，又没有失去其灵活性。一个好的框架就应该是，既能解决大部分问题，又能根据具体情况进行简单的定制开发。
废话说完，我们继续看isPermitted这个方法，它有很多重载，这里贴出org.apache.shiro.subject.support.DelegatingSubject的所有重载方法(org.apache.shiro.web.subject.support.WebDelegatingSubject并没有进行重写)。

    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];
        }
    }

    public boolean[] isPermitted(List<Permission> permissions) {
        if (hasPrincipals()) {
            return securityManager.isPermitted(getPrincipals(), permissions);
        } else {
            return new boolean[permissions.size()];
        }
    }

这里又调用了org.apache.shiro.mgt.SecurityManager.isPermitted()方法,继续贴代码,这里的实现是org.apache.shiro.mgt.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);
    }

    public boolean[] isPermitted(PrincipalCollection principals, List<Permission> permissions) {
        return this.authorizer.isPermitted(principals, permissions);
    }

我们继续跟踪代码吧，这玩意最后就跑到realm中执行的，方法的定义是在org.apache.shiro.authz.Authorizer这个接口，由于管理器和realm都对这个接口进行实现，而管理器中又有注入realm，最后就到了realm中了，当然具体每一次调用是不是realm就不好说。源码继续,实现类是org.apache.shiro.realm.AuthorizingRealm

    public boolean isPermitted(PrincipalCollection principals, String permission) {
        // getPermissionResolver()获取注入的org.apache.shiro.authz.permission.PermissionResolver
        // resolvePermission()自然是获取Permission啦，默认的是org.apache.shiro.authz.permission.WildcardPermissionResolver
        // 这一块我们也可以注入自己的PermissionResolver，对其进行扩展
        Permission p = getPermissionResolver().resolvePermission(permission);
        return isPermitted(principals, p);
    }

    public boolean isPermitted(PrincipalCollection principals, Permission permission) {
        //这个方法感觉没啥好说明的，好像前面讲过吧，就是获取当前用户的权限信息，然后交给下一步进行判断
        AuthorizationInfo info = getAuthorizationInfo(principals);
        return isPermitted(permission, info);
    }

    //changed visibility from private to protected for SHIRO-332
    protected boolean isPermitted(Permission permission, AuthorizationInfo info) {
        /**
         *getPermissions()这个方法就是从获取我们在realm保存起来的权限信息，
         *包括权限和角色，无论是对象权限还是字符串权限，他都会转换成Permission这个接口，
         *具体实现就不得而知咯，根据你传入的PermissionResolver的实现而定，默认是WildcardPermission
         */
      Collection<Permission> perms = getPermissions(info);
        if (perms != null && !perms.isEmpty()) {
            for (Permission perm : perms) {
                //这个方法就是权限验证的方法了
                if (perm.implies(permission)) {
                    return true;
                }
            }
        }
        return false;
    }

这边shiro默认的Permission是org.apache.shiro.authz.permission.WildcardPermission,他是将资源与资源的操作用:进行分隔，例如user/1:update，在纯restful风格的接口设计的时候还是可以用的。那么如果不符合我们的设计怎么办？不怕，我们这边可以注入我们自己的PermissionResolver子类就可以了，下面是我自己实现的一个子类。

public class SecurityPermissionResolver implements PermissionResolver {
    @Override
    public Permission resolvePermission(String permissionString) {
        if (permissionString.startsWith("/")) {
            return new SecurityPermission(permissionString);
        }
        return new WildcardPermission(permissionString);
    }
}

这边比较简单粗暴，如果permissionString（实际就是URL）是/开始就返回自己定义的Permission

public class SecurityPermission implements Permission{
    private String url;

    public String getUrl() {
        return url;
    }

    public void setUrl(String url) {
        this.url = url;
    }

    public SecurityPermission() {
    }

    public SecurityPermission(String url) {
        this.url = url;
    }
    @Override
    public boolean implies(Permission p) {
        if (!(p instanceof SecurityPermission))
            return false;
        SecurityPermission lp = (SecurityPermission) p;
        PatternMatcher patternMatcher = new AntPathMatcher();
        return patternMatcher.matches(this.url, lp.url);
    }
    
}

至此，权限认证流程就已经结束了。

• 题外话
  首先，经过前三篇的阅读的话，对此篇来说，应该是很容易的了，因为其中很多对象的来源在第三篇已经讲过，也没有哪一步是特别绕的。个人感觉shiro这一块的设计非常人性化。
  至于shiro的其他东西，注入ssl支持，单点登录，缓存等等，个人感觉应该是不属于shiro的核心东西了，他们都是在基本的过滤器，认证，授权的基础之上进行扩展，让shiro更加强大，这几个基础解决了，再去使用其他的，按道理来说应该是不难的。
  接下来，该写点什么呢？还没想好，希望看到的人给点建议哈。