1.缓存模块需求

1）MyBatis缓存的实现是基于Map的，从缓存里面读写数据是缓存模块的核心基础功能
2）除核心功能之外，有很多额外的附加功能，如：防止缓存击穿，添加缓存情况策略（fifo、LRU），序列化功能，日志能力和定时清空能力等
3）附加功能可以以任意的组合附加到核心基础功能之上

问题：怎样优雅地为核心功能添加附加能力？使用继承？
Ans：继承的方式是静态的，用户不能控制增加行为的方式和时机。另外，新功能存在多种组合，使用继承可能导致大量子类存在。

2.装饰器模式

Decorator Pattern允许向一个现有的对象添加新的功能，是一种用于代替继承的技术，无需通过继承增加子类就能扩展对象的新功能。使用对象的关联关系代替继承关系，更加灵活，同时避免类型体系的快速膨胀。

Component组件：组件接口定义了全部组件类和装饰器实现的行为；
ConcreteComponent组件实现类：实现Component接口，组件实现类就是被装饰器装饰的原始对象，新功能或者附加功能都是通过装饰器添加到该类的对象上的；
Decorator装饰器抽象类：实现Component接口的抽象类，在其中封装了一个Component对象，也就是被装饰的对象；
ConcreteDecorator具体装饰类：该实现类要向被装饰的对象添加某些功能。

装饰器模式优点：相对于继承，装饰器模式灵活性更强，扩展性更强。

灵活性：装饰器模式将功能切分成一个个独立的装饰器，在运行期可以根据需要动态地添加功能，甚至对添加的新功能进行自由地组合。
扩展性：当有新功能要添加时，只需要添加新的装饰器实现类，然后通过组合方式添加这个新装饰器，无需修改已有代码，符合开闭原则。

装饰器模式使用举例：

IO的设计

BufferedReader bufferedReader = 
    new BufferedReader(
        new InputStreamReader(
            new FileInputStream("c://a.txt")));

Servlet API中提供了一个request对象的Decorator设计模式的默认实现类HttpServletRequestWrapper，HttpServletRequestWrapper类增强了request对象的功能
MyBatis的缓存组件

3.MyBatis缓存组件

3.1 装饰器模式

Cache：Cache接口是缓存模块的核心接口，定义了缓存的基本操作；
PerpetualCache：在缓存模块中扮演ConcreteComponent角色，使用HashMap来实现cache的相关操作；
BlockingCache：阻塞版本的缓存装饰器，保证只有一个线程到数据库去查找指定的key对于的数据。

BlockingCache装饰器是怎样进行增强的：

  public BlockingCache(Cache delegate) {
    this.delegate = delegate;
    this.locks = new ConcurrentHashMap<>();
  }

  @Override
  public Object getObject(Object key) {
    acquireLock(key);//根据key获得锁对象，获取锁成功加锁，获取锁失败阻塞一段时间重试
    Object value = delegate.getObject(key);
    if (value != null) {//获取数据成功的，要释放锁
      releaseLock(key);
    }        
    return value;
  }

3.2 BlockingCache缓存锁相关的知识

为什么用缓存？

1）缓存是数据库访问的一道防火墙，数据库连接池是宝贵的资源
2）提高吞吐量

缓存为什么要加锁？

1）避免系统刚开始时，缓存没有预热，业务请求一下子过来的情况
2）缓存失效期到了，高并发请求过来

粗粒度锁——效率低：

细粒度锁——按key：

4.缓存查找CacheKey

MyBatis中涉及到动态SQL，因此缓存项的key不能通过一个String表示，需要通过CacheKey来封装缓存的key值。
CacheKey可以封装多个影响缓存项的因素。

构成CacheKey对象的要素：

mappedStatement的id
指定查询结果集的范围（分页信息）
查询所使用的SQL语句
用户传递给SQL语句的实际参数值

checksum和hashcode的计算方法：

  public void update(Object object) {
    //获取object的hash值
    int baseHashCode = object == null ? 1 : ArrayUtil.hashCode(object); 
    //更新count、checksum以及hashcode的值
    count++;
    checksum += baseHashCode;
    baseHashCode *= count;
    hashcode = multiplier * hashcode + baseHashCode;
    //将对象添加到updateList中
    updateList.add(object);
  }

equals方法：

  @Override
  public boolean equals(Object object) {
    if (this == object) {//比较是不是同一个对象
      return true;
    }
    if (!(object instanceof CacheKey)) {//是否类型相同
      return false;
    }

    final CacheKey cacheKey = (CacheKey) object;

    if (hashcode != cacheKey.hashcode) {//hashcode是否相同
      return false;
    }
    if (checksum != cacheKey.checksum) {//checksum是否相同
      return false;
    }
    if (count != cacheKey.count) {//count是否相同
      return false;
    }

    //以上都不相同，才按顺序比较updateList中元素的hash值是否一致
    for (int i = 0; i < updateList.size(); i++) {
      Object thisObject = updateList.get(i);
      Object thatObject = cacheKey.updateList.get(i);
      if (!ArrayUtil.equals(thisObject, thatObject)) {
        return false;
      }
    }
    return true;
  }

4.1 BaseExecutor的query

  @Override
  public <E> List<E> query(MappedStatement ms, Object parameter, RowBounds rowBounds, ResultHandler resultHandler) throws SQLException {
    //获取sql语句信息，包括占位符，参数等信息
    BoundSql boundSql = ms.getBoundSql(parameter);
    //拼装缓存的key值
    CacheKey key = createCacheKey(ms, parameter, rowBounds, boundSql);
    return query(ms, parameter, rowBounds, resultHandler, key, boundSql);
 }

 @Override
  public CacheKey createCacheKey(MappedStatement ms, Object parameterObject, RowBounds rowBounds, BoundSql boundSql) {
    if (closed) {
      throw new ExecutorException("Executor was closed.");
    }
    CacheKey cacheKey = new CacheKey();
    cacheKey.update(ms.getId());
    cacheKey.update(rowBounds.getOffset());
    cacheKey.update(rowBounds.getLimit());
    cacheKey.update(boundSql.getSql());
    List<ParameterMapping> parameterMappings = boundSql.getParameterMappings();
    TypeHandlerRegistry typeHandlerRegistry = ms.getConfiguration().getTypeHandlerRegistry();
    // mimic DefaultParameterHandler logic
    for (ParameterMapping parameterMapping : parameterMappings) {
      if (parameterMapping.getMode() != ParameterMode.OUT) {
        Object value;
        String propertyName = parameterMapping.getProperty();
        if (boundSql.hasAdditionalParameter(propertyName)) {
          value = boundSql.getAdditionalParameter(propertyName);
        } else if (parameterObject == null) {
          value = null;
        } else if (typeHandlerRegistry.hasTypeHandler(parameterObject.getClass())) {
          value = parameterObject;
        } else {
          MetaObject metaObject = configuration.newMetaObject(parameterObject);
          value = metaObject.getValue(propertyName);
        }
        cacheKey.update(value);
      }
    }
    if (configuration.getEnvironment() != null) {
      // issue #176
      cacheKey.update(configuration.getEnvironment().getId());
    }
    return cacheKey;
  }

参考

1）享学课堂Lison老师笔记

mybatis基础层源码分析3-缓存模块