目录
- sqlsessionfactory
- 不使用 xml 构建 sqlsessionfactory
- sqlsessionfactorybuilder
引言
现在内卷越来越严重，关于常用的orm框架mybatis，www.887551.com准备了三篇文章，分别将介绍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初始化 内容请搜索www.887551.com以前的文章或继续浏览下面的相关文章希望大家以后多多支持www.887551.com！
黄山市民网：https://www.huangshanshimin.com/
