素文宅

ORM - MyBatis 二级缓存实现机制详解

2022年8月1日
大约 14 分钟

ORM - MyBatis 二级缓存实现机制详解

前置准备

既然要看MyBatis源码，当然是把源码拉取下来debug一步一步看才方便呢，这里已经拉取下来，并准备好例子了。

/**
 * @author ikcross
 * @date 2022/5/9 17:31
 */
@Slf4j
public class Main {
  public static void main(String[] args) {
    String resource = "org/apache/ibatis/yyqtest/resource/mybatis-config.xml";
    InputStream inputStream = null;
    try {
      // 将XML配置文件构建为Configuration配置类
      inputStream = Resources.getResourceAsStream(resource);
    } catch (IOException e) {
      // TODO Auto-generated catch block
      e.printStackTrace();
    }
    // 通过加载配置文件流构建一个SqlSessionFactory DefaultSqlSessionFactory
    SqlSessionFactory sqlSessionFactory = null;
    sqlSessionFactory = new SqlSessionFactoryBuilder().build(inputStream);
    SqlSession sqlSession = null;
    try {
      sqlSession = sqlSessionFactory.openSession();
      RoleMapper roleMapper = sqlSession.getMapper(RoleMapper.class);
      //Role role = roleMapper.testManyParam(1L, "张三");
      //Role role = roleMapper.testAnnotation(1L);
      Role role = roleMapper.testDynamicParam(1L, "");

      log.info(role.getId() + ":" + role.getRoleName() + ":" + role.getNote());
      sqlSession.commit();

    } catch (Exception e) {
      // TODO Auto-generated catch block
      sqlSession.rollback();
      e.printStackTrace();
    } finally {
      sqlSession.close();
    }
  }
}

从上诉例子来看，我们观察到首先是解析配置文件，再获取SqlSession，获取到Sqlsession之后在进行各种的CRUD操作，我们先来看下SqlSession是怎么获取的。

SqlSession与SqlSessionFactory

图

​我们根据时序图，一步一步解开SqlSession的执行流程，首先来是通过SqlSessionFactoryBuilder解析配置文件，再根据配置文件构建并返回一个DefaultSqlSessionFactory，源码如下：

public SqlSessionFactory build(InputStream inputStream, String environment, Properties properties) {
  try {
    // 2. 创建XMLConfigBuilder对象用来解析XML配置文件，生成Configuration对象
    XMLConfigBuilder parser = new XMLConfigBuilder(inputStream, environment, properties);
    // 3. 将XML配置文件内的信息解析成Java对象Configuration对象
    Configuration config = parser.parse();
    // 4. 根据Configuration对象创建出SqlSessionFactory对象
    return build(config);
  } catch (Exception e) {
    throw ExceptionFactory.wrapException("Error building SqlSession.", e);
  } finally {
    ErrorContext.instance().reset();
    try {
      if (inputStream != null) {
        inputStream.close();
      }
    } catch (IOException e) {
      // Intentionally ignore. Prefer previous error.
    }
  }
}

public SqlSessionFactory build(Configuration config) {
  return new DefaultSqlSessionFactory(config);
}

拿到SqlSessionFactory之后，就可以根据这个SqlSessionFactory拿到SqlSession对象，源码如下：

private SqlSession openSessionFromDataSource(ExecutorType execType, TransactionIsolationLevel level, boolean autoCommit) {
  Transaction tx = null;
  try {
    final Environment environment = configuration.getEnvironment();
    final TransactionFactory transactionFactory = getTransactionFactoryFromEnvironment(environment);
    // 通过事务工厂从一个数据源来产生一个事务
    tx = transactionFactory.newTransaction(environment.getDataSource(), level, autoCommit);
    // 获取执行器，这边获得的执行器已经代理拦截器的功能
    final Executor executor = configuration.newExecutor(tx, execType);
    // 获取执行器后，再将configuration和executor封装成DefaultSqlSession
    return new DefaultSqlSession(configuration, executor, autoCommit);
  } catch (Exception e) {
    closeTransaction(tx); // may have fetched a connection so lets call close()
    throw ExceptionFactory.wrapException("Error opening session.  Cause: " + e, e);
  } finally {
    ErrorContext.instance().reset();
  }
}

