获取SqlSession对象
SqlSession session = sqlSessionFactory.openSession();
首先通过SqlSessionFactory的openSession方法获取SqlSession接口的实现类DefaultSqlSession对象。
public interface SqlSessionFactory { SqlSession openSession(); SqlSession openSession(boolean autoCommit); SqlSession openSession(Connection connection); SqlSession openSession(TransactionIsolationLevel level); SqlSession openSession(ExecutorType execType); SqlSession openSession(ExecutorType execType, boolean autoCommit); SqlSession openSession(ExecutorType execType, TransactionIsolationLevel level); SqlSession openSession(ExecutorType execType, Connection connection); Configuration getConfiguration();
}SqlSessionFactory接口提供一系列重载的openSession方法，其参数如下：
boolean autoCommit：是否开启JDBC事务的自动提交，默认为false。
Connection：提供连接。
TransactionIsolationLevel：定义事务隔离级别。
ExecutorType：定义执行器类型。
DefaultSqlSessionFactory对象调用覆写的openSession方法：
public SqlSession openSession() { return openSessionFromDataSource(configuration.getDefaultExecutorType(), null, false);
}得到一个定义了ExecutorType为configuration的默认执行器SIMPLE,事务隔离级别为null,JDBC事务自动提交为false的DefaultSqlSession对象。
获取MapperProxy代理对象
有了DefaultSqlSession对象，以查询一条数据为例，来看一下整个处理过程。
For example:
SqlSession session = sqlSessionFactory.openSession();try {
BlogMapper mapper = session.getMapper(BlogMapper.class);
Blog blog = mapper.selectBlog(101);
} finally {
session.close();
}MyBatis时序图:
根据MyBatis文档推荐的方法，调用Mapper接口中的方法实现对数据库的操作，上述例子中根据blog ID获取Blog对象。
通过DefaultSqlSession对象的getMapper方法获取的是一个MapperProxy代理对象，这也是Mapper接口不用实现类的原因。当调用BlogMapper中的方法时，由于BlogMapper是一个JDK动态代理对象，它会运行invoke方法，代码如下：
@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对象
final MapperMethod mapperMethod = cachedMapperMethod(method); //执行execute方法
return mapperMethod.execute(sqlSession, args);
}
private MapperMethod cachedMapperMethod(Method method) {
MapperMethod mapperMethod = methodCache.get(method); if (mapperMethod == null) {
mapperMethod = new MapperMethod(mapperInterface, method, sqlSession.getConfiguration());
methodCache.put(method, mapperMethod);
} return mapperMethod;
}
...invoke方法判断代理的对象是否是一个类，由于代理对象是一个接口，所以通过cachedMapperMethod生成一个MappedMethod对象，然后执行execute方法，execute方法代码如下：
public Object execute(SqlSession sqlSession, Object[] args) { Object result; switch (command.getType()) { case INSERT: { Object param = method.convertArgsToSqlCommandParam(args);
result = rowCountResult(sqlSession.insert(command.getName(), param)); break;
} case UPDATE: { Object param = method.convertArgsToSqlCommandParam(args);
result = rowCountResult(sqlSession.update(command.getName(), param)); break;
} case DELETE: { Object param = method.convertArgsToSqlCommandParam(args);
result = rowCountResult(sqlSession.delete(command.getName(), param)); break;
} 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; case FLUSH:
result = sqlSession.flushStatements(); break; default: 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;
}因为这里是根据ID查询一个对象，所以最终调用了DefaultSqlSession的selectOne方法，selectOne方法又调用自身selectList方法，最终将查询操作委托给Executor：
@Override
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.<T>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;
}
}
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 { //根据id获取MappedStatement对象
MappedStatement ms = configuration.getMappedStatement(statement); //wrapCollection方法处理集合参数
//委托Exector执行SQL
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（执行器），才是真正对JDBC操作的实例，它的结构如下：
CachingExecutor: SqlSession默认会调用CachingExecutor执行器的query方法，先从二级缓存获取数据，当无法从二级缓存获取数据时，则委托给BaseExcutor进行操作，CachingExecutor执行过程代码如下：
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); //如果二级缓存没有数据则委托给BaseExcutor进行操作
if (list == null) { list = delegate.<E> query(ms, parameterObject, rowBounds, resultHandler, key, boundSql);
tcm.putObject(cache, key, list); // issue #578 and #116
} return list;
}
} //如果没有二级缓存则委托给BaseExcutor进行操作
return delegate.<E> query(ms, parameterObject, rowBounds, resultHandler, key, boundSql);
}BaseExecutor是一个抽象类，查询操作时BaseExecutor首先从一级缓存获取数据，如果没有则由其子类来进行数据库操作，其query方法如下：
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;
}最后，我们例子中的查询操作交给了SimpleExecutor这个子类，可以看到SimpleExecutor直接调用了JDBC的代码，最终得到了我们查询的结果，其方法代码如下：
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(wrapper, 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, transaction.getTimeout());
handler.parameterize(stmt); return stmt;
}
随时随地看视频
