IT教程 ·

手把手带你阅读Mybatis源码(一)组织篇

新年新气象,接个私活赚点生活费?说说这里的弯弯绕

媒介

本日会给人人分享我们经常运用的耐久层框架——MyBatis的事情道理和源码剖析,后续会缭绕Mybatis框架做一些比较深切的解说,以后这部份内容会归置到民众号菜单栏:连载中…-框架剖析中,迎接议论!

说实话MyBatis是我第一个打仗的耐久层框架,在这之前我也没有用过Hibernate,从Java原生的Jdbc操纵数据库以后就直接过渡到了这个框架上,当时给我的第一觉得是,有一个框架太轻易了。

举一个例子吧,我们在Jdbc操纵的时刻,关于对象的封装,我们是须要经由历程ResultSet.getXXX(index)来猎取值,然后在经由历程对象的setXXX()要领举行手动注入,这类反复且无任何技术含量的事情一直以来都是被我们程序猿所蔑视的一环,而MyBatis就能够直接将我们的SQL查询出来的数据与对象直接举行映照然后直接返回一个封装完成的对象,这节省了程序猿大部份的时候,固然实在JdbcTemplate也能够做到,然则这里先不说。

MyBatis的长处有非常多,固然这也只要同时运用过Jdbc和MyBatis以后,发生对照,才会有这类庞大的落差感,但这并非本日要议论的重点,本日的重心照样放在MyBatis是如何做到这些的。

关于MyBatis,给我个人的感觉,其事情流程实际上分为两部份:第一,构建,也就是剖析我们写的xml设置,将其变成它所须要的对象。第二,就是实行,在构建完成的基础上,去实行我们的SQL,完成与Jdbc的交互。而这篇的重点会先放在构建上。

Xml设置文件

玩过这个框架的同砚都晓得,我们在零丁运用它的时刻,会须要两个设置文件,离别是mybatis-config.xml和mapper.xml,在官网上能够直接看到,固然这里为了轻易,我就直接将我的xml设置复制一份。

<!-- mybatis-config.xml -->
<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE configuration
        PUBLIC "-//mybatis.org//DTD Config 3.0//EN"
        "http://mybatis.org/dtd/mybatis-3-config.dtd">
<configuration>
    <!-- 和spring整合后 environments设置将取销 -->
    <environments default="development">
        <environment id="development">
            <!-- 运用jdbc事务管理 -->
            <transactionManager type="JDBC" />
            <!-- 数据库连接池 -->
            <dataSource type="POOLED">
                <property name="driver" value="com.mysql.jdbc.Driver" />
                <property name="url"
                          value="jdbc:mysql://xxxxxxx:3306/test?characterEncoding=utf8"/>
                <property name="username" value="username" />
                <property name="password" value="password" />
            </dataSource>
        </environment>
    </environments>

    <!-- 加载mapper.xml -->
     <mappers>
         <!-- <package name=""> -->
         <mapper resource="mapper/DemoMapper.xml"  ></mapper>
     </mappers>
</configuration>

 

<!-- DemoMapper.xml -->
<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN" "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
<mapper  namespace="com.DemoMapper">
    <select  id="queryTest"   parameterType="Map" resultType="Map">
        select * from test WHERE id =#{id}
    </select>
</mapper>

我们不难看出,在mybatis-config.xml这个文件主假如用于设置数据源、设置别号、加载mapper.xml,而且我们能够看到这个文件的<mappers>节点中包含了一个<mapper>,而这个mapper所指向的途径就是别的一个xml文件:DemoMapper.xml,而这个文件中写了我们查询数据库所用的SQL。

而,MyBatis实际上就是将这两个xml文件,剖析成设置对象,在实行中去运用它。

剖析

MyBatis须要什么设置对象?

虽然在这里我们并没有举行源码的浏览,然则作为一个程序猿,我们能够依附一样平常的开发履历做出一个假定。假定来源于问题,那末问题就是:为何要将设置和SQL语句分为两个设置文件而不是直接写在一同?

是不是是就意味着,这两个设置文件会被MyBatis离开剖析成两个差别的Java对象?

无妨先将问题放置,举行源码的浏览。

环境搭建

起首我们能够写一个最基础的运用MyBatis的代码,我这里已写好了。

