/*
 * MyBatis中所有Mapper的接口方法会被该方法拦截
 */
@Override
public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
  try {
    // 如果是Object中的方法，
    if (Object.class.equals(method.getDeclaringClass())) {
      // 则直接调用
      return method.invoke(this, args);
    } else {
      /*
       * 先获取invoker对象，再调用。
       * 如果缓存中不存在invoker对象，那么新建一个并缓存起来。
       */
      return cachedInvoker(method).invoke(proxy, method, args, sqlSession);
    }
  } catch (Throwable t) {
    throw ExceptionUtil.unwrapThrowable(t);
  }
}

private MapperMethodInvoker cachedInvoker(Method method) throws Throwable {
  try {
    return MapUtil.computeIfAbsent(methodCache, method, m -> {
      if (m.isDefault()) { // 如果是默认方法
        try {
          if (privateLookupInMethod == null) {
            return new DefaultMethodInvoker(getMethodHandleJava8(method));
          } else {
            return new DefaultMethodInvoker(getMethodHandleJava9(method));
          }
        } catch (IllegalAccessException | InstantiationException | InvocationTargetException
            | NoSuchMethodException e) {
          throw new RuntimeException(e);
        }
      } else { // 如果是普通方法
        // 这里同时创建了MapperMethod和invoker
        return new PlainMethodInvoker(new MapperMethod(mapperInterface, method, sqlSession.getConfiguration()));
      }
    });
  } catch (RuntimeException re) {
    Throwable cause = re.getCause();
    throw cause == null ? re : cause;
  }
}

private static class PlainMethodInvoker implements MapperMethodInvoker {
  private final MapperMethod mapperMethod;

  public PlainMethodInvoker(MapperMethod mapperMethod) {
    super();
    this.mapperMethod = mapperMethod;
  }

  @Override
  public Object invoke(Object proxy, Method method, Object[] args, SqlSession sqlSession) throws Throwable {
    /*
     * 执行方法
     */
    return mapperMethod.execute(sqlSession, args);
  }
}

public MapperMethod(Class<?> mapperInterface, Method method, Configuration config) {
  // 创建SQL命令对象，内部会判断SQL的类型
  this.command = new SqlCommand(config, mapperInterface, method);
  this.method = new MethodSignature(config, mapperInterface, method);
}

/*
 * MyBatis中mapper方法的核心实现
 */
public Object execute(SqlSession sqlSession, Object[] args) {
  Object result;
  /*
   * 根据命令的类型，执行不同的操作。
   * 这些操作都是基于SqlSession来执行的。
   */
  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 { // 其他情况
        /*
         * 通过参数名称解析器来处理参数，返回的类型之所以用Object，是因为会根据参数情况返回不同的类型，如Collection，Map等
         * 既然这里是Object类型的，后续执行时是怎么使用param对象的？怎么知道param是哪种具体类型的？
         */
        Object param = method.convertArgsToSqlCommandParam(args);
        // 执行查询
        result = sqlSession.selectOne(command.getName(), param);
        // 方法返回类型为Optional的情况
        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());
  }
  // 如果底层返回结果为null，但是mapper方法的返回值是基础类型但不为void，则抛出异常
  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;
}

public Object convertArgsToSqlCommandParam(Object[] args) {
  // 获取参数名-值映射
  return paramNameResolver.getNamedParams(args);
}

