6. MyBatis - 深度学习 -缓存的原理

秒速五厘米 2023-07-03 06:18 5阅读 0赞

## 前言 ##

在使用MyBatis进行开发过程中，必须要了解的就是它的一级缓存、二级缓存

## 一级缓存命中条件 ##

**一级缓存的使用条件**：必须在**同一个会话**（session）的**同一个mapper**（namespace）的**同一个方法**（statement），而且需要**相同的SQL与参数**。

StudentMapper mapper = session.getMapper(StudentMapper.class);
    Student student1 = mapper.selectInterface(1);
    Student student2 = mapper.selectInterface(1);
    // 返回 true
    System.out.println(student1 == student2);

**一级缓存的失效条件**：执行 `session.clearCache()`方法，以及 insert、update、delete 语句（无论变动数据是否与缓存数据有关，都会清除）

StudentMapper mapper = session.getMapper(StudentMapper.class);
    Student student1 = mapper.selectInterface(1);
    session.clearCache();
    Student student2 = mapper.selectInterface(1);
    // 返回 false
    System.out.println(student1 == student2);

## 一级缓存原理解析 ##

Demo

String resource = "mybatis-config.xml";
    InputStream inputStream = Resources.getResourceAsStream(resource);
    SqlSessionFactory factory = new SqlSessionFactoryBuilder().build(inputStream);
    SqlSession session = factory.openSession(true);
    // 其实内部创建了个 jdk动态代理类，MapperProxy 来处理
    StudentMapper mapper = session.getMapper(StudentMapper.class);
    // 本次着重分析这块
    Student student = mapper.selectInterface(1);
    System.out.println(student);

@Select("select id,name,cls_id as clsId,create_time as createTime from student where id = #{id}")
    Student selectInterface(Integer id);

当我们执行selectInterface方法时，动态代理拦截了此类

public class MapperProxy<T> implements InvocationHandler, Serializable { 
    @Override
      public Object invoke(Object proxy, Method method, Object[] args) throws Throwable { 
        // 如果是第一次调用方法，就进行方法的解析，比如是 SELECT、UPDATE 还是....
        final MapperMethod mapperMethod = cachedMapperMethod(method);
        // 执行
        return mapperMethod.execute(sqlSession, args);
      }
    
    }

根据上面解析的MapperMethod，进行调用

public class MapperMethod { 
    	public Object execute(SqlSession sqlSession, Object[] args) { 
        Object result;
        switch (command.getType()) { 
          case INSERT: { 
            // 增
          }
          case UPDATE: { 
            // 改
            break;
          }
          case DELETE: { 
            // 删
          }
          case SELECT:
            // 参数
            Object param = method.convertArgsToSqlCommandParam(args);
            // 查询
            result = sqlSession.selectOne(command.getName(), param);
            break;
          case FLUSH:
            result = sqlSession.flushStatements();
            break;
          default:
            // 未知方法
        }
    
        return result;
      }
    }

执行 DefaultSqlSession的selectOne

public class DefaultSqlSession implements SqlSession { 
      // 1
      @Override
      public <T> T selectOne(String statement, Object parameter) { 
        // 只允许返回null or 0条结果，否则跑出异常
        List<T> list = this.<T>selectList(statement, parameter);
        if (list.size() == 1) { 
          return list.get(0);
        } else if (list.size() > 1) { 
          throw new TooManyResultsException(...);
        } else { 
          return null;
        }
      }
      
      //2
      @Override
      public <E> List<E> selectList(String statement, Object parameter) { 
        return this.selectList(statement, parameter, RowBounds.DEFAULT);
      }
      
      //3
      @Override
      public <E> List<E> selectList(String statement, Object parameter, RowBounds rowBounds) { 
          MappedStatement ms = configuration.getMappedStatement(statement);
          // 执行CachingExecutor#query
          return executor.query(
            ms, wrapCollection(parameter), rowBounds, Executor.NO_RESULT_HANDLER);
      }
    }

执行CachingExecutor中，先查询是否命中二级

public class CachingExecutor implements Executor { 
      
      // 1
      @Override
      public <E> List<E> query(
        MappedStatement ms, Object parameterObject, 
        RowBounds rowBounds, ResultHandler resultHandler) throws SQLException { 
        // 包裹sql
        BoundSql boundSql = ms.getBoundSql(parameterObject);
        // 缓存key,其实就是计算唯一标识，这个后面补充
        CacheKey key = createCacheKey(ms, parameterObject, rowBounds, boundSql);
        // 查询
        return query(ms, parameterObject, rowBounds, resultHandler, key, boundSql);
      }
      
