Mybatis源码分析之如何理解SQLSession初始化

这篇文章主要介绍“Mybatis源码分析之如何理解SQLSession初始化”，在日常操作中，相信很多人在Mybatis源码分析之如何理解SQLSession初始化问题上存在疑惑，小编查阅了各式资料，整理出简单好用的操作方法，希望对大家解答”Mybatis源码分析之如何理解SQLSession初始化”的疑惑有所帮助！接下来，请跟着小编一起来学习吧！

10年积累的网站设计制作、网站制作经验，可以快速应对客户对网站的新想法和需求。提供各种问题对应的解决方案。让选择我们的客户得到更好、更有力的网络服务。我虽然不认识你，你也不认识我。但先做网站后付款的网站建设流程，更有红安免费网站建设让你可以放心的选择与我们合作。

这次打算写一个 Mybatis 源码分析的系列,大致分为

• Mybatis 启动流程分析

• Mybatis 的SQL 执行流程分析

• Mybatis 的拓展点以及与 Spring Boot 的整合

这篇文章先来分析 Mybati初始化流程,如何读取配置文件到,以及创建出 SqlSession 示例.主要内容包括

• 读取、解析mybatis 全局配置文件

• 映射 mapper.java 文件

• 解析 mapper.xml 文件

• 解析 mapper.xml 各个节点配置，包括 namespace、缓存、增删改查节点

• Mybatis 缓存机制

• 构建DefaultSqlSessionFactory

什么是 SQLSession

SQLSession对外提供了用户和数据库之间交互需要的所有方法，隐藏了底层的细节。默认实现类是DefaultSqlSession

SQLSession 创建示例

通过一个mybatis 官方提供的示例,看下如何手动创建 SQLSession

//Mybatis 配置文件,通常包含:数据库连接信息,Mapper.class 全限定名包路径,事务配置,插件配置等等
String resource = "org/mybatis/builder/mybatis-config.xml";
//以输入流的方式读取配置
InputStream inputStream = Resources.getResourceAsStream(resource);
//实例化出 SQLSession 的必要步骤 SqlSessionFactoryBuilder --> SqlSessionFactory  --> SqlSession
SqlSessionFactoryBuilder builder = new SqlSessionFactoryBuilder();
SqlSessionFactory factory = builder.build(inputStream);
SqlSession session = factory.openSession();

通过输入流读取mybatis-config.xml 配置文件

接下来就通过new SqlSessionFactoryBuilder() 开始我们的构建 SQLSession 源码分析

//SqlSessionFactory 有4 个构造方法,最终都会执行到全参的构造方法
public SqlSessionFactory build(Reader reader, String environment, Properties properties) {
  try {
    //首先会实例化一个 XMLConfigBuilder ,这里先有个基本的认知:XMLConfigBuilder 就是用来解析 XML 文件配置的
    XMLConfigBuilder parser = new XMLConfigBuilder(reader, environment, properties);
    //经过parser.parse()之后,XML配置文件已经被解析成了Configuration ,Configuration 对象是包含着mybatis的所有属性.
    return build(parser.parse());
  } catch (Exception e) {
    throw ExceptionFactory.wrapException("Error building SqlSession.", e);
  } finally {
   //... 关闭流,抛异常
  }
}

插句嘴,先看下XMLConfigBuilder 类图

• MLConfigBuilder : 解析全局配置文件即 mybatis-config.xml

• XMLMapperBuilder : 解析 Mapper 文件,配置在mybatis-config.xml 文件中 mapper.java 的包路径

• XMLStatementBuilder :解析 mapper 文件的节点中 ,SQL 语句标签:select,update,insert,delete

• SQLSourceBuilder:动态解析 SQL 语句,根据 SqlNode 解析 Sql 语句中的标签,比如,等标签

当然 BaseBuilder 的实现类不仅这 4 个,这里只介绍这 4 类,在后续一步步分析中都能看到这几个的身影 点进去看一下 parser.parse()

public Configuration parse() {
  // 若已经解析过了 就抛出异常
  if (parsed) {
    throw new BuilderException("Each XMLConfigBuilder can only be used once.");
  }
  // 设置解析标志位
  parsed = true;
  // 解析mybatis-config.xml的节点,读取配置文件,加载到 Configuration 中 
  parseConfiguration(parser.evalNode("/configuration"));
  return configuration;
}

通过XPathParser 对象来解析 xml 文件成XNode 对象

解析成 Configuration 成之前会先将 xml 配置文件解析成 XNode 对象