public MethodSignature(Configuration configuration, Class<?> mapperInterface, Method method) {
  Type resolvedReturnType = TypeParameterResolver.resolveReturnType(method, mapperInterface);
  if (resolvedReturnType instanceof Class<?>) {
    this.returnType = (Class<?>) resolvedReturnType;
  } else if (resolvedReturnType instanceof ParameterizedType) {
    this.returnType = (Class<?>) ((ParameterizedType) resolvedReturnType).getRawType();
  } else {
    this.returnType = method.getReturnType();
  }
  this.returnsVoid = void.class.equals(this.returnType);
  this.returnsMany = configuration.getObjectFactory().isCollection(this.returnType) || this.returnType.isArray();
  this.returnsCursor = Cursor.class.equals(this.returnType);
  this.returnsOptional = Optional.class.equals(this.returnType);
  this.mapKey = getMapKey(method);
  this.returnsMap = this.mapKey != null;
  this.rowBoundsIndex = getUniqueParamIndex(method, RowBounds.class);
  this.resultHandlerIndex = getUniqueParamIndex(method, ResultHandler.class);
  // 创建参数名称解析器
  this.paramNameResolver = new ParamNameResolver(configuration, method);
}

public ParamNameResolver(Configuration config, Method method) {
  // 判断是否使用实际的参数名称，默认为true
  this.useActualParamName = config.isUseActualParamName();
  // 获取方法参数类型
  final Class<?>[] paramTypes = method.getParameterTypes();
  // 获取方法中各个参数的注解
  final Annotation[][] paramAnnotations = method.getParameterAnnotations();
  final SortedMap<Integer, String> map = new TreeMap<>();
  int paramCount = paramAnnotations.length;
  // get names from @Param annotations
  // 遍历参数
  for (int paramIndex = 0; paramIndex < paramCount; paramIndex++) {
    // 判断是不是特殊参数，如果是则跳过（里面判断了两种类型，大部分参数都不会是这里的特殊参数）
    if (isSpecialParameter(paramTypes[paramIndex])) {
      // skip special parameters
      continue;
    }
    String name = null;
    // 遍历方法参数的注解
    for (Annotation annotation : paramAnnotations[paramIndex]) {
      // 如果是@Param注解
      if (annotation instanceof Param) {
        hasParamAnnotation = true;
        // 获取通过注解配置的参数名称
        name = ((Param) annotation).value();
        break;
      }
    }
    // 没有使用@Param注解，或者使用了注解但没有指定参数名称
    if (name == null) {
      // @Param was not specified.
      // 如果使用参数名，则获取参数名称
      if (useActualParamName) {
        name = getActualParamName(method, paramIndex);
      }
      // 如果不使用实际参数名，那么使用参数序号作为参数名
      if (name == null) {
        // use the parameter index as the name ("0", "1", ...)
        // gcode issue #71
        name = String.valueOf(map.size());
      }
    }
    // 保存参数名称
    map.put(paramIndex, name);
  }
  names = Collections.unmodifiableSortedMap(map);
}

private String getActualParamName(Method method, int paramIndex) {
  return ParamNameUtil.getParamNames(method).get(paramIndex);
}

public Object getNamedParams(Object[] args) {
  final int paramCount = names.size();
  if (args == null || paramCount == 0) {
    return null;
  } else if (!hasParamAnnotation && paramCount == 1) { // 如果参数个数为1, 而且没有@Param注解
    Object value = args[names.firstKey()];
    // 根据参数值类型建立其他的名称映射
    return wrapToMapIfCollection(value, useActualParamName ? names.get(names.firstKey()) : null);
  } else {
    // 创建参数名和值的映射
    final Map<String, Object> param = new ParamMap<>();
    int i = 0;
    // 遍历names
    for (Map.Entry<Integer, String> entry : names.entrySet()) {
      // 添加参数名-值键值对
      param.put(entry.getValue(), args[entry.getKey()]);
      // add generic param names (param1, param2, ...)
      // 创建通用参数名，即前缀（param）+ 序号
      final String genericParamName = GENERIC_NAME_PREFIX + (i + 1);
      // ensure not to overwrite parameter named with @Param
      /*
       * 如果通用参数名没有被使用，则添加进去；
       * 从这里也可以看出来，对于每个参数，都会有一个通用参数名；
       */
      if (!names.containsValue(genericParamName)) {
        param.put(genericParamName, args[entry.getKey()]);
      }
      i++;
    }
    return param;
  }
}

