Mybatis缓存策略源码

Mybatis3.5.1源码分析

1. Mybatis-SqlSessionFactoryBuilder，XMLConfigBuilder，XPathParser源码解析
2. Mybatis-Configuration源码解析
3. Mybatis-事务对象源码解析
4. Mybatis-数据源源码解析
5. Mybatis缓存策略源码解析
6. Mybatis-DatabaseIdProvider源码解析
7. Mybatis-TypeHandler源码解析
8. Mybatis-Reflector源码解析
9. Mybatis-ObjectFactory，ObjectWrapperFactory源码分析
10. Mybatis-Mapper各类标签封装类源码解析
11. Mybatis-XMLMapperBuilder,XMLStatmentBuilder源码分析
12. Mybatis-MapperAnnotationBuilder源码分析
13. [Mybatis-MetaObject,MetaClass源码解析]https://www.jianshu.com/p/f51fa552f30a)
14. Mybatis-LanguageDriver源码解析
15. Mybatis-SqlSource源码解析
16. Mybatis-SqlNode源码解析
17. Mybatis-KeyGenerator源码解析
18. Mybatis-Executor源码解析
19. Mybatis-ParameterHandler源码解析
20. Mybatis-StatementHandler源码解析
21. Mybatis-DefaultResultSetHandler(一)源码解析
22. Mybatis-DefaultResultSetHandler(二)源码解析
23. Mybatis-ResultHandler,Cursor,RowBounds 源码分析
24. Mybatis-MapperProxy源码解析
25. Mybatis-SqlSession源码解析
26. Mybatis-Interceptor源码解析

Cache

缓存策略类都是基于装饰者设计模式进行开发的

/**
 *    Copyright 2009-2019 the original author or authors.
 *
 *    Licensed under the Apache License, Version 2.0 (the "License");
 *    you may not use this file except in compliance with the License.
 *    You may obtain a copy of the License at
 *
 *       http://www.apache.org/licenses/LICENSE-2.0
 *
 *    Unless required by applicable law or agreed to in writing, software
 *    distributed under the License is distributed on an "AS IS" BASIS,
 *    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 *    See the License for the specific language governing permissions and
 *    limitations under the License.
 */
package org.apache.ibatis.cache;

import java.util.concurrent.locks.ReadWriteLock;

/**
 * SPI for cache providers. 为缓存提供者的接口(SPI:串行外设接口。)
 * 

 * One instance of cache will be created for each namespace. 每个命名空间都会创建一个缓存的实例对象
 * 

 * The cache implementation must have a constructor that receives the cache id as an String parameter.
 * 继承{@link Cache}的实现类必须有一个可接收一个缓存ID的String类型参数的构造函数
 * 

 * MyBatis will pass the namespace as id to the constructor.
 * Mybatis会将命名空间作为id传入构造方法
 *
 * 
 * public MyCache(final String id) {
 *  if (id == null) {
 *    throw new IllegalArgumentException("Cache instances require an ID");
 *  }
 *  this.id = id;
 *  initialize();
 * }
 * 
 * @author Clinton Begin
 */

public interface Cache {

  /**
   * 获取缓存对象的唯一标识,一般是Mapper.xml的命名空间
   * @return The identifier of this cache
   */
  String getId();

  /**
   * 保存key/value到缓存对象中
   * @param key Can be any object but usually it is a {@link CacheKey} 可以是任何对象，但一般是CacheKey对象
   * @param value The result of a select. 查询结果
   */
  void putObject(Object key, Object value);

  /**
   * 从缓存对象中获取key对应的value
   * @param key The key
   * @return The object stored in the cache.
   */
  Object getObject(Object key);

  /**
   * 

   *     移除key对应的value
   * 
   * As of 3.3.0 this method is only called during a rollback
   * for any previous value that was missing in the cache.
   * This lets any blocking cache to release the lock that
   * may have previously put on the key.
   * A blocking cache puts a lock when a value is null
   * and releases it when the value is back again.
   * This way other threads will wait for the value to be
   * available instead of hitting the database.
   * 在3.3.0后，这个方法只是在回滚在缓存中丢失了的任何之前的值。
   * 这使得任何一个阻塞缓存释放可能之前写入键的锁。
   * 一个阻塞缓存当值为null时加一个锁，在值再次后台时释放这个所。
   * 这样其他线程会等待可用的价值,而不是数据库。
   * @param key The key
   * @return Not used
   */
  Object removeObject(Object key);

  /**
   * Clears this cache instance.
   * 清空缓存
   */
  void clear();