      // 2 
      @Override
      public <E> List<E> query(MappedStatement ms, Object parameterObject, RowBounds rowBounds, ResultHandler resultHandler, CacheKey key, BoundSql boundSql)
          throws SQLException { 
        Cache cache = ms.getCache();
        if (cache != null) { 
          // 命中二级缓存，下面讲解，先知道个点就行
        }
        // SimpleExecutor#query
        return delegate.<E> query(ms, parameterObject, rowBounds, resultHandler, key, boundSql);
      }
    }

其实这里执行的 SimpleExcutor\#query方法，但方法都在BaseExecutor

public abstract class BaseExecutor implements Executor { 
       // 缓存
     	 protected PerpetualCache localCache;
      
        @Override
      public <E> List<E> query(MappedStatement ms, Object parameter, RowBounds rowBounds, ResultHandler resultHandler, CacheKey key, BoundSql boundSql) throws SQLException { 
    		....
        if (queryStack == 0 && ms.isFlushCacheRequired()) { 
          clearLocalCache();
        }
        // 先从缓存中取
        list = resultHandler == null ? (List<E>) localCache.getObject(key) : null;
        if (list != null) { 
          // 缓存中拿到值，就使用缓存中的
          handleLocallyCachedOutputParameters(ms, key, parameter, boundSql);
        } else { 
          // 从数据库中查询，并记录缓存
          list = queryFromDatabase(ms, parameter, rowBounds, resultHandler, key, boundSql);
        }
        return list;
      }
    
    	private <E> List<E> queryFromDatabase(MappedStatement ms, Object parameter, RowBounds rowBounds, ResultHandler resultHandler, CacheKey key, BoundSql boundSql) throws SQLException { 
        List<E> list;
        localCache.putObject(key, EXECUTION_PLACEHOLDER);
        try { 
          // 从数据库中查询
          list = doQuery(ms, parameter, rowBounds, resultHandler, boundSql);
        } finally { 
          // 无论任何情况，先移出key
          localCache.removeObject(key);
        }
        // 成功加入缓存
        localCache.putObject(key, list);
        // 存储过程的话，再保存一个
        if (ms.getStatementType() == StatementType.CALLABLE) { 
          localOutputParameterCache.putObject(key, parameter);
        }
        return list;
      }
      
    }

**上面就已经把一级缓存的关键代码圈出来了，接下来我们来看下什么时候创建了SimpleExcutor，这样也就知道一级缓存的生命周期了**

// 回到我们的源码
    SqlSessionFactory factory = new SqlSessionFactoryBuilder().build(inputStream);
    SqlSession session = factory.openSession(true);
    StudentMapper mapper = session.getMapper(StudentMapper.class);

public class DefaultSqlSessionFactory implements SqlSessionFactory { 
      @Override
      public SqlSession openSession(boolean autoCommit) { 
        return openSessionFromDataSource(configuration.getDefaultExecutorType(), null, autoCommit);
      }
    
        private SqlSession openSessionFromDataSource(ExecutorType execType, TransactionIsolationLevel level, boolean autoCommit) { 
          // 事务管理
          final TransactionFactory transactionFactory = getTransactionFactoryFromEnvironment(environment);
          tx = transactionFactory.newTransaction(environment.getDataSource(), level, autoCommit);
          // 创建 Executor
          final Executor executor = configuration.newExecutor(tx, execType);
          // 创建会话
          return new DefaultSqlSession(configuration, executor, autoCommit);
      }
      
    }

查看创建

public class Configuration { 
      
    	public Executor newExecutor(Transaction transaction, ExecutorType executorType) { 
        executorType = executorType == null ? defaultExecutorType : executorType;
        executorType = executorType == null ? ExecutorType.SIMPLE : executorType;
        Executor executor;
        if (ExecutorType.BATCH == executorType) { 
          // 批量处理
          executor = new BatchExecutor(this, transaction);
        } else if (ExecutorType.REUSE == executorType) { 
          // 重复使用
          executor = new ReuseExecutor(this, transaction);
        } else { 
          // 简单,其实就是走整个
          executor = new SimpleExecutor(this, transaction);
        }
        if (cacheEnabled) { 
          // 用cache包裹，装饰模式
          executor = new CachingExecutor(executor);
        }
        executor = (Executor) interceptorChain.pluginAll(executor);
        return executor;
      }
    }

证明localCache 也就是一级缓存其存储作用域为Session

public class SimpleExecutor extends BaseExecutor { 
    
      public SimpleExecutor(Configuration configuration, Transaction transaction) { 
        super(configuration, transaction);
      }
      
    }

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

我们来看下缓存的结构，基于 PerpetualCache 的 HashMap 本地缓存

public class PerpetualCache implements Cache { 
      ....
      private Map<Object, Object> cache = new HashMap<Object, Object>();
      ...
      @Override
      public void putObject(Object key, Object value) { 
        cache.put(key, value);
      }
    