public XNode evalNode(Object root, String expression) {
  //mybatis 自已定义了一个XPathParser 对象来解析 xml ,其实对Document做了封装 
  Node node = (Node) evaluate(expression, root, XPathConstants.NODE);
  if (node == null) {
    return null;
  }
  return new XNode(this, node, variables);
}

解析config.xml 中的各个节点

接下来就看看下mybatis 是如何一步步读取配置文件的

/**
 * 解析 mybatis-config.xml的 configuration节点
 * 解析 XML 中的各个节点
 */
private void parseConfiguration(XNode root) {
  try {
    /**
     * 解析 properties节点
     *     
     *     解析到org.apache.ibatis.parsing.XPathParser#variables
     *     org.apache.ibatis.session.Configuration#variables
     */
    propertiesElement(root.evalNode("properties"));
    /**
     * 解析我们的mybatis-config.xml中的settings节点
     * 具体可以配置哪些属性:http://www.mybatis.org/mybatis-3/zh/configuration.html#settings
     * 
          
          
         
         
         
          ..............
         
     *
     */
    Properties settings = settingsAsProperties(root.evalNode("settings"));
    /**
     * 基本没有用过该属性
     * VFS含义是虚拟文件系统；主要是通过程序能够方便读取本地文件系统、FTP文件系统等系统中的文件资源。
       Mybatis中提供了VFS这个配置，主要是通过该配置可以加载自定义的虚拟文件系统应用程序
       解析到：org.apache.ibatis.session.Configuration#vfsImpl
     */
    loadCustomVfs(settings);
    /**
     * 指定 MyBatis 所用日志的具体实现，未指定时将自动查找。
     * SLF4J | LOG4J | LOG4J2 | JDK_LOGGING | COMMONS_LOGGING | STDOUT_LOGGING | NO_LOGGING
     * 解析到org.apache.ibatis.session.Configuration#logImpl
     */
    loadCustomLogImpl(settings);
    /**
     * 解析我们的别名
     * 
         
      
     
        
     
     解析到oorg.apache.ibatis.session.Configuration#typeAliasRegistry.typeAliases
     */
    typeAliasesElement(root.evalNode("typeAliases"));
    /**
     * 解析我们的插件(比如分页插件)
     * mybatis自带的
     * Executor (update, query, flushStatements, commit, rollback, getTransaction, close, isClosed)
       ParameterHandler (getParameterObject, setParameters)
       ResultSetHandler (handleResultSets, handleOutputParameters)
       StatementHandler (prepare, parameterize, batch, update, query)
      解析到：org.apache.ibatis.session.Configuration#interceptorChain.interceptors
     */
    pluginElement(root.evalNode("plugins"));

    objectFactoryElement(root.evalNode("objectFactory"));
    objectWrapperFactoryElement(root.evalNode("objectWrapperFactory"));
    reflectorFactoryElement(root.evalNode("reflectorFactory"));
    // 设置settings 和默认值
    settingsElement(settings);
    // read it after objectFactory and objectWrapperFactory issue #631

    /**
     * 解析我们的mybatis环境,解析 DataSource
       
         
           
           
           
           
           
           
           
         

       
         
         
         
         
         
         
         
       
     
     *  解析到：org.apache.ibatis.session.Configuration#environment
     *  在集成spring情况下由 spring-mybatis提供数据源 和事务工厂
     */
    environmentsElement(root.evalNode("environments"));
    /**
     * 解析数据库厂商
     *     
              
              
              
              
           
     *  解析到：org.apache.ibatis.session.Configuration#databaseId
     */
    databaseIdProviderElement(root.evalNode("databaseIdProvider"));
    /**
     * 解析我们的类型处理器节点
     * 
          
        
        解析到：org.apache.ibatis.session.Configuration#typeHandlerRegistry.typeHandlerMap
     */
    typeHandlerElement(root.evalNode("typeHandlers"));
    /**
     * 最最重要的就是解析我们的mapper
     *
     resource：来注册我们的class类路径下的
     url:来指定我们磁盘下的或者网络资源的
     class:
     若注册Mapper不带xml文件的,这里可以直接注册
     若注册的Mapper带xml文件的，需要把xml文件和mapper文件同名 同路径
     -->
     
        
        


          
        -->
     
     * 解析 mapper:
     * 1.解析mapper.java接口 解析到：org.apache.ibatis.session.Configuration#mapperRegistry.knownMappers
     * 2.解析 mapper.xml 配置
     */
    mapperElement(root.evalNode("mappers"));
  } catch (Exception e) {
    throw new BuilderException("Error parsing SQL Mapper Configuration. Cause: " + e, e);
  }
}

