Mybatis源码分析---Mybatis二级缓存中的责任链模式

一、Mybatis的源码写的像艺术品

Mybatis的代码设计的非常有观赏性，其中大量使用设计模式，并且用的非常棒；比如Mybatis将日志功能委托给其他的日志框架使用的是适配器模式加工厂模式实现的；Mybatis的插件是通过代理模式+责任链模式实现的；Mybatis的二级缓存是装饰器模式+责任链模式实现的；读源码不仅可以让我们了解其底层技术细节，有利于提高我们自己的编码能力，也可以学习这些优秀的框架中采用什么样的数据结构？引入了什么算法？组件的抽象遵循了什么样的设计原则？

二、实现二级缓存的需求分析

1、内存存储；

2、防止穿透；

3、过期清理；

4、防止溢出；

5、记录命中率；

6、日志功能；

7、线程同步；

8、垃圾回收

这些都是实现Mybatis二级缓存功能时要考虑的问题。面对如此多的细节性功能如果是我们该如何设计？如何让二级缓存的功能具有扩展性？

三、Mybatis二级缓存的设计

源码位置：

1、装饰器模式的应用--- delegate

放出两个Cache接口的实现类看看就知道了；

//线程同步
public class SynchronizedCache implements Cache {

  private final Cache delegate;  //持有另外一个Cache的引用

  public SynchronizedCache(Cache delegate) {
    this.delegate = delegate;
  }

  @Override
  public String getId() {
    return delegate.getId();
  }

  @Override
  public synchronized int getSize() {
    return delegate.getSize();
  }

  @Override
  public synchronized void putObject(Object key, Object object) {
    delegate.putObject(key, object);
  }

  @Override
  public synchronized Object getObject(Object key) {
    return delegate.getObject(key);
  }

  @Override
  public synchronized Object removeObject(Object key) {
    return delegate.removeObject(key);
  }

  @Override
  public synchronized void clear() {
    delegate.clear();
  }

  @Override
  public int hashCode() {
    return delegate.hashCode();
  }

  @Override
  public boolean equals(Object obj) {
    return delegate.equals(obj);
  }

}

//日志、命中率统计
public class LoggingCache implements Cache {

  private final Log log;
  private final Cache delegate;   //持有另一个Cache的引用
  protected int requests = 0;
  protected int hits = 0;

  public LoggingCache(Cache delegate) {
    this.delegate = delegate;
    this.log = LogFactory.getLog(getId());
  }

  @Override
  public String getId() {
    return delegate.getId();
  }

  @Override
  public int getSize() {
    return delegate.getSize();
  }

  @Override
  public void putObject(Object key, Object object) {
    delegate.putObject(key, object);
  }

  @Override
  public Object getObject(Object key) {
    requests++;
    final Object value = delegate.getObject(key);
    if (value != null) {
      hits++;
    }
    if (log.isDebugEnabled()) {
      log.debug("Cache Hit Ratio [" + getId() + "]: " + getHitRatio());
    }
    return value;
  }

  @Override
  public Object removeObject(Object key) {
    return delegate.removeObject(key);
  }

  @Override
  public void clear() {
    delegate.clear();
  }

  @Override
  public int hashCode() {
    return delegate.hashCode();
  }

  @Override
  public boolean equals(Object obj) {
    return delegate.equals(obj);
  }

  private double getHitRatio() {
    return (double) hits / (double) requests;
  }

}

这便是装饰器模式的应用，见到delegate这个单词就要敏感的认识到这是什么设计模式；

2、责任链模式在哪里

责任链模式总需要一条“链子”将各式各样的Cache组织起来，它在哪里？

它位于mapping包下，名为CacheBuilder。

具体是如何组织的我都标注在源码里了，大家可以粘贴到本地自己研究一下；

package org.apache.ibatis.mapping;

import org.apache.ibatis.builder.InitializingObject;
import org.apache.ibatis.cache.Cache;
import org.apache.ibatis.cache.CacheException;
import org.apache.ibatis.cache.decorators.BlockingCache;
import org.apache.ibatis.cache.decorators.LoggingCache;
import org.apache.ibatis.cache.decorators.LruCache;
import org.apache.ibatis.cache.decorators.ScheduledCache;
import org.apache.ibatis.cache.decorators.SerializedCache;
import org.apache.ibatis.cache.decorators.SynchronizedCache;
import org.apache.ibatis.cache.impl.PerpetualCache;
import org.apache.ibatis.reflection.MetaObject;
import org.apache.ibatis.reflection.SystemMetaObject;

import java.lang.reflect.Constructor;
import java.util.ArrayList;
import java.util.List;
import java.util.Map;
import java.util.Properties;


public class CacheBuilder {
  private final String id;
  private Class implementation;
  private final List> decorators;
  private Integer size;
  private Long clearInterval;
  private boolean readWrite;
  private Properties properties;
  private boolean blocking;

  public CacheBuilder(String id) {
    this.id = id;
    this.decorators = new ArrayList>();
  }

  public CacheBuilder implementation(Class implementation) {
    this.implementation = implementation;
    return this;
  }

