解析Mybatis SqlSessionFactory初始化原理

• sqlsessionfactory
  
• 不使用 xml 构建 sqlsessionfactory
  
• sqlsessionfactorybuilder
  

引言

现在内卷越来越严重，关于常用的orm框架mybatis，小编准备了三篇文章，分别将介绍sqlsessionfactory初始化原理、sqlsession执行流程，mybatis代理模式运行方式与最终总结，这是第一篇，感兴趣的朋友可以持续关注。

sqlsessionfactory

每个基于 mybatis 的应用都是以一个 sqlsessionfactory 的实例为核心的。sqlsessionfactory 的实例可以通过 sqlsessionfactorybuilder 获得。而 sqlsessionfactorybuilder 则可以从 xml 配置文件或一个预先配置的 configuration 实例来构建出 sqlsessionfactory 实例。

从 xml 文件中构建 sqlsessionfactory 的实例非常简单，建议使用类路径下的资源文件进行配置。 但也可以使用任意的输入流（inputstream）实例，比如用文件路径字符串或 file:// url 构造的输入流。mybatis 包含一个名叫 resources 的工具类，它包含一些实用方法，使得从类路径或其它位置加载资源文件更加容易。

string resource = "org/mybatis/example/mybatis-config.xml";
inputstream inputstream = resources.getresourceasstream(resource);
sqlsessionfactory sqlsessionfactory = new sqlsessionfactorybuilder().build(inputstream);

xml 配置文件中包含了对 mybatis 系统的核心设置，包括获取数据库连接实例的数据源（datasource）以及决定事务作用域和控制方式的事务管理器（transactionmanager）。后面会再探讨 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>
  <environments default="development">
    <environment id="development">
      <transactionmanager type="jdbc"/>
      <datasource type="pooled">
        <property name="driver" value="${driver}"/>
        <property name="url" value="${url}"/>
        <property name="username" value="${username}"/>
        <property name="password" value="${password}"/>
      </datasource>
    </environment>
  </environments>
  <mappers>
    <mapper resource="org/mybatis/example/blogmapper.xml"/>
  </mappers>
</configuration>

当然，还有很多可以在 xml 文件中配置的选项，上面的示例仅罗列了最关键的部分。 注意 xml 头部的声明，它用来验证 xml 文档的正确性。environment 元素体中包含了事务管理和连接池的配置。mappers 元素则包含了一组映射器（mapper），这些映射器的 xml 映射文件包含了 sql 代码和映射定义信息。

不使用 xml 构建 sqlsessionfactory

如果你更愿意直接从 java 代码而不是 xml 文件中创建配置，或者想要创建你自己的配置建造器，mybatis 也提供了完整的配置类，提供了所有与 xml 文件等价的配置项。

datasource datasource = blogdatasourcefactory.getblogdatasource();
transactionfactory transactionfactory = new jdbctransactionfactory();
environment environment = new environment("development", transactionfactory, datasource);
configuration configuration = new configuration(environment);
configuration.addmapper(blogmapper.class);
sqlsessionfactory sqlsessionfactory = new sqlsessionfactorybuilder().build(configuration);

注意该例中，configuration 添加了一个映射器类（mapper class）。映射器类是 java 类，它们包含 sql 映射注解从而避免依赖 xml 文件。不过，由于 java 注解的一些限制以及某些 mybatis 映射的复杂性，要使用大多数高级映射（比如：嵌套联合映射），仍然需要使用 xml 配置。有鉴于此，如果存在一个同名 xml 配置文件，mybatis 会自动查找并加载它（在这个例子中，基于类路径和 blogmapper.class 的类名，会加载 blogmapper.xml）。具体细节稍后讨论。

sqlsessionfactorybuilder

string resource = "mybatis-config.xml";
inputstream inputstream = resources.getresourceasstream(resource);
sqlsessionfactory sqlsessionfactory = new sqlsessionfactorybuilder().build(inputstream);

build 方法：

// 1.我们最初调用的build
public sqlsessionfactory build(inputstream inputstream) {
    //调用了重载方法
    return build(inputstream, null, null);
}
​
// 2.调用的重载方法
public sqlsessionfactory build(inputstream inputstream, string environment, properties properties) {
    try {
        // 创建 xmlconfigbuilder, xmlconfigbuilder是专门解析mybatis的配置文件的类
        xmlconfigbuilder parser = new xmlconfigbuilder(inputstream, environment, properties);
        // 执行 xml 解析
        // 创建 defaultsqlsessionfactory 对象
        return build(parser.parse());
    } catch (exception e) {
        //···
    }
}

parser.parse()

public configuration parse() {
    if (parsed) {
      throw new builderexception("each xmlconfigbuilder can only be used once.");
    }
    // 标记已解析
    parsed = true;
    // parser.evalnode("/configuration")，
    // 通过xpath 读取配置文件的节点，将读取出配置文件的所以节点
    //<configuration>
    //   <environments default="development">
   //   </environments>
    //<configuration>
    parseconfiguration(parser.evalnode("/configuration"));
    return configuration;
  }

parseconfiguration(xnode root)

