Mybatis工作机制源码分析—一次select请求处理流程

        本文从源码分析的角度分析Mybatis一次select请求处理流程。

select整体处理流程

时序图

DefaultSqlSession.selectOne工作流程

时序图

DynamicSqlSource构建BoundSql工作流程

相关源码

/** DefaultSqlSession.java */
public  T selectOne(String statement, Object parameter) {
	// Popular vote was to return null on 0 results and throw exception on too many.
	List 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;
	}
}

public  List selectList(String statement, Object parameter) {
	return this.selectList(statement, parameter, RowBounds.DEFAULT);
}

public  List selectList(String statement, Object parameter, RowBounds rowBounds) {
	try {
		// 根据statement id获取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();
	}
}

/** CachingExecutor.java */
public  List query(MappedStatement ms, Object parameterObject, RowBounds rowBounds, ResultHandler resultHandler) throws SQLException {
	// MappedStatement构建BoundSql，实际用DynamicSqlSource或StaticSqlSource构建BoundSql
	BoundSql boundSql = ms.getBoundSql(parameterObject);
	// 构建CacheKey
	CacheKey key = createCacheKey(ms, parameterObject, rowBounds, boundSql);
	return query(ms, parameterObject, rowBounds, resultHandler, key, boundSql);
}

/** MappedStatement.java */
public BoundSql getBoundSql(Object parameterObject) {
	BoundSql boundSql = sqlSource.getBoundSql(parameterObject);
	List parameterMappings = boundSql.getParameterMappings();
	if (parameterMappings == null || parameterMappings.isEmpty()) {
		boundSql = new BoundSql(configuration, boundSql.getSql(), parameterMap.getParameterMappings(), parameterObject);
	}

	// check for nested result maps in parameter mappings (issue #30)
	for (ParameterMapping pm : boundSql.getParameterMappings()) {
		String rmId = pm.getResultMapId();
		if (rmId != null) {
			ResultMap rm = configuration.getResultMap(rmId);
		if (rm != null) {
			hasNestedResultMaps |= rm.hasNestedResultMaps();
		}
	  }
	}

	return boundSql;
}

/** DynamicSqlSource.java */
// DynamicSqlSource构建BoundSql
public BoundSql getBoundSql(Object parameterObject) {
	DynamicContext context = new DynamicContext(configuration, parameterObject);
	// 根据sql语句中的、等元素，动态组建完整的sql语句
	rootSqlNode.apply(context);
	SqlSourceBuilder sqlSourceParser = new SqlSourceBuilder(configuration);
	Class parameterType = parameterObject == null ? Object.class : parameterObject.getClass();
	// context.getSql()获取的sql语句是完整sql语句的原始形式，包括#{}等
	// 将sql语句解析为StaticSqlSource
	SqlSource sqlSource = sqlSourceParser.parse(context.getSql(), parameterType, context.getBindings());
	// 用StaticSqlSource构建BoundSql
	BoundSql boundSql = sqlSource.getBoundSql(parameterObject);
	// 添加metaParameter
	for (Map.Entry entry : context.getBindings().entrySet()) {
		boundSql.setAdditionalParameter(entry.getKey(), entry.getValue());
	}
	return boundSql;
}

/** MixedSqlNode.java */
public boolean apply(DynamicContext context) {
	for (SqlNode sqlNode : contents) {
		sqlNode.apply(context);
	}
	return true;
}

/** StaticTextSqlNode.java */
public boolean apply(DynamicContext context) {
	context.appendSql(text);
	return true;
}

/** TrimSqlNode.java */
public boolean apply(DynamicContext context) {
	FilteredDynamicContext filteredDynamicContext = new FilteredDynamicContext(context);
	boolean result = contents.apply(filteredDynamicContext);
	filteredDynamicContext.applyAll();
	return result;
}

/** TrimSqlNode.FilteredDynamicContext.java */
public void appendSql(String sql) {
	sqlBuffer.append(sql);
}

public void applyAll() {
	sqlBuffer = new StringBuilder(sqlBuffer.toString().trim());
	String trimmedUppercaseSql = sqlBuffer.toString().toUpperCase(Locale.ENGLISH);
	if (trimmedUppercaseSql.length() > 0) {
		applyPrefix(sqlBuffer, trimmedUppercaseSql);
		applySuffix(sqlBuffer, trimmedUppercaseSql);
	}
	delegate.appendSql(sqlBuffer.toString());
}

/** SqlSourceBuilder.java */
public SqlSource parse(String originalSql, Class parameterType, Map additionalParameters) {
	ParameterMappingTokenHandler handler = new ParameterMappingTokenHandler(configuration, parameterType, additionalParameters);
	// 解析#{}形式的参数
	GenericTokenParser parser = new GenericTokenParser("#{", "}", handler);
	// 解析后的sql为用"?"替换#{}参数，且提取对应参数的ParameterMapping
	String sql = parser.parse(originalSql);
	// 以StaticSqlSource为解析结果
	return new StaticSqlSource(configuration, sql, handler.getParameterMappings());
}

/** BoundSql.java */
public void setAdditionalParameter(String name, Object value) {
	metaParameters.setValue(name, value);
}

/** CachingExecutor.java */
public CacheKey createCacheKey(MappedStatement ms, Object parameterObject, RowBounds rowBounds, BoundSql boundSql) {
	return delegate.createCacheKey(ms, parameterObject, rowBounds, boundSql);
}