通过上面两个步骤拿到SqlSession之后，就可以进行CRUD了

  • 将xml配置文件解析成流
  • SqlSessionFactory.build将配置文件解析成Configuration，并返回一个SqlSessionFactory对象
  • 拿到SqlSessionFactory对象之后，从Environment中拿到DataSource并产生一个事务
  • 根据事务Transaction和执行器类型（SIMPLE, REUSE, BATCH，默认是SIMPLE）获取一个执行器Executor（–>该对象非常重要，事实上sqlsession的所有操作都是通过它完成的）
  • 创建sqlsession对象。

MapperProxy

拿到Sqlsession对象之后，就可以拿到我们所写的xxxMapper，再根据这个xxxmapper就可以调用方法，最终进行CRUD。我们来关注下我们这个xxxMapper是一个接口，接口是不能被实例化的，为什么可以直接通过getMapper方式拿到呢？xxxMapper和我们的xxxMapper.xml文件之间又是如何联系的？别急，我们接着往下看。

我们先来看下时序图：

图

通过这个时序图可以看到是通过代理的方式来搞定的，当执行到自己写的方法里面的时候，其实通过了MapperProxy在进行代理。话不多说，我们直接来看下怎么获取MapperProxy对象的吧： 哦吼↑ ↓

DefaultSqlSession

/**
* 什么都不做，直接去configuration里面去找
* @param type Mapper interface class
* @param <T>
* @return
*/
@Override
public <T> T getMapper(Class<T> type) {
	return configuration.getMapper(type, this);
}

Configuration

// mapperRegistry实质上是一个Map，里面注册了启动过程中解析的各种Mapper.xml
protected final MapperRegistry mapperRegistry = new MapperRegistry(this);

/**
 * configuration也什么都不做，去mapperRegistry里面找
 * @param type
 * @param sqlSession
 * @param <T>
 * @return
 */
public <T> T getMapper(Class<T> type, SqlSession sqlSession) {
	return mapperRegistry.getMapper(type, sqlSession);
}

这里会发现，这个mapperRegistry是什么东西啊，mapperRegistry实质上是一个Map，里面注册了启动过程中解析的各种Mapper.xml。我们点进去看看

Map<Class<?>, MapperProxyFactory<?>> knownMappers = new HashMap<>();

​mapperRegistry的key是接口的Class类型

​mapperRegistry的Value是MapperProxyFactory,用于生成对应的MapperProxy（动态代理类）

​这里具体是怎么加进去的可以去了解了解解析配置的篇章，我们接着往下走，看看MapperRegistry的源码：

MapperRegistry

/**
 * MapperRegistry标识很无奈，没人做，只有我来做了
 * @param type
 * @param sqlSession
 * @param <T>
 * @return
 */
@SuppressWarnings("unchecked")
public <T> T getMapper(Class<T> type, SqlSession sqlSession) {
  // MapperRegistry表示也要偷懒，偷偷的把粗活交给MapperProxyFactory去做。
  final MapperProxyFactory<T> mapperProxyFactory = (MapperProxyFactory<T>) knownMappers.get(type);
  // 如果配置文件中没有配置相关Mapper,直接抛异常
  if (mapperProxyFactory == null) {
    throw new BindingException("Type " + type + " is not known to the MapperRegistry.");
  }
  try {
    // 我们看到mapper都是接口，因为接口是不能实例化的，这里通过动态代理实现,具体可以看下MapperProxy这个类
    return mapperProxyFactory.newInstance(sqlSession);
  } catch (Exception e) {
    throw new BindingException("Error getting mapper instance. Cause: " + e, e);
  }
}

MapperProxyFactory这里是将接口实例化的过程，我们进去看看：

MapperProxyFactory

public class MapperProxyFactory<T> {
  /**
   * 生成Mapper接口的动态代理类MapperProxy，MapperProxy实现了InvocationHandler接口
   *
   * @param mapperProxy
   * @return
   */
  @SuppressWarnings("unchecked")
  protected T newInstance(MapperProxy<T> mapperProxy) {
      // 动态代理，我们写的一些接口
    return (T) Proxy.newProxyInstance(mapperInterface.getClassLoader(), new Class[]{mapperInterface}, mapperProxy);
  }