public static Object wrapToMapIfCollection(Object object, String actualParamName) {
  // 如果是Collection及其子类型
  if (object instanceof Collection) {
    ParamMap<Object> map = new ParamMap<>();
    map.put("collection", object);
    if (object instanceof List) { // 如果是list，则同时添加这种参数名映射
      map.put("list", object);
    }
    // 实际参数名映射
    Optional.ofNullable(actualParamName).ifPresent(name -> map.put(name, object));
    return map;
  } else if (object != null && object.getClass().isArray()) { // 如果是数组类型
    ParamMap<Object> map = new ParamMap<>();
    map.put("array", object);
    Optional.ofNullable(actualParamName).ifPresent(name -> map.put(name, object));
    return map;
  }
  return object;
}

public SqlSessionTemplate(SqlSessionFactory sqlSessionFactory, ExecutorType executorType,
    PersistenceExceptionTranslator exceptionTranslator) {

  notNull(sqlSessionFactory, "Property 'sqlSessionFactory' is required");
  notNull(executorType, "Property 'executorType' is required");

  this.sqlSessionFactory = sqlSessionFactory;
  this.executorType = executorType;
  this.exceptionTranslator = exceptionTranslator;
  // 创建SqlSession的代理对象，实际的操作会委托给此对象处理
  this.sqlSessionProxy = (SqlSession) newProxyInstance(SqlSessionFactory.class.getClassLoader(),
      new Class[] { SqlSession.class }, new SqlSessionInterceptor());
}

  private class SqlSessionInterceptor implements InvocationHandler {
    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
      /*
       * 获取sqlSession，与Spring的事务机制适配
       * 这里的sqlSessionFactory是DefaultSqlSessionFactory类型的，
       *  参考SqlSessionFactoryBean#buildSqlSessionFactory方法的结尾，也就是SqlSessionFactoryBuilder的build方法。
       * 这里的SqlSessionFactory是DefaultSqlSessionFactory，所以这里创建的是DefaultSqlSession类型的对象。
       */
      SqlSession sqlSession = getSqlSession(SqlSessionTemplate.this.sqlSessionFactory,
          SqlSessionTemplate.this.executorType, SqlSessionTemplate.this.exceptionTranslator);
      try {
        // 调用目标方法，通过上面获取的sqlSession来反射调用
        Object result = method.invoke(sqlSession, args);
        // 如果当前操作不在事务中，则立马提交
        if (!isSqlSessionTransactional(sqlSession, SqlSessionTemplate.this.sqlSessionFactory)) {
          // force commit even on non-dirty sessions because some databases require
          // a commit/rollback before calling close()
          sqlSession.commit(true);
        }
        return result;
      } catch (Throwable t) {
        Throwable unwrapped = unwrapThrowable(t);
        if (SqlSessionTemplate.this.exceptionTranslator != null && unwrapped instanceof PersistenceException) {
          // release the connection to avoid a deadlock if the translator is no loaded. See issue #22
          closeSqlSession(sqlSession, SqlSessionTemplate.this.sqlSessionFactory);
          sqlSession = null;
          Throwable translated = SqlSessionTemplate.this.exceptionTranslator
              .translateExceptionIfPossible((PersistenceException) unwrapped);
          if (translated != null) {
            unwrapped = translated;
          }
        }
        throw unwrapped;
      } finally {
        if (sqlSession != null) {
          // 关闭sqlSession
          closeSqlSession(sqlSession, SqlSessionTemplate.this.sqlSessionFactory);
        }
      }
    }
  }

  @Override
  public <T> T selectOne(String statement, Object parameter) {
    // 通过代理执行，此代理用于适配spring的事务管理，参考上面构造方法中该变量的初始化
    return this.sqlSessionProxy.selectOne(statement, parameter);
  }