public static void main(String[] args) throws Exception {
    String resource = "mybatis-config.xml";
    InputStream inputStream = Resources.getResourceAsStream(resource);
    //建立SqlSessionFacory
    SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder().build(inputStream);
    /******************************分割线******************************/
    SqlSession sqlSession = sqlSessionFactory.openSession();
    //猎取Mapper
    DemoMapper mapper = sqlSession.getMapper(DemoMapper.class);
    Map<String,Object> map = new HashMap<>();
    map.put("id","123");
    System.out.println(mapper.selectAll(map));
    sqlSession.close();
    sqlSession.commit();
  }

看源码重要的一点就是要找到源码的进口,而我们能够从这几行程序动身,来看看构建究竟是在哪入手下手的。

起首不难看出,这段程序显现经由历程字撙节读取了mybatis-config.xml文件,然后经由历程SqlSessionFactoryBuilder.build()要领,建立了一个SqlSessionFactory(这里用到了工场形式和构建者形式),前面说过,MyBatis就是经由历程我们写的xml设置文件,来构建设置对象的,那末设置文件地点的处所,就肯定是构建入手下手的处所,也就是build要领。

构建入手下手

进入build要领,我们能够看到这里的确有剖析的意义,这个要领返回了一个SqlSessionFactory,而这个对象也是运用组织者形式建立的,无妨继承往下走。

  public SqlSessionFactory build(InputStream inputStream, String environment, Properties properties) {
    try {
      //剖析mybatis-config.xml
      //XMLConfigBuilder  组织者
      XMLConfigBuilder parser = new XMLConfigBuilder(inputStream, environment, properties);
      //parse(): 剖析mybatis-config.xml内里的节点
      return build(parser.parse());
    } catch (Exception e) {
      throw ExceptionFactory.wrapException("Error building SqlSession.", e);
    } finally {
      ErrorContext.instance().reset();
      try {
        inputStream.close();
      } catch (IOException e) {
        // Intentionally ignore. Prefer previous error.
      }
    }
  }

进入parse():

public Configuration parse() {
    //检察该文件是不是已剖析过
    if (parsed) {
      throw new BuilderException("Each XMLConfigBuilder can only be used once.");
    }
    //假如没有剖析过,则继承往下剖析,而且将标识符置为true
    parsed = true;
    //剖析<configuration>节点
    parseConfiguration(parser.evalNode("/configuration"));
    return configuration;
  }

注重parse的返回值,Configuration,这个素昧平生的单词彷佛在哪见过,是不是与mybatis-config.xml中的<configuration>节点有所关联呢?

答案是肯定的,我们能够接着往下看。

看到这里,虽然代码量还不是迥殊多,然则最少如今我们能够在大脑中获得一个大抵的主线图,也以下图所示:

手把手带你阅读Mybatis源码(一)组织篇 IT教程 第1张

沿着这条主线,我们进入parseConfiguration(XNode)要领,接着往下看。

 private void parseConfiguration(XNode root) {
    try {
      //剖析<Configuration>下的节点
      //issue #117 read properties first
      //<properties>
      propertiesElement(root.evalNode("properties"));
      //<settings>
      Properties settings = settingsAsProperties(root.evalNode("settings"));
      loadCustomVfs(settings);
      loadCustomLogImpl(settings);
      //别号<typeAliases>剖析
      // 所谓别号 实在就是把你指定的别号对应的class存储在一个Map当中
      typeAliasesElement(root.evalNode("typeAliases"));
      //插件 <plugins>
      pluginElement(root.evalNode("plugins"));
      //自定义实例化对象的行动<objectFactory>
      objectFactoryElement(root.evalNode("objectFactory"));
      //MateObject   轻易反射操纵实体类的对象
      objectWrapperFactoryElement(root.evalNode("objectWrapperFactory"));
      reflectorFactoryElement(root.evalNode("reflectorFactory"));
      settingsElement(settings);
      // read it after objectFactory and objectWrapperFactory issue #631
      //<environments>
      environmentsElement(root.evalNode("environments"));
      databaseIdProviderElement(root.evalNode("databaseIdProvider"));
      // typeHandlers
      typeHandlerElement(root.evalNode("typeHandlers"));
      //重要 <mappers> 指向我们寄存SQL的xxxxMapper.xml文件
      mapperElement(root.evalNode("mappers"));
    } catch (Exception e) {
      throw new BuilderException("Error parsing SQL Mapper Configuration. Cause: " + e, e);
    }
  }