解析 mapper 文件

解析 mapper.java 接口到knowMappers 中

private void mapperElement(XNode parent) throws Exception {
  if (parent != null) {
    //获取我们mappers节点下的一个一个的mapper节点
    for (XNode child : parent.getChildren()) {
      /**
         * 指定 mapper 的 4 中方式:
         * 1.指定的 mapper 所在的包路径,批量注册
         * 2.通过 resource 目录指定
         * 3.通过 url 指定,从网络资源或者本地磁盘
         * 4.通过 class 路径注册
         */
      //判断我们mapper是不是通过批量注册的
      if ("package".equals(child.getName())) {
        String mapperPackage = child.getStringAttribute("name");
        configuration.addMappers(mapperPackage);
      } else {
        //判断从classpath下读取我们的mapper
        String resource = child.getStringAttribute("resource");
        //判断是不是从我们的网络资源读取(或者本地磁盘得)
        String url = child.getStringAttribute("url");
        //解析这种类型(要求接口和xml在同一个包下)
        String mapperClass = child.getStringAttribute("class");

        //解析 mapper 文件
        if (resource != null && url == null && mapperClass == null) {
          ErrorContext.instance().resource(resource);
          // 把mapper文件读取出一个流,是不是似曾相识,最开始的时候读取mybatis-config.xml 配置文件也是通过输入流的方式读取的
          InputStream inputStream = Resources.getResourceAsStream(resource);
          //创建读取XmlMapper构建器对象,用于来解析我们的mapper.xml文件,上面提到过的 XMLMapperBuilder对象
          /**
           * 读取的 mapper 文件会被放入到 MapperRegistry 中的 knownMappers中
           * Map, MapperProxyFactory> knownMappers = new HashMap<>();
           * 为后续创建 Mapper 代理对象做准备
           */
          XMLMapperBuilder mapperParser = new XMLMapperBuilder(inputStream, configuration, resource, configuration.getSqlFragments());
          //真正的解析我们的mapper.xml配置文件,这里就会来解析我们的sql
          mapperParser.parse();
        } else if (resource == null && url != null && mapperClass == null) {
          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) {
          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.");
        }
      }
    }
  }
}

解析 mapper.xml 文件

解析Mapper.xml 中的 SQL 标签

//解析的 SQL 语句节点会放在Configuration.MappedStatement.SqlSource 中,SqlSource 中包含了一个个的 SQLNode,一个标签对应一个 SQLNode
public void parse() {
  //判断当前的Mapper是否被加载过
  if (!configuration.isResourceLoaded(resource)) {
    //真正的解析我们的mapper
    configurationElement(parser.evalNode("/mapper"));
    //把资源保存到我们Configuration中
    configuration.addLoadedResource(resource);

    bindMapperForNamespace();
  }
  
  parsePendingResultMaps();
  parsePendingCacheRefs();
  parsePendingStatements();
}

解析 mapper.xml 中的各个节点

