吃透Shiro源码4----Cache、CacheManager

技术手法

（1）究竟什么是缓存

缓存这个词语，我耳朵都快听出茧子了，什么Redis、Ecache。不过，到底什么是缓存，说实在的，我一直很模糊其概念。今天终于接近了缓存代码的源头。缓存到底是什么？我的总结：缓存对象是一个可以封装多组键值对的特殊对象。因此，缓存可以视为一种容器。

如下代码展示了缓存最顶层的接口。原来缓存一点都不神秘，它就是一种可以用来增删对象的容器。

public interface Cache<K, V> ...
    
    /**
     * 存
     *
     * @param key   key
     * @param value value
     */
    void put(K key, V value) throws CacheException;

    /**
     * 取
     *
     * @param key key
     * @return value
     */
    V get(K key) throws CacheException;


   /**
     * 删
     *
     * @param k key
     * @return value
     */
    V remove(K k) throws CacheException;

（2）用Map作为缓存实现

既然缓存是容器，那么在单机部署或者是单线程情况下，可以创建一个简单的缓存实现。用HashMap等Map接口实现作为底层实现。如果为了保证线程安全，可以使用ConcurrentMap接口实现。下面的代码中实现了一个简易的缓存实现类。

public class MapCache<K, V> implements Cache<K, V> ...

    /**
     * 底层实现Map
     */
    private final Map<K, V> map;

    /**
     * 此缓存的名字
     */
    private final String name;

    public MapCache(String name, Map<K, V> backingMap) {
        if (name == null) {
            throw 
            new IllegalArgumentException("缓存对象name为空");
        }

        if (backingMap == null) {
            throw 
            new IllegalArgumentException("缓存对象backingMap为空");
        }
        this.map = backingMap;
        this.name = name;
    }

    @Override
    public void put(K key, V value) throws CacheException {
        //HashMap是可以允许键为空的，放在其内部数组的第一个角标上
        map.put(key, value);
    }

    @Override
    public V get(K key) throws CacheException {
        return map.get(key);
    }

    @Override
    public void clear() throws CacheException {
        map.clear();
    }

（3）如何管理缓存生命周期

Shiro使用CacheManager接口来管理Cache对象的生命周期。

public interface CacheManager {


    /**
     * 通过缓存的名字获取缓存实例对象
     * 如果没有此缓存实例对象，
     * 那么就按照此名字创建一个缓存实例
     *
     * @param name 缓存实例名称
     * @return 指明名称的缓存对象
     * @throws CacheException 异常
     */
    <K, V> Cache<K, V> getCache(String name) 
                                throws CacheException;
}

/**
 * 一个很简单的缓存管理器
 */
public abstract class AbstractCacheManager 
                         implements CacheManager ...

    //缓存的name对应缓存Cache对象
    private final ConcurrentMap<String, Cache> caches;

    public AbstractCacheManager() {
        this.caches = new ConcurrentHashMap<>();
    }

    @Override
    public <K, V> Cache<K, V> getCache(String name)  {
        ...
        Cache cache = caches.get(name);

        if (cache == null) {
            cache = createCache(name);
            //把新创建的cache存到内部Map中。
            Cache existing = caches.putIfAbsent(name, cache);
            if (existing != null) {
                cache = existing;
            }
        }
        //未检查
        return cache;
    }

    /**
     * 通过提供的名字创建缓存对象
     *
     * @param name 期望的缓存实例名称
     * @return 新创建的缓存实例
     */
    protected abstract <K, V> Cache<K, V> 
                                createCache(String name);
}

（4）AOP解析方法上的注解思路

学了不少Shiro源码，我发现大佬们的代码风格总是面向接口。比如如何解析出方法上的注解。大佬先创建了AnnotationHandler用来封装要被处理的注解类。AnnotationResolver用来从具体的方法上解析出用了指定注解类的注解对象。
具体的实现类还没有研究到，不过总体的思路已经掌握。

/**
 * 此类用于处理注解，提供一个基础的抽象类
 */
public abstract class AnnotationHandler ...
    /**
     * 要被处理的注解
     */
    private Class<? extends Annotation> annotationClass;
}

public interface AnnotationResolver ...

    /**
     * 返回方法执行情况对象MethodInvocation上指定类型的注解实例
     * 如果没有使用注解，则返回null
     *
     * @param mi 方法执行调用对象的情况
     * @param clazz            指定注解
     * @return 指定注解对象
     */
    Annotation getAnnotation(MethodInvocation mi,
                         Class<? extends Annotation> clazz);
}

/**
 * 本类用于解析出方法上的具体的注解实例对象
 * AnnotationHandler它提供了要被处理的注解类
 * AnnotationResolver它提供了从方法上获取指定的注解类对象实例
 */