能够看到这个要领已在剖析<configuration>下的节点了,比方<settings>,<typeAliases>,<environments><mappers>

这里重要运用了分步构建,每一个剖析差别标签的要领内部都对Configuration对象举行了set或许别的相似的操纵,经由这些操纵以后,一个Configuration对象就构建终了了,这里由于代码量比较大,而且大多数构建都是些细节,也许晓得如何用就能够了,就不在文章中说清楚明了,我会挑一个重要的说,固然有兴致的同砚能够本身去pull MyBatis的源码看看。

Mappers

上文中提到,mybatis-config.xml文件中我们肯定会写一个叫做<mappers>的标签,这个标签中的<mapper>节点寄存了我们对数据库举行操纵的SQL语句,所以这个标签的构建会作为本日剖析的重点。

起首在看源码之前,我们先回想一下我们在mapper标签内一般会如何举行设置,一般有以下几种设置体式格局。

<mappers>
    <!-- 经由历程设置文件途径 -->
  <mapper resource="mapper/DemoMapper.xml" ></mapper>
    <!-- 经由历程Java全限制类名 -->
  <mapper class="com.mybatistest.TestMapper"/>
   <!-- 经由历程url 一般是mapper不在当地时用 -->
  <mapper url=""/>
    <!-- 经由历程包名 -->
  <package name="com.mybatistest"/>
    <!-- 注重 mapper节点中,能够运用resource/url/class三种体式格局猎取mapper-->
</mappers>

这是<mappers>标签的几种设置体式格局,经由历程这几种设置体式格局,能够协助我们更轻易明白mappers的剖析。

private void mapperElement(XNode parent) throws Exception {
  if (parent != null) {
      //遍历剖析mappers下的节点
      for (XNode child : parent.getChildren()) {
      //起首剖析package节点
      if ("package".equals(child.getName())) {
        //猎取包名
        String mapperPackage = child.getStringAttribute("name");
        configuration.addMappers(mapperPackage);
      } else {
        //假如不存在package节点,那末扫描mapper节点
        //resource/url/mapperClass三个值只能有一个值是有值的
        String resource = child.getStringAttribute("resource");
        String url = child.getStringAttribute("url");
        String mapperClass = child.getStringAttribute("class");
        //优先级 resource>url>mapperClass
        if (resource != null && url == null && mapperClass == null) {
            //假如mapper节点中的resource不为空
          ErrorContext.instance().resource(resource);
           //那末直接加载resource指向的XXXMapper.xml文件为字撙节
          InputStream inputStream = Resources.getResourceAsStream(resource);
          //经由历程XMLMapperBuilder剖析XXXMapper.xml,能够看到这里构建的XMLMapperBuilde还传入了configuration,所以以后肯定是会将mapper封装到configuration对象中去的。
          XMLMapperBuilder mapperParser = new XMLMapperBuilder(inputStream, configuration, resource, configuration.getSqlFragments());
          //剖析
          mapperParser.parse();
        } else if (resource == null && url != null && mapperClass == null) {
          //假如url!=null,那末经由历程url剖析
          ErrorContext.instance().resource(url);
          InputStream inputStream = Resources.getUrlAsStream(url);
          XMLMapperBuilder mapperParser = new XMLMapperBuilder(inputStream, configuration, url, configuration.getSqlFragments());
          mapperParser.parse();
        } else if (resource == null && url == null && mapperClass != null) {
            //假如mapperClass!=null,那末经由历程加载类组织Configuration
          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.");
        }
      }
    }
  }
}

手把手带你阅读Mybatis源码(一)组织篇 IT教程 第2张

我们的设置文件中写的是经由历程resource来加载mapper.xml的,所以会经由历程XMLMapperBuilder来举行剖析,我们能够进去他的parse要领中看一下:

public void parse() {
    //推断文件是不是之前剖析过
    if (!configuration.isResourceLoaded(resource)) {
        //剖析mapper文件节点(重要)(下面贴了代码)
      configurationElement(parser.evalNode("/mapper"));
      configuration.addLoadedResource(resource);
      //绑定Namespace内里的Class对象
      bindMapperForNamespace();
    }
    //从新剖析之前剖析不了的节点,先不看,末了填坑。
    parsePendingResultMaps();
    parsePendingCacheRefs();
    parsePendingStatements();
  }