public static SqlSession getSqlSession(SqlSessionFactory sessionFactory, ExecutorType executorType,
    PersistenceExceptionTranslator exceptionTranslator) {

  notNull(sessionFactory, NO_SQL_SESSION_FACTORY_SPECIFIED);
  notNull(executorType, NO_EXECUTOR_TYPE_SPECIFIED);

  // 通过spring的事务同步管理器来获取sqlSession
  SqlSessionHolder holder = (SqlSessionHolder) TransactionSynchronizationManager.getResource(sessionFactory);

  SqlSession session = sessionHolder(executorType, holder);
  if (session != null) {
    return session;
  }

  LOGGER.debug(() -> "Creating a new SqlSession");
  // 如果上面没有获取到，则新建一个sqlSession
  session = sessionFactory.openSession(executorType);

  // 添加到线程本地存储中，避免后续重复创建
  registerSessionHolder(sessionFactory, executorType, exceptionTranslator, session);

  return session;
}

public class DefaultSqlSessionFactory implements SqlSessionFactory {

  private final Configuration configuration;

  public DefaultSqlSessionFactory(Configuration configuration) {
    this.configuration = configuration;
  }

  @Override
  public SqlSession openSession() {
    return openSessionFromDataSource(configuration.getDefaultExecutorType(), null, false);
  }

  @Override
  public SqlSession openSession(boolean autoCommit) {
    return openSessionFromDataSource(configuration.getDefaultExecutorType(), null, autoCommit);
  }

  @Override
  public SqlSession openSession(ExecutorType execType) {
    return openSessionFromDataSource(execType, null, false);
  }

  @Override
  public SqlSession openSession(TransactionIsolationLevel level) {
    return openSessionFromDataSource(configuration.getDefaultExecutorType(), level, false);
  }

  @Override
  public SqlSession openSession(ExecutorType execType, TransactionIsolationLevel level) {
    return openSessionFromDataSource(execType, level, false);
  }

  @Override
  public SqlSession openSession(ExecutorType execType, boolean autoCommit) {
    return openSessionFromDataSource(execType, null, autoCommit);
  }

  @Override
  public SqlSession openSession(Connection connection) {
    return openSessionFromConnection(configuration.getDefaultExecutorType(), connection);
  }

  @Override
  public SqlSession openSession(ExecutorType execType, Connection connection) {
    return openSessionFromConnection(execType, connection);
  }

  @Override
  public Configuration getConfiguration() {
    return configuration;
  }

  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);
      // 创建sqlSession
      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();
    }
  }

  private SqlSession openSessionFromConnection(ExecutorType execType, Connection connection) {
    try {
      boolean autoCommit;
      try {
        // 使用数据库的配置
        autoCommit = connection.getAutoCommit();
      } catch (SQLException e) {
        // Failover to true, as most poor drivers
        // or databases won't support transactions

        // 如果报错，则使用自动提交
        autoCommit = true;
      }
      final Environment environment = configuration.getEnvironment();
      final TransactionFactory transactionFactory = getTransactionFactoryFromEnvironment(environment);
      // 创建事务对象
      final Transaction tx = transactionFactory.newTransaction(connection);
      // 创建执行器
      final Executor executor = configuration.newExecutor(tx, execType);
      // 创建SqlSession
      return new DefaultSqlSession(configuration, executor, autoCommit);
    } catch (Exception e) {
      throw ExceptionFactory.wrapException("Error opening session.  Cause: " + e, e);
    } finally {
      ErrorContext.instance().reset();
    }
  }

  private TransactionFactory getTransactionFactoryFromEnvironment(Environment environment) {
    if (environment == null || environment.getTransactionFactory() == null) {
      return new ManagedTransactionFactory();
    }
    // 在Spring中，返回的是SpringManagedTransactionFactory，参考SqlSessionFactoryBean构建SqlSessionFactory时的设置
    return environment.getTransactionFactory();
  }

  private void closeTransaction(Transaction tx) {
    if (tx != null) {
      try {
        tx.close();
      } catch (SQLException ignore) {
        // Intentionally ignore. Prefer previous error.
      }
    }
  }

}

