protected MixedSqlNode parseDynamicTags(XNode node) {
 // 創(chuàng)建 SqlNode 數(shù)組
 List<SqlNode> contents = new ArrayList<>();
 // 遍歷 SQL 節(jié)點(diǎn)的所有子節(jié)點(diǎn)
 NodeList children = node.getNode().getChildNodes();
 for (int i = 0; i < children.getLength(); i++) {
  // 當(dāng)前子節(jié)點(diǎn)
  XNode child = node.newXNode(children.item(i));
  // 如果類型是 Node.CDATA_SECTION_NODE 或者 Node.TEXT_NODE 時(shí)
  if (child.getNode().getNodeType() == Node.CDATA_SECTION_NODE || child.getNode().getNodeType() == Node.TEXT_NODE) {
   // 獲得內(nèi)容
   String data = child.getStringBody("");
   // 創(chuàng)建 TextSqlNode 對(duì)象
   TextSqlNode textSqlNode = new TextSqlNode(data);
   // 如果是動(dòng)態(tài)的 TextSqlNode 對(duì)象(是否使用了${}表達(dá)式)
   if (textSqlNode.isDynamic()) {
    // 添加到 contents 中
    contents.add(textSqlNode);
    // 標(biāo)記為動(dòng)態(tài) SQL
    isDynamic = true;
    // 如果是非動(dòng)態(tài)的 TextSqlNode 對(duì)象
   } else {
    // 創(chuàng)建 StaticTextSqlNode 添加到 contents 中
    contents.add(new StaticTextSqlNode(data));
   }
   // 如果類型是 Node.ELEMENT_NODE，其實(shí)就是XMl中<where>等那些動(dòng)態(tài)標(biāo)簽
  } else if (child.getNode().getNodeType() == Node.ELEMENT_NODE) { // issue #628
   // 根據(jù)子節(jié)點(diǎn)的標(biāo)簽，獲得對(duì)應(yīng)的 NodeHandler 對(duì)象
   String nodeName = child.getNode().getNodeName();
   NodeHandler handler = nodeHandlerMap.get(nodeName);
   if (handler == null) { // 獲得不到，說(shuō)明是未知的標(biāo)簽，拋出 BuilderException 異常
    throw new BuilderException("Unknown element <" + nodeName + "> in SQL statement.");
   }
   // 執(zhí)行 NodeHandler 處理
   handler.handleNode(child, contents);
   // 標(biāo)記為動(dòng)態(tài) SQL
   isDynamic = true;
  }
 }
 // 創(chuàng)建 MixedSqlNode 對(duì)象
 return new MixedSqlNode(contents);
}

public ParamNameResolver(Configuration config, Method method) {
 final Class<?>[] paramTypes = method.getParameterTypes();
 final Annotation[][] paramAnnotations = method.getParameterAnnotations();
 final SortedMap<Integer, String> map = new TreeMap<Integer, String>();
 int paramCount = paramAnnotations.length;
 // 獲取方法中每個(gè)參數(shù)在SQL中的參數(shù)名
 for (int paramIndex = 0; paramIndex < paramCount; paramIndex++) {
  // 跳過(guò)RowBounds、ResultHandler類型
  if (isSpecialParameter(paramTypes[paramIndex])) {
   continue;
  }
  String name = null;
  // 遍歷參數(shù)上面的所有注解，如果有Param注解，使用它的值作為參數(shù)名
  for (Annotation annotation : paramAnnotations[paramIndex]) {
   if (annotation instanceof Param) {
    hasParamAnnotation = true;
    name = ((Param) annotation).value();
    break;
   }
  }
  // 如果沒(méi)有指定注解
  if (name == null) {
   // 如果開(kāi)啟了useActualParamName配置，則參數(shù)名為argn(n>=0)，如果是Java8以上并且開(kāi)啟-parameters，則為實(shí)際的參數(shù)名
   if (config.isUseActualParamName()) {
    name = getActualParamName(method, paramIndex);
   }
   // 否則為下標(biāo)
   if (name == null) {
    name = String.valueOf(map.size());
   }
  }
  map.put(paramIndex, name);
 }
 names = Collections.unmodifiableSortedMap(map);
}