  /**
   * Optional. This method is not called by the core.
   * 获取缓存对象中存储的键/值对的数量
   * @return The number of elements stored in the cache (not its capacity).
   */
  int getSize();

  /**
   * 获取读写锁，这个方法mybatis的所有Cache实现类都没有重写过，都是直接返回null
   * 

   *   从3.2.6起这个方法不再被框架核心调用,任何需要的锁，都必须由缓存供应商提供
   * 
   * Optional. As of 3.2.6 this method is no longer called by the core.
   * 

   * Any locking needed by the cache must be provided internally by the cache provider.
   *
   * @return A ReadWriteLock
   */
  ReadWriteLock getReadWriteLock();

}

PerpetualCache

/**
 *    Copyright 2009-2018 the original author or authors.
 *
 *    Licensed under the Apache License, Version 2.0 (the "License");
 *    you may not use this file except in compliance with the License.
 *    You may obtain a copy of the License at
 *
 *       http://www.apache.org/licenses/LICENSE-2.0
 *
 *    Unless required by applicable law or agreed to in writing, software
 *    distributed under the License is distributed on an "AS IS" BASIS,
 *    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 *    See the License for the specific language governing permissions and
 *    limitations under the License.
 */
package org.apache.ibatis.cache.impl;

import java.util.HashMap;
import java.util.Map;
import java.util.concurrent.locks.ReadWriteLock;

import org.apache.ibatis.cache.Cache;
import org.apache.ibatis.cache.CacheException;

/**
 * 永久缓存 Cache接口实现类,里面就是维护着一个HashMap
 * 

 *     Cache接口只有这唯一一个基础实现，其他实现类全都是装饰模式持有另一个缓存对象
 * 
 * @author Clinton Begin
 */
public class PerpetualCache implements Cache {

  /**
   * 缓存对象的唯一标识
   */
  private final String id;

  /**
   * 对象内部维护的HashMap,缓存Map
   */
  private Map cache = new HashMap<>();

  public PerpetualCache(String id) {
    this.id = id;
  }

  @Override
  public String getId() {
    return id;
  }

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

  @Override
  public void putObject(Object key, Object value) {
    cache.put(key, value);
  }

  @Override
  public Object getObject(Object key) {
    return cache.get(key);
  }

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

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

  @Override
  public ReadWriteLock getReadWriteLock() {
    return null;
  }

  /**
   * 通过判断ID去实现相等,如果当前类型对象的ID属性为null会抛出{@link CacheException}
   */
  @Override
  public boolean equals(Object o) {
    if (getId() == null) {
      throw new CacheException("Cache instances require an ID.");
    }
    //地址判断
    if (this == o) {
      return true;
    }
    //是否是子类
    if (!(o instanceof Cache)) {
      return false;
    }

    Cache otherCache = (Cache) o;
    //判断ID
    return getId().equals(otherCache.getId());
  }

  /**
   * 以为属性ID的hashCode作为本类对象的hashCode，如果当前类型对象的ID属性为null会抛出{@link CacheException}
   */
  @Override
  public int hashCode() {
    if (getId() == null) {
      throw new CacheException("Cache instances require an ID.");
    }
    return getId().hashCode();
  }

}

FifoCache

/**
 *    Copyright 2009-2019 the original author or authors.
 *
 *    Licensed under the Apache License, Version 2.0 (the "License");
 *    you may not use this file except in compliance with the License.
 *    You may obtain a copy of the License at
 *
 *       http://www.apache.org/licenses/LICENSE-2.0
 *
 *    Unless required by applicable law or agreed to in writing, software
 *    distributed under the License is distributed on an "AS IS" BASIS,
 *    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 *    See the License for the specific language governing permissions and
 *    limitations under the License.
 */
package org.apache.ibatis.cache.decorators;

import java.util.Deque;
import java.util.LinkedList;
import java.util.concurrent.locks.ReadWriteLock;

import org.apache.ibatis.cache.Cache;

/**
 * FIFO (first in, first out) cache decorator.
 * 使用先进先出缓存策略的缓存装饰类
 * @author Clinton Begin
 */
public class FifoCache implements Cache {

  /**
   * 委托Cache对象
   */
  private final Cache delegate;
  /**
   * 键列表
   * 

   *     Deque是Queue的子接口,我们知道Queue是一种队列形式,而Deque则是双向队列,它支持从两个端点方向检索和插入元素,
   *     因此Deque既可以支持LIFO形式也可以支持LIFO形式.Deque接口是一种比Stack和Vector更为丰富的抽象数据形式,因为它同时实现了以上两者.
   * 
   * 

   *     初始化时，该属性的实现类默认是{@link LinkedList}
   * 
   */
  private final Deque