      @Override
      public Object getObject(Object key) { 
        return cache.get(key);
      }
    }

进行了 C/U/D 操作后，默认该作用域下所有 select 中的缓存将被clear

public abstract class BaseExecutor implements Executor { 
     
     @Override
     public int update(MappedStatement ms, Object parameter) throws SQLException { 
       // 别看名字叫update，实际 insert、update、delete都会执行到这里
       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);
     }
     
     @Override
     public void clearLocalCache() { 
       if (!closed) { 
         localCache.clear();
         localOutputParameterCache.clear();
       }
     }
    }

## 二级缓存 ##

二级缓存的使用条件：必须在**会话提交或关闭之后才会填充二级缓存**（session）的**同一个mapper**（namespace）的**同一个方法**（statement），而且需要**相同的SQL与参数**。并且 `readWrite=true` 实体对象必须实现 Serializable 接口。

二级缓存的失效条件：

1.  xml中配置的update不能清空 @CacheNamespace 中的缓存数据，因为与接口不属于同一命名空间缓存
2.  只有修改的的时候提交之后，才会执行清除操作
3.  任何一种增删改查操作，都会清空整个 namespace 的数据

### demo ###

@CacheNamespace(readWrite = false, flushInterval = 60000)
    public interface StudentMapper { 
        @Select("select id,name,cls_id as clsId,create_time as createTime from student where id = #{id}")
        Student selectInterface(Integer id);
    }

@Test
    public void twoLevelCache() throws IOException { 
      String resource = "mybatis-config.xml";
      InputStream inputStream = Resources.getResourceAsStream(resource);
      SqlSessionFactory factory = new SqlSessionFactoryBuilder().build(inputStream);
      SqlSession session1 = factory.openSession(true);
      Student student1 = session1
        .getMapper(StudentMapper.class)
        .selectInterface(1);
      // 关闭会话一，不关闭不会记录二级缓存
      session1.close();
      // 查询会话二
      Student student2 = factory.openSession(true)
        .getMapper(StudentMapper.class)
        .selectInterface(1);
      // 查看是否为同一对象
      System.out.println(student1 == student2);
    }

### 源码 - 命中 ###

关键代码，上面已经知道CacheExcutor执行query的时候，优先二级，我们来看下二级缓存的源码注释

public class CachingExecutor implements Executor { 
      private final TransactionalCacheManager tcm = new TransactionalCacheManager();
      
    	@Override
      public <E> List<E> query(MappedStatement ms, Object parameterObject, RowBounds rowBounds, ResultHandler resultHandler, CacheKey key, BoundSql boundSql)
          throws SQLException { 
        // 如果有注解 CacheNamespace 则此处不为空 cache = 
        Cache cache = ms.getCache();
        // 是否启动二级缓存
        if (cache != null) { 
          /* * 是否将flushCache其设置为 true 后， * 只要语句被调用，都会导致本地缓存和二级缓存被清空，默认值：false */
          flushCacheIfRequired(ms);
          // 是否使用缓存 && resultHandler == null
          if (ms.isUseCache() && resultHandler == null) { 
            // 确认是否支持，主要是判断存储过程时，如果打开缓存就报错
            ensureNoOutParams(ms, boundSql);
            // 从二级缓存中取值，也就是 TransactionalCacheManager#getObject(cache, key);
            @SuppressWarnings("unchecked")
            List<E> list = (List<E>) tcm.getObject(cache, key);
            if (list == null) { 
              // SimpleExecutor#query
              list = delegate.<E> query(ms, parameterObject, rowBounds, resultHandler, key, boundSql);
              // 记录二级缓存 TransactionalCache#putObject 
              tcm.putObject(cache, key, list); // issue #578 and #116
            }
            return list;
          }
        }
        // SimpleExecutor#query
        return delegate.<E> query(ms, parameterObject, rowBounds, resultHandler, key, boundSql);
      }
      
    }

如果没命中，最终put到这里

public class TransactionalCache implements Cache { 
      
      @Override
      public void putObject(Object key, Object object) { 
        entriesToAddOnCommit.put(key, object);
      }
      
    }

### 源码 - 获取缓存的关键 ###

上面源码的位置，继续往下

// 从二级缓存中取值，也就是 TransactionalCacheManager#getObject(cache, key);
    @SuppressWarnings("unchecked")
    List<E> list = (List<E>) tcm.getObject(cache, key);

因为不难，也没有特别复杂的代码，我直接贴调用链把

