MyBatis 源码深度拆解(七):一级缓存底层彻底拆解

// org.apache.ibatis.cache.impl.PerpetualCachepublic class PerpetualCache implements Cache {    private final String id;    private final Map<Object, Object> cache = new HashMap<>();    public PerpetualCache(String id) {        this.id = id;    }    @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();    }    // ... 其他方法}

public abstract class BaseExecutor implements Executor {    protected PerpetualCache localCache;    protected PerpetualCache localOutputParameterCache;    public BaseExecutor(Configuration configuration, Transaction transaction) {        this.localCache = new PerpetualCache("LocalCache");        this.localOutputParameterCache = new PerpetualCache("LocalOutputParameterCache");        // ...    }}

@Overridepublic CacheKey createCacheKey(MappedStatement ms, Object parameterObject, RowBounds rowBounds, BoundSql boundSql) {    if (closed) {        throw new ExecutorException("Executor was closed.");    }    CacheKey cacheKey = new CacheKey();    // 1. MappedStatement 的 id（namespace + id）    cacheKey.update(ms.getId());    // 2. RowBounds 的 offset 和 limit    cacheKey.update(rowBounds.getOffset());    cacheKey.update(rowBounds.getLimit());    // 3. SQL 字符串（已替换 #{} 为 ?）    cacheKey.update(boundSql.getSql());    // 4. 参数值（按顺序）    List<ParameterMapping> parameterMappings = boundSql.getParameterMappings();    TypeHandlerRegistry typeHandlerRegistry = ms.getConfiguration().getTypeHandlerRegistry();    MetaObject metaObject = null;    for (ParameterMapping parameterMapping : parameterMappings) {        // 存储过程的 OUT 参数不参与缓存 Key 计算        if (parameterMapping.getMode() != ParameterMode.OUT) {            Object value;            String propertyName = parameterMapping.getProperty();            if (boundSql.hasAdditionalParameter(propertyName)) {                // 优先从附加参数中获取（如 <bind> 定义的变量）                value = boundSql.getAdditionalParameter(propertyName);            } else if (parameterObject == null) {                value = null;            } else if (typeHandlerRegistry.hasTypeHandler(parameterObject.getClass())) {                // 参数本身是简单类型，直接使用                value = parameterObject;            } else {                // 通过反射获取 POJO 的属性值                if (metaObject == null) {                    metaObject = configuration.newMetaObject(parameterObject);                }                value = metaObject.getValue(propertyName);            }            cacheKey.update(value);        }    }    if (configuration.getEnvironment() != null) {        // 5. 环境 id（若存在多环境）        cacheKey.update(configuration.getEnvironment().getId());    }    return cacheKey;}

public class CacheKey implements Cloneable, Serializable {    private static final int DEFAULT_MULTIPLYER = 37;    private static final int DEFAULT_HASHCODE = 17;    private final int multiplier = DEFAULT_MULTIPLYER;    private int hashcode = DEFAULT_HASHCODE;    private long checksum = 0;    private int count = 0;    private List<Object> updateList = new ArrayList<>();    publicvoidupdate(Object object) {        int baseHashCode = object == null ? 1 : ArrayUtil.hashCode(object);        count++;        checksum += baseHashCode;        baseHashCode *= count;        hashcode = multiplier * hashcode + baseHashCode;        updateList.add(object);    }    @Override    public boolean equals(Object object) {        // 比较 hashcode、checksum、count 以及 updateList 中的每个元素        // 只有当所有要素都相等时，才认为两个 CacheKey 相等    }}

@Override  public <E> List<E> query(MappedStatement ms, Object parameter, RowBounds rowBounds, ResultHandler resultHandler,      CacheKey key, BoundSql boundSql) throws SQLException {    // 用于记录当前执行的 SQL 资源信息，便于调试和错误报告    ErrorContext.instance().resource(ms.getResource()).activity("executing a query").object(ms.getId());    if (closed) {      throw new ExecutorException("Executor was closed.");    }    // 1. 如果 flushCacheRequired 为 true（如 <select flushCache="true">），清空本地缓存    if (queryStack == 0 && ms.isFlushCacheRequired()) {      clearLocalCache();    }    List<E> list;    try {      queryStack++;      // 2. 尝试从一级缓存获取      list = resultHandler == null ? (List<E>) localCache.getObject(key) : null;      if (list != null) {        // 缓存命中，处理存储过程的输出参数（如果存在）        handleLocallyCachedOutputParameters(ms, key, parameter, boundSql);      } else {        // 3. 未命中，从数据库查询        list = queryFromDatabase(ms, parameter, rowBounds, resultHandler, key, boundSql);      }    } finally {      queryStack--;    }    if (queryStack == 0) {      // 延迟加载（Lazy Load） 的核心      for (DeferredLoad deferredLoad : deferredLoads) {        deferredLoad.load();      }      // issue #601      deferredLoads.clear();      if (configuration.getLocalCacheScope() == LocalCacheScope.STATEMENT) {        // issue #482        clearLocalCache();      }    }    return list;  }

// BaseExecutorprivate <E> List<E> queryFromDatabase(MappedStatement ms, Object parameter, RowBounds rowBounds,                                      ResultHandler resultHandler, CacheKey key, BoundSql boundSql) {    List<E> list;    // 先放入占位符，防止并发查询时重复查库（实际是避免递归查询死循环）    localCache.putObject(key, EXECUTION_PLACEHOLDER);    try {        list = doQuery(ms, parameter, rowBounds, resultHandler, boundSql);    } finally {        localCache.removeObject(key);    }    // 将真实结果存入缓存    localCache.putObject(key, list);    //对这步感兴趣的小伙伴可以去研究研究O(∩_∩)O哈~  为什么要缓存参数？    if (ms.getStatementType() == StatementType.CALLABLE) {      localOutputParameterCache.putObject(key, parameter);    }    return list;}

// BaseExecutorprivate void handleLocallyCachedOutputParameters(MappedStatement ms, CacheKey key, Object parameter, BoundSql boundSql) {    if (ms.getStatementType() == StatementType.CALLABLE) {        // 从 localOutputParameterCache 中取出之前缓存的 OUT 参数        final Object cachedOutputParameter = localOutputParameterCache.getObject(key);        // 将缓存的 OUT 参数值设置回 parameter 对象中        // 具体实现省略...    }}

// BaseExecutor@Overridepublic int update(MappedStatement ms, Object parameter) {    ErrorContext.instance().resource(ms.getResource()).activity("executing an update").object(ms.getId());    if (closed) {        throw new ExecutorException("Executor was closed.");    }    clearLocalCache();   // 任何更新操作都会清空一级缓存    return doUpdate(ms, parameter);}

// SqlSession 接口方法voidclearCache();

@Overridepublic void clearCache() {    executor.clearLocalCache();}

<settingname="localCacheScope"value="STATEMENT"/>

// BaseExecutor.query 方法最后if (configuration.getLocalCacheScope() == LocalCacheScope.STATEMENT) {    clearLocalCache();}

<select id="selectUser" resultType="User" flushCache="true">    SELECT * FROM user WHERE id = #{id}</select>

if (queryStack == 0 && ms.isFlushCacheRequired()) {    clearLocalCache();}

// CachingExecutor.queryCache cache = ms.getCache();if (cache != null) {    // 先尝试从二级缓存获取（实际是 TransactionalCache）    list = tcm.getObject(cache, key);    if (list == null) {        // 二级缓存未命中，调用 delegate.query（即 BaseExecutor.query）        list = delegate.query(...);        // 将结果存入事务缓存        tcm.putObject(cache, key, list);    }    return list;}// 没有二级缓存，直接走 BaseExecutorreturn delegate.query(...);