public Object getNamedParams(Object[] args) {
 final int paramCount = names.size();
 // 無(wú)參數(shù)，直接返回null
 if (args == null || paramCount == 0) {
  return null;
 } else if (!hasParamAnnotation && paramCount == 1) {
  // 一個(gè)參數(shù)，并且沒(méi)有注解，直接返回這個(gè)對(duì)象
  return args[names.firstKey()];
 } else {
  // 其他情況則返回一個(gè)Map對(duì)象
  final Map<String, Object> param = new ParamMap<Object>();
  int i = 0;
  for (Map.Entry<Integer, String> entry : names.entrySet()) {
   // 先直接放入name的鍵和對(duì)應(yīng)位置的參數(shù)值，其實(shí)就是構(gòu)造函數(shù)中存入的值
   param.put(entry.getValue(), args[entry.getKey()]);
   // add generic param names (param1, param2, ...)
   final String genericParamName = GENERIC_NAME_PREFIX + String.valueOf(i + 1);
   // 防止覆蓋 @Param 的參數(shù)值
   if (!names.containsValue(genericParamName)) {
    // 然后放入GENERIC_NAME_PREFIX + index + 1，其實(shí)就是param1，params2，paramn
    param.put(genericParamName, args[entry.getKey()]);
   }
   i++;
  }
  return param;
 }
}

private Object wrapCollection(final Object object) {
 // 如果對(duì)象是集合屬性
 if (object instanceof Collection) {
  StrictMap<Object> map = new StrictMap<Object>();
  // 加入一個(gè)collection參數(shù)
  map.put("collection", object);
  // 如果是一個(gè)List集合
  if (object instanceof List) {
   // 額外加入一個(gè)list屬性使用
   map.put("list", object);
  }
  return map;
 } else if (object != null && object.getClass().isArray()) {
  // 數(shù)組使用array
  StrictMap<Object> map = new StrictMap<Object>();
  map.put("array", object);
  return map;
 }
 return object;
}

if (propertyMapping.getNestedQueryId() != null && propertyMapping.isLazy()) {
 resultObject = configuration.getProxyFactory().createProxy(resultObject, lazyLoader, configuration, objectFactory, constructorArgTypes, constructorArgs);
}

// 如果要求延遲加載，則延遲加載
if (propertyMapping.isLazy()) {
 // 如果該屬性配置了延遲加載，則將其添加到 `ResultLoader.loaderMap` 中，等待真正使用時(shí)再執(zhí)行嵌套查詢并得到結(jié)果對(duì)象。
 lazyLoader.addLoader(property, metaResultObject, resultLoader);
 // 返回已定義
 value = DEFERED;
 // 如果不要求延遲加載，則直接執(zhí)行加載對(duì)應(yīng)的值
} else {
 value = resultLoader.loadResult();
}

@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());
 // 已經(jīng)關(guān)閉，則拋出 ExecutorException 異常
 if (closed) {
  throw new ExecutorException("Executor was closed.");
 }
 // 清空本地緩存，如果 queryStack 為零，并且要求清空本地緩存。
 if (queryStack == 0 && ms.isFlushCacheRequired()) {
  clearLocalCache();
 }
 List<E> list;
 try {
  // queryStack + 1
  queryStack++;
  // 從一級(jí)緩存中，獲取查詢結(jié)果
  list = resultHandler == null ? (List<E>) localCache.getObject(key) : null;
  // 獲取到，則進(jìn)行處理
  if (list != null) {
   handleLocallyCachedOutputParameters(ms, key, parameter, boundSql);
   // 獲得不到，則從數(shù)據(jù)庫(kù)中查詢
  } else {
   list = queryFromDatabase(ms, parameter, rowBounds, resultHandler, key, boundSql);
  }
 } finally {
  // queryStack - 1
  queryStack--;
 }
 if (queryStack == 0) {
  // 執(zhí)行延遲加載
  for (DeferredLoad deferredLoad : deferredLoads) {
   deferredLoad.load();
  }
  // issue #601
  // 清空 deferredLoads
  deferredLoads.clear();
  // 如果緩存級(jí)別是 LocalCacheScope.STATEMENT ，則進(jìn)行清理
  if (configuration.getLocalCacheScope() == LocalCacheScope.STATEMENT) {
   // issue #482
   clearLocalCache();
  }
 }
 return list;
}