@Override
public <T> T selectOne(String statement) {
  return this.selectOne(statement, null);
}

@Override
public <T> T selectOne(String statement, Object parameter) {
  // Popular vote was to return null on 0 results and throw exception on too many.
  // 执行查询，复用列表查询逻辑
  List<T> list = this.selectList(statement, parameter);
  if (list.size() == 1) {
    // 返回查询结果
    return list.get(0);
  } else if (list.size() > 1) {
    // 期待查询1条记录，结果返回了多条则抛出异常
    throw new TooManyResultsException("Expected one result (or null) to be returned by selectOne(), but found: " + list.size());
  } else {
    return null;
  }
}

@Override
public <E> List<E> selectList(String statement) {
  return this.selectList(statement, null);
}

@Override
public <E> List<E> selectList(String statement, Object parameter) {
  return this.selectList(statement, parameter, RowBounds.DEFAULT);
}

@Override
public <E> List<E> selectList(String statement, Object parameter, RowBounds rowBounds) {
  return selectList(statement, parameter, rowBounds, Executor.NO_RESULT_HANDLER);
}

private <E> List<E> selectList(String statement, Object parameter, RowBounds rowBounds, ResultHandler handler) {
  try {
    // 根据mapper方法的ID（mapper接口的全限定名称拼接上方法的名称）来获取映射语句
    MappedStatement ms = configuration.getMappedStatement(statement);
    // 交给执行器进行查询
    return executor.query(ms, wrapCollection(parameter), rowBounds, handler);
  } catch (Exception e) {
    throw ExceptionFactory.wrapException("Error querying database.  Cause: " + e, e);
  } finally {
    ErrorContext.instance().reset();
  }
}

public static class SqlCommand {

  private final String name;
  private final SqlCommandType type;

  public SqlCommand(Configuration configuration, Class<?> mapperInterface, Method method) {
    final String methodName = method.getName();
    final Class<?> declaringClass = method.getDeclaringClass();
    // 获取方法对应的SQL语句
    MappedStatement ms = resolveMappedStatement(mapperInterface, methodName, declaringClass,
        configuration);
    if (ms == null) { // 没找到语句
      // 如果方法被@Flush注解修饰
      if (method.getAnnotation(Flush.class) != null) {
        name = null;
        // 则设置SQL类型为FLUSH
        type = SqlCommandType.FLUSH;
      } else {
        // 没找都映射的语句，则报错。这个错误在学习和工作中比较常见。
        throw new BindingException("Invalid bound statement (not found): "
            + mapperInterface.getName() + "." + methodName);
      }
    } else {
      name = ms.getId();
      // 设置SQL语句类型
      type = ms.getSqlCommandType();
      if (type == SqlCommandType.UNKNOWN) {
        throw new BindingException("Unknown execution method for: " + name);
      }
    }
  }

  public String getName() {
    return name;
  }

  public SqlCommandType getType() {
    return type;
  }

  private MappedStatement resolveMappedStatement(Class<?> mapperInterface, String methodName,
      Class<?> declaringClass, Configuration configuration) {
    // 计算语句的id，可以看到是mapper接口的全限定名称拼接上接口方法名称
    String statementId = mapperInterface.getName() + "." + methodName;
    // 从配置中获取语句
    if (configuration.hasStatement(statementId)) {
      return configuration.getMappedStatement(statementId);
    } else if (mapperInterface.equals(declaringClass)) {
      return null;
    }
    for (Class<?> superInterface : mapperInterface.getInterfaces()) {
      if (declaringClass.isAssignableFrom(superInterface)) {
        MappedStatement ms = resolveMappedStatement(superInterface, methodName,
            declaringClass, configuration);
        if (ms != null) {
          return ms;
        }
      }
    }
    return null;
  }
}

public Executor newExecutor(Transaction transaction) {
  return newExecutor(transaction, defaultExecutorType);
}