  public T newInstance(SqlSession sqlSession) {
    final MapperProxy<T> mapperProxy = new MapperProxy<>(sqlSession, mapperInterface, methodCache);
    return newInstance(mapperProxy);
  }
}

​通过这个MapperProxyFactory就可以拿到类MapperProxy代理对象，简单来说，我们通过这个代理就可以很方便的去使用我们写的一些dao层的接口了，上例子

  RoleMapper roleMapper = sqlSession.getMapper(RoleMapper.class);
  Role role = roleMapper.testManyParam(1L, "张三");
  Role role = roleMapper.testAnnotation(1L);
  Role role = roleMapper.testDynamicParam(1L, "");

拿到这个对象之后，接下来就是sql语句的执行了呢，来，上源码，真正的主菜来了。

Executor

​ SqlSession只是一个门面，前面做的一些事情都只是铺垫，真正的的干事的其实是Excutor，SqlSession对数据库的操作都是通过Executor来完成的。与SqlSession一样，Executor也是动态创建的，老样子先上时序图：

图

在看MapperProxy的方法之前，我们先回到获取Excutor对象的方法configuration.newExecutor(tx, execType);

/**
 * Executor分成两大类，一类是CacheExecutor，另一类是普通Executor。
 *
 * @param transaction
 * @param executorType
 * @return
 */
public Executor newExecutor(Transaction transaction, ExecutorType executorType) {
  executorType = executorType == null ? defaultExecutorType : executorType;
  // 这句再做一下保护,囧,防止粗心大意的人将defaultExecutorType设成null?
  executorType = executorType == null ? ExecutorType.SIMPLE : executorType;
  Executor executor;
  // 普通Executor又分为三种基本的Executor执行器，SimpleExecutor、ReuseExecutor、BatchExecutor。
  if (ExecutorType.BATCH == executorType) {
    executor = new BatchExecutor(this, transaction);
  } else if (ExecutorType.REUSE == executorType) {
    // 执行update或select，以sql作为key查找Statement对象，存在就使用，不存在就创建，用完后，不关闭Statement对象，而是放置于Map<String,Statement>内，供下一次使用。简言之，就是重复使用Statement对象
    executor = new ReuseExecutor(this, transaction);
  } else {
    // 每执行一次update或select，就开启一个Statement对象，用完立刻关闭Statement对象。
    executor = new SimpleExecutor(this, transaction);
  }
  if (cacheEnabled) {
    // CacheExecutor其实是封装了普通的Executor，和普通的区别是在查询前先会查询缓存中
    // 是否存在结果，如果存在就使用缓存中的结果，如果不存在还是使用普通的Executor进行
    // 查询，再将查询出来的结果存入缓存。
    executor = new CachingExecutor(executor);
  }
  // 调用每个拦截器的方法，这里的话应该是为了方便扩展,方便开发者自定义拦截器做一些处理
  executor = (Executor) interceptorChain.pluginAll(executor);
  return executor;
}

从上诉代码可以看出，如果不开启缓存cache的话，创建的Executor只是3中基础类型之一，BatchExecutor专门用于执行批量sql操作，ReuseExecutor会重用statement执行sql操作，SimpleExecutor只是简单执行sql没有什么特别的。

​开启了缓存（默认开启），就会去创建CachingExecutor，这个缓存执行器在查询数据库前会先查找缓存是否存在结果，如果存在就使用缓存中的结果，如果不存在还是使用普通的Executor进行查询，再将查询出来的结果存入缓存。我们还看到这里有个加载插件的方法，就说明这里是可以被插件拦截的，如果定义了针对Executor类型的插件，最终生成的Executor对象是被各个插件插入后的代理对象。

​接下来，咱们才要真正的去了解sql的执行过程了。回到上面来看，我们拿到了MapperProxy，调用Mapper接口的所有方法都会优先调用到这个代理类的invoke方法（注意由于MyBatis中的Mapper接口没有实现类，所以MpperProxy这个代理对象中没有委托类，也就是说MapperProxy干了代理类和委托类的事情），具体是怎么做的，上源码：

