MyBatis的Sql执行过程源码解读

1.先获得SqlSessionFactory

通过SqlSessionFactoryBuilder去读取mybatis的配置文件，然后build一个DefaultSqlSessionFactory。

/**
* 一系列的构造方法最终都会调用本方法（配置文件为Reader时会调用本方法，还有一个InputStream方法与此对应）
* @param reader
* @param environment
* @param properties
* @return
*/
public SqlSessionFactory build(Reader reader, String environment, Properties properties) {
try {
//通过XMLConfigBuilder解析配置文件，解析的配置相关信息都会封装为一个Configuration对象
XMLConfigBuilder parser = new XMLConfigBuilder(reader, environment, properties);
//这儿创建DefaultSessionFactory对象
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.
}
}
}

public SqlSessionFactory build(Configuration config) {
return new DefaultSqlSessionFactory(config);
}

2.通过SqlSessionFactory去获取SqlSession对象

public SqlSession openSession()
{
return openSessionFromDataSource(configuration.getDefaultExecutorType(), null, false);
}

private SqlSession openSessionFromDataSource(ExecutorType execType, TransactionIsolationLevel level, boolean autoCommit)
{
Transaction tx = null;
try
{
//通过Configuration对象去获取相关的配置信息，Environment对象包含了数据源和事务的配置
final Environment environment = configuration.getEnvironment();
final TransactionFactory transactionFactory = getTransactionFactoryFromEnvironment(environment);
tx = transactionFactory.newTransaction(environment.getDataSource(), level, autoCommit);
//实际上就是Executor来执行sql语句，executor是对于Statement的封装
final Executor executor = configuration.newExecutor(tx, execType, autoCommit);
//创建DefaultSqlSession对象
return new DefaultSqlSession(configuration, executor);
}
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();
}
}

这样就获得了SqlSession对象

3.通过SqlSession获得Mapper

public <T> T getMapper(Class<T> type)
{
return configuration.<T>getMapper(type, this);
}

这里通过Configuration的getMapper方法来获得

public <T> T getMapper(Class<T> type, SqlSession sqlSession)
{
return mapperRegistry.getMapper(type, sqlSession);
}

protected MapperRegistry mapperRegistry = new MapperRegistry(this);

继续看MapperRegistry的getMapper方法

public <T> T getMapper(Class<T> type, SqlSession sqlSession)
{
final MapperProxyFactory<T> mapperProxyFactory = (MapperProxyFactory<T>) knownMappers.get(type);
if (mapperProxyFactory == null)
throw new BindingException("Type " + type + " is not known to the MapperRegistry.");
try
{
return mapperProxyFactory.newInstance(sqlSession);   //此处使用反射，生成一个MapperProxyFactory对象
}
catch (Exception e)
{
throw new BindingException("Error getting mapper instance. Cause: " + e, e);
}
}

private final Map<Class<?>, MapperProxyFactory<?>> knownMappers = new HashMap<Class<?>, MapperProxyFactory<?>>();<span style="font-family: Arial, Helvetica, sans-serif; font-size: 12px; background-color: rgb(255, 255, 255);">            </span>

knownMappers在读取配置文件的时候，已经将mapper信息放入其中了。

继续看MapperProxyFactory的newInstance方法：

protected T newInstance(MapperProxy<T> mapperProxy)
{
return (T) Proxy.newProxyInstance(mapperInterface.getClassLoader(), new Class[] { mapperInterface }, mapperProxy);
}

public T newInstance(SqlSession sqlSession)
{
final MapperProxy<T> mapperProxy = new MapperProxy<T>(sqlSession, mapperInterface, methodCache);
return newInstance(mapperProxy);
}

MapperProxy就是一个代理类，使用的是jdk的动态代理

public Object invoke(Object proxy, Method method, Object[] args) throws Throwable
{
if (Object.class.equals(method.getDeclaringClass()))
{
return method.invoke(this, args);
}
final MapperMethod mapperMethod = cachedMapperMethod(method);
return mapperMethod.execute(sqlSession, args);
}

这里的invoke方法可以明确看出使用的是jdk的动态代理

这样的话就会返回一个mapper的代理类，每次执行的时候，回交给MapperMethod类的execute方法

public Object execute(SqlSession sqlSession, Object[] args)
{
Object result;
if (SqlCommandType.INSERT == command.getType())
{
Object param = method.convertArgsToSqlCommandParam(args);
result = rowCountResult(sqlSession.insert(command.getName(), param));
}
else if (SqlCommandType.UPDATE == command.getType())
{
Object param = method.convertArgsToSqlCommandParam(args);
result = rowCountResult(sqlSession.update(command.getName(), param));
}
else if (SqlCommandType.DELETE == command.getType())
{
Object param = method.convertArgsToSqlCommandParam(args);
result = rowCountResult(sqlSession.delete(command.getName(), param));
}
else if (SqlCommandType.SELECT == command.getType())
{
if (method.returnsVoid() && method.hasResultHandler())
{
executeWithResultHandler(sqlSession, args);
result = null;
}
else if (method.returnsMany())
{
result = executeForMany(sqlSession, args);
}
else if (method.returnsMap())
{
result = executeForMap(sqlSession, args);
}
else
{
Object param = method.convertArgsToSqlCommandParam(args);
result = sqlSession.selectOne(command.getName(), param);
}
}
else
{
throw new BindingException("Unknown execution method for: " + command.getName());
}
if (result == null && method.getReturnType().isPrimitive() && !method.returnsVoid())
{
throw new BindingException("Mapper method '" + command.getName()
+ " attempted to return null from a method with a primitive return type (" + method.getReturnType() + ").");
}
return result;
}

可以看出，也就是判断一下CURD的类型，然后实际调用的还是SqlSession 的方法，在这里以selectList为例

public <E> List<E> selectList(String statement, Object parameter, RowBounds rowBounds) {
try {
MappedStatement ms = configuration.getMappedStatement(statement);
List<E> result = executor.query(ms, wrapCollection(parameter), rowBounds, Executor.NO_RESULT_HANDLER);
return result;
} catch (Exception e) {
throw ExceptionFactory.wrapException("Error querying database.  Cause: " + e, e);
} finally {
ErrorContext.instance().reset();
}
}

继续查找Executor的query方法，在这里使用BaseExecutor的

public <E> List<E> query(MappedStatement ms, Object parameter, RowBounds rowBounds, ResultHandler resultHandler) throws SQLException
{
BoundSql boundSql = ms.getBoundSql(parameter);
CacheKey key = createCacheKey(ms, parameter, rowBounds, boundSql);
return query(ms, parameter, rowBounds, resultHandler, key, boundSql);
}

继续查找到SimpleExecutor的doQuery，可以看到

public <E> List<E> doQuery(MappedStatement ms, Object parameter, RowBounds rowBounds, ResultHandler resultHandler, BoundSql boundSql) throws SQLException
{
Statement stmt = null;
try
{
Configuration configuration = ms.getConfiguration();
StatementHandler handler = configuration.newStatementHandler(this, ms, parameter, rowBounds, resultHandler, boundSql);
stmt = prepareStatement(handler, ms.getStatementLog());
return handler.<E>query(stmt, resultHandler);
}
finally
{
closeStatement(stmt);
}
}

private Statement prepareStatement(StatementHandler handler, Log statementLog) throws SQLException
{
Statement stmt;
Connection connection = getConnection(statementLog);
stmt = handler.prepare(connection);
handler.parameterize(stmt);
return stmt;
}

可以看出实际上也就好似调用的jdbc