//解析我们的节点
private void configurationElement(XNode context) {
  try {
    /**
     * 解析我们的namespace属性
     * 
     */
    String namespace = context.getStringAttribute("namespace");
    if (namespace == null || namespace.equals("")) {
      throw new BuilderException("Mapper's namespace cannot be empty");
    }
    //保存我们当前的namespace  并且判断接口完全类名==namespace
    builderAssistant.setCurrentNamespace(namespace);
    /**
     * 解析我们的缓存引用
     * 说明我当前的缓存引用和DeptMapper的缓存引用一致
     * 
          解析到org.apache.ibatis.session.Configuration#cacheRefMap<当前namespace,ref-namespace>
          异常下（引用缓存未使用缓存）：org.apache.ibatis.session.Configuration#incompleteCacheRefs
     */
    cacheRefElement(context.evalNode("cache-ref"));
    /**
     * 解析我们的cache节点
     * 
        解析到：org.apache.ibatis.session.Configuration#caches
               org.apache.ibatis.builder.MapperBuilderAssistant#currentCache
     */
    cacheElement(context.evalNode("cache"));
    /**
     * 解析paramterMap节点
     */
    parameterMapElement(context.evalNodes("/mapper/parameterMap"));
    /**
     * 解析我们的resultMap节点
     * 解析到：org.apache.ibatis.session.Configuration#resultMaps
     *    异常 org.apache.ibatis.session.Configuration#incompleteResultMaps
     *
     */
    resultMapElements(context.evalNodes("/mapper/resultMap"));
    /**
     * 解析我们通过sql节点
     *  解析到org.apache.ibatis.builder.xml.XMLMapperBuilder#sqlFragments
     *   其实等于 org.apache.ibatis.session.Configuration#sqlFragments
     *   因为他们是同一引用，在构建XMLMapperBuilder 时把Configuration.getSqlFragments传进去了
     */
    sqlElement(context.evalNodes("/mapper/sql"));
    /**
     * 解析我们的select | insert |update |delete节点
     * 解析到org.apache.ibatis.session.Configuration#mappedStatements
     * 最终SQL节点会被解析成 MappedStatement,一个节点就是对应一个MappedStatement
     * 准确的说 sql 节点被解析成 SQLNode 封装在 MappedStatement.SqlSource 中
     * SQLNode 对应的就是 sql 节点中的子标签,比如,, 等
     */
    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 cacheElement(XNode context) {
    if (context != null) {
    /**
     * cache元素可指定如下属性，每种属性的指定都是针对都是针对底层Cache的一种装饰，采用的是装饰器的模式
     * 缓存属性:
     * 1.eviction: 缓存过期策略:默认是LRU
     *      LRU – 最近最少使用的:移除最长时间不被使用的对象。--> LruCache
     *      FIFO – 先进先出:按对象进入缓存的顺序来移除它们。--> FifoCache
     *      SOFT – 软引用:移除基于垃圾回收器状态和软引用规则的对象。--> SoftCache
     *      WEAK – 弱引用:更积极地移除基于垃圾收集器状态和弱引用规则的对象。--> WeakCache
     * 2.flushInterval: 清空缓存的时间间隔,单位毫秒,默认不清空,指定了之后将会用 ScheduleCache 封装
     * 3.size :缓存对象的大小,默认是 1024,其是针对LruCache而言的，LruCache默认只存储最多1024个Key
     * 4.readOnly :默认是false，底层SerializedCache包装，会在写缓存的时候将缓存对象进行序列化，然后在读缓存的时候进行反序列化，这样每次读到的都将是一个新的对象，即使你更改了读取到的结果，也不会影响原来缓存的对象;true-给所有调用者返回缓存对象的相同实例
     * 5.blocking : 默认为false，当指定为true时将采用BlockingCache进行封装,在进行增删改之后的并发查询，只会有一条去数据库查询，而不会并发访问
     * 6.type: type属性用来指定当前底层缓存实现类，默认是PerpetualCache，如果我们想使用自定义的Cache，则可以通过该属性来指定，对应的值是我们自定义的Cache的全路径名称
     */
      //解析cache节点的type属性
      String type = context.getStringAttribute("type", "PERPETUAL");
      //根据type的String获取class类型
      Class typeClass = typeAliasRegistry.resolveAlias(type);
      //获取缓存过期策略:默认是LRU
      String eviction = context.getStringAttribute("eviction", "LRU");
      Class evictionClass = typeAliasRegistry.resolveAlias(eviction);
      //flushInterval（刷新间隔）属性可以被设置为任意的正整数，设置的值应该是一个以毫秒为单位的合理时间量。 默认情况是不设置，也就是没有刷新间隔，缓存仅仅会在调用语句时刷新。
      Long flushInterval = context.getLongAttribute("flushInterval");
      //size（引用数目）属性可以被设置为任意正整数，要注意欲缓存对象的大小和运行环境中可用的内存资源。默认值是 1024。
      Integer size = context.getIntAttribute("size");
      //只读）属性可以被设置为 true 或 false。只读的缓存会给所有调用者返回缓存对象的相同实例。 因此这些对象不能被修改。这就提供了可观的性能提升。而可读写的缓存会（通过序列化）返回缓存对象的拷贝。 速度上会慢一些，但是更安全，因此默认值是 false
      boolean readWrite = !context.getBooleanAttribute("readOnly", false);
      boolean blocking = context.getBooleanAttribute("blocking", false);
      Properties props = context.getChildrenAsProperties();
      //把缓存节点加入到Configuration中
      //这里的 builder()方法利用责任链方式循环实例化Cache 对象
      builderAssistant.useNewCache(typeClass, evictionClass, flushInterval, size, readWrite, blocking, props);
    }
  }

Mybatis 缓存机制

MyBatis自带的缓存有一级缓存和二级缓存

一级缓存

Mybatis一级缓存是指Session缓存。作用域默认是一个SqlSession。默认开启一级缓存,范围有SESSION和STATEMENT两种，默认是SESSION,如果需要更改一级缓存的范围，可以在Mybatis的配置文件中，通过localCacheScope指定

二级缓存

Mybatis的二级缓存是指mapper映射文件。二级缓存的作用域是同一个namespace下的mapper映射文件内容，多个SqlSession共享。二级缓存是默认启用的,但是需要手动在 mapper 文件中设置启动二级缓存

//在 mapper.xml 文件加上此配置,该 mapper 文件对应的 SQL就开启了缓存
  

或者直接关闭缓存

//在全局配置文件中关闭缓存

  

注意:如果开启了二级缓存,查询结果的映射对象一定要实现Serializable ,因为mybatis 缓存对象的时候默认是会对映射对象进行序列号操作的

解析select | insert |update |delete节点

private void buildStatementFromContext(List list, String requiredDatabaseId) {
  //循环我们的select|delte|insert|update节点
  for (XNode context : list) {
    //创建一个xmlStatement的构建器对象
    final XMLStatementBuilder statementParser = new XMLStatementBuilder(configuration, builderAssistant, context, requiredDatabaseId);
    try {
      //通过该步骤解析之后 mapper.xml 的 sql 节点就也被解析了  
      statementParser.parseStatementNode();
    } catch (IncompleteElementException e) {
      configuration.addIncompleteStatement(statementParser);
    }
  }
}

至此配置mybatis 的配置文件已经解析完成,配置文件已经解析成了Configuration,会到最初,我们的目标是获取 SqlSession 对象,通过new SqlSessionFactoryBuilder().build(reader) 已经构建出了一个SqlSessionFactory 工厂对象,还差一步 SqlSession session = sqlMapper.openSession();

根据 Configuration build 出 DefaultSqlSessionFactory

通过分析DefaultSqlSession 的 openSession() 来实例化 SQLSession 对象

//从session中开启一个数据源
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);
    /**
     * 创建一个sql执行器对象
     * 一般情况下 若我们的mybaits的全局配置文件的cacheEnabled默认为ture就返回
     * 一个cacheExecutor,若关闭的话返回的就是一个SimpleExecutor
     */
    final Executor executor = configuration.newExecutor(tx, execType);
    //创建返回一个DeaultSqlSessoin对象返回
    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();
  }
}