// 從數(shù)據(jù)庫(kù)中讀取操作
private <E> List<E> queryFromDatabase(MappedStatement ms, Object parameter, RowBounds rowBounds, ResultHandler resultHandler, CacheKey key, BoundSql boundSql) throws SQLException {
 List<E> list;
 // 在緩存中，添加占位對(duì)象。此處的占位符，和延遲加載有關(guān)，可見(jiàn) `DeferredLoad#canLoad()` 方法
 localCache.putObject(key, EXECUTION_PLACEHOLDER);
 try {
  // 執(zhí)行讀操作
  list = doQuery(ms, parameter, rowBounds, resultHandler, boundSql);
 } finally {
  // 從緩存中，移除占位對(duì)象
  localCache.removeObject(key);
 }
 // 添加到緩存中
 localCache.putObject(key, list);
 // 暫時(shí)忽略，存儲(chǔ)過(guò)程相關(guān)
 if (ms.getStatementType() == StatementType.CALLABLE) {
  localOutputParameterCache.putObject(key, parameter);
 }
 return list;
}

@Override
public CacheKey createCacheKey(MappedStatement ms, Object parameterObject, RowBounds rowBounds, BoundSql boundSql) {
 if (closed) {
  throw new ExecutorException("Executor was closed.");
 }
 // 創(chuàng)建 CacheKey 對(duì)象
 CacheKey cacheKey = new CacheKey();
 // 設(shè)置 id、offset、limit、sql 到 CacheKey 對(duì)象中
 cacheKey.update(ms.getId());
 cacheKey.update(rowBounds.getOffset());
 cacheKey.update(rowBounds.getLimit());
 cacheKey.update(boundSql.getSql());
 // 設(shè)置 ParameterMapping 數(shù)組的元素對(duì)應(yīng)的每個(gè) value 到 CacheKey 對(duì)象中
 List<ParameterMapping> parameterMappings = boundSql.getParameterMappings();
 TypeHandlerRegistry typeHandlerRegistry = ms.getConfiguration().getTypeHandlerRegistry();
 // mimic DefaultParameterHandler logic 這塊邏輯，和 DefaultParameterHandler 獲取 value 是一致的。
 for (ParameterMapping parameterMapping : parameterMappings) {
  if (parameterMapping.getMode() != ParameterMode.OUT) {
   Object value;
   String propertyName = parameterMapping.getProperty();
   if (boundSql.hasAdditionalParameter(propertyName)) {
    value = boundSql.getAdditionalParameter(propertyName);
   } else if (parameterObject == null) {
    value = null;
   } else if (typeHandlerRegistry.hasTypeHandler(parameterObject.getClass())) {
    value = parameterObject;
   } else {
    MetaObject metaObject = configuration.newMetaObject(parameterObject);
    value = metaObject.getValue(propertyName);
   }
   cacheKey.update(value);
  }
 }
 // 設(shè)置 Environment.id 到 CacheKey 對(duì)象中
 if (configuration.getEnvironment() != null) {
  // issue #176
  cacheKey.update(configuration.getEnvironment().getId());
 }
 return cacheKey;
}

/**
 * 一級(jí)緩存的實(shí)現(xiàn)類，部分源代碼
 */
public class PerpetualCache implements Cache {
 /**
  * 緩存容器
  */
 private Map<Object, Object> cache = new HashMap<>();

 @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);
 }
}

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) {
  // 如果需要清空緩存，則進(jìn)行清空
  flushCacheIfRequired(ms);
  if (ms.isUseCache() && resultHandler == null) {
   // 暫時(shí)忽略，存儲(chǔ)過(guò)程相關(guān)
   ensureNoOutParams(ms, boundSql);
   @SuppressWarnings("unchecked")
   // 從二級(jí)緩存中，獲取結(jié)果
   List<E> list = (List<E>) tcm.getObject(cache, key);
   if (list == null) {
    // 如果不存在，則從數(shù)據(jù)庫(kù)中查詢
    list = delegate.query(ms, parameterObject, rowBounds, resultHandler, key, boundSql);
    // 緩存結(jié)果到二級(jí)緩存中
    tcm.putObject(cache, key, list); // issue #578 and #116
   }
   // 如果存在，則直接返回結(jié)果
   return list;
  }
 }
 // 不使用緩存，則從數(shù)據(jù)庫(kù)中查詢
 return delegate.query(ms, parameterObject, rowBounds, resultHandler, key, boundSql);
}