getObject:35, TransactionalCacheManager (org.apache.ibatis.cache)
    getObject:68, TransactionalCache (org.apache.ibatis.cache.decorators)
    getObject:50, SynchronizedCache (org.apache.ibatis.cache.decorators)
    getObject:57, LoggingCache (org.apache.ibatis.cache.decorators)
    getObject:60, ScheduledCache (org.apache.ibatis.cache.decorators)
    getObject:74, LruCache (org.apache.ibatis.cache.decorators)
    getObject:55, PerpetualCache (org.apache.ibatis.cache.impl)

### 源码 - 保存缓存的关键 ###

不知道你有没有发现，我们上面只是将二级缓存保存到当前的会话中，并没有实现跨会话？

`对上面这句话有疑问？看下下面代码`

// 你每次创建一个session的时候，也对应创建一个CachingExecutor，那就是说CachingExecutor是会话级生命周期
    public class CachingExecutor implements Executor { 
      private final TransactionalCacheManager tcm = new TransactionalCacheManager();
    }

我们来看下，什么时候把会话的二级缓存刷新到全局的

// 我们代码关闭session的时候
    session1.close();

public class DefaultSqlSession implements SqlSession { 
      @Override
      public void close() { 
        try { 
          executor.close(isCommitOrRollbackRequired(false));
          closeCursors();
          dirty = false;
        } finally { 
          ErrorContext.instance().reset();
        }
      }
    }

public class CachingExecutor implements Executor { 
      private final TransactionalCacheManager tcm = new TransactionalCacheManager();
      
      @Override
      public void close(boolean forceRollback) { 
        try { 
          //issues #499, #524 and #573
          if (forceRollback) {  
            tcm.rollback();
          } else { 
            tcm.commit();
          }
        } finally { 
          delegate.close(forceRollback);
        }
      }
      
    }

public class TransactionalCacheManager { 
        private final Map<Cache, TransactionalCache> transactionalCaches = new HashMap<Cache, TransactionalCache>();
    
      
      public void commit() { 
        for (TransactionalCache txCache : transactionalCaches.values()) { 
          txCache.commit();
        }
      }
      
      public void rollback() { 
        for (TransactionalCache txCache : transactionalCaches.values()) { 
          // TransactionalCache
          txCache.rollback();
        }
      }
    }

public class TransactionalCache implements Cache { 
      public void commit() { 
        if (clearOnCommit) { 
          delegate.clear();
        }
        // 刷新未处理的二级缓存到,SynchronizedCache中
        flushPendingEntries();
        reset();
      }
    
      public void rollback() { 
        // 从代理中删除二级缓存
        unlockMissedEntries();
        reset();
      }
      
      private void flushPendingEntries() { 
        for (Map.Entry<Object, Object> entry : entriesToAddOnCommit.entrySet()) { 
          // SynchronizedCache#putObject
          delegate.putObject(entry.getKey(), entry.getValue());
        }
        for (Object entry : entriesMissedInCache) { 
          if (!entriesToAddOnCommit.containsKey(entry)) { 
            delegate.putObject(entry, null);
          }
        }
      }
    
      private void unlockMissedEntries() { 
        for (Object entry : entriesMissedInCache) { 
          try { 
            // SynchronizedCache#removeObject
            delegate.removeObject(entry);
          } catch (Exception e) { 
            log.warn("Unexpected exception while notifiying a rollback to the cache adapter."
                + "Consider upgrading your cache adapter to the latest version. Cause: " + e);
          }
        }
      }
    }

调用链

putObject:45, SynchronizedCache (org.apache.ibatis.cache.decorators)
    putObject:51, LoggingCache (org.apache.ibatis.cache.decorators)
    putObject:55, ScheduledCache (org.apache.ibatis.cache.decorators)
    putObject:67, LruCache (org.apache.ibatis.cache.decorators)
    putObject:50, PerpetualCache (org.apache.ibatis.cache.impl)

## 在线图解 ##

![img][]

## 总结 ##

### 一级缓存 ###

1.  一级缓存其存储作用域为Session
2.  必须在**同一个会话**（session）的**同一个mapper**（namespace）的**同一个方法**（statement），而且需要**相同的SQL与参数**。
3.  基于 PerpetualCache 的 HashMap 本地缓存
4.  进行了 C/U/D 操作后，默认该作用域下所有 select 中的缓存将被clear
5.  当 Session flush 或 close 之后，该 Session 中的所有 Cache 就将清空，默认打开一级缓存

### 二级缓存 ###

二级缓存的失效条件：

[img]: https://imgconvert.csdnimg.cn/aHR0cDovL2Fzc2V0cy5wcm9jZXNzb24uY29tL2NoYXJ0X2ltYWdlLzVlMzRjZWM2ZTRiMDA2YTQzYWU4ODVjMC5wbmc?x-oss-process=image/format,png