// 创建执行器
public Executor newExecutor(Transaction transaction, ExecutorType executorType) {
  executorType = executorType == null ? defaultExecutorType : executorType;
  Executor executor;
  // 根据执行器类型，创建不同的执行器对象

  if (ExecutorType.BATCH == executorType) {
    executor = new BatchExecutor(this, transaction);
  } else if (ExecutorType.REUSE == executorType) {
    executor = new ReuseExecutor(this, transaction);
  } else {
    // 默认情况下使用SIMPLE执行器
    executor = new SimpleExecutor(this, transaction);
  }
  // 如果开启了缓存
  if (cacheEnabled) {
    // 则封装一下执行器
    executor = new CachingExecutor(executor);
  }
  // 应用拦截器
  executor = (Executor) interceptorChain.pluginAll(executor);
  return executor;
}

@Override
public <E> List<E> query(MappedStatement ms, Object parameterObject, RowBounds rowBounds, ResultHandler resultHandler) throws SQLException {
  // 获取实际的SQL（处理完动态SQL后），其中可能还包含参数占位符
  BoundSql boundSql = ms.getBoundSql(parameterObject);
  // 创建缓存key
  CacheKey key = createCacheKey(ms, parameterObject, rowBounds, boundSql);
  // 执行查询
  return query(ms, parameterObject, rowBounds, resultHandler, key, boundSql);
}

@Override
public <E> List<E> query(MappedStatement ms, Object parameterObject, RowBounds rowBounds, ResultHandler resultHandler, CacheKey key, BoundSql boundSql)
    throws SQLException {
  /*
   * 获取二级缓存对象，可见这里与SqlSession无关，具体与什么有关，要看MappedStatement的cache属性的设置逻辑。
   * （实际上这里的二级缓存以namespace维度来隔离）
   * 所以也说二级缓存与sqlSession无关，与namespace才有关。
   */
  Cache cache = ms.getCache();
  if (cache != null) {
    // 如果mapper中的语句设置了flushCache=true（默认值为false），清空二级缓存；实际上该字段配置还会清空一级缓存（见BaseExecutor）。
    flushCacheIfRequired(ms);
    /*
     * 如果当前语句使用缓存，且没有设置结果处理器
     * 如果mapper中的语句配置了useCache=false（默认值是true），则表示关闭二级缓存。
     */
    if (ms.isUseCache() && resultHandler == null) {
      ensureNoOutParams(ms, boundSql);
      @SuppressWarnings("unchecked")
      List<E> list = (List<E>) tcm.getObject(cache, key);
      // 未命中缓存
      if (list == null) {
        // 委托给普通执行器查询
        list = delegate.query(ms, parameterObject, rowBounds, resultHandler, key, boundSql);
        // 将查询结果放入二级缓存中
        tcm.putObject(cache, key, list); // issue #578 and #116
      }
      return list;
    }
  }
  // 委托给普通执行器查询
  return delegate.query(ms, parameterObject, rowBounds, resultHandler, key, boundSql);
}

private void flushCacheIfRequired(MappedStatement ms) {
  Cache cache = ms.getCache();
  if (cache != null && ms.isFlushCacheRequired()) {
    tcm.clear(cache);
  }
}

private void cacheElement(XNode context) {
  if (context != null) {
    // 解析type属性
    String type = context.getStringAttribute("type", "PERPETUAL");
    Class<? extends Cache> typeClass = typeAliasRegistry.resolveAlias(type);
    // 解析eviction属性
    String eviction = context.getStringAttribute("eviction", "LRU");
    Class<? extends Cache> evictionClass = typeAliasRegistry.resolveAlias(eviction);
    // 解析flushInterval属性
    Long flushInterval = context.getLongAttribute("flushInterval");
    // 解析size属性
    Integer size = context.getIntAttribute("size");
    // 即欸新readOnly属性
    boolean readWrite = !context.getBooleanAttribute("readOnly", false);
    // 解析blocking属性
    boolean blocking = context.getBooleanAttribute("blocking", false);
    // 获取子节点配置
    Properties props = context.getChildrenAsProperties();
    // 构建Cache对象
    builderAssistant.useNewCache(typeClass, evictionClass, flushInterval, size, readWrite, blocking, props);
  }
}