  public CacheBuilder addDecorator(Class decorator) {
    if (decorator != null) {
      this.decorators.add(decorator);
    }
    return this;
  }

  public CacheBuilder size(Integer size) {
    this.size = size;
    return this;
  }

  public CacheBuilder clearInterval(Long clearInterval) {
    this.clearInterval = clearInterval;
    return this;
  }

  public CacheBuilder readWrite(boolean readWrite) {
    this.readWrite = readWrite;
    return this;
  }

  public CacheBuilder blocking(boolean blocking) {
    this.blocking = blocking;
    return this;
  }

  public CacheBuilder properties(Properties properties) {
    this.properties = properties;
    return this;
  }

  public Cache build() {
    setDefaultImplementations();
    //cache的类型是PerpetualCache
    Cache cache = newBaseCacheInstance(implementation, id);
    setCacheProperties(cache);
    // issue #352, do not apply decorators to custom caches
    if (PerpetualCache.class.equals(cache.getClass())) { //判断这个起点是不是想要的PerpetualCache
      for (Class decorator : decorators) {
        cache = newCacheDecoratorInstance(decorator, cache);  //将LruCache放到责任链的另一个第二个节点上
        setCacheProperties(cache);
      }
      cache = setStandardDecorators(cache);
    } else if (!LoggingCache.class.isAssignableFrom(cache.getClass())) {
      cache = new LoggingCache(cache);
    }
    return cache;
  }

  private void setDefaultImplementations() {
    if (implementation == null) {
      //第一个放进到责任链上的是 PerpetualCache
      implementation = PerpetualCache.class;
      if (decorators.isEmpty()) {
        decorators.add(LruCache.class);
      }
    }
  }

  private Cache setStandardDecorators(Cache cache) {
    try {
      MetaObject metaCache = SystemMetaObject.forObject(cache);
      if (size != null && metaCache.hasSetter("size")) {
        metaCache.setValue("size", size);
      }
      //如果这个参数不为空，就
      if (clearInterval != null) {
        cache = new ScheduledCache(cache);
        ((ScheduledCache) cache).setClearInterval(clearInterval);
      }
      //如果有readWrite的配置，在责任链中加入SerializedCache
      if (readWrite) {
        cache = new SerializedCache(cache);
      }
      //在链的上游加入LoggingCache
      cache = new LoggingCache(cache);
      //链的上游加入SynchronizedCache
      cache = new SynchronizedCache(cache);
      if (blocking) {
        cache = new BlockingCache(cache);
      }
      return cache;
    } catch (Exception e) {
      throw new CacheException("Error building standard cache decorators.  Cause: " + e, e);
    }
  }

  private void setCacheProperties(Cache cache) {
    if (properties != null) {
      MetaObject metaCache = SystemMetaObject.forObject(cache);
      for (Map.Entry entry : properties.entrySet()) {
        String name = (String) entry.getKey();
        String value = (String) entry.getValue();
        if (metaCache.hasSetter(name)) {
          Class type = metaCache.getSetterType(name);
          if (String.class == type) {
            metaCache.setValue(name, value);
          } else if (int.class == type
              || Integer.class == type) {
            metaCache.setValue(name, Integer.valueOf(value));
          } else if (long.class == type
              || Long.class == type) {
            metaCache.setValue(name, Long.valueOf(value));
          } else if (short.class == type
              || Short.class == type) {
            metaCache.setValue(name, Short.valueOf(value));
          } else if (byte.class == type
              || Byte.class == type) {
            metaCache.setValue(name, Byte.valueOf(value));
          } else if (float.class == type
              || Float.class == type) {
            metaCache.setValue(name, Float.valueOf(value));
          } else if (boolean.class == type
              || Boolean.class == type) {
            metaCache.setValue(name, Boolean.valueOf(value));
          } else if (double.class == type
              || Double.class == type) {
            metaCache.setValue(name, Double.valueOf(value));
          } else {
            throw new CacheException("Unsupported property type for cache: '" + name + "' of type " + type);
          }
        }
      }
    }
    if (InitializingObject.class.isAssignableFrom(cache.getClass())) {
      try {
        ((InitializingObject) cache).initialize();
      } catch (Exception e) {
        throw new CacheException("Failed cache initialization for '"
          + cache.getId() + "' on '" + cache.getClass().getName() + "'", e);
      }
    }
  }

  private Cache newBaseCacheInstance(Class cacheClass, String id) {
    Constructor cacheConstructor = getBaseCacheConstructor(cacheClass);
    try {
      return cacheConstructor.newInstance(id);
    } catch (Exception e) {
      throw new CacheException("Could not instantiate cache implementation (" + cacheClass + "). Cause: " + e, e);
    }
  }

  private Constructor getBaseCacheConstructor(Class cacheClass) {
    try {
      return cacheClass.getConstructor(String.class);
    } catch (Exception e) {
      throw new CacheException("Invalid base cache implementation (" + cacheClass + ").  "
        + "Base cache implementations must have a constructor that takes a String id as a parameter.  Cause: " + e, e);
    }
  }

