Shiro探索1. Realm

1. Realm 是什么？汉语意思：领域，范围；王国；这个比较抽象；

简单一点就是：Realm 用来对用户进行认证和角色授权的

再简单一点，一个用户怎么判断它有没有登陆？这个用户是什么角色有哪些权限？

是不是需要我们查询数据库或者从缓存中获取相关的角色信息或者进行登陆认真。

2. 其实呢？就是我们说的DAO！！！或者我们说的Mapper ，就是用来访问数据库的工具

对的！！ 就是用来访问数据库的工具。只是在访问数据库的基础上，有一些其他的功能而已。

3.  看看类继承关系

看看这里 类 AuthorizingRealm 其中Authorizing 是授权的意思； 这是一个抽象类

我们一般自己定义一个Realm 直接继承AuthorizingRealm并实现两个抽象方法

protected abstract AuthenticationInfo doGetAuthenticationInfo(AuthenticationToken token) throws AuthenticationException;
//这个是AuthenticatingRealm类中的放法

protected abstract AuthorizationInfo doGetAuthorizationInfo(PrincipalCollection principals);
// 这个是AuthorizingRealm类中的方法

注意这两个单词

Authenticating  认证，就是判定有没有登陆

Authorizing 授权，就是给登陆的用户分配一些特定的角色，所以需要先登录了，才能进行授权（角色分配）

上述两个抽象方法需要实现；一个用来登陆，一个用来授权

4.  再认识一下两个参数：

AuthenticationToken 就是Token,一般是根据请求的数据，比如用户名和密码 生成的token; 
   这个token如果保存着用户名和密码数据，那么在 doGetAuthenticationInfo（）这个方法中就可以进行访问数据库进行登陆操作；

PrincipalCollection  这个参数，可以用到可以不用；
            这个里面存放的Subject 中的 principal；因为可以定义多个Realm,所以可能会生成多个Subject;
            principal 就是subject 的身份标识，一般用比如用户名，邮箱，id 等

5. 最后非常重要的思想：

doGetAuthenticationInfo

doGetAuthorizationInfo

这两个方法，是要直接进行访问数据库的，不要在里面进行访问shiro配置的缓存；

因为shiro 只有在缓存中找不到时，才会调用这两个方法

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

public final AuthenticationInfo getAuthenticationInfo(AuthenticationToken token) throws AuthenticationException {

        AuthenticationInfo info = getCachedAuthenticationInfo(token);// 先调用访问缓存的方法；【这个方法就不贴了，可看源码，就是从cache中获取】
        if (info == null) {
            //otherwise not cached, perform the lookup:
            info = doGetAuthenticationInfo(token);// 如果缓存中没有，则调用我们的方法
            log.debug("Looked up AuthenticationInfo [{}] from doGetAuthenticationInfo", info);
            if (token != null && info != null) {
                cacheAuthenticationInfoIfPossible(token, info);// 写入缓存
            }
        } else {
            log.debug("Using cached authentication info [{}] to perform credentials matching.", info);
        }

        if (info != null) {
            assertCredentialsMatch(token, info);
        } else {
            log.debug("No AuthenticationInfo found for submitted AuthenticationToken [{}].  Returning null.", token);
        }

        return info;
    }

从上述可以看到，我们实现认证和授权的方法时，要直接从数据库中获取，而不需要从shiro使用的缓存中获取；
除非是多级缓存，比如shiro 定义的cache 用的缓存和该方法内的缓存不是同一个缓存。
但无论怎样，一定要最终到数据库中去获取最根本的数据。

关于shiro 缓存机制，我们下次再总结