仔细一点看你会发现configuration 就是刚才千辛万苦创建出来的 Configuration 对象,包含所有 mybatis 配置信息.至此SQLSession 的创建已分析完毕.

总结

总结一下上述流程:

第一步:通过输入流读取mybatis-config.xml 配置文件

1:通过XPathParser 读取xml 配置文件成 XNode 属性 2:通过 XMLConfigBuilder 解析 mybatis-config.xml 中的各个节点配置,包括

• 解析properties 节点

• 解析settings 节点

• 加载日志框架

• 解析 typeAliases

• 解析拓展插架 plugins

• 解析数据源 DataSource

• 解析类型处理器 typeHandle

• 解析 mapper文件

第二步:读取 mapper.java 类

读取方式有 package,resource,url,class ,最终都会放入到 Map, MapperProxyFactory> knownMappers 中

第三步: 读取 mapper.xml 节点

1.同样以输入流的方式读取 mapper.xml 文件 2.通过 XMLMapperBuilder 实例解析 mapper.xml 文件中各个接点属性

• 解析 namespace 属性

• 解析缓存引用 cache-ref

• 解析 cache 节点

• 解析 resultMap 节点

• 解析 sql 节点

• 解析 select | insert |update |delete节点 3.通过 XMLStatementBuilder 解析SQL 标签

第四步:将所有配置属性都封装到 Configuration 对象中,构建出SqlSessionFactory 工厂实例

第五步:从session中开启一个数据源 SqlSessionFactory#openSession(),默认是 DefaultSqlSession

到此，关于“Mybatis源码分析之如何理解SQLSession初始化”的学习就结束了，希望能够解决大家的疑惑。理论与实践的搭配能更好的帮助大家学习，快去试试吧！若想继续学习更多相关知识，请继续关注创新互联网站，小编会继续努力为大家带来更多实用的文章！

文章题目：Mybatis源码分析之如何理解SQLSession初始化
网页地址：http://6mz.cn/article/jpcpij.html