MapperProxy

MapperProxy的invoke方法本质上是交给了MapperMethodInvoker，MapperMethodInvoker实质就是封装了一层MapperMethod。

/**
 * 通过动态代理后，所有的Mapper方法调用都会走这个invoke方法
 *
 * @param proxy
 * @param method
 * @param args
 * @return
 * @throws Throwable
 */
@Override
public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
  try {
    // 并不是任何一个方法都需要执行调用代理对象进行执行，如果这个方法是Object中通用的方法（toString、hashCode等）无需执行
    if (Object.class.equals(method.getDeclaringClass())) {
      return method.invoke(this, args);
    } else {
      // cachedInvoker封装了一个MapperMethod对象
      // 拆分出来更好理解
      MapperMethodInvoker mapperMethodInvoker = cachedInvoker(method);
      return mapperMethodInvoker.invoke(proxy, method, args, sqlSession);
    }
  } catch (Throwable t) {
    throw ExceptionUtil.unwrapThrowable(t);
  }
}

MapperMethod

根据参数和返回值类型选择不同的sqlSession来执行。这样mapper对象和sqlSession就真正关联起来了

/**
 * 这里其实就是先判断CRUD的类型，根据类型去选择到底执行了sqlSession中的哪个方法
 * @param sqlSession
 * @param args
 * @return
 */
public Object execute(SqlSession sqlSession, Object[] args) {
  Object result;
  switch (command.getType()) {
    case INSERT: {
      Object param = method.convertArgsToSqlCommandParam(args);
      result = rowCountResult(sqlSession.insert(command.getName(), param));
      break;
    }
    case UPDATE: {
      Object param = method.convertArgsToSqlCommandParam(args);
      result = rowCountResult(sqlSession.update(command.getName(), param));
      break;
    }
    case DELETE: {
      Object param = method.convertArgsToSqlCommandParam(args);
      result = rowCountResult(sqlSession.delete(command.getName(), param));
      break;
    }
    case SELECT:
      if (method.returnsVoid() && method.hasResultHandler()) {
        executeWithResultHandler(sqlSession, args);
        result = null;
      } else if (method.returnsMany()) {
        // 多条记录
        result = executeForMany(sqlSession, args);
      } else if (method.returnsMap()) {
        // 如果结果是map
        result = executeForMap(sqlSession, args);
      } else if (method.returnsCursor()) {
        result = executeForCursor(sqlSession, args);
      } else {
        // 从字面意义上看，讲转换的参数放到sql里面
        // Map<String, Object> param
        Object param = method.convertArgsToSqlCommandParam(args);
        result = sqlSession.selectOne(command.getName(), param);
        if (method.returnsOptional()
            && (result == null || !method.getReturnType().equals(result.getClass()))) {
          result = Optional.ofNullable(result);
        }
      }
      break;
    case FLUSH:
      result = sqlSession.flushStatements();
      break;
    default:
      throw new BindingException("Unknown execution method for: " + command.getName());
  }
  if (result == null && method.getReturnType().isPrimitive() && !method.returnsVoid()) {
    throw new BindingException("Mapper method '" + command.getName()
        + " attempted to return null from a method with a primitive return type (" + method.getReturnType() + ").");
  }
  return result;
}

既然又回到SqlSession了，前面提到过，sqlsession只是一个门面，真正发挥作用的是executor，对sqlsession方法的访问最终都会落到executor的相应方法上去。Executor分成两大类，一类是CacheExecutor，另一类是普通Executor。Executor的创建前面已经介绍了，那么咱们就看看SqlSession的CRUD方法了，为了省事，还是就选择其中的一个方法来做分析吧。这儿，咱们选择了selectList方法。这里有宝宝就好奇了，从上面的代码来看只有selectOne方法呢，哪里来的selectList。其实selectOne方法里面本质就是调用了selectList方法。

