我们从最简单的一段代码开始，分析清楚mybatis的大致工作流程。然后再从代码细节上分析mybatis的一些特性。
基础代码示例
public class test {
public static void main(String[] args) throws IOException{
String resource = "example/mybatis-config.xml";
// 加载配置文件 并构建SqlSessionFactory对象
InputStream inputStream = Resources.getResourceAsStream(resource);
SqlSessionFactory factory = new SqlSessionFactoryBuilder().build(inputStream);
// 从SqlSessionFactory对象中获取 SqlSession对象
SqlSession sqlSession = factory.openSession();
// 执行操作
User user=new User();
user.setId(1);
Object u= (User)sqlSession.selectOne("getUser", user);
System.out.println(u.toString());
// 关闭SqlSession
sqlSession.close();
}
}
其中User类其实就是一个只有id，username，password的pojo。我就不粘贴代码了。
mybatis当然少不了对应的sql代码了。
<?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="example.Dao.UserMapper">
<select id="getUser" parameterType="int" resultType="example.Pojo.User">
select * from user where id= #{id}
</select>
</mapper>
还有任何框架都少不了的配置。
<?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="com.mysql.jdbc.Driver"/>
<property name="url" value="jdbc:mysql://localhost:3306/mybatis_study?useUnicode=true"/>
<property name="username" value="root"/>
<property name="password" value="root"/>
</dataSource>
</environment>
</environments>
<mappers>
<mapper resource="example/UserMapper.xml"/>
</mappers>
</configuration>
代码都粘贴出来了，下面我们就以这段代码为例分析，mybatis的执行流程。
执行流程分析
SqlSessionFactory的创建过程
第一行有效的代码是这个InputStream inputStream = Resources.getResourceAsStream(resource);这个地方，Resources是一个工具类，它的作用就是方便我们加载各种资源文件的。至于它的内部是如何实现的，这都不重要。总之，这行代码所做的工作就是简简单单的加载我们的配置文件。
我们的重头戏其实是这行代码 SqlSessionFactory factory = new SqlSessionFactoryBuilder().build(inputStream);
我们把这行代码分成两部分分析，第一部分就是new SqlSessionFactoryBuilder(),这个不需要怎么解释，这一部分的作用就是创建一个SqlSessionFactoryBuilder对象，第二部分就是调用了该对象的SqlSessionFactory build(Reader reader)方法，这个方法非常的重要，这个方法实际上最终调用的是另一个重载方法,它的具体实现如下：
public SqlSessionFactory build(Reader reader, String environment, Properties properties) {
try {
XMLConfigBuilder parser = new XMLConfigBuilder(reader, environment, properties);
return build(parser.parse());
} catch (Exception e) {
throw ExceptionFactory.wrapException("Error building SqlSession.", e);
} finally {
ErrorContext.instance().reset();
try {
reader.close();
} catch (IOException e) {
// Intentionally ignore. Prefer previous error.
}
}
}
这段代码，如果我们不考虑其它东西的话，这段代码其实就做了三件事情，利用我们传入的配置文件的reader（后面两个参数调用的时候传的是null），创建了一个XMLConfigBuilder对象，然后调用该对象的parse()方法，拿到了一个Configuration对象，利用这个Configuration对象,使用build(Configuration cofig)方法，创建了SqlSessionFactory对象,然后将SqlSessionFactory对象返回。
下面我们就分别解释这三个步骤到底干了什么。
- 第一步：创建
XMLConfigBuilder对象。
虽然看起来简单的new了一下该对象就创建好了.实际上还是比较复杂的.各种重载的构造器层层调用，最终来到了这个构造器。
private XMLConfigBuilder(XPathParser parser, String environment, Properties props) {
//创建一个空的Configuration对象，实例化了XMLConfigBuilder对象
super(new Configuration());
ErrorContext.instance().resource("SQL Mapper Configuration");
//对属性各种赋值
//我们配置时分离出的Properties文件中的信息，就是在这里进入到mybatis的
this.configuration.setVariables(props);
this.parsed = false;
this.environment = environment;
//parser就是用来解析XML文件的，在之前的构造器中，已经将配置文件的inputStream设置到该对象中去了
this.parser = parser;
}
既然这个构造器所做的事情基本都是给属性赋值，那么我们就得好好分析一波，XMLConfigBuilder到底有哪些属性，它们的作用是什么。
//下面三个是继承自父类BaseBuilder中的属性
/**
* 存储基础配置信息的一个对象
*/
protected final Configuration configuration;
/**
* 故名思意，就是存储各种类型的别名的一个对象
*/
protected final TypeAliasRegistry typeAliasRegistry;
/**
* 存储各种类型的类型处理器的对象
*/
protected final TypeHandlerRegistry typeHandlerRegistry;
/**
* 标记该配置文件是否已经解析过
*/
private boolean parsed;
/**
* 解析器模块，配置文件就由它进行解析
*/
private final XPathParser parser;
private String environment;
/**
* 默认反射工厂实现
*/
private final ReflectorFactory localReflectorFactory = new DefaultReflectorFactory();
- 第二步：使用
XMLConfigBuilder对象的，Configuration parse()方法，获取到Configuration对象。
该方法的实现如下：
public Configuration parse() {
if (parsed) {
throw new BuilderException("Each XMLConfigBuilder can only be used once.");
}
parsed = true;//将该配置文件标记为已解析
//对配置文件中的configuration节点下的所有属性进行解析，并将解析到的信息封装到
//XMLConfigBuilder对象的configuration属性中。
parseConfiguration(parser.evalNode("/configuration"));
//将填充好各种值的configuration返回
return configuration;
}
看完这段代码，我们可以知道，第二部其实就是去解析配置文件中的configuration节点下的信息，去初始化XMLConfigBuilder对象中的configuration属性，然后将初始化完毕的configuration返回即可。
- 第三步：利用刚才得到的充满各种配置信息的
configuration作为参数，调用SqlSessionFactory build(Configuration config)方法，来构建SqlSessionFactory对象
它首先是调用了这个方法：
public SqlSessionFactory build(Configuration config) {
return new DefaultSqlSessionFactory(config);
}
这个方法实例化了一个SqlSessionFactory接口的实现类DefaultSqlSessionFactory.
具体的实例化过程如下：
public DefaultSqlSessionFactory(Configuration configuration) {
this.configuration = configuration;
}
非常的简单，只不过是将configuration传递到了DefaultSqlSessionFactory对象。
到此我们已经成功的创建了SqlSessionFactory对象。
不过到这里，我们好像忽略了一个非常重要的环节，我们的UserMapperx.xml文件在解析配置文件的configuration节点的时候，是如何处理的呢？
创建SqlSessionFactory时是如何处理Mapper.xml的呢？
想要知道我们的Mapper.xml文件是如何处理的，首先要找到是在哪个地方处理的。
在我们之前分析SqlSessionFactory的创建过程时，我们就分析到XMLConfigBuilder的Configuration parse()方法，这个方法中就进行了配置文件的解析。那么处理Mapper.xml文件也应该是从这个地方开始的。
在Configuration parse()中调用了一个重要的方法void parseConfiguration(XNode root),它的具体实现如下；
private void parseConfiguration(XNode root) {
try {
//issue #117 read properties first
propertiesElement(root.evalNode("properties"));
Properties settings = settingsAsProperties(root.evalNode("settings"));
loadCustomVfs(settings);
loadCustomLogImpl(settings);
typeAliasesElement(root.evalNode("typeAliases"));
pluginElement(root.evalNode("plugins"));
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"));
typeHandlerElement(root.evalNode("typeHandlers"));
//在这个地方处理的mappers
mapperElement(root.evalNode("mappers"));
} catch (Exception e) {
throw new BuilderException("Error parsing SQL Mapper Configuration. Cause: " + e, e);
}
}
我们查看处理mappers的具体的地方：它的实现如下：
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);
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.");
}
}
}
}
}
这个方法看起来非常的复杂，但我们至少可以得到一点信息：
mapper配置有三种写法：
<mappers>
<mapper url=""/>
<mapper class=""/>
<mapper resource=""/>
</mappers>
这个方法看起来非常的复杂，但是它也不过是做三件事情，拿到mapper文件，创建XMLMapperBuilder对象，解析mapper文件。
-
第一步：根据配置的信息，获取每个节点所指定的mapper文件
以mapper的一种配置为例：InputStream inputStream = Resources.getResourceAsStream(resource);
它还是利用了用来加载各种资源文件的强大的Resources工具类。 -
第二步：创建
XMLMapperBuilder对象。XMLMapperBuilder mapperParser = new XMLMapperBuilder(inputStream, configuration, resource, configuration.getSqlFragments());
创建XMLMapperBuilder的过程，基本上就是实例化，然后将参数中的各种值注入。 -
第三步：解析对应的mapper节点
mapperParser.parse();
这个方法的具体实现如下；
public void parse() {
if (!configuration.isResourceLoaded(resource)) { //如果没有解析过
//解析每个mapper节点中的信息
configurationElement(parser.evalNode("/mapper"));
//将当前文件加入已解析文件集合
configuration.addLoadedResource(resource);
//将mapper和命名空间进行绑定
//本质就是将命名空间所对应的类和mapper文件都加入configuration中
bindMapperForNamespace();
}
parsePendingResultMaps();
parsePendingCacheRefs();
parsePendingStatements();
}
这个部分涉及到的细节非常的多，如果你熟悉mybatis中mapper的写法你就会知道，mapper中的标签非常的多，写法也比较复杂，所有这部分的源码其实也非常的复杂，因此这部分我准备之后专门分析一波。
SqlSession的创建过程
经过前面的努力，我们已经拿到了SqlSessionFactory对象。现在就需要创建SqlSession对象了。这个过程，由这行代码来完成。SqlSession sqlSession = factory.openSession();
它的具体实现如下:
public SqlSession openSession() {
return openSessionFromDataSource(configuration.getDefaultExecutorType(), null, false);
}
这个方法中涉及到一个非常重要的方法：
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);
//创建执行器
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 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(executor);
}
executor = (Executor) interceptorChain.pluginAll(executor);
return executor;
}
观察这个方法，我们首先能够得到的信息就是执行器有三种类型。它们分别是：
ExecutorType.SIMPLE：这个类型不做任何其它的事情，它为每个语句创建一个PreparedStatement
ExecutorType.REUSE：这种类型会重复使用PreparedStatements。
ExecutorType.BATCH：这个类型这个类型批量更新，且必要地区别开其中的select 语句，确保动作易于理解。
我们就以ExecutorType.SIMPLE类型为例，来看一些，创建执行器的时候，到底做了什么事情。executor = new SimpleExecutor(this, transaction);
这行代码实质上是调用了SimpleExecutor的父类BaseExecutor的构造方法。
其具体实现如下：
protected BaseExecutor(Configuration configuration, Transaction transaction) {
this.transaction = transaction;
this.deferredLoads = new ConcurrentLinkedQueue<>();
this.localCache = new PerpetualCache("LocalCache");
this.localOutputParameterCache = new PerpetualCache("LocalOutputParameterCache");
this.closed = false;
this.configuration = configuration;
this.wrapper = this;
}
在构造函数中完成了一些重要属性的注入。其中比较关键的就是transaction属性，这个对象包括了获取数据库连接，提交，回滚等一系列直接操作数据库的方法。
这个接口如下：
public interface Transaction {
/**
* Retrieve inner database connection.
* @return DataBase connection
* @throws SQLException
*/
Connection getConnection() throws SQLException;
/**
* Commit inner database connection.
* @throws SQLException
*/
void commit() throws SQLException;
/**
* Rollback inner database connection.
* @throws SQLException
*/
void rollback() throws SQLException;
/**
* Close inner database connection.
* @throws SQLException
*/
void close() throws SQLException;
/**
* Get transaction timeout if set.
* @throws SQLException
*/
Integer getTimeout() throws SQLException;
}
我们回到刚才分析的SqlSession openSessionFromDataSource(ExecutorType execType, TransactionIsolationLevel level, boolean autoCommit).
拿到构造器，就可创建SqlSession.
具体实现是这行代码：return new DefaultSqlSession(configuration, executor, autoCommit);
调用的构造器的具体实现如下：
public DefaultSqlSession(Configuration configuration, Executor executor, boolean autoCommit) {
this.configuration = configuration;
this.executor = executor;
this.dirty = false;
this.autoCommit = autoCommit;
}
我们可以看出，将配置信息与执行器封装起来，就得到了SqlSession
SqlSession是如何操作数据库的
我们以查询为例：
Object u= (User)sqlSession.selectOne("getUser", user);
具体的实现如下：
public <T> T selectOne(String statement, Object parameter) {
// Popular vote was to return null on 0 results and throw exception on too many.
List<T> list = this.selectList(statement, parameter);
if (list.size() == 1) {
return list.get(0);
} else if (list.size() > 1) {
throw new TooManyResultsException("Expected one result (or null) to be returned by selectOne(), but found: " + list.size());
} else {
return null;
}
}
从这段代码，可以看出这段代码起主要作用的就是 List<T> list = this.selectList(statement, parameter);这段代码，其余代码都是用于处理返回值的。
那么下面我们就分析一波selectList(statement, parameter)的具体实现：
public <E> List<E> selectList(String statement, Object parameter) {
return this.selectList(statement, parameter, RowBounds.DEFAULT);
}
//最终调用了这个重载实现
public <E> List<E> selectList(String statement, Object parameter, RowBounds rowBounds) {
try {
/*MappedStatement就是对sql语句和相关配置信息的封装，
基本上执行一个sql所需的信息，MappedStatement中都有*/
MappedStatement ms = configuration.getMappedStatement(statement);
return executor.query(ms, wrapCollection(parameter), rowBounds, Executor.NO_RESULT_HANDLER);
} catch (Exception e) {
throw ExceptionFactory.wrapException("Error querying database. Cause: " + e, e);
} finally {
ErrorContext.instance().reset();
}
}
这段代码，首先拿到封装了执行该sql的所有信息的MappedStatement对象，然后就调用执行器执行sql。
不过，在调用执行器之前，它还对我们的传入的参数进行处理，处理参数的代码是wrapCollection(parameter)
处理参数的逻辑也非常的简单，基本上就是对复杂参数类型的一种标记。对普通的对象不进行处理。
private Object wrapCollection(final Object object) {
if (object instanceof Collection) {
StrictMap<Object> map = new StrictMap<>();
map.put("collection", object);
if (object instanceof List) {
map.put("list", object);
}
return map;
} else if (object != null && object.getClass().isArray()) {
StrictMap<Object> map = new StrictMap<>();
map.put("array", object);
return map;
}
return object;
}
所有的准备工作，都准备好了之后，就是执行器去执行查询了。
public <E> List<E> query(MappedStatement ms, Object parameter, RowBounds rowBounds, ResultHandler resultHandler) throws SQLException {
//可以理解为对sql信息的进一步处理，更加接近jdbc
BoundSql boundSql = ms.getBoundSql(parameter);
//计算缓存的key
CacheKey key = createCacheKey(ms, parameter, rowBounds, boundSql);
return query(ms, parameter, rowBounds, resultHandler, key, boundSql);
}
//接下来调用了这个方法
public <E> List<E> query(MappedStatement ms, Object parameterObject, RowBounds rowBounds, ResultHandler resultHandler, CacheKey key, BoundSql boundSql)
throws SQLException {
//尝试从缓存中读取
Cache cache = ms.getCache();
if (cache != null) {
flushCacheIfRequired(ms);
if (ms.isUseCache() && resultHandler == null) {
ensureNoOutParams(ms, boundSql);
@SuppressWarnings("unchecked")
List<E> list = (List<E>) tcm.getObject(cache, key);
if (list == null) {
//缓存中，查询结果为空，就继续查询
list = delegate.query(ms, parameterObject, rowBounds, resultHandler, key, boundSql);
tcm.putObject(cache, key, list); // issue #578 and #116
}
return list;
}
}
return delegate.query(ms, parameterObject, rowBounds, resultHandler, key, boundSql);
}
//如果没有缓存，或缓存无效的话，会调用这个方法，从数据库中查询
public <E> List<E> query(MappedStatement ms, Object parameter, RowBounds rowBounds, ResultHandler resultHandler, CacheKey key, BoundSql boundSql) throws SQLException {
ErrorContext.instance().resource(ms.getResource()).activity("executing a query").object(ms.getId());
if (closed) {
throw new ExecutorException("Executor was closed.");
}
if (queryStack == 0 && ms.isFlushCacheRequired()) {
clearLocalCache();
}
List<E> list;
try {
queryStack++;
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);
}
} finally {
queryStack--;
}
if (queryStack == 0) {
for (DeferredLoad deferredLoad : deferredLoads) {
deferredLoad.load();
}
// issue #601
deferredLoads.clear();
if (configuration.getLocalCacheScope() == LocalCacheScope.STATEMENT) {
// issue #482
clearLocalCache();
}
}
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 {
localCache.removeObject(key);
}
localCache.putObject(key, list);
if (ms.getStatementType() == StatementType.CALLABLE) {
localOutputParameterCache.putObject(key, parameter);
}
return list;
}
public <E> List<E> doQuery(MappedStatement ms, Object parameter, RowBounds rowBounds, ResultHandler resultHandler, BoundSql boundSql) throws SQLException {
Statement stmt = null;
try {
//获取configuration对象
Configuration configuration = ms.getConfiguration();
StatementHandler handler = configuration.newStatementHandler(wrapper, ms, parameter, rowBounds, resultHandler, boundSql);
stmt = prepareStatement(handler, ms.getStatementLog());
return handler.query(stmt, resultHandler);
} finally {
closeStatement(stmt);
}
}
public <E> List<E> query(Statement statement, ResultHandler resultHandler) throws SQLException {
PreparedStatement ps = (PreparedStatement) statement;
ps.execute();
return resultSetHandler.handleResultSets(ps);
}
public <E> List<E> query(Statement statement, ResultHandler resultHandler) throws SQLException {
//这里的sql就是可以执行的sql了
String sql = boundSql.getSql();
statement.execute(sql);
//对查询的结果集进行处理
return resultSetHandler.handleResultSets(statement);
}
这部分也非常的复杂，以后专门研究一波，在写个博客吧。