public abstract class AnnotationMethodInterceptor ...

    private AnnotationHandler handler;

    /**
     * 用于超找方法上的注解的解析器
     */
    private AnnotationResolver resolver;

    /**
     * 要被处理的方法上的注解对象
     *
     * @param mi 方法执行具体情况对象
     * @return 方法上正在被处理的注解对象
     */
    protected Annotation getAnnotation(MethodInvocation mi) {
      return this.resolver.
        getAnnotation(mi, this.handler.getAnnotationClass());
    }
}

重点研究类

import java.lang.reflect.Method;
/**
 * 方法正在调用的情况
 */
public interface MethodInvocation {

    /**
     * 继续方法调用链，如果是最后一个方法，则调用自己
     *
     * @return 方法执行结果
     * @throws Throwable 异常
     */
    Object proceed() throws Throwable;


    /**
     * 返回要调用的实际方法{@link Method}
     *
     * @return 实际要被调用的方法
     */
    Method getMethod();

    /**
     * 获取方法上的参数，没有返回null
     *
     * @return 方法参数
     */
    Object[] getArguments();

    /**
     * 返回保存当前连接点的对象
     * 返回被代理的对象？
     *
     * @return 某对象，看具体怎么实现的吧
     */
    Object getThis();
}

public interface MethodInterceptor {


    /**
     * 调用指定的{@link MethodInvocation#proceed()}，
     * 从而允许实现围绕实际调用进行前/后/最终执行。
     *
     * @param methodInvocation methodInvocation
     * @return 方法返回值
     * @throws Throwable 异常
     */
    Object invoke(MethodInvocation methodInvocation) 
                                         throws Throwable;
}

import java.lang.annotation.Annotation;
public interface AnnotationResolver {
    /**
     * 返回方法执行情况对象{@link MethodInvocation}上
     * 指定类型的注解实例
     * 如果没有使用注解，则返回null
     *
     * @param mi方法执行调用对象
     * @param clazz            指定注解
     * @return 指定注解对象
     */
    Annotation getAnnotation(MethodInvocation mi,
    					 Class<? extends Annotation> clazz);
}

package com.wise.security.aop;

import java.lang.annotation.Annotation;
import java.lang.reflect.Method;

/**
 * 返回方法上指定类型的注解对象
 */
public class DefaultAnnotationResolver 
                   implements AnnotationResolver {

    @Override
    public Annotation getAnnotation(MethodInvocation methodInvocation, 
                      Class<? extends Annotation> clazz) {

        Method method = methodInvocation.getMethod();
        if (method == null) {
            throw new IllegalArgumentException("调用的方法是空");
        }
        //获取方法上指定类型的注解实例
        Annotation annotation = method.getAnnotation(clazz);

        //如果是空，再尝试一下去代理的对象上找找看？
        if(annotation == null){
            annotation = methodInvocation.getThis().getClass().getAnnotation(clazz);
        }
        return annotation;
    }
}

import java.lang.annotation.Annotation;

/**
 * 本类用于解析出方法上的具体的注解实例对象
 * AnnotationHandler它提供了要被处理的注解类
 * AnnotationResolver它提供了从方法上获取指定的注解类对象实例
 */
public abstract class AnnotationMethodInterceptor extends MethodInterceptorSupport {

    private AnnotationHandler handler;

    /**
     * 用于超找方法上的注解的解析器
     */
    private AnnotationResolver resolver;

    public AnnotationMethodInterceptor(AnnotationHandler handler) {
        this(handler, new DefaultAnnotationResolver());
    }

    public AnnotationMethodInterceptor(AnnotationHandler handler, AnnotationResolver resolver) {
        if (handler == null) {
            throw new IllegalArgumentException("注解处理器为空");
        }
        if (resolver == null) {
            resolver = new DefaultAnnotationResolver();
        }
        this.handler = handler;
        this.resolver = resolver;
    }

    public AnnotationHandler getHandler() {
        return handler;
    }

    public void setHandler(AnnotationHandler handler) {
        this.handler = handler;
    }

    public AnnotationResolver getResolver() {
        return resolver;
    }

    public void setResolver(AnnotationResolver resolver) {
        this.resolver = resolver;
    }

    /**
     * 是否
     * 能够处理方法上的注解
     * 的拦截器
     *
     * @param mi
     * @return
     */
    public boolean supports(MethodInvocation mi) {
        return getAnnotation(mi) != null;
    }

    /**
     * 要被处理的方法上的注解对象
     *
     * @param mi 方法执行具体情况对象
     * @return 方法上正在被处理的注解对象
     */
    protected Annotation getAnnotation(MethodInvocation mi) {
        return this.resolver.getAnnotation(mi,
                  this.handler.getAnnotationClass());
    }
}

import java.util.Collection;
import java.util.Set;

/**
 * 缓存有效地存储临时对象，主要是为了提高应用程序的性能。
 * Shiro本身并没有实现完整的Cache机制，因为那超出了安全框架的核心能力
 * 相反，此接口在基础层的顶部提供了一个抽象（包装器）API。
 * 缓存框架的缓存实例（例如JCache，Ehcache，JCS，OSCache，JBossCache，TerraCotta，Coherence，
 * GigaSpaces等），允许Shiro用户配置他们选择的任何缓存机制。
 */