public Cache useNewCache(Class<? extends Cache> typeClass,
       Class<? extends Cache> evictionClass,
       Long flushInterval,
       Integer size,
       boolean readWrite,
       boolean blocking,
       Properties props) {
 // 創(chuàng)建 Cache 對(duì)象
 Cache cache = new CacheBuilder(currentNamespace)
  .implementation(valueOrDefault(typeClass, PerpetualCache.class))
  .addDecorator(valueOrDefault(evictionClass, LruCache.class))
  .clearInterval(flushInterval)
  .size(size)
  .readWrite(readWrite)
  .blocking(blocking)
  .properties(props)
  .build();
 // 添加到 configuration 的 caches 中
 configuration.addCache(cache);
 // 賦值給 currentCache
 currentCache = cache;
 return cache;
}

public Cache useCacheRef(String namespace) {
 if (namespace == null) {
  throw new BuilderException("cache-ref element requires a namespace attribute.");
 }
 try {
  unresolvedCacheRef = true; // 標(biāo)記未解決
  // 獲得 Cache 對(duì)象
  Cache cache = configuration.getCache(namespace);
  // 獲得不到，拋出 IncompleteElementException 異常
  if (cache == null) {
   throw new IncompleteElementException("No cache for namespace '" + namespace + "' could be found.");
  }
  // 記錄當(dāng)前 Cache 對(duì)象
  currentCache = cache;
  unresolvedCacheRef = false; // 標(biāo)記已解決
  return cache;
 } catch (IllegalArgumentException e) {
  throw new IncompleteElementException("No cache for namespace '" + namespace + "' could be found.", e);
 }
}

public void putObject(Object key, Object object) {
 // 暫存 KV 到 entriesToAddOnCommit 中
 entriesToAddOnCommit.put(key, object);
}

public void commit() {
 // 如果 clearOnCommit 為 true ，則清空 delegate 緩存
 if (clearOnCommit) {
  delegate.clear();
 }
 // 將 entriesToAddOnCommit、entriesMissedInCache 刷入 delegate 中
 flushPendingEntries();
 // 重置
 reset();
}

public void clear() {
 // 標(biāo)記 clearOnCommit 為 true
 clearOnCommit = true;
 // 清空 entriesToAddOnCommit
 entriesToAddOnCommit.clear();
}

public Object getObject(Object key) {
 // issue #116
 // 從 delegate 中獲取 key 對(duì)應(yīng)的 value
 Object object = delegate.getObject(key);
 // 如果不存在，則添加到 entriesMissedInCache 中
 if (object == null) {
  entriesMissedInCache.add(key);
 }
 // issue #146
 // 如果 clearOnCommit 為 true ，表示處于持續(xù)清空狀態(tài)，則返回 null
 if (clearOnCommit) {
  return null;
  // 返回 value
 } else {
  return object;
 }
}

public void rollback() {
 // 從 delegate 移除出 entriesMissedInCache
 unlockMissedEntries();
 // 重置
 reset();
}

private void reset() {
 // 重置 clearOnCommit 為 false
 clearOnCommit = false;
 // 清空 entriesToAddOnCommit、entriesMissedInCache
 entriesToAddOnCommit.clear();
 entriesMissedInCache.clear();
}

// 創(chuàng)建 ParameterHandler 對(duì)象
public ParameterHandler newParameterHandler(MappedStatement mappedStatement, Object parameterObject, BoundSql boundSql) {
 // 創(chuàng)建 ParameterHandler 對(duì)象
 ParameterHandler parameterHandler = mappedStatement.getLang().createParameterHandler(mappedStatement, parameterObject, boundSql);
 // 應(yīng)用插件
 parameterHandler = (ParameterHandler) interceptorChain.pluginAll(parameterHandler);
 return parameterHandler;
}

// 創(chuàng)建 ResultSetHandler 對(duì)象
public ResultSetHandler newResultSetHandler(Executor executor, MappedStatement mappedStatement, RowBounds rowBounds, ParameterHandler parameterHandler,
           ResultHandler resultHandler, BoundSql boundSql) {
 // 創(chuàng)建 DefaultResultSetHandler 對(duì)象
 ResultSetHandler resultSetHandler = new DefaultResultSetHandler(executor, mappedStatement, parameterHandler, resultHandler, boundSql, rowBounds);
 // 應(yīng)用插件
 resultSetHandler = (ResultSetHandler) interceptorChain.pluginAll(resultSetHandler);
 return resultSetHandler;
}

