7. MyBatis - 深度学习 - 初始化流程

青旅半醒 2023-07-03 06:18 46阅读 0赞

## 前言 ##

本文整理一下，MyBatis启动的时候都做了什么，具体对应xml or 接口中如何解析

## 重点画圈圈 ##

<table> 
 <thead> 
  <tr> 
   <th>类</th> 
   <th>说明</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>XMLConfigBuilder</td> 
   <td>mybatis-config.xml 文件解析</td> 
  </tr> 
  <tr> 
   <td>XMLScriptBuilder</td> 
   <td>XML中动态SQL解析</td> 
  </tr> 
  <tr> 
   <td>XMLLanguageDriver</td> 
   <td>动态SQL语言解析，比如if where这些</td> 
  </tr> 
  <tr> 
   <td>MapperAnnotationBuilder</td> 
   <td>针对Mapper接口注解接口</td> 
  </tr> 
  <tr> 
   <td>XMLMapperBuilder</td> 
   <td>mybatis-mapper.xml 文件解析</td> 
  </tr> 
  <tr> 
   <td>XMLStatementBuilder</td> 
   <td>对XML中的SQL解析</td> 
  </tr> 
 </tbody> 
</table>

## 示例代码 ##

String resource = "mybatis-config.xml";
    InputStream inputStream = Resources.getResourceAsStream(resource);
    SqlSessionFactory factory = new SqlSessionFactoryBuilder().build(inputStream);
    SqlSession session = factory.openSession(true);

mybatis-config.xml 一般有以下关键字段

配置文件的解析流程其实是把上述XML描述元素转换成对应的JAVA对像过程，最终关系如下图：

\[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-yrCdV5ja-1580708441619)(media/7. MyBatis - 深度学习 - 执行流程解析/配置详情.png)\]

## mybatis-mapper.xml 文件解析 ##

public class SqlSessionFactoryBuilder { 
      
      public SqlSessionFactory build(
        InputStream inputStream, String environment, Properties properties) { 
        // 创建
        XMLConfigBuilder parser = new XMLConfigBuilder(inputStream, environment, properties);
        // 重点关注一下XMLConfigBuilder#parse
        return build(parser.parse());
      }
    }

public class XMLConfigBuilder extends BaseBuilder { 
      
      // 1
      public Configuration parse() { 
        if (parsed) { 
          throw new BuilderException("Each XMLConfigBuilder can only be used once.");
        }
        parsed = true;
        // Config.xml 文件解析
        parseConfiguration(parser.evalNode("/configuration"));
        return configuration;
      }
      
      // 2
    	private void parseConfiguration(XNode root) { 
        try { 
          //issue #117 read properties first
          // 属性配置
          propertiesElement(root.evalNode("properties"));
          // 自定义配置
          Properties settings = settingsAsProperties(root.evalNode("settings"));
          loadCustomVfs(settings);
          // typeAliases
          typeAliasesElement(root.evalNode("typeAliases"));
          // 插件
          pluginElement(root.evalNode("plugins"));
          // objectFactory
          objectFactoryElement(root.evalNode("objectFactory"));
          objectWrapperFactoryElement(root.evalNode("objectWrapperFactory"));
          reflectorFactoryElement(root.evalNode("reflectorFactory"));
          settingsElement(settings);
          // read it after objectFactory and objectWrapperFactory issue #631
          // 环境变量配置
          environmentsElement(root.evalNode("environments"));
          // 数据配置
          databaseIdProviderElement(root.evalNode("databaseIdProvider"));
          // typeHandlers
          typeHandlerElement(root.evalNode("typeHandlers"));
          // 配置中的接口类
          mapperElement(root.evalNode("mappers"));
        } catch (Exception e) { 
          throw new BuilderException("Error parsing SQL Mapper Configuration. Cause: " + e, e);
        }
      }
      
     // 3
     private void mapperElement(XNode parent) throws Exception { 
        if (parent != null) { 
          for (XNode child : parent.getChildren()) { 
            if ("package".equals(child.getName())) { 
              // 引入包名
              String mapperPackage = child.getStringAttribute("name");
              configuration.addMappers(mapperPackage);
            } else { 
              String resource = child.getStringAttribute("resource");
              String url = child.getStringAttribute("url");
              String mapperClass = child.getStringAttribute("class");
              if (resource != null && url == null && mapperClass == null) { 
                ErrorContext.instance().resource(resource);
                InputStream inputStream = Resources.getResourceAsStream(resource);
                // Mapper.xml 文件解析
                XMLMapperBuilder mapperParser = new XMLMapperBuilder(inputStream, configuration, resource, configuration.getSqlFragments());
                mapperParser.parse();
              } else if (resource == null && url != null && mapperClass == null) { 
                ErrorContext.instance().resource(url);
                InputStream inputStream = Resources.getUrlAsStream(url);
                // Mapper.xml 文件解析
                XMLMapperBuilder mapperParser = new XMLMapperBuilder(inputStream, configuration, url, configuration.getSqlFragments());
                mapperParser.parse();
              } else if (resource == null && url == null && mapperClass != null) { 
                // 对接口类解析
                Class<?> mapperInterface = Resources.classForName(mapperClass);
                configuration.addMapper(mapperInterface);
              } else { 
                throw new BuilderException("A mapper element may only specify a url, resource or class, but not more than one.");
              }
            }
          }
        }
      }
      
    }