/** BaseExecutor.java */
// 创建CacheKey，用MappedStatement、parameterObject、rowBounds、boundSql影响CacheKey的hashCode
public CacheKey createCacheKey(MappedStatement ms, Object parameterObject, RowBounds rowBounds, BoundSql boundSql) {
	if (closed) {
		throw new ExecutorException("Executor was closed.");
	}
	CacheKey cacheKey = new CacheKey();
	// cacheKey关联MappedStatement id
	cacheKey.update(ms.getId());
	// cacheKey关联rowBounds offset
	cacheKey.update(Integer.valueOf(rowBounds.getOffset()));
	// cacheKey关联Offset limit
	cacheKey.update(Integer.valueOf(rowBounds.getLimit()));
	// cacheKey关联boundSql sql
	cacheKey.update(boundSql.getSql());
	List parameterMappings = boundSql.getParameterMappings();
	TypeHandlerRegistry typeHandlerRegistry = ms.getConfiguration().getTypeHandlerRegistry();
	// mimic DefaultParameterHandler logic
	for (int i = 0; i < parameterMappings.size(); i++) {
		ParameterMapping parameterMapping = parameterMappings.get(i);
		if (parameterMapping.getMode() != ParameterMode.OUT) {
			Object value;
			String propertyName = parameterMapping.getProperty();
			if (boundSql.hasAdditionalParameter(propertyName)) {
				value = boundSql.getAdditionalParameter(propertyName);
			} else if (parameterObject == null) {
				value = null;
			} else if (typeHandlerRegistry.hasTypeHandler(parameterObject.getClass())) {
				value = parameterObject;
			} else {
				MetaObject metaObject = configuration.newMetaObject(parameterObject);
				value = metaObject.getValue(propertyName);
			}
			// cacheKey关联parameterMapping value
			cacheKey.update(value);
		}
	}
	if (configuration.getEnvironment() != null) {
		// cacheKey关联environment id
		cacheKey.update(configuration.getEnvironment().getId());
	}
	return cacheKey;
}    

/** CachingExecutor.java */
public  List query(MappedStatement ms, Object parameterObject, RowBounds rowBounds, ResultHandler resultHandler, CacheKey key, BoundSql boundSql)
  throws SQLException {
	Cache cache = ms.getCache();
	if (cache != null) {
		// CachingExecutor缓存处理，MappedStatement级缓存结合TransactionalCache缓存
		flushCacheIfRequired(ms);
		if (ms.isUseCache() && resultHandler == null) {
			ensureNoOutParams(ms, parameterObject, boundSql);
			@SuppressWarnings("unchecked")
			List list = (List) 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);
}

/** BaseExecutor.java */
public  List 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 list;
	try {
		queryStack++;
		// 查看本地缓存，有则直接返回
		list = resultHandler == null ? (List) localCache.getObject(key) : null;
		if (list != null) {
			// 处理本地缓存的输出参数
			handleLocallyCachedOutputParameters(ms, key, parameter, boundSql);
		} else {
			// 从Database查询
			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) {
			// MappedStatement级别的缓存，则清空本地缓存
			clearLocalCache();
		}
	}
	return list;
}

private void handleLocallyCachedOutputParameters(MappedStatement ms, CacheKey key, Object parameter, BoundSql boundSql) {
	if (ms.getStatementType() == StatementType.CALLABLE) {
		final Object cachedParameter = localOutputParameterCache.getObject(key);
		if (cachedParameter != null && parameter != null) {
			final MetaObject metaCachedParameter = configuration.newMetaObject(cachedParameter);
			final MetaObject metaParameter = configuration.newMetaObject(parameter);
			for (ParameterMapping parameterMapping : boundSql.getParameterMappings()) {
				if (parameterMapping.getMode() != ParameterMode.IN) {
					final String parameterName = parameterMapping.getProperty();
					final Object cachedValue = metaCachedParameter.getValue(parameterName);
					metaParameter.setValue(parameterName, cachedValue);
				}
			}
		}
	}
}

private  List queryFromDatabase(MappedStatement ms, Object parameter, RowBounds rowBounds, ResultHandler resultHandler, CacheKey key, BoundSql boundSql) throws SQLException {
	List list;
	localCache.putObject(key, EXECUTION_PLACEHOLDER);
	try {
		// 从Database查询
		list = doQuery(ms, parameter, rowBounds, resultHandler, boundSql);
	} finally {
		// 清空本地之前CacheKey对应的缓存
		localCache.removeObject(key);
	}
	// 将查询结果key——list缓存到localCache
	localCache.putObject(key, list);
	if (ms.getStatementType() == StatementType.CALLABLE) {
		// 将key——parameter缓存到localOutputParameterCache
		localOutputParameterCache.putObject(key, parameter);
	}
	return list;
}

/** SimpleExecutor.java */
public  List 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.query(stmt, resultHandler);
	} finally {
		// close Statement
		closeStatement(stmt);
	}
}

/** RoutingStatementHandler.java */
public  List query(Statement statement, ResultHandler resultHandler) throws SQLException {
	return delegate.query(statement, resultHandler);
}

/** PreparedStatementHandler.java */
public  List query(Statement statement, ResultHandler resultHandler) throws SQLException {
	PreparedStatement ps = (PreparedStatement) statement;
	ps.execute();
	return resultSetHandler. handleResultSets(ps);
}

DefaultResultSetHandler.handleResultSets工作流程

时序图

相关源码

/** DefaultResultSetHandler.java */
public List