public class TransactionalCacheManager {

  private final Map<Cache, TransactionalCache> transactionalCaches = new HashMap<>();

  public void clear(Cache cache) {
    getTransactionalCache(cache).clear();
  }

  public Object getObject(Cache cache, CacheKey key) {
    return getTransactionalCache(cache).getObject(key);
  }

  public void putObject(Cache cache, CacheKey key, Object value) {
    getTransactionalCache(cache).putObject(key, value);
  }

  public void commit() {
    for (TransactionalCache txCache : transactionalCaches.values()) {
      txCache.commit();
    }
  }

  public void rollback() {
    for (TransactionalCache txCache : transactionalCaches.values()) {
      txCache.rollback();
    }
  }

  private TransactionalCache getTransactionalCache(Cache cache) {
    return MapUtil.computeIfAbsent(transactionalCaches, cache, TransactionalCache::new);
  }

}

private static final Log log = LogFactory.getLog(BaseExecutor.class);

protected Transaction transaction;
protected Executor wrapper;

protected ConcurrentLinkedQueue<DeferredLoad> deferredLoads;
protected PerpetualCache localCache;
protected PerpetualCache localOutputParameterCache;
protected Configuration configuration;

protected int queryStack;
private boolean closed;

protected BaseExecutor(Configuration configuration, Transaction transaction) {
  this.transaction = transaction;
  this.deferredLoads = new ConcurrentLinkedQueue<>();
  this.localCache = new PerpetualCache("LocalCache");
  this.localOutputParameterCache = new PerpetualCache("LocalOutputParameterCache");
  this.closed = false;
  this.configuration = configuration;
  this.wrapper = this;
}

@Override
public <E> List<E> query(MappedStatement ms, Object parameter, RowBounds rowBounds, ResultHandler resultHandler) throws SQLException {
  /*
   * 获取BoundSql对象
   * 每次执行都要获取一次BoundSql对象，是因为MyBatis的动态SQL机制，不同参数对应了不同的SQL内容，所以每次执行时才获取。
   * 这里内部是通过MappedStatement中的SqlSource来获取的，这一步是分析MyBatis动态SQL的入口。
   *
   * 如果mapper方法有多个参数，那么这里只有一个Object类型的parameter参数是什么情况？
   *  是因为在上层的MapperMethod中会根据参数进行封装，不同情况会有不同的封装，为了兼容，这里使用Object。
   */
  BoundSql boundSql = ms.getBoundSql(parameter);
  // 创建缓存键
  CacheKey key = createCacheKey(ms, parameter, rowBounds, boundSql);
  // 执行查询
  return query(ms, parameter, rowBounds, resultHandler, key, boundSql);
}