// 解析每个节点 这里每个方法进去都会有很多配置，这里就不一一解析，大家感兴趣可以看看，
//  settingselement(settings);mapperelement(root.evalnode("mappers"));
private void parseconfiguration(xnode root) {
    try {
        //issue #117 read properties first
        // 解析 <properties /> 标签
        propertieselement(root.evalnode("properties"));
        // 解析 <settings /> 标签
        properties settings = settingsasproperties(root.evalnode("settings"));
        // 加载自定义的 vfs 实现类
        loadcustomvfs(settings);
        // 解析 <typealiases /> 标签
        typealiaseselement(root.evalnode("typealiases"));
        // 解析 <plugins /> 标签
        pluginelement(root.evalnode("plugins"));
        // 解析 <objectfactory /> 标签
        objectfactoryelement(root.evalnode("objectfactory"));
        // 解析 <objectwrapperfactory /> 标签
        objectwrapperfactoryelement(root.evalnode("objectwrapperfactory"));
        // 解析 <reflectorfactory /> 标签
        reflectorfactoryelement(root.evalnode("reflectorfactory"));
        // 赋值 <settings /> 到 configuration 属性
        settingselement(settings);
        // read it after objectfactory and objectwrapperfactory issue #631
        // 解析 <environments /> 标签
        environmentselement(root.evalnode("environments"));
        // 解析 <databaseidprovider /> 标签
        databaseidproviderelement(root.evalnode("databaseidprovider"));
        // 解析 <typehandlers /> 标签
        typehandlerelement(root.evalnode("typehandlers"));
        // 解析 <mappers /> 标签
        mapperelement(root.evalnode("mappers"));
    } catch (exception e) {
        throw new builderexception("error parsing sql mapper configuration. cause: " + e, e);
    }
}

    // 获取mapper
  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 {
            // 读取resource 标签 
          string resource = child.getstringattribute("resource");
           // 读取url 标签  
          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);
            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);
            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.");
          }
        }
      }
    }
  }

private void settingselement(properties props) {
    configuration.setautomappingbehavior(automappingbehavior.valueof(props.getproperty("automappingbehavior", "partial")));
    configuration.setautomappingunknowncolumnbehavior(automappingunknowncolumnbehavior.valueof(props.getproperty("automappingunknowncolumnbehavior", "none")));
    configuration.setcacheenabled(booleanvalueof(props.getproperty("cacheenabled"), true));
    configuration.setproxyfactory((proxyfactory) createinstance(props.getproperty("proxyfactory")));
 .....
    configuration.setshrinkwhitespacesinsql(booleanvalueof(props.getproperty("shrinkwhitespacesinsql"), false));
  }

mapperparser.parse();

// 这里我们先看一下 mapperparser.parse();方法 懂得原理，都是类似的
  public void parse() {
    if (!configuration.isresourceloaded(resource)) {
      // 加载 mapper所有子节点
      configurationelement(parser.evalnode("/mapper"));
      configuration.addloadedresource(resource);
        // 绑定 namespace
      bindmapperfornamespace();
    }
 // 构建resultmap  
    parsependingresultmaps();
    parsependingcacherefs();
    parsependingstatements();
  }
   // 这里将解析整个 xml文件
    private void configurationelement(xnode context) {
    try {
      string namespace = context.getstringattribute("namespace");
      if (namespace == null || namespace.isempty()) {
        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"));
        // 解析标签，
      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
  public void parse() {
    string resource = type.tostring();
    if (!configuration.isresourceloaded(resource)) {
      loadxmlresource();
      configuration.addloadedresource(resource);
      assistant.setcurrentnamespace(type.getname());
      parsecache();
      parsecacheref();
      for (method method : type.getmethods()) {
        if (!canhavestatement(method)) {
          continue;
        }
        if (getannotationwrapper(method, false, select.class, selectprovider.class).ispresent()
            && method.getannotation(resultmap.class) == null) {
          parseresultmap(method);
        }
        try {
          parsestatement(method);
        } catch (incompleteelementexception e) {
          configuration.addincompletemethod(new methodresolver(this, method));
        }
      }
    }
    parsependingmethods();
  }

到此mybatis的初始化工作就完毕了，主要做了两件大事

• 解析核心配置文件到configuration对象，解析映射配置文件到mappedstatement对象，并保存在configuration的对应map中
• 创建了defaultsqlsessionfactory返回

通过上面的代码分析，总结了一下使用的重要的类，通过下图的装配，最终返回sqlsessionfactory，而sqlsessionfactory的最终实现是 defaultsqlsessionfactory，关于defaultsqlsessionfactory的介绍我们将放在下篇文章进行讲解，感兴趣的小伙伴可以持续关注！

拓展

看到这里很多人就会有个疑问，这是通过配置文件的方式在进行配置，但是springboot 没有这样的配置文件，是怎么做到的呢？其实springboot是通过自定配置完成；

@configuration
// 实例化 sqlsessionfactory
@conditionalonclass({sqlsessionfactory.class, sqlsessionfactorybean.class})
@conditionalonsinglecandidate(datasource.class)
// mybatisproperties 我们常用的配置
@enableconfigurationproperties({mybatisproperties.class})
@autoconfigureafter({datasourceautoconfiguration.class, mybatislanguagedriverautoconfiguration.class})
public class mybatisautoconfiguration implements initializingbean {}

到此这篇关于解析mybatis sqlsessionfactory初始化原理的文章就介绍到这了,更多相关mybatis sqlsessionfactory初始化 内容请搜索以前的文章或继续浏览下面的相关文章希望大家以后多多支持！