//剖析mapper文件内里的节点
// 拿到内里设置的设置项 终究封装成一个MapperedStatemanet
private void configurationElement(XNode context) {
  try {
      //猎取定名空间 namespace,这个很重要,后期mybatis会经由历程这个动态代办我们的Mapper接口
    String namespace = context.getStringAttribute("namespace");
    if (namespace == null || namespace.equals("")) {
        //假如namespace为空则抛一个非常
      throw new BuilderException("Mapper's namespace cannot be empty");
    }
    builderAssistant.setCurrentNamespace(namespace);
    //剖析缓存节点
    cacheRefElement(context.evalNode("cache-ref"));
    cacheElement(context.evalNode("cache"));

    //剖析parameterMap(过期)和resultMap  <resultMap></resultMap>
    parameterMapElement(context.evalNodes("/mapper/parameterMap"));
    resultMapElements(context.evalNodes("/mapper/resultMap"));
    //剖析<sql>节点 
    //<sql id="staticSql">select * from test</sql> (可重用的代码段)
    //<select> <include refid="staticSql"></select>
    sqlElement(context.evalNodes("/mapper/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);
  }
}

在这个parse()要领中,挪用了一个configuationElement代码,用于剖析XXXMapper.xml文件中的种种节点,包含<cache><cache-ref><paramaterMap>(已过期)、<resultMap><sql>、另有增编削查节点,和上面雷同的是,我们也挑一个重要的来讲,由于剖析历程都迥然差别。

毋庸置疑的是,我们在XXXMapper.xml中必不可少的就是编写SQL,与数据库交互重要靠的也就是这个,所以偏重说说剖析增编削查节点的要领——buildStatementFromContext()。

在没贴代码之前,依据这个名字就能够略知一二了,这个要领会依据我们的增编削查节点,来组织一个Statement,而用过原生Jdbc的都晓得,Statement就是我们操纵数据库的对象。

private void buildStatementFromContext(List<XNode> list) {
    if (configuration.getDatabaseId() != null) {
      buildStatementFromContext(list, configuration.getDatabaseId());
    }
    //剖析xml
    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 {
      //剖析xml节点
      statementParser.parseStatementNode();
    } catch (IncompleteElementException e) {
      //xml语句有问题时 存储到鸠合中 等剖析完能剖析的再从新剖析
      configuration.addIncompleteStatement(statementParser);
    }
  }
}


public void parseStatementNode() {
    //猎取<select id="xxx">中的id
    String id = context.getStringAttribute("id");
    //猎取databaseId 用于多数据库,这里为null
    String databaseId = context.getStringAttribute("databaseId");

    if (!databaseIdMatchesCurrent(id, databaseId, this.requiredDatabaseId)) {
      return;
    }
    //猎取节点名  select update delete insert
    String nodeName = context.getNode().getNodeName();
    //依据节点名,获得SQL操纵的范例
    SqlCommandType sqlCommandType = SqlCommandType.valueOf(nodeName.toUpperCase(Locale.ENGLISH));
    //推断是不是是查询
    boolean isSelect = sqlCommandType == SqlCommandType.SELECT;
    //是不是革新缓存 默许:增编削革新 查询不革新
    boolean flushCache = context.getBooleanAttribute("flushCache", !isSelect);
    //是不是运用二级缓存 默许值:查询运用 增编削不运用
    boolean useCache = context.getBooleanAttribute("useCache", isSelect);
    //是不是须要处置惩罚嵌套查询效果 group by

    // 三组数据 分红一个嵌套的查询效果
    boolean resultOrdered = context.getBooleanAttribute("resultOrdered", false);

    // Include Fragments before parsing
    XMLIncludeTransformer includeParser = new XMLIncludeTransformer(configuration, builderAssistant);
    //替代Includes标签为对应的sql标签内里的值
    includeParser.applyIncludes(context.getNode());

    //猎取parameterType名
    String parameterType = context.getStringAttribute("parameterType");
    //猎取parameterType的Class
    Class<?> parameterTypeClass = resolveClass(parameterType);

    //剖析设置的自定义脚本语言驱动 这里为null
    String lang = context.getStringAttribute("lang");
    LanguageDriver langDriver = getLanguageDriver(lang);

    // Parse selectKey after includes and remove them.
    //剖析selectKey
    processSelectKeyNodes(id, parameterTypeClass, langDriver);

    // Parse the SQL (pre: <selectKey> and <include> were parsed and removed)
    //设置主键自增划定规矩
    KeyGenerator keyGenerator;
    String keyStatementId = id + SelectKeyGenerator.SELECT_KEY_SUFFIX;
    keyStatementId = builderAssistant.applyCurrentNamespace(keyStatementId, true);
    if (configuration.hasKeyGenerator(keyStatementId)) {
      keyGenerator = configuration.getKeyGenerator(keyStatementId);
    } else {
      keyGenerator = context.getBooleanAttribute("useGeneratedKeys",
          configuration.isUseGeneratedKeys() && SqlCommandType.INSERT.equals(sqlCommandType))
          ? Jdbc3KeyGenerator.INSTANCE : NoKeyGenerator.INSTANCE;
    }
/************************************************************************************/
    //剖析Sql(重要)  依据sql文原本推断是不是须要动态剖析 假如没有动态sql语句且 只要#{}的时刻 直接静态剖析运用?占位 当有 ${} 不剖析
    SqlSource sqlSource = langDriver.createSqlSource(configuration, context, parameterTypeClass);
    //猎取StatementType,能够明白为Statement和PreparedStatement
    StatementType statementType = StatementType.valueOf(context.getStringAttribute("statementType", StatementType.PREPARED.toString()));
    //没用过
    Integer fetchSize = context.getIntAttribute("fetchSize");
    //超时时候
    Integer timeout = context.getIntAttribute("timeout");
    //已过期
    String parameterMap = context.getStringAttribute("parameterMap");
    //猎取返回值范例名
    String resultType = context.getStringAttribute("resultType");
    //猎取返回值烈性的Class
    Class<?> resultTypeClass = resolveClass(resultType);
    //猎取resultMap的id
    String resultMap = context.getStringAttribute("resultMap");
    //猎取效果集范例
    String resultSetType = context.getStringAttribute("resultSetType");
    ResultSetType resultSetTypeEnum = resolveResultSetType(resultSetType);
    if (resultSetTypeEnum == null) {
      resultSetTypeEnum = configuration.getDefaultResultSetType();
    }
    String keyProperty = context.getStringAttribute("keyProperty");
    String keyColumn = context.getStringAttribute("keyColumn");
    String resultSets = context.getStringAttribute("resultSets");

    //将适才猎取到的属性,封装成MappedStatement对象(代码贴鄙人面)
    builderAssistant.addMappedStatement(id, sqlSource, statementType, sqlCommandType,
        fetchSize, timeout, parameterMap, parameterTypeClass, resultMap, resultTypeClass,
        resultSetTypeEnum, flushCache, useCache, resultOrdered,
        keyGenerator, keyProperty, keyColumn, databaseId, langDriver, resultSets);
  }

//将适才猎取到的属性,封装成MappedStatement对象
  public MappedStatement addMappedStatement(
      String id,
      SqlSource sqlSource,
      StatementType statementType,
      SqlCommandType sqlCommandType,
      Integer fetchSize,
      Integer timeout,
      String parameterMap,
      Class<?> parameterType,
      String resultMap,
      Class<?> resultType,
      ResultSetType resultSetType,
      boolean flushCache,
      boolean useCache,
      boolean resultOrdered,
      KeyGenerator keyGenerator,
      String keyProperty,
      String keyColumn,
      String databaseId,
      LanguageDriver lang,
      String resultSets) {

    if (unresolvedCacheRef) {
      throw new IncompleteElementException("Cache-ref not yet resolved");
    }

    //id = namespace
    id = applyCurrentNamespace(id, false);
    boolean isSelect = sqlCommandType == SqlCommandType.SELECT;

      //经由历程组织者形式+链式变成,组织一个MappedStatement的组织者
    MappedStatement.Builder statementBuilder = new MappedStatement.Builder(configuration, id, sqlSource, sqlCommandType)
        .resource(resource)
        .fetchSize(fetchSize)
        .timeout(timeout)
        .statementType(statementType)
        .keyGenerator(keyGenerator)
        .keyProperty(keyProperty)
        .keyColumn(keyColumn)
        .databaseId(databaseId)
        .lang(lang)
        .resultOrdered(resultOrdered)
        .resultSets(resultSets)
        .resultMaps(getStatementResultMaps(resultMap, resultType, id))
        .resultSetType(resultSetType)
        .flushCacheRequired(valueOrDefault(flushCache, !isSelect))
        .useCache(valueOrDefault(useCache, isSelect))
        .cache(currentCache);

    ParameterMap statementParameterMap = getStatementParameterMap(parameterMap, parameterType, id);
    if (statementParameterMap != null) {
      statementBuilder.parameterMap(statementParameterMap);
    }

      //经由历程组织者组织MappedStatement
    MappedStatement statement = statementBuilder.build();
     //将MappedStatement对象封装到Configuration对象中
    configuration.addMappedStatement(statement);
    return statement;
  }

这个代码段虽然很长,然则一句话描述它就是烦琐但不庞杂,内里重要也就是对xml的节点举行剖析。举个比上面简朴的例子吧,假定我们有如许一段设置:

<select id="selectDemo" parameterType="java.lang.Integer" resultType='Map'>
    SELECT * FROM test
</select>

MyBatis须要做的就是,先推断这个节点是用来干什么的,然后再猎取这个节点的id、parameterType、resultType等属性,封装成一个MappedStatement对象,由于这个对象很庞杂,所以MyBatis运用了组织者形式来组织这个对象,末了当MappedStatement对象组织完成后,将其封装到Configuration对象中。

代码实行至此,基础就完毕了对Configuration对象的构建,MyBatis的第一阶段:组织,也就到这里完毕了,如今再来回覆我们在文章开头提出的那两个问题:MyBatis须要组织什么对象?以及是不是两个设置文件对应着两个对象?,好像就已有了答案,这里做一个总结:

MyBatis须要对设置文件举行剖析,终究会剖析成一个Configuration对象,然则要说两个设置文件对应了两个对象实际上也没有错:

  • Configuration对象,保留了mybatis-config.xml的设置信息。
  • MappedStatement,保留了XXXMapper.xml的设置信息。

然则终究MappedStatement对象会封装到Configuration对象中,合二为一,成为一个零丁的对象,也就是Configuration。

末了给人人画一个构建历程的流程图:

手把手带你阅读Mybatis源码(一)组织篇 IT教程 第3张

填坑

SQL语句在哪剖析?

仔细的同砚大概已发现了,上文中只说了去节点中猎取一些属性从而构建设置对象,然则最重要的SQL语句并没有提到,这是由于这部份我想要和属性区离开零丁说,由于MyBatis支撑动态SQL和${}#{}的多样的SQL,所以这里零丁提出来讲会比较适宜。

起首能够确认的是,适才我们走完的那一全部流程中,包含了SQL语句的生成,下面贴代码(这一段代码相称绕,不好读)。

//剖析Sql(重要)  依据sql文原本推断是不是须要动态剖析 假如没有动态sql语句且 只要#{}的时刻 直接静态剖析运用?占位 当有 ${} 不剖析
SqlSource sqlSource = langDriver.createSqlSource(configuration, context, parameterTypeClass);

这里就是生成Sql的进口,以单步调试的角度接着往下看。

/*进入createSqlSource要领*/
@Override
public SqlSource createSqlSource(Configuration configuration, XNode script, Class<?> parameterType) {
    //进入这个组织
    XMLScriptBuilder builder = new XMLScriptBuilder(configuration, script, parameterType);
    //进入parseScriptNode
    return builder.parseScriptNode();
}
/**
进入这个要领
*/
public SqlSource parseScriptNode() {
    //#
    //会先剖析一遍
    MixedSqlNode rootSqlNode = parseDynamicTags(context);
    SqlSource sqlSource;
    if (isDynamic) {
      //假如是${}会直接不剖析,守候实行的时刻直接赋值
      sqlSource = new DynamicSqlSource(configuration, rootSqlNode);
    } else {
      //用占位符体式格局来剖析  #{} --> ?
      sqlSource = new RawSqlSource(configuration, rootSqlNode, parameterType);
    }
    return sqlSource;
}
protected MixedSqlNode parseDynamicTags(XNode node) {
    List<SqlNode> contents = new ArrayList<>();
    //猎取select标签下的子标签
    NodeList children = node.getNode().getChildNodes();
    for (int i = 0; i < children.getLength(); i++) {
      XNode child = node.newXNode(children.item(i));
      if (child.getNode().getNodeType() == Node.CDATA_SECTION_NODE || child.getNode().getNodeType() == Node.TEXT_NODE) {
          //假如是查询
        //猎取原生SQL语句 这里是 select * from test where id = #{id}
        String data = child.getStringBody("");
        TextSqlNode textSqlNode = new TextSqlNode(data);
        //搜检sql是不是是${}
        if (textSqlNode.isDynamic()) {
            //假如是${}那末直接不剖析
          contents.add(textSqlNode);
          isDynamic = true;
        } else {
            //假如不是,则直接生成静态SQL
            //#{} -> ?
          contents.add(new StaticTextSqlNode(data));
        }
      } else if (child.getNode().getNodeType() == Node.ELEMENT_NODE) { // issue #628
          //假如是增编削
        String nodeName = child.getNode().getNodeName();
        NodeHandler handler = nodeHandlerMap.get(nodeName);
        if (handler == null) {
          throw new BuilderException("Unknown element <" + nodeName + "> in SQL statement.");
        }
        handler.handleNode(child, contents);
        isDynamic = true;
      }
    }
    return new MixedSqlNode(contents);
  }

 

/*从上面的代码段到这一段中心须要经由许多代码,就不一段一段贴了*/
public SqlSource parse(String originalSql, Class<?> parameterType, Map<String, Object> additionalParameters) {
    ParameterMappingTokenHandler handler = new ParameterMappingTokenHandler(configuration, parameterType, additionalParameters);
    //这里会生成一个GenericTokenParser,传入#{}作为入手下手和完毕,然后挪用其parse要领,即可将#{}换为 ?
    GenericTokenParser parser = new GenericTokenParser("#{", "}", handler);
    //这里能够剖析#{} 将其替代为?
    String sql = parser.parse(originalSql);
    return new StaticSqlSource(configuration, sql, handler.getParameterMappings());
  }

//经由一段庞杂的剖析历程
public String parse(String text) {
    if (text == null || text.isEmpty()) {
      return "";
    }
    // search open token
    int start = text.indexOf(openToken);
    if (start == -1) {
      return text;
    }
    char[] src = text.toCharArray();
    int offset = 0;
    final StringBuilder builder = new StringBuilder();
    StringBuilder expression = null;
    //遍历内里一切的#{} select ?  ,#{id1} ${}
    while (start > -1) {
      if (start > 0 && src[start - 1] == '') {
        // this open token is escaped. remove the backslash and continue.
        builder.append(src, offset, start - offset - 1).append(openToken);
        offset = start + openToken.length();
      } else {
        // found open token. let's search close token.
        if (expression == null) {
          expression = new StringBuilder();
        } else {
          expression.setLength(0);
        }
        builder.append(src, offset, start - offset);
        offset = start + openToken.length();
        int end = text.indexOf(closeToken, offset);
        while (end > -1) {
          if (end > offset && src[end - 1] == '') {
            // this close token is escaped. remove the backslash and continue.
            expression.append(src, offset, end - offset - 1).append(closeToken);
            offset = end + closeToken.length();
            end = text.indexOf(closeToken, offset);
          } else {
            expression.append(src, offset, end - offset);
            break;
          }
        }
        if (end == -1) {
          // close token was not found.
          builder.append(src, start, src.length - start);
          offset = src.length;
        } else {
            //运用占位符 ?
            //注重handler.handleToken()要领,这个要领是中心
          builder.append(handler.handleToken(expression.toString()));
          offset = end + closeToken.length();
        }
      }
      start = text.indexOf(openToken, offset);
    }
    if (offset < src.length) {
      builder.append(src, offset, src.length - offset);
    }
    return builder.toString();
}

//BindingTokenParser 的handleToken
//当扫描到${}的时刻挪用此要领  实在就是不剖析 在运转时刻在替代成详细的值
@Override
public String handleToken(String content) {
  this.isDynamic = true;
  return null;
}
//ParameterMappingTokenHandler的handleToken
//全局扫描#{id} 字符串以后  会把内里一切 #{} 挪用handleToken 替代为?
@Override
public String handleToken(String content) {
      parameterMappings.add(buildParameterMapping(content));
      return "?";
}

这段代码相称绕,我们应当站在一个宏观的角度去对待它。所以我直接在这里归纳综合一下:

起首这里会经由历程<select>节点猎取到我们的SQL语句,假定SQL语句中只要${},那末直接就什么都不做,在运转的时刻直接举行赋值。

而假如扫描到了#{}字符串以后,会举行替代,将#{}替代为 ?

那末他是如何举行推断的呢?

这里会生成一个GenericTokenParser,这个对象能够传入一个openToken和closeToken,假如是#{},那末openToken就是#{,closeToken就是 },然后经由历程parse要领中的handler.handleToken()要领举行替代。

在这之前由于已举行过SQL是不是含有#{}的推断了,所以在这里假如是只要${},那末handler就是BindingTokenParser的实例化对象,假如存在#{},那末handler就是ParameterMappingTokenHandler的实例化对象。

离别举行处置惩罚。

上文中提到的剖析不了的节点是什么意义?

依据上文的代码我们可知,剖析Mapper.xml文件中的每一个节点是有次序的。

那末假定我写了这么一个几个节点:

<select id="demoselect" paramterType='java.lang.Integer' resultMap='demoResultMap'>
</select>
<resultMap id="demoResultMap" type="demo">
    <id column property>
    <result coulmn property>
</resultMap>

select节点是须要猎取resultMap的,然则此时resultMap并没有被剖析到,所以剖析到<select>这个节点的时刻是没法猎取到resultMap的信息的。

我们来看看MyBatis是如何做的:

private void buildStatementFromContext(List<XNode> list, String requiredDatabaseId) {
    for (XNode context : list) {
    final XMLStatementBuilder statementParser = new XMLStatementBuilder(configuration, builderAssistant, context, requiredDatabaseId);
    try {
      //剖析xml节点
      statementParser.parseStatementNode();
    } catch (IncompleteElementException e) {
      //xml语句有问题时 存储到鸠合中 等剖析完能剖析的再从新剖析
      configuration.addIncompleteStatement(statementParser);
    }
  }
}

当剖析到某个节点出现问题的时刻,会抛一个非常,然后会挪用configuration的addIncompleteStatement要领,将这个剖析对象先暂存到这个鸠合中,比及一切的节点都剖析终了以后,在对这个鸠合内的剖析对象继承剖析:

public void parse() {
      //推断文件是不是之前剖析过
    if (!configuration.isResourceLoaded(resource)) {
        //剖析mapper文件
      configurationElement(parser.evalNode("/mapper"));
      configuration.addLoadedResource(resource);
      //绑定Namespace内里的Class对象
      bindMapperForNamespace();
    }

    //从新剖析之前剖析不了的节点
    parsePendingResultMaps();
    parsePendingCacheRefs();
    parsePendingStatements();
}
private void parsePendingResultMaps() {
    Collection<ResultMapResolver> incompleteResultMaps = configuration.getIncompleteResultMaps();
    synchronized (incompleteResultMaps) {
      Iterator<ResultMapResolver> iter = incompleteResultMaps.iterator();
      while (iter.hasNext()) {
        try {
            //增加resultMap
          iter.next().resolve();
          iter.remove();
        } catch (IncompleteElementException e) {
          // ResultMap is still missing a resource...
        }
      }
    }
}
public ResultMap resolve() {
    //增加resultMap
    return assistant.addResultMap(this.id, this.type, this.extend, this.discriminator, this.resultMappings, this.autoMapping);
  }

结语

至此全部MyBatis的查询前构建的历程就基础说完了,简朴地总结就是,MyBatis会在实行查询之前,对设置文件举行剖析成设置对象:Configuration,以便在后面实行的时刻去运用,而寄存SQL的xml又会剖析成MappedStatement对象,然则终究这个对象也会到场Configuration中。

至于Configuration是如何被运用的,以及SQL的实行部份,我会鄙人一篇说SQL实行的时刻分享。

并发与多线程

参与评论