@SuppressWarnings("unchecked")
@Override
public <E> List<E> query(MappedStatement ms, Object parameter, RowBounds rowBounds, ResultHandler resultHandler, CacheKey key, BoundSql boundSql) throws SQLException {
  ErrorContext.instance().resource(ms.getResource()).activity("executing a query").object(ms.getId());
  if (closed) {
    throw new ExecutorException("Executor was closed.");
  }
  /*
   * 清空本地（一级）缓存
   * 如果mapper中的语句配置了flushCache=true（默认值是false），则首次执行查询时清空一级缓存，后续的嵌套执行产生的缓存取决于localCacheScope。
   * 这里的queryStack == 0用于判断当前查询是否没有被嵌套在其他查询中。
   *  如果存在嵌套，是怎么触发嵌套查询的？以及执行流程是怎样的（是怎么执行到这里的）？
   */
  if (queryStack == 0 && ms.isFlushCacheRequired()) {
    clearLocalCache();
  }
  List<E> list;
  try {
    queryStack++;
    // 从一级缓存中查询
    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);
    }
  } finally {
    queryStack--;
  }
  if (queryStack == 0) {
    // 处理延迟加载
    for (DeferredLoad deferredLoad : deferredLoads) {
      deferredLoad.load();
    }
    // issue #601
    // 清空延迟加载对象
    deferredLoads.clear();
    /*
     * 如果一级缓存的级别是语句，则清空（为什么这里要清空，清空了岂不是缓存就没意义了？）
     * 如果在主配置中将缓存的scope设置为STATEMENT，那么表示禁用一级缓存，
     *   因为上面的queryFromDatabase方法中会将查询结果设置到一级缓存中，所以这里要清空。
     *   其实设置一级缓存时就应该判断是否开启了一级缓存，没开启就不用设置，避免无效操作。
     */
    if (configuration.getLocalCacheScope() == LocalCacheScope.STATEMENT) {
      // issue #482
      clearLocalCache();
    }
  }
  return list;
}

@Override
public void clearLocalCache() {
  if (!closed) {
    localCache.clear();
    localOutputParameterCache.clear();
  }
}

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 {
    // 执行数据库查询，这是一个模板方法，参考默认的执行器SimpleExecutor中的实现
    list = doQuery(ms, parameter, rowBounds, resultHandler, boundSql);
  } finally {
    // 移除上面放入的占位对象
    localCache.removeObject(key);
  }
  // 将查询结果设置到一级缓存中
  localCache.putObject(key, list);
  if (ms.getStatementType() == StatementType.CALLABLE) {
    localOutputParameterCache.putObject(key, parameter);
  }
  return list;
}

protected abstract <E> List<E> doQuery(MappedStatement ms, Object parameter, RowBounds rowBounds, ResultHandler resultHandler, BoundSql boundSql)
    throws SQLException;

public 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 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 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;
    return getId().equals(otherCache.getId());
  }

  @Override
  public int hashCode() {
    if (getId() == null) {
      throw new CacheException("Cache instances require an ID.");
    }
    return getId().hashCode();
  }

}

@Override
public <E> List<E> doQuery(MappedStatement ms, Object parameter, RowBounds rowBounds, ResultHandler resultHandler, BoundSql boundSql) throws SQLException {
  Statement stmt = null;
  try {
    // 获取配置对象
    Configuration configuration = ms.getConfiguration();
    // 创建StatementHandler
    StatementHandler handler = configuration.newStatementHandler(wrapper, ms, parameter, rowBounds, resultHandler, boundSql);
    // 通过Statement来处理SQL语句
    stmt = prepareStatement(handler, ms.getStatementLog());
    // 执行查询
    return handler.query(stmt, resultHandler);
  } finally {
    closeStatement(stmt);
  }
}

private Statement prepareStatement(StatementHandler handler, Log statementLog) throws SQLException {
  Statement stmt;
  // 获取JDBC连接
  Connection connection = getConnection(statementLog);
  // 处理语句
  stmt = handler.prepare(connection, transaction.getTimeout());
  // 为语句设置参数
  handler.parameterize(stmt);
  return stmt;
}

// 创建语句处理器
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;
}

@Override
public Statement prepare(Connection connection, Integer transactionTimeout) throws SQLException {
  ErrorContext.instance().sql(boundSql.getSql());
  Statement statement = null;
  try {
    // 创建和初始化statement对象
    statement = instantiateStatement(connection);
    // 设置语句超时时间
    setStatementTimeout(statement, transactionTimeout);
    setFetchSize(statement);
    return statement;
  } catch (SQLException e) {
    closeStatement(statement);
    throw e;
  } catch (Exception e) {
    closeStatement(statement);
    throw new ExecutorException("Error preparing statement.  Cause: " + e, e);
  }
}