@Override
public <T> T selectOne(String statement, Object parameter) {
  // Popular vote was to return null on 0 results and throw exception on too many.
  // 转而去调用selectList,很简单的，如果得到0条则返回null，得到1条则返回1条，得到多条报TooManyResultsException错
  // 这里没有查询到结果的时候会返回null。因此一般建议mapper中编写resultType使用包装类型
  List<T> list = this.selectList(statement, parameter);
  if (list.size() == 1) {
    return list.get(0);
  } else if (list.size() > 1) {
    throw new TooManyResultsException("Expected one result (or null) to be returned by selectOne(), but found: " + list.size());
  } else {
    return null;
  }
}

石锤了！！！，接下来我们来看下selectList方法。

DefaultSqlSession

/**
 *
 * @param statement 全限定名称+方法名 例如org.apache.ibatis.yyqtest.mapper.RoleMapper.testAnnotation
 * @param parameter
 * @param rowBounds
 * @param handler
 * @param <E>
 * @return
 */
private <E> List<E> selectList(String statement, Object parameter, RowBounds rowBounds, ResultHandler handler) {
  try {
    // 根据传入的全限定命+方法名从映射的map中取出MappedStatement对象
    MappedStatement ms = configuration.getMappedStatement(statement);
    // 之类能看到CRUD实际上是交给Executor处理
    return executor.query(ms, wrapCollection(parameter), rowBounds, handler);
  } catch (Exception e) {
    throw ExceptionFactory.wrapException("Error querying database.  Cause: " + e, e);
  } finally {
    ErrorContext.instance().reset();
  }
}

​这里的statement是全限定名称+方法名字，例如org.apache.ibatis.yyqtest.mapper.RoleMapper.testAnnotation，具体怎么来的，可以自己debug看下是怎么得到的。这里的getMapperStatement做了什么呢。话不多说上源码。

 protected final Map<String, MappedStatement> mappedStatements = new StrictMap<MappedStatement>("Mapped Statements collection")
    .conflictMessageProducer((savedValue, targetValue) ->
      ". please check " + savedValue.getResource() + " and " + targetValue.getResource());

Configuration
public MappedStatement getMappedStatement(String id, boolean validateIncompleteStatements) {
  if (validateIncompleteStatements) {
    buildAllStatements();
  }
  return mappedStatements.get(id);
}

​映射的语句,存在Map里,这里应该是扫描配置文件的时候就已经加进去了 key是全限定名+方法名 value是对应的mappedStatements。这个MapperStatements方法到底有什么作用呢，我们先别急。先回到executor.query的方法继续往下走。

StatementHandler

可以看出，Executor本质上也是个甩手掌柜，具体的事情原来是StatementHandler来完成的。当Executor将指挥棒交给StatementHandler后，接下来的工作就是StatementHandler的事了。我们先看看StatementHandler是如何创建的：

public StatementHandler newStatementHandler(Executor executor, MappedStatement mappedStatement, Object parameterObject, RowBounds rowBounds, ResultHandler resultHandler, BoundSql boundSql) {
  StatementHandler statementHandler = new RoutingStatementHandler(executor, mappedStatement, parameterObject, rowBounds, resultHandler, boundSql);
  statementHandler = (StatementHandler) interceptorChain.pluginAll(statementHandler);
  return statementHandler;
}

可以看到每次创建的StatementHandler都是RoutingStatementHandler，它只是一个分发者，他一个属性delegate用于指定用哪种具体的StatementHandler。可选的StatementHandler有SimpleStatementHandler、PreparedStatementHandler和CallableStatementHandler三种。选用哪种在mapper配置文件的每个statement里指定，默认的是PreparedStatementHandler。同时还要注意到StatementHandler是可以被拦截器拦截的，和Executor一样，被拦截器拦截后的对像是一个代理对象。

tatementHandler创建后需要执行一些初始操作，比如statement的开启和参数设置、对于PreparedStatement还需要执行参数的设置操作等。代码如下：

private Statement prepareStatement(StatementHandler handler, Log statementLog) throws SQLException {
  Statement stmt;
  Connection connection = getConnection(statementLog);
  stmt = handler.prepare(connection, transaction.getTimeout());
  handler.parameterize(stmt);
  return stmt;
}