public interface Cache<K, V> {

    /**
     * 存入
     *
     * @param key   key
     * @param value value
     */
    void put(K key, V value) throws CacheException;

    /**
     * 取
     *
     * @param key key
     * @return value
     */
    V get(K key) throws CacheException;


    /**
     * 清除所有
     */
    void clear() throws CacheException;

    /**
     * 删除
     *
     * @param k key
     * @return value
     */
    V remove(K k) throws CacheException;


    /**
     * 获取缓存内K-V个数
     *
     * @return K-V个数
     */
    int size();


    /**
     * 返回所有key的视图
     *
     * @return key视图
     */
    Set<K> keys();


    /**
     * 返回所有value视图
     *
     * @return
     */
    Collection<V> values();


}

import com.wise.security.util.CollectionUtils;

import java.util.Collection;
import java.util.Collections;
import java.util.Map;
import java.util.Set;

/**
 * 缓存对象到底是什么？
 * 缓存对象其实就是一组可以封装多个键值对的特殊对象
 * 缓存因此可以视为容器
 */
public class MapCache<K, V> implements Cache<K, V> {

    /**
     * 内部的Map，适用于单线程
     */
    private final Map<K, V> map;

    /**
     * 此缓存的名字
     */
    private final String name;

    public MapCache(String name, Map<K, V> backingMap) {
        if (name == null) {
            throw new IllegalArgumentException("缓存对象name为空");
        }

        if (backingMap == null) {
            throw new IllegalArgumentException("缓存对象backingMap为空");
        }
        this.map = backingMap;
        this.name = name;
    }

    @Override
    public void put(K key, V value) throws CacheException {
        //HashMap是可以运行键为空的，放在其内部数组的第一个角标上
        map.put(key, value);
    }

    @Override
    public V get(K key) throws CacheException {
        return map.get(key);
    }

    @Override
    public void clear() throws CacheException {
        map.clear();
    }

    @Override
    public V remove(K k) throws CacheException {
        return map.remove(k);
    }

    @Override
    public int size() {
        return map.size();
    }

    @Override
    public Set<K> keys() {
        Set<K> keys = map.keySet();
        if (CollectionUtils.isEmpty(keys)) {
            return Collections.emptySet();
        }
        return Collections.unmodifiableSet(keys);
    }

    @Override
    public Collection<V> values() {
        Collection<V> values = map.values();
        if (CollectionUtils.isEmpty(values)) {
            return Collections.emptyList();
        }
        return Collections.unmodifiableCollection(values);
    }
}

import com.wise.security.util.Destroyable;
import com.wise.security.util.LifecycleUtils;
import com.wise.security.util.StringUtils;

import java.util.concurrent.ConcurrentHashMap;
import java.util.concurrent.ConcurrentMap;

/**
 * 一个很简单的缓存管理器
 */
public abstract class AbstractCacheManager implements CacheManager, Destroyable {

    private final ConcurrentMap<String, Cache> caches;

    public AbstractCacheManager() {
        this.caches = new ConcurrentHashMap<>();
    }

    @Override
    public <K, V> Cache<K, V> getCache(String name) throws CacheException {
        if (!StringUtils.hasText(name)) {
            throw new IllegalArgumentException("缓存对象名称为空");
        }
        Cache cache = caches.get(name);

        if (cache == null) {
            cache = createCache(name);
            //把新创建的cache存到内部Map中。此方法就是value为空，就存K-V
            Cache existing = caches.putIfAbsent(name, cache);
            if (existing != null) {
                cache = existing;
            }
        }
        //未检查
        return cache;
    }


    @Override
    public void destroy() throws Exception {
        for (Cache cache : caches.values()) {
            LifecycleUtils.destroy(cache);
        }
        caches.clear();
    }

    /**
     * 通过提供的名字创建缓存管理器
     *
     * @param name 期望的缓存实例名称
     * @return 新创建的缓存实例
     */
    protected abstract <K, V> Cache<K, V> createCache(String name);
}

import java.util.concurrent.ConcurrentHashMap;

/**
 * 有内存限制的缓存管理器
 */
public class MemoryConstrainedCacheManager 
                         extends AbstractCacheManager {


    /**
     * Shiro源码中提供了一个在单线程下线程安全的Map接口实现
     * 并且能够帮助限制内存，因此这个类才被命名为：有内存限制的缓存管理器
     * <p>
     * SoftHashMap源代码我就不深究了
     * 为了模拟出类似的效果
     * 我为缓存接口内部实现创建一个ConcurrentHashMap吧
     *
     * @param name 期望的缓存实例名称
     * @return 缓存对象
     */
    @Override
    protected <K, V> Cache<K, V> createCache(String name) {
        return new MapCache<>
             (name, new ConcurrentHashMap<>(16));
    }
}