  private Cache newCacheDecoratorInstance(Class cacheClass, Cache base) {
    Constructor cacheConstructor = getCacheDecoratorConstructor(cacheClass);
    try {
      //使用反射机制生成一个Cache
      return cacheConstructor.newInstance(base);
    } catch (Exception e) {
      throw new CacheException("Could not instantiate cache decorator (" + cacheClass + "). Cause: " + e, e);
    }
  }

  private Constructor getCacheDecoratorConstructor(Class cacheClass) {
    try {
      return cacheClass.getConstructor(Cache.class);
    } catch (Exception e) {
      throw new CacheException("Invalid cache decorator (" + cacheClass + ").  "
        + "Cache decorators must have a constructor that takes a Cache instance as a parameter.  Cause: " + e, e);
    }
  }
}

入口方法：

  public Cache build() {
    setDefaultImplementations();
    //cache的类型是PerpetualCache
    Cache cache = newBaseCacheInstance(implementation, id);
    setCacheProperties(cache);
    // issue #352, do not apply decorators to custom caches
    if (PerpetualCache.class.equals(cache.getClass())) { //判断这个起点是不是想要的PerpetualCache
      for (Class decorator : decorators) {
        cache = newCacheDecoratorInstance(decorator, cache);  //将LruCache放到责任链的另一个第二个节点上
        setCacheProperties(cache);
      }
      cache = setStandardDecorators(cache);
    } else if (!LoggingCache.class.isAssignableFrom(cache.getClass())) {
      cache = new LoggingCache(cache);
    }
    return cache;
  }

这个方法中调用了三个封装的方法：

第一个：setDefaultImplementations()

  private void setDefaultImplementations() {
    if (implementation == null) {
      //第一个放进到责任链上的是 PerpetualCache
      implementation = PerpetualCache.class;
      if (decorators.isEmpty()) {
        decorators.add(LruCache.class);
      }
    }
  }

本方法实际上就是给2个变量赋值，implementation 赋值是PerpetualCache.class，下面的方法中会使用这个变量用反射的方法生成PerpetualCache对象；

private final List> decorators; decorators是List类型的，初始化的时候把LruCache.class添加进列表了；这也是Mybatis二级缓存的默认淘汰机制。明明只有一个LruCahe.class，这里为什么要使用List去存放呢？我想应该是设计者想未来做进一步的扩展！

第二个：Cache cache = newBaseCacheInstance(implementation, id);

  private Cache newBaseCacheInstance(Class cacheClass, String id) {
    Constructor cacheConstructor = getBaseCacheConstructor(cacheClass);
    try {
      return cacheConstructor.newInstance(id);
    } catch (Exception e) {
      throw new CacheException("Could not instantiate cache implementation (" + cacheClass + "). Cause: " + e, e);
    }
  }

  private Constructor getBaseCacheConstructor(Class cacheClass) {
    try {
      return cacheClass.getConstructor(String.class);
    } catch (Exception e) {
      throw new CacheException("Invalid base cache implementation (" + cacheClass + ").  "
        + "Base cache implementations must have a constructor that takes a String id as a parameter.  Cause: " + e, e);
    }
  }

利用反射生成一个对应类型的Cache，同样是为了扩展功能的时候能够复用这些代码，作者使用了反射机制；

第三个：setCacheProperties(cache);

这段代码大概意思是把配置信息中的信息设置到Cache中，然后做初始化；

重点流程：

类型判断，链的起点必须是PerpetualCache类型的Cache ；然后遍历decorators，每一个decorator都会被传入private Cache newCacheDecoratorInstance(Class cacheClass, Cache base);

然后是：cache = setStandardDecorators(cache);生成的新的cache直接赋给原来的cache变量，这样就把不同的Cache节点串起来了。

setStandardDecorators这个私有方法封装的代码：

  private Cache setStandardDecorators(Cache cache) {
    try {
      MetaObject metaCache = SystemMetaObject.forObject(cache);
      if (size != null && metaCache.hasSetter("size")) {
        metaCache.setValue("size", size);
      }
      //如果这个参数不为空，就
      if (clearInterval != null) {
        cache = new ScheduledCache(cache);
        ((ScheduledCache) cache).setClearInterval(clearInterval);
      }
      //如果有readWrite的配置，在责任链中加入SerializedCache
      if (readWrite) {
        cache = new SerializedCache(cache);
      }
      //在链的上游加入LoggingCache
      cache = new LoggingCache(cache);
      //链的上游加入SynchronizedCache
      cache = new SynchronizedCache(cache);
      if (blocking) {
        cache = new BlockingCache(cache);
      }
      return cache;
    } catch (Exception e) {
      throw new CacheException("Error building standard cache decorators.  Cause: " + e, e);
    }
  }

根据配置将其它类型的Cache串到“责任链”上；

到这里二级缓存中涉及的责任链模式的代码就基本分析完了，其中还有一些细节的东西，感兴趣的自己去研究一下源码。先掌握大块的，太细节的东西可以放一放！

三、流程梳理