这里呢会创建一个StatementHandler对象，这个对象中同时会 封装ParameterHandler和ResultSetHandler对象。调用StatementHandler预编译参数 以及设置参数值，使用ParameterHandler来给sql设置参数。

参数设置完毕后，执行数据库操作（update或query）。如果是query最后还有个查询结果的处理过程。接下来，咱们看看StatementHandler 的一个实现类 PreparedStatementHandler（这也是我们最常用的，封装的是PreparedStatement）, 看看它使怎么去处理的：

@Override
public <E> List<E> query(Statement statement, ResultHandler resultHandler) throws SQLException {
  PreparedStatement ps = (PreparedStatement) statement;
  ps.execute();
  // 将处理好的结果交给了ResultSetHandler
  return resultSetHandler.handleResultSets(ps);
}

到这里，一次sql的执行流程就执行完了！

简单总结

获取SqlSession流程

  • SqlSessuibFactoryBuilder解析配置文件，并将这些配置放到一个Configuration对象，这个对象中包含了MyBatis需要的所有配置，然后会用这个Configuration对象再去创建一个SqlSessionFactory对象。
  • 拿到SqlSessionFactory对象后，会调用SqlSessionFactory的openSession方法，这个方法根据解析配置文件的事务和执行器类型来创建一个执行器，这个执行器就是真正sql的执行者。最后将执行器和configuration封装起来返回一个DefaultSqlSession
  • 拿到SqlSession之后就能执行各种CRUD的方法了。

Sql执行流程

  • 拿到SqlSession之后调用getMapper方法，拿到Maper接口的代理对象MapperProxy，调用Mapper接口的所有方法都会调用MapperProxy的invoke方法。
  • 到达invoke方法，就会掉用执行器的executer方法。
  • 往下，层层调下来会进入Executor组件（如果配置插件会对Executor进行动态代 理）的query方法，这个方法中会创建一个StatementHandler对象，这个对象中同时会 封装ParameterHandler和ResultSetHandler对象。调用StatementHandler预编译参数 以及设置参数值，使用ParameterHandler来给sql设置参数。
  • 调用StatementHandler的增删改查方法获得结果，ResultSetHandler对结果进行封 装转换，请求结束。

MyBatis一些重要的类

  • MapperRegistry：本质上是一个Map其中的key是Mapper接口的全限定名， value的MapperProxyFactory；
  • MapperProxyFactory：这个类是MapperRegistry中存的value值，在通过 sqlSession获取Mapper时，其实先获取到的是这个工厂，然后通过这个工厂创建 Mapper的动态代理类；
  • MapperProxy：实现了InvocationHandler接口，Mapper的动态代理接口方法的调 用都会到达这个类的invoke方法；
  • MapperMethod：判断你当前执行的方式是增删改查哪一种，并通过SqlSession执 行相应的操作；
  • SqlSession：作为MyBatis工作的主要顶层API，表示和数据库交互的会话，完成必 要数据库增删改查功能；
  • Executor：MyBatis执行器，是MyBatis 调度的核心，负责SQL语句的生成和查询缓 存的维护；
  • StatementHandler：封装了JDBC Statement操作，负责对JDBC statement 的操作，如设 置参数、将Statement结果集转换成List集合。
  • ParameterHandler：负责对用户传递的参数转换成JDBC Statement 所需要的参数
  • ResultSetHandler：负责将JDBC返回的ResultSet结果集对象转换成List类型的集合；
  • TypeHandler：负责java数据类型和jdbc数据类型之间的映射和转换
  • MappedStatement：MappedStatement维护了一条节点 的封装
  • SqlSource：负责根据用户传递的parameterObject，动态地生成SQL语句，将信息封装到 BoundSql对象中，并返回
  • BoundSql：表示动态生成的SQL语句以及相应的参数信息
  • Configuration：MyBatis所有的配置信息都维持在Configuration对象之中。

引用资料

  • https://blog.csdn.net/qq_48123829/article/details/125169561
COPYRIGHT © 2015 - 2022 ALL RIGHTS RESERVED | YOODB.COM 京ICP备14059688号