本文将按mybatis中主要数据库查询操作的流程对其源码进行简单分析。目录如下：
1、mybatis的主要工作流程
2、mybatis进行数据查询的小实例
3、源码分析
3.1、获取SqlSessionFactory（配置文件解析）
3.2、Mapper对象获取
3.3、Mapper方法执行
4、总结
1、mybatis的主要工作流程
mybatis的工作流程：
加载配置-->SQL解析-->SQL执行-->结果映射
加载配置：配置来源于两个地方，一处是配置文件，一处是Java代码的注解，将SQL的配置信息加载成为一个个MappedStatement对象（包括了传入参数映射配置、执行的SQL语句、结果映射配置），存储在内存中。
SQL解析：当API接口层接收到调用请求时，会接收到传入SQL的ID和传入对象（可以是Map、JavaBean或者基本数据类型），Mybatis会根据SQL的ID找到对应的MappedStatement，然后根据传入参数对象对MappedStatement进行解析，解析后可以得到最终要执行的SQL语句和参数。
SQL执行：将最终得到的SQL和参数拿到数据库进行执行，得到操作数据库的结果。
结果映射：将操作数据库的结果按照映射的配置进行转换，可以转换成HashMap、JavaBean或者基本数据类型，并将最终结果返回
后面将按这个步骤来注解分析源码.
2、mybatis进行数据查询的小实例
下面代码主要展示了mybatis中进行数据库操作的几个核心要素。
public void testFindUserById(int userId) throws IOException {
// mybatis配置文件
String resource = "mybatis-config.xml";
// mybatis通过SqlSessionFactory获取SessionFactory
// 然后获取SqlSession，通过sqlSession来获取映射执行SQL的。
SqlSessionFactory sf = new SqlSessionFactoryBuilder().build(Resources.getResourceAsReader(resource));;
SqlSession sqlSession = null;
if (sf != null) {
sqlSession = getSqlSessionFactory().openSession();
SysUserDao userDao = sqlSession.getMapper(SysUserDao.class);
SysUser user = userDao.findUserById(userId);
}
}
通过配置文件，生成了SqlSessionFactory，从而创建 SqlSession，在mybatis中，所有的sql执行，都是通过SqlSession来实现的。
获取到sqlSession对象后，即可通过对应的getMapper方法来获取接口的动态实现类了，从而完成接口方法的执行。
3、源码分析
本节开始，将按照上面的代码执行过程，对mybatis的源码进行分析。分析涉及到以下几个大的过程：
- 1、对配置文件的解析。需要搞明白配置文件中的数据解析存储到哪儿了
- 2、接口类实现的获取。由于mybatis中是通过接口定义方法+xml配置方式来完成对数据库的操作，核心是通过动态代理的方式来构造接口实现类的，对这个获取过程和方法的执行需要分析。
- 3、接口类中的方法的执行。同上
3.1、获取SqlSessionFactory（配置文件解析）
配置文件的解析过程，实际上是通过获取SqlSessionFactory来实现的，这个过程看下图：
获取SqlSessionFactory流程.png
在前面的例子中有一行代码：
SqlSessionFactory sf = new SqlSessionFactoryBuilder().build(Resources.getResourceAsReader(resource));;
调用SqlSessionFactoryBuilder().build方法来创建sqlSession工厂，builder方法的入口参数是Reader，通过调用Resources.getResourceAsReader(resource)来实现的。
mybatis中的Resources类主要是通过类加载器来简化对各种资源的获取操作
SqlSessionFactoryBuilder类主要提供了基于Reader和InputStream来解析xml文件的方法，主要依赖于XMLConfigBuilder来实现,通过XMLConfigBuilder的parse方法解析xml配置文件得到Configuration对象，通过configuration对象构造默认的SqlFactory实现类DefaultSqlSessionFactory实例
SqlSessionFactoryBuilder的build方法最终调用到以下方法：
/**
* 解析xml文件两个步骤：
* 1、读取xml信息；
* 2、根据xml信息构建SqlSession工厂
*/
public SqlSessionFactory build(Reader reader, String environment, Properties properties) {
try {
logger.info("build init.");
// 1. 通过XMLConfigBuilder来解析xml配置文件
XMLConfigBuilder parser = new XMLConfigBuilder(reader, environment, properties);
// 2. 调用xml解析器进行解析得到Configuration对象,xml文件中的配置信息都存储到configuration对象中了
// 3. 创建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.
}
}
}
创建SelSessionFactory对象
// 创建SelSessionFactory对象
public SqlSessionFactory build(Configuration config) {
return new DefaultSqlSessionFactory(config);
}
实际上，创建SessionFactory对象的过程分为以下3大步骤：
- 通过XMLConfigBuilder来解析xml配置文件
- 调用xml解析器进行解析得到Configuration对象
- 创建defaultSessionFactory对象
// 进行解析操作 将最终解析到的数据存储在configuration对象中
public Configuration parse() {
if (parsed) {
throw new BuilderException("Each XMLConfigBuilder can only be used once.");
}
parsed = true;
// 从根节点configuration上开始解析
parseConfiguration(parser.evalNode("/configuration"));
// 这个地方的configuration是在当前类XMLConfigBuilder的父类BaseBuilder中定义的，在本类的构造方法中创建
// 这儿configuration对象已经返回了，通过上面的代码可以构造出SqlSessionFactory的实现对象了。
return configuration;
}
接下来，在parseConfiguration方法中开始xml文件的解析：
// 解析configuration节点下的配置，可对照mybatis-config.xml文件
private void parseConfiguration(XNode root) {
try {
// 提取settings
Properties settings = settingsAsPropertiess(root.evalNode("settings")); // 解析settings
//issue #117 read properties first
propertiesElement(root.evalNode("properties")); // 解析properties
loadCustomVfs(settings);
// 别名解析
typeAliasesElement(root.evalNode("typeAliases"));
// 插件解析
pluginElement(root.evalNode("plugins"));
// 解析自定义的ObjectFatory实现
objectFactoryElement(root.evalNode("objectFactory"));
objectWrapperFactoryElement(root.evalNode("objectWrapperFactory"));
reflectionFactoryElement(root.evalNode("reflectionFactory"));
// 解析settings
settingsElement(settings);
// read it after objectFactory and objectWrapperFactory issue #631
// 解析environments 数据源的配置
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);
}
}
上面的代码中开始对配置文件中的各个节点进行解析，我们目前关注mapper的解析即可：
private void mapperElement(XNode parent) throws Exception {
logger.info("开始解析Mappers节点");
if (parent != null) {
for (XNode child : parent.getChildren()) {
if ("package".equals(child.getName())) {
logger.info("开始处理package节点");
String mapperPackage = child.getStringAttribute("name");
// 调用configuration的添加方法
configuration.addMappers(mapperPackage);
} else {
// 通常将在另外的配置文件中配置SQL
String resource = child.getStringAttribute("resource");
String url = child.getStringAttribute("url");
String mapperClass = child.getStringAttribute("class");
if (resource != null && url == null && mapperClass == null) {
// <mapper resource="com/xxxxxxx/dao/****Mapper.xml"/>
logger.info("解析resource:" + resource);
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) {
// url方式解析
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.");
}
}
}
}
logger.info("解析Mappers节点结束！");
}
在xml中配置了如下的mapper:
<mapper resource="com/xxxxxxx/dao/****Mapper.xml"/>，通过resource定位到指定的配置文件中，再进行解析，XMLMapperBuilder中parse方法如下：
public void parse() {
logger.info(" 开始解析mapper文件：XMLMapperBuilder.parse");
if (!configuration.isResourceLoaded(resource)) {
// 对mapper文件中对各个元素进行解析
configurationElement(parser.evalNode("/mapper"));
configuration.addLoadedResource(resource);
bindMapperForNamespace();
}
parsePendingResultMaps();
parsePendingChacheRefs();
parsePendingStatements();
}
private void configurationElement(XNode context) {
try {
String namespace = context.getStringAttribute("namespace");
if (namespace == null || namespace.equals("")) {
throw new BuilderException("Mapper's namespace cannot be empty");
}
logger.info("解析到mapper文件中的namespace元素：" + namespace);
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"));
// 解析配置文件中的sql语句，重点关注这儿
buildStatementFromContext(context.evalNodes("select|insert|update|delete"));
} catch (Exception e) {
throw new BuilderException("Error parsing Mapper XML. Cause: " + e, e);
}
}
重点看对sql的解析
private void buildStatementFromContext(List<XNode> list) {
logger.info("解析mapper文件中insert | delete | update | select 元素");
if (configuration.getDatabaseId() != null) {
buildStatementFromContext(list, configuration.getDatabaseId());
}
buildStatementFromContext(list, null);
}
private void buildStatementFromContext(List<XNode> list, String requiredDatabaseId) {
// 循环遍历sql语句配置
for (XNode context : list) {
final XMLStatementBuilder statementParser = new XMLStatementBuilder(configuration, builderAssistant, context, requiredDatabaseId);
try {
// 解析配置节点，并构造产生SQL封装体
statementParser.parseStatementNode();
} catch (IncompleteElementException e) {
configuration.addIncompleteStatement(statementParser);
}
}
}
SQL的处理，涉及到对配置信息的解析，以及对这些信息对封装处理上
/**
* 该方法完成：
* 1、对sql配置中的数据进行解析提取
* 2、通过builderAssistant的addMappedStatement方法来对解析到的数据进行封装，并保存到configuration中去
*/
public void parseStatementNode() {
// 下面对配置信息进行逐个解析
String id = context.getStringAttribute("id");
String databaseId = context.getStringAttribute("databaseId");
if (!databaseIdMatchesCurrent(id, databaseId, this.requiredDatabaseId)) {
return;
}
Integer fetchSize = context.getIntAttribute("fetchSize");
Integer timeout = context.getIntAttribute("timeout");
String parameterMap = context.getStringAttribute("parameterMap");
String parameterType = context.getStringAttribute("parameterType");
Class<?> parameterTypeClass = resolveClass(parameterType);
String resultMap = context.getStringAttribute("resultMap");
String resultType = context.getStringAttribute("resultType");
String lang = context.getStringAttribute("lang");
LanguageDriver langDriver = getLanguageDriver(lang);
Class<?> resultTypeClass = resolveClass(resultType);
String resultSetType = context.getStringAttribute("resultSetType");
StatementType statementType = StatementType.valueOf(context.getStringAttribute("statementType", StatementType.PREPARED.toString()));
ResultSetType resultSetTypeEnum = resolveResultSetType(resultSetType);
String nodeName = context.getNode().getNodeName();
SqlCommandType sqlCommandType = SqlCommandType.valueOf(nodeName.toUpperCase(Locale.ENGLISH));
boolean isSelect = sqlCommandType == SqlCommandType.SELECT;
boolean flushCache = context.getBooleanAttribute("flushCache", !isSelect);
boolean useCache = context.getBooleanAttribute("useCache", isSelect);
boolean resultOrdered = context.getBooleanAttribute("resultOrdered", false);
// Include Fragments before parsing
XMLIncludeTransformer includeParser = new XMLIncludeTransformer(configuration, builderAssistant);
includeParser.applyIncludes(context.getNode());
// Parse selectKey after includes and remove them.
processSelectKeyNodes(id, parameterTypeClass, langDriver);
// Parse the SQL (pre: <selectKey> and <include> were parsed and removed)
SqlSource sqlSource = langDriver.createSqlSource(configuration, context, parameterTypeClass);
String resultSets = context.getStringAttribute("resultSets");
String keyProperty = context.getStringAttribute("keyProperty");
String keyColumn = context.getStringAttribute("keyColumn");
KeyGenerator keyGenerator;
String keyStatementId = id + SelectKeyGenerator.SELECT_KEY_SUFFIX;
keyStatementId = builderAssistant.applyCurrentNamespace(keyStatementId, true);
if (configuration.hasKeyGenerator(keyStatementId)) {
keyGenerator = configuration.getKeyGenerator(keyStatementId);
} else {
keyGenerator = context.getBooleanAttribute("useGeneratedKeys",
configuration.isUseGeneratedKeys() && SqlCommandType.INSERT.equals(sqlCommandType))
? new Jdbc3KeyGenerator() : new NoKeyGenerator();
}
// 通过builderAssistant的addMappedStatement方法来对解析到的数据进行封装
builderAssistant.addMappedStatement(id, sqlSource, statementType, sqlCommandType,
fetchSize, timeout, parameterMap, parameterTypeClass, resultMap, resultTypeClass,
resultSetTypeEnum, flushCache, useCache, resultOrdered,
keyGenerator, keyProperty, keyColumn, databaseId, langDriver, resultSets);
}
public MappedStatement addMappedStatement(
String id,
SqlSource sqlSource,
StatementType statementType,
SqlCommandType sqlCommandType,
Integer fetchSize,
Integer timeout,
String parameterMap,
Class<?> parameterType,
String resultMap,
Class<?> resultType,
ResultSetType resultSetType,
boolean flushCache,
boolean useCache,
boolean resultOrdered,
KeyGenerator keyGenerator,
String keyProperty,
String keyColumn,
String databaseId,
LanguageDriver lang,
String resultSets) {
logger.info("解析mapper文件中的sql语句对象 元素 id:" + id);
if (unresolvedCacheRef) {
throw new IncompleteElementException("Cache-ref not yet resolved");
}
id = applyCurrentNamespace(id, false);
boolean isSelect = sqlCommandType == SqlCommandType.SELECT;
MappedStatement.Builder statementBuilder = new MappedStatement.Builder(configuration, id, sqlSource, sqlCommandType)
.resource(resource)
.fetchSize(fetchSize)
.timeout(timeout)
.statementType(statementType)
.keyGenerator(keyGenerator)
.keyProperty(keyProperty)
.keyColumn(keyColumn)
.databaseId(databaseId)
.lang(lang)
.resultOrdered(resultOrdered)
.resulSets(resultSets)
.resultMaps(getStatementResultMaps(resultMap, resultType, id))
.resultSetType(resultSetType)
.flushCacheRequired(valueOrDefault(flushCache, !isSelect))
.useCache(valueOrDefault(useCache, isSelect))
.cache(currentCache);
ParameterMap statementParameterMap = getStatementParameterMap(parameterMap, parameterType, id);
if (statementParameterMap != null) {
statementBuilder.parameterMap(statementParameterMap);
}
// 存储解析到到sql语句
MappedStatement statement = statementBuilder.build();
// 添加statement对象，对sql 的解析封装完成
configuration.addMappedStatement(statement);
return statement;
}
到此，对sql的解析封装完成，mybatis将mapper中的sql语句封装到MappedStatement对象中，存储到configuration对象的mappedStatements映射中。
Configuration类中的存储SQL封装的集合：
// 映射的SQL语句
protected final Map<String, MappedStatement> mappedStatements = new StrictMap<MappedStatement>("Mapped Statements collection");
在执行SQL 的时候还要从上述集合中获取对应的sql相关信息。
3.2 Mapper对象获取
在前面的实例代码中很容易就获取到SqlSession对象了，有一行代码是获取Mapper对象的：
SysUserDao userDao = sqlSession.getMapper(SysUserDao.class);
先看SqlSession对象的获取，通过上面分析，得到SqlSessionFactory的实现是DefaultSqlSessionFactory类。其openSession方法如下：
/**
* 创建SqlSession
* @see org.apache.ibatis.session.SqlSessionFactory#openSession()
*/
@Override
public SqlSession openSession() {
logger.info("open session...");
return openSessionFromDataSource(configuration.getDefaultExecutorType(), null, false);
}
/**
* 获取SqlSession对象
* @param execType
* @param level
* @param autoCommit
* @return
*/
private SqlSession openSessionFromDataSource(ExecutorType execType, TransactionIsolationLevel level, boolean autoCommit) {
Transaction tx = null;
try {
logger.info("openSessionFromDataSource...");
// environment内包含了数据源和事务相关的配置
final Environment environment = configuration.getEnvironment();
// 根据environment获取事务管理
final TransactionFactory transactionFactory = getTransactionFactoryFromEnvironment(environment);
// 从environment中获取DataSource
tx = transactionFactory.newTransaction(environment.getDataSource(), level, autoCommit);
// 执行器，通过Excutor来执行SQL语句，Excutor是对Statement的封装
final Executor executor = configuration.newExecutor(tx, execType);
// 创建了一个DefaultSqlSession对象，传入了执行器
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();
}
}
得到的SqlSession对象是DefaultSqlSession类的对象，现在看其getMapper方法
/**
* 直接去configuration中找相关的mapper对象
* @see org.apache.ibatis.session.SqlSession#getMapper(java.lang.Class)
*/
@Override
public <T> T getMapper(Class<T> type) {
logger.info("getMapper name:" + type.getName());
return configuration.<T>getMapper(type, this);
}
Configuration类中的getMapper方法：
public <T> T getMapper(Class<T> type, SqlSession sqlSession) {
return mapperRegistry.getMapper(type, sqlSession);
}
调用了MapperRegistry类中的方法，MapperRegistry主要负责mapper的注册，提供mapper代理功能。
public <T> T getMapper(Class<T> type, SqlSession sqlSession) {
// 让代理去找mapper
final MapperProxyFactory<T> mapperProxyFactory = (MapperProxyFactory<T>) knownMappers.get(type);
if (mapperProxyFactory == null) {
throw new BindingException("Type " + type + " is not known to the MapperRegistry.");
}
try {
// 关键： 创建,具体的mapper代理执行类来创建。
return mapperProxyFactory.newInstance(sqlSession);
} catch (Exception e) {
throw new BindingException("Error getting mapper instance. Cause: " + e, e);
}
}
public T newInstance(SqlSession sqlSession) {
// 注意MapperProxy代理类，后续mapper方法执行的时候会到该代理的invoke方法中去
final MapperProxy<T> mapperProxy = new MapperProxy<T>(sqlSession, mapperInterface, methodCache);
return newInstance(mapperProxy);
}
protected T newInstance(MapperProxy<T> mapperProxy) {
// 动态代理我们写的dao接口
return (T) Proxy.newProxyInstance(mapperInterface.getClassLoader(), new Class[] { mapperInterface }, mapperProxy);
}
mybatis通过jdk的动态代理来为我们创建了mapper接口的实现。需要注意：
MapperProxy这个代理类，后续mapper方法执行的时候会到该代理的invoke方法中去
3.3 Mapper方法执行
/**
* MapperProxy在执行时会触发此方法
* @see java.lang.reflect.InvocationHandler#invoke(java.lang.Object, java.lang.reflect.Method, java.lang.Object[])
*/
@Override
public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
// 方法所在的是不是一个类？ Mapper是一个接口，不是类，则跳过
System.out.println("method.getDeclaringClass():" + method.getDeclaringClass());
if (Object.class.equals(method.getDeclaringClass())) {
try {
return method.invoke(this, args);
} catch (Throwable t) {
throw ExceptionUtil.unwrapThrowable(t);
}
}
final MapperMethod mapperMethod = cachedMapperMethod(method);
// 交给mapperMethod去执行
return mapperMethod.execute(sqlSession, args);
}
MapperMethod是整个代理机制中的核心，对SqlSession中的方法做了封装。
/**
* 根据sql类型去判断执行，最终还是去调用sqlSession中的方法去完成
* @param sqlSession
* @param args
* @return
*/
public Object execute(SqlSession sqlSession, Object[] args) {
// 返回结果
Object result;
// insert操作
if (SqlCommandType.INSERT == command.getType()) {
// 参数转换处理
Object param = method.convertArgsToSqlCommandParam(args);
// 调用sqlSession的insert方法
result = rowCountResult(sqlSession.insert(command.getName(), param));
// update
} else if (SqlCommandType.UPDATE == command.getType()) {
Object param = method.convertArgsToSqlCommandParam(args);
result = rowCountResult(sqlSession.update(command.getName(), param));
// delete
} else if (SqlCommandType.DELETE == command.getType()) {
Object param = method.convertArgsToSqlCommandParam(args);
result = rowCountResult(sqlSession.delete(command.getName(), param));
// select
} else if (SqlCommandType.SELECT == command.getType()) {
// 如果返回void,并且参数有结果处理器
if (method.returnsVoid() && method.hasResultHandler()) {
executeWithResultHandler(sqlSession, args);
result = null;
// 返回多行结果的
} else if (method.returnsMany()) {
// 分析这儿
result = executeForMany(sqlSession, args);
// 返回类型是map
} else if (method.returnsMap()) {
result = executeForMap(sqlSession, args);
} else {
// 否则，就是查询单个对象的
Object param = method.convertArgsToSqlCommandParam(args);
result = sqlSession.selectOne(command.getName(), param);
}
// flush操作
} else if (SqlCommandType.FLUSH == command.getType()) {
result = sqlSession.flushStatements();
} else {
// 不匹配，说明，mapper中定义的方法不对
throw new BindingException("Unknown execution method for: " + command.getName());
}
//如果返回值为空 并且方法返回值类型是基础类型 并且不是VOID 则抛出异常
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;
}
executeForMany方法：
/**
* 返回多行查询结果的，主要是调用sqlSession的seleceList方法实现
* @param sqlSession
* @param args
* @param <E>
* @return
*/
private <E> Object executeForMany(SqlSession sqlSession, Object[] args) {
List<E> result;
Object param = method.convertArgsToSqlCommandParam(args);
// 如果参数中含有rowBounds则调用分页查询
if (method.hasRowBounds()) {
RowBounds rowBounds = method.extractRowBounds(args);
result = sqlSession.<E>selectList(command.getName(), param, rowBounds);
} else {
// 没有分页，普通查询
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;
}
对数据库的操作 最终还是落到SqlSession(DefaultSqlSession实现）类上了。看查询操作：
/**
* 在MapperProxy中调用
* @see org.apache.ibatis.session.SqlSession#selectList(java.lang.String, java.lang.Object, org.apache.ibatis.session.RowBounds)
*/
@Override
public <E> List<E> selectList(String statement, Object parameter, RowBounds rowBounds) {
try {
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();
}
}
DefaultSqlSession中的selectList 方法
/**
* 在MapperProxy中调用
* @see org.apache.ibatis.session.SqlSession#selectList(java.lang.String, java.lang.Object, org.apache.ibatis.session.RowBounds)
*/
@Override
public <E> List<E> selectList(String statement, Object parameter, RowBounds rowBounds) {
try {
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();
}
}
BaseExecutor中query方法：
public <E> List<E> query(MappedStatement ms, Object parameter, RowBounds rowBounds, ResultHandler resultHandler) throws SQLException {
BoundSql boundSql = ms.getBoundSql(parameter);
// 生成缓存key
CacheKey key = createCacheKey(ms, parameter, rowBounds, boundSql);
return query(ms, parameter, rowBounds, resultHandler, key, boundSql);
}
SimpleExecutor中的查询方法：
/**
* 在SqlSession中调用
* @see org.apache.ibatis.executor.BaseExecutor#doQuery(org.apache.ibatis.mapping.MappedStatement, java.lang.Object, org.apache.ibatis.session.RowBounds, org.apache.ibatis.session.ResultHandler, org.apache.ibatis.mapping.BoundSql)
*/
@Override
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对象
StatementHandler handler = configuration.newStatementHandler(wrapper, ms, parameter, rowBounds, resultHandler, boundSql);
// 预编译和基础设置
stmt = prepareStatement(handler, ms.getStatementLog());
// StatementHandler封装了Statement,让其处理，并通过resultHandler来完成对结果集对回调处理
return handler.<E>query(stmt, resultHandler);
} finally {
closeStatement(stmt);
}
}
最终通过结果处理器进行回调，完成对查询到的结果集进行处理并返回。
4、总结
整体上，按照查询涉及到的代码过了一遍，对mybatis的源码有了个大体的了解，后续对其逐步进行解析。
