接上一篇文章SqlSessionFactory的创建
https://www.jianshu.com/p/eb3d06a7c77d
SqlSession的创建过程
既然已经得到了SqlSessionFactory，那么SqlSession将由SqlSessionFactory进行创建。
SqlSession sqlSession=sqlSessionFactory.openSession();
这样，我们就来看看这个SqlSessionFactory的 openSession方法是如何创建SqlSession对象的。根据上面的分析，这里的SqlSessionFactory类型对象其实是一个DefaultSqlSessionFactory对象，因此，需要到DefaultSqlSessionFactory类中去看openSession方法。
// DefaultSqlSessionFactory 类
@Override
public SqlSession openSession() {
return openSessionFromDataSource(
configuration.getDefaultExecutorType(), null, false);
}
/**
* 这里对参数类型进行说明
* ExecutorType 指定Executor的类型，分为三种：SIMPLE, REUSE, BATCH
* TransactionIsolationLevel 指定事务隔离级别
* 使用null,则表示使用数据库默认的事务隔离界别
* autoCommit 是否自动提交
*/
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);
// 创建Executor，即执行器
// 它是真正用来Java和数据库交互操作的类，后面会展开说。
final Executor executor = configuration.newExecutor(tx, execType);
// 创建DefaultSqlSession对象返回，因为SqlSession是一个接口
// 可以类比DefaultSqlSessionFactory
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();
}
}
这样我们就得到了DefaultSqlSession(SqlSession)。可以看到基本覆盖数据库的各种操作，增删查改，以及简单的事务的操作。
image-20181028144109252
接下来就要看看它的执行过程。
SqlSession的执行过程
获取到了SqlSession之后，则需要执行下面的语句
CountryMapper countryMapper=
sqlSession.getMapper(CountryMapper.class);
因此我们要看看getMapper这个方法干了什么。上面的分析知道，这里的sqlSession其实是DefaultSqlSession对象，因此需要在DefaultSqlSession中去查看这个方法。
// DefaultSqlSession 类
@Override
public <T> T getMapper(Class<T> type) {
return configuration.<T>getMapper(type, this);
}
这里的configuration是Configuration类的实例，在SqlSessionFactory中创建并完成所有配置的解析后，初始化DefaultSqlSession时，SqlSessionFactory将配置作为属性传给DefaultSqlSession，因此前面解析的所有配置，都能在这里查到。
因此我们继续往下看，这里就要定位到Configuration类的getMapper方法了。
public <T> T getMapper(Class<T> type, SqlSession sqlSession) {
// mapperRegistry 是一个mapper配置的容器，前面有提到
// 配置路径下所有扫描到的mapper在初始化完成Configuration以后，都会加载进来
// 每一个mapper都被存储在了MapperRegistry的knownMappers中了
// 在初始化配置的时候执行addMapper，在获取Mapper的时候执行getMapper
return mapperRegistry.getMapper(type, sqlSession);
}
因此，我们就要来看看MapperRegistry的getMapper方法
// MapperRegistry的getMapper方法
@SuppressWarnings("unchecked")
public <T> T getMapper(Class<T> type, SqlSession sqlSession) {
// 从knownMappers集合中获取mapper,创建MapperProxyFactory
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);
} catch (Exception e) {
throw new BindingException("Error getting mapper instance. Cause: " + e, e);
}
}
看到了MapperProxyFactory很明显这是一个工厂类，所以肯定会有MapperProxy这么一个类，而看到Proxy，这里肯定用到了代理，也肯定就是动态代理了。
我们来看看获取代理对象的方法 newInstance
// MapperProxyFactory 类
...
@SuppressWarnings("unchecked")
protected T newInstance(MapperProxy<T> mapperProxy) {
return (T) Proxy.newProxyInstance(mapperInterface.getClassLoader(), new Class[] { mapperInterface }, mapperProxy);
}
public T newInstance(SqlSession sqlSession) {
// MapperProxy实现了InvocationHandler，扩展了invoke方法，维护代理逻辑。
final MapperProxy<T> mapperProxy = new MapperProxy<T>(sqlSession, mapperInterface, methodCache);
return newInstance(mapperProxy);
}
...
这里我们可以看到动态代理对接口的绑定，它的作用就是生成动态代理对象。这里最终返回了CountryMapper接口的代理对象。
而代理对象则被放到了MapperProxy中。通过idea打断点，来查看CountryMapper的详细信息，我们也可以看到这是一个MapperProxy对象。
image-20181028102601358
因此，在执行countryMapper.selectAll()方法时，便会进入到MapperProxy的invoke方法中来。
我们来看一下MapperProxy的部分代码。
// MapperProxy类
...
@Override
public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
try {
// 判断是否是一个类
if (Object.class.equals(method.getDeclaringClass())) {
return method.invoke(this, args);
} else if (isDefaultMethod(method)) {
return invokeDefaultMethod(proxy, method, args);
}
} catch (Throwable t) {
throw ExceptionUtil.unwrapThrowable(t);
}
// 显然，我们这里是一个接口，则执行下面的流程
// 生成MapperMethod对象，通过cachedMapperMethod初始化
final MapperMethod mapperMethod = cachedMapperMethod(method);
// 执行execute方法， 把sqlSession和当前参数传递进去
return mapperMethod.execute(sqlSession, args);
}
...
接着来看看execute方法
// MapperMethod 类的方法
// MapperMethod采用命令模式运行，根据上下文跳转
public Object execute(SqlSession sqlSession, Object[] args) {
Object result;
switch (command.getType()) {
...
case SELECT:
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 if (method.returnsCursor()) {
result = executeForCursor(sqlSession, args);
} else {
Object param = method.convertArgsToSqlCommandParam(args);
result = sqlSession.selectOne(command.getName(), param);
}
break;
...
}
}
private <E> Object executeForMany(SqlSession sqlSession, Object[] args) {
List<E> result;
// 将Java参数转换为Sql命令行参数
Object param = method.convertArgsToSqlCommandParam(args);
// 是否需要分页
if (method.hasRowBounds()) {
RowBounds rowBounds = method.extractRowBounds(args);
// 通过SqlSession对象执行查询，带分页
// command.getName() 获取Mapper接口当前执行方法selectAll的全路径名
result = sqlSession.<E>selectList(command.getName(), param, rowBounds);
} else {
// 通过SqlSession对象执行查询，不带分页
result = sqlSession.<E>selectList(command.getName(), param);
}
// issue #510 Collections & arrays support
if (!method.getReturnType().isAssignableFrom(result.getClass())) {
if (method.getReturnType().isArray()) {
return convertToArray(result);
} else {
return convertToDeclaredCollection(sqlSession.getConfiguration(), result);
}
}
return result;
}
至此已经基本可以明白了，Mybatis为什么只用Mapper接口就可以运行SQL，因为映射器的XML文件的命名空间对应的便是这个接口的全路径，它能根据全路径和方法名绑定起来，通过动态代理技术，让这个接口跑起来。然后采用命令模式，根据上下文跳转，最终还是使用SqlSession接口的方法使得它能够进行查询。
接着我们就来看看selectList的源码。
result = sqlSession.<E>selectList(command.getName(), param);
注意这里的sqlSession，其实是DefaultSqlSession的对象，因此要去看DefaultSqlSession的selectList方法。
@Override
public <E> List<E> selectList(String statement, Object parameter) {
// 分页参数选择默认，表示不分页
return this.selectList(statement, parameter, RowBounds.DEFAULT);
}
@Override
public <E> List<E> selectList(String statement, Object parameter, RowBounds rowBounds) {
try {
// 从Configuration配置中获取MappedStatement对象
MappedStatement ms = configuration.getMappedStatement(statement);
// 使用executor进行查询
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();
}
}
接着就进入了Executor查询之后，将结果返回。那么Executor是如何进行查询的呢？
下一篇文章再见！