public class XMLMapperBuilder extends BaseBuilder { 
      
      public void parse() { 
        if (!configuration.isResourceLoaded(resource)) { 
           // 解析mapper
          configurationElement(parser.evalNode("/mapper"));
          configuration.addLoadedResource(resource);
          bindMapperForNamespace();
        }
      }
    
      private void configurationElement(XNode context) { 
        try { 
          String namespace = context.getStringAttribute("namespace");
          if (namespace == null || namespace.equals("")) { 
            throw new BuilderException("Mapper's namespace cannot be empty");
          }
          builderAssistant.setCurrentNamespace(namespace);
          cacheRefElement(context.evalNode("cache-ref"));
          cacheElement(context.evalNode("cache"));
          parameterMapElement(context.evalNodes("/mapper/parameterMap"));
          resultMapElements(context.evalNodes("/mapper/resultMap"));
          sqlElement(context.evalNodes("/mapper/sql"));
          // 解析sql select|insert|update|delete"
          buildStatementFromContext(context.evalNodes("select|insert|update|delete"));
        } catch (Exception e) { 
          throw new BuilderException("Error parsing Mapper XML. The XML location is '" + resource + "'. Cause: " + e, e);
        }
      }
      
     private void buildStatementFromContext(List<XNode> list) { 
        if (configuration.getDatabaseId() != null) { 
          // 继续
          buildStatementFromContext(list, configuration.getDatabaseId());
        }
        buildStatementFromContext(list, null);
      }
      
      private void buildStatementFromContext(List<XNode> list, String requiredDatabaseId) { 
        for (XNode context : list) { 
          final XMLStatementBuilder statementParser = new XMLStatementBuilder(configuration, builderAssistant, context, requiredDatabaseId);
          try { 
            // 逐个Statement解析
            statementParser.parseStatementNode();
          } catch (IncompleteElementException e) { 
            configuration.addIncompleteStatement(statementParser);
          }
        }
      }
    }

### 图解 ###

![img][]

## 会话的创建 ##

public class DefaultSqlSessionFactory implements SqlSessionFactory { 
      @Override
      public SqlSession openSession() { 
        return openSessionFromDataSource(configuration.getDefaultExecutorType(), null, false);
      }
    
      @Override
      public SqlSession openSession(boolean autoCommit) { 
        return openSessionFromDataSource(configuration.getDefaultExecutorType(), null, autoCommit);
      }
      
      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);
          // 创建 Executor
          final Executor executor = configuration.newExecutor(tx, execType);
          // 创建会话
          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();
        }
      }
    }

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) { 
          // executor = new CachingExecutor(SimpleExecutor);
          executor = new CachingExecutor(executor);
        }
        // 这里留一下，下个文章要说
        executor = (Executor) interceptorChain.pluginAll(executor);
        return executor;
      }
      
    }

### 图解 ###

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly94aWFtZW4uYmxvZy5jc2RuLm5ldA_size_16_color_FFFFFF_t_70]

## 方法执行 StatementHandler ##

public class DefaultSqlSession implements SqlSession { 
      @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);
      }
    }

public class CachingExecutor implements Executor { 
      @Override
      public <E> List<E> query(MappedStatement ms, Object parameterObject, RowBounds rowBounds, ResultHandler resultHandler, CacheKey key, BoundSql boundSql)
          throws SQLException { 
        ....
        // SimpleExecutor#query
        return delegate.<E> query(ms, parameterObject, rowBounds, resultHandler, key, boundSql);
      }
    }

// 其实这里是 SimpleExecutor 的实现类
    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;
      }
    
    }

public class SimpleExecutor extends BaseExecutor { å
    	@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();
          // 创建 RoutingStatementHandler，内部初始化了多个 Statement
          StatementHandler handler = configuration.newStatementHandler(wrapper, ms, parameter, rowBounds, resultHandler, boundSql);
          // 通过 RoutingStatementHandler#prepare 创建 PreparedStatement
          stmt = prepareStatement(handler, ms.getStatementLog());
          // RoutingStatementHandler#query
          return handler.<E>query(stmt, resultHandler);
        } finally { 
          closeStatement(stmt);
        }
      }
    }

### 图解 ###

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly94aWFtZW4uYmxvZy5jc2RuLm5ldA_size_16_color_FFFFFF_t_70 1]

[img]: https://imgconvert.csdnimg.cn/aHR0cDovL2Fzc2V0cy5wcm9jZXNzb24uY29tL2NoYXJ0X2ltYWdlLzVlMzY2Y2JjZTRiMDQ5ODI4MDliN2Y5Ny5wbmc?x-oss-process=image/format,png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly94aWFtZW4uYmxvZy5jc2RuLm5ldA_size_16_color_FFFFFF_t_70]: https://img-blog.csdnimg.cn/20200203134126515.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly94aWFtZW4uYmxvZy5jc2RuLm5ldA==,size_16,color_FFFFFF,t_70
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly94aWFtZW4uYmxvZy5jc2RuLm5ldA_size_16_color_FFFFFF_t_70 1]: https://img-blog.csdnimg.cn/20200203134059681.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly94aWFtZW4uYmxvZy5jc2RuLm5ldA==,size_16,color_FFFFFF,t_70