// 創(chuàng)建 StatementHandler 對(duì)象
public StatementHandler newStatementHandler(Executor executor, MappedStatement mappedStatement, Object parameterObject, RowBounds rowBounds, ResultHandler resultHandler, BoundSql boundSql) {
 // 創(chuàng)建 RoutingStatementHandler 對(duì)象
 StatementHandler statementHandler = new RoutingStatementHandler(executor, mappedStatement, parameterObject, rowBounds, resultHandler, boundSql);
 // 應(yīng)用插件
 statementHandler = (StatementHandler) interceptorChain.pluginAll(statementHandler);
 return statementHandler;
}

/**
  * 創(chuàng)建 Executor 對(duì)象
  *
  * @param transaction 事務(wù)對(duì)象
  * @param executorType 執(zhí)行器類型
  * @return Executor 對(duì)象
  */
public Executor newExecutor(Transaction transaction, ExecutorType executorType) {
 // 獲得執(zhí)行器類型
 executorType = executorType == null ? defaultExecutorType : executorType; // 使用默認(rèn)
 executorType = executorType == null ? ExecutorType.SIMPLE : executorType; // 使用 ExecutorType.SIMPLE
 // 創(chuàng)建對(duì)應(yīng)實(shí)現(xiàn)的 Executor 對(duì)象
 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);
 }
 // 如果開(kāi)啟緩存，創(chuàng)建 CachingExecutor 對(duì)象，進(jìn)行包裝
 if (cacheEnabled) {
  executor = new CachingExecutor(executor);
 }
 // 應(yīng)用插件
 executor = (Executor) interceptorChain.pluginAll(executor);
 return executor;
}

/**
 * 應(yīng)用所有插件
 *
 * @param target 目標(biāo)對(duì)象
 * @return 應(yīng)用結(jié)果
 */
public Object pluginAll(Object target) {
 for (Interceptor interceptor : interceptors) {
  target = interceptor.plugin(target);
 }
 return target;
}

/**
 * 創(chuàng)建目標(biāo)類的代理對(duì)象
 *
 * @param target 目標(biāo)類
 * @param interceptor 攔截器對(duì)象
 * @return 代理對(duì)象
 */
public static Object wrap(Object target, Interceptor interceptor) {
 // 獲得攔截的方法映射
 Map<Class<?>, Set<Method>> signatureMap = getSignatureMap(interceptor);
 // 獲得目標(biāo)類的類型
 Class<?> type = target.getClass();
 // 獲得目標(biāo)類的接口集合
 Class<?>[] interfaces = getAllInterfaces(type, signatureMap);
 // 若有接口，則創(chuàng)建目標(biāo)對(duì)象的 JDK Proxy 對(duì)象
 if (interfaces.length > 0) {
  return Proxy.newProxyInstance(
   type.getClassLoader(),
   interfaces,
   new Plugin(target, interceptor, signatureMap)); // 因?yàn)?Plugin 實(shí)現(xiàn)了 InvocationHandler 接口，所以可以作為 JDK 動(dòng)態(tài)代理的調(diào)用處理器
 }
 // 如果沒(méi)有，則返回原始的目標(biāo)對(duì)象
 return target;
}

@Override
public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
 try {
  // 獲得目標(biāo)方法是否被攔截
  Set<Method> methods = signatureMap.get(method.getDeclaringClass());
  if (methods != null && methods.contains(method)) {
   // 如果是，則攔截處理該方法
   return interceptor.intercept(new Invocation(target, method, args));
  }
  // 如果不是，則調(diào)用原方法
  return method.invoke(target, args);
 } catch (Exception e) {
  throw ExceptionUtil.unwrapThrowable(e);
 }
}

private static Map<Class<?>, Set<Method>> getSignatureMap(Interceptor interceptor) {
 Intercepts interceptsAnnotation = interceptor.getClass().getAnnotation(Intercepts.class);
 // issue #251
 if (interceptsAnnotation == null) {
  throw new PluginException("No @Intercepts annotation was found in interceptor " + interceptor.getClass().getName());
 }
 Signature[] sigs = interceptsAnnotation.value();
 Map<Class<?>, Set<Method>> signatureMap = new HashMap<>();
 for (Signature sig : sigs) {
  Set<Method> methods = signatureMap.computeIfAbsent(sig.type(), k -> new HashSet<>());
  try {
   Method method = sig.type().getMethod(sig.method(), sig.args());
   methods.add(method);
  } catch (NoSuchMethodException e) {
   throw new PluginException("Could not find method on " + sig.type() + " named " + sig.method() + ". Cause: " + e, e);
  }
 }
 return signatureMap;
}