还是接着上一篇深入源码分析mybatis查询原理（三）继续讨论。
由于前面几篇的查询都是没有带参数的，那么我现在加一个带参数查询的方法，来看一下mybatis如何处理参数并查询。
EmpTexst.java t1()方法
Emp emp = empmapper.queryByEmpNoAndName(1, "admin");
System.out.println(emp);empmapper.java
//按条件查询
Emp queryByEmpNoAndName(@Param("empNo") int empNo, @Param("name") String name);<select id="queryByEmpNoAndName" resultType="emp">
select * from emp where EMPNO = #{empNo} and ENAME = #{name}
</select>以上就是增加的查询
在Emp emp = empmapper.queryByEmpNoAndName(1, "admin");打上断点。
进入源码
@Override
public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
if (Object.class.equals(method.getDeclaringClass())) {
try {
return method.invoke(this, args);
} catch (Throwable t) {
throw ExceptionUtil.unwrapThrowable(t);
}
}
final MapperMethod mapperMethod = cachedMapperMethod(method);
return mapperMethod.execute(sqlSession, args);
}重点关注mapperMethod.execute(sqlSession, args); 前面方法都讨论过了，今天接着讨论这个方法
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;
}这个execute方法会根据执行SQL的类型和返回结果的类型选择合适的sql执行，这个查询将会执行
Object param = method.convertArgsToSqlCommandParam(args);
result = sqlSession.selectOne(command.getName(), param);
可以看到这里的参数列表[1，admin]。
断点进入 convertArgsToSqlCommandParam 这个方法，从这个方法名字可以知道，这个方法的作用是将参数列表转换为SQL的参数。源码
public Object convertArgsToSqlCommandParam(Object[] args) {
return paramNameResolver.getNamedParams(args);
}这里看到有一个 paramNameResolver 对象，ParamNameResolver类是用来对方法的参数做解析的，解析的过程是在创建 MethodSignature 对象时解析的，由于上一章方法没有参数，所以参数解析也就没有讨论到，现在给它补上，不好意思，这样子就有点乱了。那我们回顾一下 MethodSignature 创建过程吧
public MethodSignature(Configuration configuration, Class<?> mapperInterface, Method method) {
Type resolvedReturnType = TypeParameterResolver.resolveReturnType(method, mapperInterface);
if (resolvedReturnType instanceof Class<?>) {
this.returnType = (Class<?>) resolvedReturnType;
} else if (resolvedReturnType instanceof ParameterizedType) {
this.returnType = (Class<?>) ((ParameterizedType) resolvedReturnType).getRawType();
} else {
this.returnType = method.getReturnType();
}
this.returnsVoid = void.class.equals(this.returnType);
this.returnsMany = (configuration.getObjectFactory().isCollection(this.returnType) || this.returnType.isArray());
this.returnsCursor = Cursor.class.equals(this.returnType);
this.mapKey = getMapKey(method);
this.returnsMap = (this.mapKey != null);
this.rowBoundsIndex = getUniqueParamIndex(method, RowBounds.class);
this.resultHandlerIndex = getUniqueParamIndex(method, ResultHandler.class);
this.paramNameResolver = new ParamNameResolver(configuration, method);
}MethodSignature是什么，何时创建都在上一章讨论过了，这里不再重复啰嗦了。好，我们点进去看看ParamNameResolver的创建过程。
ParamNameResolver 创建
public ParamNameResolver(Configuration config, Method method) {
final Class<?>[] paramTypes = method.getParameterTypes();
final Annotation[][] paramAnnotations = method.getParameterAnnotations();
final SortedMap<Integer, String> map = new TreeMap<Integer, String>();
int paramCount = paramAnnotations.length;
// get names from @Param annotations
for (int paramIndex = 0; paramIndex < paramCount; paramIndex++) {
if (isSpecialParameter(paramTypes[paramIndex])) {
// skip special parameters
continue;
}
String name = null;
for (Annotation annotation : paramAnnotations[paramIndex]) {
if (annotation instanceof Param) {
hasParamAnnotation = true;
name = ((Param) annotation).value();
break;
}
}
if (name == null) {
// @Param was not specified.
if (config.isUseActualParamName()) {
name = getActualParamName(method, paramIndex);
}
if (name == null) {
// use the parameter index as the name ("0", "1", ...)
// gcode issue #71
name = String.valueOf(map.size());
}
}
map.put(paramIndex, name);
}
names = Collections.unmodifiableSortedMap(map);
}解读一下这段代码：首先，通过java的反射获取到参数的类型和参数的注解method.getParameterAnnotations()方法返回的是注解的二维数组，每一个方法的参数包含一个注解数组。
到这里，停一下，这个参数注解是个二维数组，那么这个二维数组是怎么排列组合的呢，参数注解的length和参数类型数组的length有什么关系？
看上面的图知道，paramAnnotations[0][0] = @org.apache.ibatis.annotations.Param(value=name),
paramAnnotations[1][0] = @org.apache.ibatis.annotations.Param(value=name),也就是说二维数组是包含多个仅有一个值的数组.因为参数前可以添加多个注解,所以是二维数组,一个参数上不可以添加相同的注解,同一个注解可以加在不同的参数上!
而这个一维数组的length就是参数数组的length，如果一个参数没有加注解，一个参数加了注解，会是怎么样的呢，我们改一下代码。
empmapper.java//按条件查询
Emp queryByEmpNoAndName(int empNo, @Param("name") String name);<select id="queryByEmpNoAndName" resultType="emp">
select * from emp where EMPNO = #{0} and ENAME = #{name}
</select>再次断点进入，查看
可以看到第一个是空，第二个没有区别。
好，回到主线上，mybatis通过反射获取到参数类型数组和注解数组后，遍历所有的参数 ，判断这个参数的类型是否是特殊类型,这里特殊类型指RowBounds和ResultHandler，是的话跳过，咱不处理 ，然后判断这个参数是否是用来Param注解，如果使用的话，设置hasParamAnnotation为true,表示参数中使用了Param注解，然后设置name就是Param注解的值，把name放到map中，键为参数在方法中的位置，value为Param的值 ，如果没有使用Param注解,判断是否开启了UseActualParamName，如果开启了，则使用java8的反射得到方法的名字。如果没有开启，那么就会使用参数索引作为name。
这个讨论的有点，乱举个例子，mybatis通过创建ParamNameResolver时对参数做解析。解析的结果：
Emp queryByEmpNoAndName(int empNo, @Param("name") String name);
解析结果：{0=0, 1=name}
Emp queryByEmpNoAndName(@Param("empNo") int empNo, @Param("name") String name);
解析结果：{0=empNo, 1=name}
Emp queryByEmpNoAndName(@Param("empNo") int empNo, String name);
解析结果：{0=empNo, 1=1}
好了，我们回到paramNameResolver.getNamedParams(args);接着往下讨论
public Object getNamedParams(Object[] args) {
final int paramCount = names.size();
if (args == null || paramCount == 0) {
return null;
} else if (!hasParamAnnotation && paramCount == 1) {
return args[names.firstKey()];
} else {
final Map<String, Object> param = new ParamMap<Object>();
int i = 0;
for (Map.Entry<Integer, String> entry : names.entrySet()) {
param.put(entry.getValue(), args[entry.getKey()]);
// add generic param names (param1, param2, ...)
final String genericParamName = GENERIC_NAME_PREFIX + String.valueOf(i + 1);
// ensure not to overwrite parameter named with @Param
if (!names.containsValue(genericParamName)) {
param.put(genericParamName, args[entry.getKey()]);
}
i++;
}
return param;
}
}解读这段代码，首先如果只有一个参数，就返回这个参数，否者的话就是遍历names，取出Map的value作为参数param的key，根据names的key作为索引，从args中取出值作为参数names的value.接着生成参数 names(格式就是，param+i ，生成为param1，param2，param3.....)作为param的key,并把args作为值，若args 为 [1, admin]。那这一步生成的param就是{param1=1, param2=admin}。
可能这么说有点不清晰，还是把上面的例子拿过来。
args 为 [1, admin]。
Emp queryByEmpNoAndName(int empNo, @Param("name") String name);
names 为 {0=0, 1=name}
解析结果：{0=1, name=admin, param1=1, param2=admin}
Emp queryByEmpNoAndName(@Param("empNo") int empNo, @Param("name") String name);
解析结果：name=admin, empNo=1, param1=1, param2=admin}
Emp queryByEmpNoAndName(@Param("empNo") int empNo, String name);
解析结果：{1=admin, empNo=1, param1=1, param2=admin}
至此 把参数列表解析成SQL参数讨论完成。
接着回到这段代码：
Object param = method.convertArgsToSqlCommandParam(args);
result = sqlSession.selectOne(command.getName(), param);selectOne方法
@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;
}
}接着定位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 {
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();
}
}接续 query方法
@Override
public <E> List<E> query(MappedStatement ms, Object parameterObject, RowBounds rowBounds, ResultHandler resultHandler) throws SQLException {
BoundSql boundSql = ms.getBoundSql(parameterObject);
CacheKey key = createCacheKey(ms, parameterObject, rowBounds, boundSql);
return query(ms, parameterObject, rowBounds, resultHandler, key, boundSql);
}首先 获取 BoundSql ，这是什么呢？
/**
* Copyright 2009-2016 the original author or authors.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.apache.ibatis.mapping;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import org.apache.ibatis.reflection.MetaObject;
import org.apache.ibatis.reflection.property.PropertyTokenizer;
import org.apache.ibatis.session.Configuration;
/**
* An actual SQL String got form an {@link SqlSource} after having processed any dynamic content.
* The SQL may have SQL placeholders "?" and an list (ordered) of an parameter mappings
* with the additional information for each parameter (at least the property name of the input object to read
* the value from).
* </br>
* Can also have additional parameters that are created by the dynamic language (for loops, bind...).
*
* @author Clinton Begin
*/
public class BoundSql {
private String sql;
private List<ParameterMapping> parameterMappings;
private Object parameterObject;
private Map<String, Object> additionalParameters;
private MetaObject metaParameters;
public BoundSql(Configuration configuration, String sql, List<ParameterMapping> parameterMappings, Object parameterObject) {
this.sql = sql;
this.parameterMappings = parameterMappings;
this.parameterObject = parameterObject;
this.additionalParameters = new HashMap<String, Object>();
this.metaParameters = configuration.newMetaObject(additionalParameters);
}
public String getSql() {
return sql;
}
public List<ParameterMapping> getParameterMappings() {
return parameterMappings;
}
public Object getParameterObject() {
return parameterObject;
}
public boolean hasAdditionalParameter(String name) {
PropertyTokenizer prop = new PropertyTokenizer(name);
String indexedName = prop.getIndexedName();
return additionalParameters.containsKey(indexedName);
}
public void setAdditionalParameter(String name, Object value) {
metaParameters.setValue(name, value);
}
public Object getAdditionalParameter(String name) {
return metaParameters.getValue(name);
}
}英文好的同学 可以看看这段：
/**
* An actual SQL String got form an {@link SqlSource} after having processed any dynamic content.
* The SQL may have SQL placeholders "?" and an list (ordered) of an parameter mappings
* with the additional information for each parameter (at least the property name of the input object to read
* the value from).
* </br>
* Can also have additional parameters that are created by the dynamic language (for loops, bind...).
*
* @author Clinton Begin
*/这个对象有三个属性很重要：
private String sql; //从解析时可以看出这个sql不是配置文件中的sql,这个sql已经经过了处理(如:占用位符的处理、动态语句的解析if、foreach等待)
private List<ParameterMapping> parameterMappings; //sql对应的参数列表（包含了参数名，类型，jdbc类型等等）
private Object parameterObject;//参数接下来是创建CacheKey，这个CacheKey，使用一级缓存中会用到，这个暂时不讨论，写一章专门讨论缓存时在讨论。
接着 query
@Override
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, parameterObject, boundSql);
@SuppressWarnings("unchecked")
List<E> list = (List<E>) tcm.getObject(cache, key);
if (list == null) {
list = delegate.<E> query(ms, parameterObject, rowBounds, resultHandler, key, boundSql);
tcm.putObject(cache, key, list); // issue #578 and #116
}
return list;
}
}
return delegate.<E> query(ms, parameterObject, rowBounds, resultHandler, key, boundSql);
}可以看到，首先获取缓存，根据CacheKey,从缓存中获取结果，如果没有则，从数据库中获取，并把结果设置到缓存中，以备后续有相同的查询，提高性能。这需要注意的一点是之前调用query的Executor都是CachingExecutor，现在调用query的Executor是SimpleExecutor，这是一种设计模式：装饰者模式。
好，进入SimpleExecutor的query方法，但是当我们代码单步进入的是BaseExecutor。
这里代码多，就在里面写上注释了
@SuppressWarnings("unchecked")
@Override
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.");
}
//如果设置刷新缓存 ，并且queryStack查询堆栈为0，清局部缓存，再查询（queryStack 处理递归调用）
if (queryStack == 0 && ms.isFlushCacheRequired()) {
clearLocalCache();
}
List<E> list;
try {
//加一，这样递归调用到上面的时候就不会再清局部缓存了
queryStack++;
//尝试根据cachekey从localCache去查
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;
}关注 queryFromDatabase方法
private <E> List<E> queryFromDatabase(MappedStatement ms, Object parameter, RowBounds rowBounds, ResultHandler resultHandler, CacheKey key, BoundSql boundSql) throws SQLException {
List<E> list;
localCache.putObject(key, EXECUTION_PLACEHOLDER);
try {
list = doQuery(ms, parameter, rowBounds, resultHandler, boundSql);
} finally {
localCache.removeObject(key);
}
localCache.putObject(key, list);
if (ms.getStatementType() == StatementType.CALLABLE) {
localOutputParameterCache.putObject(key, parameter);
}
return list;
}再看 doQuery
@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 handler = configuration.newStatementHandler(wrapper, ms, parameter, rowBounds, resultHandler, boundSql);
stmt = prepareStatement(handler, ms.getStatementLog());
return handler.<E>query(stmt, resultHandler);
} finally {
closeStatement(stmt);
}
}跟源码看一下 configuration.newStatementHandler，一路点下去，看到
public RoutingStatementHandler(Executor executor, MappedStatement ms, Object parameter, RowBounds rowBounds, ResultHandler resultHandler, BoundSql boundSql) {
switch (ms.getStatementType()) {
case STATEMENT:
delegate = new SimpleStatementHandler(executor, ms, parameter, rowBounds, resultHandler, boundSql);
break;
case PREPARED:
delegate = new PreparedStatementHandler(executor, ms, parameter, rowBounds, resultHandler, boundSql);
break;
case CALLABLE:
delegate = new CallableStatementHandler(executor, ms, parameter, rowBounds, resultHandler, boundSql);
break;
default:
throw new ExecutorException("Unknown statement type: " + ms.getStatementType());
}
}根据StatementType 创建对应的StatementHandler，而 StatementType 是在mapper.xml中配置的，默认为PREPARED
接着关注一下prepareStatement方法：
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;
}首先获取连接，然后获取 PreparedStatement。我们知道myBatis是对jdbc的封装，回想一下jdbc执行SQL的步骤吧。
1.加载驱动。 ---->> ---myBatis 配置文件 获取dataSource.
2.获取数据库连接。 ---->> --- myBatis获取prepareStatement时
3.创建Statement。 ---->>-----上图也说明了myBatis怎么获取Statement
4.准备SQL ---->> ----- myBatis 的boundSql对象封装处理好的SQL信息，参数信息。
5.设置参数 ---->> ----- 看上图代码，也就是这段代码：
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;
}关注一下这段代码：handler.parameterize(stmt);
一路点过去
@Override
public void setParameters(PreparedStatement ps) {
ErrorContext.instance().activity("setting parameters").object(mappedStatement.getParameterMap().getId());
List<ParameterMapping> parameterMappings = boundSql.getParameterMappings();
if (parameterMappings != null) {
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)) { // issue #448 ask first for additional params
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);
}
TypeHandler typeHandler = parameterMapping.getTypeHandler();
JdbcType jdbcType = parameterMapping.getJdbcType();
if (value == null && jdbcType == null) {
jdbcType = configuration.getJdbcTypeForNull();
}
try {
typeHandler.setParameter(ps, i + 1, value, jdbcType);
} catch (TypeException e) {
throw new TypeException("Could not set parameters for mapping: " + parameterMapping + ". Cause: " + e, e);
} catch (SQLException e) {
throw new TypeException("Could not set parameters for mapping: " + parameterMapping + ". Cause: " + e, e);
}
}
}
}
}这段代码就是PreparedStatement对象设置参数。首先获取ParameterMapping列表，这个ParameterMapping主要是做参数解析后的结果，可以看到解析出了 参数的javaType,jdbcType,mode等等。
这段代码中我们重点关注 那几个if else 分支
if (parameterMapping.getMode() != ParameterMode.OUT) {
Object value;
String propertyName = parameterMapping.getProperty();
if (boundSql.hasAdditionalParameter(propertyName)) { // issue #448 ask first for additional params
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);
}
TypeHandler typeHandler = parameterMapping.getTypeHandler();
JdbcType jdbcType = parameterMapping.getJdbcType();
if (value == null && jdbcType == null) {
jdbcType = configuration.getJdbcTypeForNull();
}
try {
typeHandler.setParameter(ps, i + 1, value, jdbcType);
} catch (TypeException e) {
throw new TypeException("Could not set parameters for mapping: " + parameterMapping + ". Cause: " + e, e);
} catch (SQLException e) {
throw new TypeException("Could not set parameters for mapping: " + parameterMapping + ". Cause: " + e, e);
}
}从parameterMapping中获取到属性，
首先判断这个属性是否是额外的参数，也就是使用 <if> <foreach>的时候，mybatis自动生成的动态参数，如果是的话就从动态参数中去取值。
第二，如果这个参数是空，那么直接返回空。
第三，如果参数是一个简单类型，或者是注册了typeHandler的对象类型，就直接使用参数作为返回值，最后一个是复杂对象或者是Map类型，把参数对象包装成MetaObject，通过getValue获取值。
之后设置参数值。
6.执行SQL语句 ---->> ---- 下边这个 doQuery
7.处理结果集 ---->>-----
再回到 doQuery 方法 看 handler.<E>query(stmt, resultHandler);
@Override
public <E> List<E> query(Statement statement, ResultHandler resultHandler) throws SQLException {
PreparedStatement ps = (PreparedStatement) statement;
ps.execute();
return resultSetHandler.<E> handleResultSets(ps);
}如果有读者发现我说的有不对的地方，还望大家多多指教！
扫一扫
425
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
