在前面的章节中，我们学习了mapper接口代理对象是如何生成的，知道了mapper使用了jdk的动态代理技术生成，这篇文章将探讨mapper是如何运行的，在运行过程中都做了哪些事情。
MapperProxy
在前面的源码分析中可以知道，这个类是一个InvocationHandler的实现，代理对象执行的时候，最终会执行到该类的invoke()方法，因此我们直接探讨下该类的方法实现。
invoke()
public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
try {
if (Object.class.equals(method.getDeclaringClass())) {
return method.invoke(this, args);
} else {
return cachedInvoker(method).invoke(proxy, method, args, sqlSession);
}
} catch (Throwable t) {
throw ExceptionUtil.unwrapThrowable(t);
}
}
这个方法的实现是比较简单的，可以分为两个部分：
- 判断执行的方法是否为Object的方法，如果是，则直接执行
- 否则执行
cacheInvoker()方法，该方法返回的是一个MethodInvoker对象，该对象最终实现方法的执行.
cachedInvoker()
private MapperMethodInvoker cachedInvoker(Method method) throws Throwable {
try {
// 返回MapperMethodInvoker对象, 该方法会缓存下来，以防止方法重复调用的时候重复解析
return MapUtil.computeIfAbsent(methodCache, method, m -> {
// 这个判断是判断方法是否为默认方法，因为在1.8之后接口能够有默认实现
// 因此这里做了一个特殊的判断
if (m.isDefault()) {
try {
// 这里主要也是1.8和之后版本的一些差异，在实现上的一些不同
if (privateLookupInMethod == null) {
return new DefaultMethodInvoker(getMethodHandleJava8(method));
} else {
return new DefaultMethodInvoker(getMethodHandleJava9(method));
}
} catch (IllegalAccessException | InstantiationException | InvocationTargetException
| NoSuchMethodException e) {
throw new RuntimeException(e);
}
} else {
// 如果不止默认方法，则返回PlainMethodInvoker
return new PlainMethodInvoker(new MapperMethod(mapperInterface, method, sqlSession.getConfiguration()));
}
});
} catch (RuntimeException re) {
Throwable cause = re.getCause();
throw cause == null ? re : cause;
}
}
在以上代码中可以得知，MethodInvoker有两种类型，分别对应不同的方法执行策略：
- 当执行方法是默认的接口方法时，则使用
DefaultMethodInvoker - 否则使用
PlainMethodInvoker实现来执行方法
在判断方法为接口default定义方法的时候，做了一个版本的区分，这个是JDK提供的查找类方法的一种实现，主要通过MethodHandles配合Lookup来实现的，在1.9之后发生了一些变化，所以这里在做法上有些差异。
DefaultMethodInvoker
默认方法执行主要用来处理接口上的默认方法的执行，因此在默认方法执行的时候，其实与数据库操作关系不大，主要还是看具体方法体的实现。
private static class DefaultMethodInvoker implements MapperMethodInvoker {
private final MethodHandle methodHandle;
public DefaultMethodInvoker(MethodHandle methodHandle) {
super();
this.methodHandle = methodHandle;
}
@Override
public Object invoke(Object proxy, Method method, Object[] args, SqlSession sqlSession) throws Throwable {
return methodHandle.bindTo(proxy).invokeWithArguments(args);
}
}
这里其实可以看出，只是调用了MethodHandle执行方法，因此这里就不做过多阐述。
PlainMethodInvoker
当执行的接口中的方法时，此时该类起到了最终方法执行的承上启下的作用，该类也作为mapper接口方法执行的关键类
private static class PlainMethodInvoker implements MapperMethodInvoker {
private final MapperMethod mapperMethod;
public PlainMethodInvoker(MapperMethod mapperMethod) {
super();
this.mapperMethod = mapperMethod;
}
@Override
public Object invoke(Object proxy, Method method, Object[] args, SqlSession sqlSession) throws Throwable {
return mapperMethod.execute(sqlSession, args);
}
}
MethodInvoker的执行，最终还是通过MapperMethod类来执行，达到预期的效果。
MapperMethod
该类做了接口方法与xml操作SQL语句的映射关系，同时最终将参数与SQL语句合并的实现，该类也是mapper执行的类型，我们先看该类是如何创建的。
构造器
public MapperMethod(Class<?> mapperInterface, Method method, Configuration config) {
this.command = new SqlCommand(config, mapperInterface, method);
this.method = new MethodSignature(config, mapperInterface, method);
}
构造器中包含了两个主要类型，分别是SqlCommand一级MethodSignature类型。这两个类型有什么作用呢?
SqlCommand
public SqlCommand(Configuration configuration, Class<?> mapperInterface, Method method) {
// 获取执行方法的名称
final String methodName = method.getName();
// 获取方法声明类型
final Class<?> declaringClass = method.getDeclaringClass();
// 根据声明类型和方法获取方法与sql的映射实体，这个实体对象实在
// Configuration初始化阶段就已经完成了
MappedStatement ms = resolveMappedStatement(mapperInterface, methodName, declaringClass,
configuration);
// 如果没有包含映射对象
if (ms == null) {
// 判断是否包含Flush注解
if (method.getAnnotation(Flush.class) != null) {
name = null;
type = SqlCommandType.FLUSH;
} else {
// 抛出异常，没有找到映射实体对象
throw new BindingException("Invalid bound statement (not found): "
+ mapperInterface.getName() + "." + methodName);
}
} else {
// 映射对象存在，获取id
name = ms.getId();
// 获取sql操作类型
type = ms.getSqlCommandType();
// 如果sql操作类型无法识别，则抛出异常
if (type == SqlCommandType.UNKNOWN) {
throw new BindingException("Unknown execution method for: " + name);
}
}
}
这个方法功能主要目的在于：
- 通过执行的方法和声明类型确认方法与SQL的映射对象
MappedStatement - 通过
MappedStatement对象确认SQL的操作类型
resolveMappedStatement()
该方法主要是寻找到方法与SQL的映射关系，因为接口可以继承多层次，执行的方法可能会在父接口中，因此这里在解析的时候，需要递归的寻找。
private MappedStatement resolveMappedStatement(Class<?> mapperInterface, String methodName,
Class<?> declaringClass, Configuration configuration) {
// 获取statement的唯一id
String statementId = mapperInterface.getName() + "." + methodName;
// 判断Configuration中是否包含了Statement映射
if (configuration.hasStatement(statementId)) {
// 如果包含，则直接获取
return configuration.getMappedStatement(statementId);
} else if (mapperInterface.equals(declaringClass)) {
// 如果接口对象与方法声明对象是同一个类，就说明该方法已经没有映射,
// 此时直接返回null即可
return null;
}
// 遍历当前接口的所有继承接口列表
for (Class<?> superInterface : mapperInterface.getInterfaces()) {
// 判断当前接口是否为方法声明接口的派生，如果是，则递归解析并获取SQL映射实体
if (declaringClass.isAssignableFrom(superInterface)) {
MappedStatement ms = resolveMappedStatement(superInterface, methodName,
declaringClass, configuration);
if (ms != null) {
return ms;
}
}
}
return null;
}
通过以上分析可以得知，在获取MappedStatement对象的时候，statementId的生成规则为当前接口全限定+".方法名"
- 在没有找到MappedStatement时，如果方法有@Flush接口，则按照Flush操作执行
- 如果没有@Flush接口，这是就会抛出异常
在mybatis中每个方法都需要与sql有映射关系，如果没有这层映射关系，此时的错误并不会在初始化时抛出，而是在执行时抛出异常。
MethodSignature
该类主要记录方法的签名信息，包含了方法的参数，返回值等信息。
public MethodSignature(Configuration configuration, Class<?> mapperInterface, Method method) {
// 这里是解析泛型化参数，获取返回值的具体类型
Type resolvedReturnType = TypeParameterResolver.resolveReturnType(method, mapperInterface);
// 判断类型是否为class对象
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);
// 判断返回的类型是否为Optional
this.returnsOptional = Optional.class.equals(this.returnType);
// 如果返回值为map, 则判断是否包含了MapKey注解，如果包含则返回
this.mapKey = getMapKey(method);
// 是否返回值为Map
this.returnsMap = this.mapKey != null;
// 判断参数是否为RowBounds, 如果是，则返回index信息
this.rowBoundsIndex = getUniqueParamIndex(method, RowBounds.class);
// 判断参数中是否包含ResultHandler, 如果包含怎返回参数所在的位置
this.resultHandlerIndex = getUniqueParamIndex(method, ResultHandler.class);
// 参数名称解析器
this.paramNameResolver = new ParamNameResolver(configuration, method);
}
通过源码可以得知，主要是对方法参数一些特别的类型。例如RowBounds、ResultHandler一些特殊处理，同时也对MapKey注解的解释，这里面比较复杂的是ParamNameResolver的实现，这个是对参数名称的解释，主要看下这个类的实现.
ParamNameResolver
这个类主要是方法参数名称的解析，这里名称主要是在xml配置中能够使用#{}表达式获取参数的一个别名，具体源码如下:
public ParamNameResolver(Configuration config, Method method) {
// 是否使用实际的参数名称，默认值为true
this.useActualParamName = config.isUseActualParamName();
// 参数类型列表
final Class<?>[] paramTypes = method.getParameterTypes();
// 获取方法参数列表
final Annotation[][] paramAnnotations = method.getParameterAnnotations();
final SortedMap<Integer, String> map = new TreeMap<>();
// 参数的数量
int paramCount = paramAnnotations.length;
// get names from @Param annotations
for (int paramIndex = 0; paramIndex < paramCount; paramIndex++) {
// 这里判断是否为特殊的参数，主要判断参数类型是否为
// RowBounds和ResultHandler实现的类，如果是特殊的类，则直接跳过
if (isSpecialParameter(paramTypes[paramIndex])) {
// skip special parameters
continue;
}
String name = null;
// 判断当前参数是否被@Param修饰，如果是，择取@Param的value的值
// 作为参数名称
for (Annotation annotation : paramAnnotations[paramIndex]) {
if (annotation instanceof Param) {
hasParamAnnotation = true;
name = ((Param) annotation).value();
break;
}
}
// 如果没有被@Param修饰
if (name == null) {
// @Param was not specified.
// 如果使用实际的参数名称
if (useActualParamName) {
// 获取实际的参数名称
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中
map.put(paramIndex, name);
}
// 将名称封装称为不可修改
names = Collections.unmodifiableSortedMap(map);
}
执行方法execute()
通过前面分析中，可以知道SqlCommand中包含了SqlCommand和MethodSignature的实例化过程，当这两个类实例化完成后，就来到了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()) {
// 这里判断方法没有返回值，并且包含了ResultHandler时执行
executeWithResultHandler(sqlSession, args);
result = null;
} else if (method.returnsMany()) {
// 返回结合或者数组的时候执行
result = executeForMany(sqlSession, args);
} else if (method.returnsMap()) {
// 返回map时候执行
result = executeForMap(sqlSession, args);
} else if (method.returnsCursor()) {
// 返回指针的时候执行
result = executeForCursor(sqlSession, args);
} else {
// 其他情况
Object param = method.convertArgsToSqlCommandParam(args);
result = sqlSession.selectOne(command.getName(), param);
if (method.returnsOptional()
&& (result == null || !method.getReturnType().equals(result.getClass()))) {
result = Optional.ofNullable(result);
}
}
break;
case FLUSH:
// 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;
}
在上面的执行源码中，有比较多相同方法的调用，例如: convertArgsToSqlCommandParam()、rowCountResult()方法的调用, 这里就优先查看这些公共方法所做的事情，然后再单独看每个操作的个性。
MethodSignature#convertArgsToSqlCommandParam()
这个方法根据名称可以看出，是将方法参数转换为SQL命令参数信息，该方法在MethodSignature中, 我们具体看下是怎么样执行的。
public Object convertArgsToSqlCommandParam(Object[] args) {
return paramNameResolver.getNamedParams(args);
}
该方法的执行最终是由ParamNameResolver来实现的，具体源码如下：
public Object getNamedParams(Object[] args) {
// 这里获取参数的数量，这里的参数是去除了特殊的参数类型的, 即
// RowBounds, ResultHandler
final int paramCount = names.size();
// 方法没有入参，直接返回null
if (args == null || paramCount == 0) {
return null;
} else if (!hasParamAnnotation && paramCount == 1) {
// 这里条件是没有@Param注解，并且参数的长度为1
Object value = args[names.firstKey()];
// 这里判断value的值是否为集合，如果是集合的话，则参数列表中需要特殊处理
// 如果value的类型是collection, 则新增collection的key
// 如果value的类型是List, 则新增List的key
// 如果value的值为Array, 则新增array的key
return wrapToMapIfCollection(value, useActualParamName ? names.get(0) : null);
} else {
// 当包含@Param或者有多个参数时
final Map<String, Object> param = new ParamMap<>();
int i = 0;
for (Map.Entry<Integer, String> entry : names.entrySet()) {
// 设置参数值到map中
param.put(entry.getValue(), args[entry.getKey()]);
// add generic param names (param1, param2, ...)
// 生成通用的参数名称，则是param+索引位置
// 这里其实要注意，这里的参数中的索引其实是没有算上特殊参数索引的
// 因此这里回事一个特殊性
final String genericParamName = GENERIC_NAME_PREFIX + (i + 1);
// ensure not to overwrite parameter named with @Param
// 如果没有包含paramName, 则加入到参数map中
if (!names.containsValue(genericParamName)) {
param.put(genericParamName, args[entry.getKey()]);
}
i++;
}
return param;
}
}
通过上面的源码分析，我们可出一下结论：
- 当参数只有一个并且没有被@Param注解修饰，这是如果参数为集合类型或者数组类型，则可以根据collection、list或者array来获取参数值
- 无论参数是否被@Param注解修饰，都会按照参数索引位置生成
param(index)名称的参数，但是当参数中包含了RowBounds或者ResultHandler时，这个时候参数索引会发生变化，需要排除这两个特殊参数的索引位。
rowCountResult()
该函数是对SQL执行结果的处理，主要是匹配返回值问题，具体源码如下：
private Object rowCountResult(int rowCount) {
// 结果
final Object result;
// 方法没有返回值
if (method.returnsVoid()) {
result = null;
} else if (Integer.class.equals(method.getReturnType()) || Integer.TYPE.equals(method.getReturnType())) {
// 返回值为Integer, 则返回影响行的数量
result = rowCount;
} else if (Long.class.equals(method.getReturnType()) || Long.TYPE.equals(method.getReturnType())) {
// 如果是Long型，返回影响行的数量
result = (long) rowCount;
} else if (Boolean.class.equals(method.getReturnType()) || Boolean.TYPE.equals(method.getReturnType())) {
// 如果是布尔类型，则判断是否影响行数量大于0
result = rowCount > 0;
} else {
// 否则抛出异常
throw new BindingException("Mapper method '" + command.getName() + "' has an unsupported return type: " + method.getReturnType());
}
return result;
}
这个函数通过源码可以知道，这是针对insert、delete、update操作而言，因为这些操作不会返回具体的行数据，而是返回收到影响行的数量，因此都可以通过这种方式处理.
更新数据(INSERT/UPDATE/DELETE)
插入操作顾名思义，就是向数据库中插入数据，insert操作是通过SqlSession来完成的，具体源码如下:
@Override
public int insert(String statement, Object parameter) {
return update(statement, parameter);
}
public int update(String statement, Object parameter) {
try {
dirty = true;
// 获取sql映射语句
MappedStatement ms = configuration.getMappedStatement(statement);
return executor.update(ms, wrapCollection(parameter));
} catch (Exception e) {
throw ExceptionFactory.wrapException("Error updating database. Cause: " + e, e);
} finally {
ErrorContext.instance().reset();
}
}
插入操作也是通过update()方法来完成操作，这里的statement其实是传入的是具体的sql操作的Id的属性，这个值在Configuration中包含了映射关系，因此可以通过id直接从Configuration中获取接口，其次真正执行update操作的是Executor来完成。
在前面的源码中得知，Executor如果我们设定了Interceptor是针对Executor拦截的时候，这个时候Executor其实是一个代理类，这个代理类最终会通过Plugin这个类来完成拦截的处理操作，这里就不做介绍，后面介绍拦截器在介绍拦截器的作用。
Executor#update()
前面在分析Mapper对象创建的时候谈到了Executor的几种类型，大家有兴趣可以去看看之前的文章，这里就以CachingExecutor来作为具体。因为这个类相对于其他功能来说可以联通缓存部分简单介绍。
public int update(MappedStatement ms, Object parameterObject) throws SQLException {
// 判断是否刷新缓存
flushCacheIfRequired(ms);
// 调用update方法
return delegate.update(ms, parameterObject);
}
BaseExecutor
因为CachingExecutor是一个代理对象，只负责一级缓存的管理，因此最终还是要最终的BaseExectuor来执行，update方法都是通过父类来进行定义，具体源码如下:
@Override
public int update(MappedStatement ms, Object parameter) throws SQLException {
ErrorContext.instance().resource(ms.getResource()).activity("executing an update").object(ms.getId());
if (closed) {
throw new ExecutorException("Executor was closed.");
}
// 清楚本地缓存
clearLocalCache();
// 执行更新
return doUpdate(ms, parameter);
}
在这段源码中就看到了对于二级缓存的使用，在执行更新操作的时候，都会先清空本地的二级缓存信息，这里的doUpdate()方法是一个抽象方法，需要具体的Executor实现的时候执行，前面我们介绍过，如果没有特别指定类型，默认为SimpleExecutor类，因此这里只关心这个类，其他类型作用，大家可以自行查看。
SimpleExecutor
public int doUpdate(MappedStatement ms, Object parameter) throws SQLException {
Statement stmt = null;
try {
// 获取Configuration对象
Configuration configuration = ms.getConfiguration();
// 获取StatementHandler对象
StatementHandler handler = configuration.newStatementHandler(this, ms, parameter, RowBounds.DEFAULT, null, null);
// 预编译Statment
stmt = prepareStatement(handler, ms.getStatementLog());
// 执行update
return handler.update(stmt);
} finally {
// 关闭statement
closeStatement(stmt);
}
}
这个方法封装了sql与参数之间的解析环节，并最终获取Statement对象并最终执行update操作，这里主要类型为StatementHandler对象，我们来看看改着如何处理。
Configuration#newStatementHandler()
public StatementHandler newStatementHandler(Executor executor, MappedStatement mappedStatement, Object parameterObject, RowBounds rowBounds, ResultHandler resultHandler, BoundSql boundSql) {
StatementHandler statementHandler = new RoutingStatementHandler(executor, mappedStatement, parameterObject, rowBounds, resultHandler, boundSql);
statementHandler = (StatementHandler) interceptorChain.pluginAll(statementHandler);
return statementHandler;
}
这段代码主要有两个重点：
- 使用RoutingStatementHandler来做statement的处理
- 调用Interceptor对StatementHandler进行处理，这里可能会改变StatementHandler的类型以及内部的一些处理逻辑。
这里对于拦截器相关原理这里不做解析，后面会有专门的章节介绍拦截器的工作原理
prepareStatement()
这个方法就是获取Statement对象的地方，这个就不用多介绍了，JDK的标准API, 大家应该都很熟悉。
private Statement prepareStatement(StatementHandler handler, Log statementLog) throws SQLException {
Statement stmt;
// 获取数据库连接
Connection connection = getConnection(statementLog);
// 预编译statement
stmt = handler.prepare(connection, transaction.getTimeout());
// 对stamt进行参数化
handler.parameterize(stmt);
return stmt;
}
首先是获取数据库连接，然后就是对sql的处理，这个时候需要将SQL中的参数占位符替换为?站位符，具体代码如下;
RoutingStatementHandler#handle()
上面介绍了使用了改了作为SQL的处理方式，这里暂不考虑拦截器带来的影响，我们先看下RoutingStatementHandler初始化的构造方法，里面包含了一些特别的信息。
public RoutingStatementHandler(Executor executor, MappedStatement ms, Object parameter, RowBounds rowBounds, ResultHandler resultHandler, BoundSql boundSql) {
switch (ms.getStatementType()) {
// 参数类型为STATEMENT
case STATEMENT:
delegate = new SimpleStatementHandler(executor, ms, parameter, rowBounds, resultHandler, boundSql);
break;
// PREPARED: 预编译SQL
case PREPARED:
delegate = new PreparedStatementHandler(executor, ms, parameter, rowBounds, resultHandler, boundSql);
break;
// CALLABLE:调用存储过程
case CALLABLE:
delegate = new CallableStatementHandler(executor, ms, parameter, rowBounds, resultHandler, boundSql);
break;
default:
throw new ExecutorException("Unknown statement type: " + ms.getStatementType());
}
}
哈哈哈，到这里就应该明白这个Routing的含义了，其实就是根据操作类型做一些分发操作，那我们主要关注PreparedStatementHandler对象，因为我们大部分情况下为了避免SQL注入带来的问题，都会采用预编译的模式.
PreparedStatementHandler
prepare()
这个方法其实是定义在BaseStatementHandler类中，作为统一处理的模板方法，具体源码如下：
public Statement prepare(Connection connection, Integer transactionTimeout) throws SQLException {
ErrorContext.instance().sql(boundSql.getSql());
Statement statement = null;
try {
// 实例化statement
statement = instantiateStatement(connection);
// 设置超时时间
setStatementTimeout(statement, transactionTimeout);
// 设置fetchsize
setFetchSize(statement);
return statement;
} catch (SQLException e) {
// 关闭statment
closeStatement(statement);
throw e;
} catch (Exception e) {
// 关闭statement
closeStatement(statement);
throw new ExecutorException("Error preparing statement. Cause: " + e, e);
}
}
instantiateStatement()
实例化Statement方法是一个抽象方法，需要具体的子类来实现的，查看具体源码:
@Override
protected Statement instantiateStatement(Connection connection) throws SQLException {
// 获取sql
String sql = boundSql.getSql();
// 调用parepareStatement方法预编译sql
if (mappedStatement.getKeyGenerator() instanceof Jdbc3KeyGenerator) {
String[] keyColumnNames = mappedStatement.getKeyColumns();
if (keyColumnNames == null) {
return connection.prepareStatement(sql, PreparedStatement.RETURN_GENERATED_KEYS);
} else {
return connection.prepareStatement(sql, keyColumnNames);
}
} else if (mappedStatement.getResultSetType() == ResultSetType.DEFAULT) {
return connection.prepareStatement(sql);
} else {
return connection.prepareStatement(sql, mappedStatement.getResultSetType().getValue(), ResultSet.CONCUR_READ_ONLY);
}
}
这里的实例化sql则是直接调用Connection#prepareStatment()方法，执行预编译操作。
parameterize()
前面已经生成预编译SQL，当我们真正执行的时候，就需要传入参数信息，该方法作用就在于对参数进行设置。
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) {
// 参数为null, 则不需要解析
value = null;
} else if (typeHandlerRegistry.hasTypeHandler(parameterObject.getClass())) {
// 判断对于当前参数类型，是否能够处理
value = parameterObject;
} else {
// 将参数解析为MetaObject
MetaObject metaObject = configuration.newMetaObject(parameterObject);
value = metaObject.getValue(propertyName);
}
// 获取当前参数映射的类型处理器
TypeHandler typeHandler = parameterMapping.getTypeHandler();
// 获取目标jdbc类型
JdbcType jdbcType = parameterMapping.getJdbcType();
if (value == null && jdbcType == null) {
jdbcType = configuration.getJdbcTypeForNull();
}
try {
// 这里根据类型处理器执行设置参数的操作，具体类型是根据jdbc类型来定的
// 因此这里暂不做过多解释
typeHandler.setParameter(ps, i + 1, value, jdbcType);
} catch (TypeException | SQLException e) {
throw new TypeException("Could not set parameters for mapping: " + parameterMapping + ". Cause: " + e, e);
}
}
}
}
}
update()
执行更新操作, 当sql参数设置完成后，就可以执行更新了，具体逻辑如下：
public int update(Statement statement) throws SQLException {
PreparedStatement ps = (PreparedStatement) statement;
// 执行更新
ps.execute();
// 更新记录条数
int rows = ps.getUpdateCount();
// 获取参数对象
Object parameterObject = boundSql.getParameterObject();
// 获取key生成器
KeyGenerator keyGenerator = mappedStatement.getKeyGenerator();
// 将生成key放置到参数对象中
keyGenerator.processAfter(executor, mappedStatement, ps, parameterObject);
return rows;
}
上面只是针对INSERT做了个解析，其他UPDATE/DELETE都是调用更新方法实现的，因此基本类似，这里就不做过多的阐述.
查询数据(SELECT)
查询数据相对于其他操作而言，最困难的在于对结果的解析，以及返回期望的对象，在查询的时候，代码片段为：
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);
if (method.returnsOptional()
&& (result == null || !method.getReturnType().equals(result.getClass()))) {
result = Optional.ofNullable(result);
}
}
break;
executeWithResultHandler()无参返回
对于查询而言，当方法放回void的时候，这时候在方法参数中可能会有ResultHandler实现，通过ResultHandler实现对结果的解析，具体代码如下：
private void executeWithResultHandler(SqlSession sqlSession, Object[] args) {
// 获取sql映射对象
MappedStatement ms = sqlSession.getConfiguration().getMappedStatement(command.getName());
// 判断当前的执行并不是callable操作, 并且返回值为void是，这时就会抛出异常
if (!StatementType.CALLABLE.equals(ms.getStatementType())
&& void.class.equals(ms.getResultMaps().get(0).getType())) {
throw new BindingException("method " + command.getName()
+ " needs either a @ResultMap annotation, a @ResultType annotation,"
+ " or a resultType attribute in XML so a ResultHandler can be used as a parameter.");
}
// 设置sql参数映射
Object param = method.convertArgsToSqlCommandParam(args);
// 判断方法是否包含了RowBounds的实现
if (method.hasRowBounds()) {
// 获取RowBounds
RowBounds rowBounds = method.extractRowBounds(args);
// 调用select方法
sqlSession.select(command.getName(), param, rowBounds, method.extractResultHandler(args));
} else {
// 调用select方法
sqlSession.select(command.getName(), param, method.extractResultHandler(args));
}
}
executeForMany()
处理查询结果为结合的操作，具体源码如下:
private <E> Object executeForMany(SqlSession sqlSession, Object[] args) {
List<E> result;
// 获取参数对象
Object param = method.convertArgsToSqlCommandParam(args);
// 判断参数是否包含RowBounds
if (method.hasRowBounds()) {
// 获取RowBounds
RowBounds rowBounds = method.extractRowBounds(args);
// 调用selectList接口
result = sqlSession.selectList(command.getName(), param, rowBounds);
} else {
result = sqlSession.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;
}
executeForMap()
该方法用于处理返回结果为Map的方法，具体实现如下：
private <K, V> Map<K, V> executeForMap(SqlSession sqlSession, Object[] args) {
Map<K, V> result;
// 获取参数
Object param = method.convertArgsToSqlCommandParam(args);
// 是否包含了RowBounds
if (method.hasRowBounds()) {
// 获取参数中的RowBounds
RowBounds rowBounds = method.extractRowBounds(args);
// 调用SelectMap
result = sqlSession.selectMap(command.getName(), param, method.getMapKey(), rowBounds);
} else {
result = sqlSession.selectMap(command.getName(), param, method.getMapKey());
}
return result;
}
executeForCursor()
该方法主要用于返回类型为指针时，具体处理源码如下：
private <T> Cursor<T> executeForCursor(SqlSession sqlSession, Object[] args) {
Cursor<T> result;
Object param = method.convertArgsToSqlCommandParam(args);
if (method.hasRowBounds()) {
RowBounds rowBounds = method.extractRowBounds(args);
result = sqlSession.selectCursor(command.getName(), param, rowBounds);
} else {
result = sqlSession.selectCursor(command.getName(), param);
}
return result;
}
对于这种情况，只是返回的方法不一样的而已，因此这里就不做过多介绍。
处理返回单个值
// 包装参数对象
Object param = method.convertArgsToSqlCommandParam(args);
// 返回一个值
result = sqlSession.selectOne(command.getName(), param);
// 判断返回值是否为Optional, 如果是则用Optional包装
if (method.returnsOptional()
&& (result == null || !method.getReturnType().equals(result.getClass()))) {
result = Optional.ofNullable(result);
}
对于以上代码中可以得知，其实一共就集中情况：
- 返回单个值或者
Optional - 返回
Map结果集 - 返回
Collection - 返回
Cursor结果集
这些在SqlSession中都有对应的包装类，因此我们查看对应的方法就行。
SqlSession
通过对于源码分析，在查询中一共可以分为三类，分别为selectList, selectCursor, selectMap三种，因此我们只对这三个公共方法做介绍。
selectList
private <E> List<E> selectList(String statement, Object parameter, RowBounds rowBounds, ResultHandler handler) {
try {
// 获取sql映射对象
MappedStatement ms = configuration.getMappedStatement(statement);
// 通过executor执行查询插座
return executor.query(ms, wrapCollection(parameter), rowBounds, handler);
} catch (Exception e) {
throw ExceptionFactory.wrapException("Error querying database. Cause: " + e, e);
} finally {
ErrorContext.instance().reset();
}
}
这里最终的查询还是交予了Executor完成，如更新操作一样，我们这里还是以CachingExecutor和SimpleExecutor来看源码，其他类型的实现，可以自己查看源码。
CachingExecutor
public <E> List<E> query(MappedStatement ms, Object parameterObject, RowBounds rowBounds, ResultHandler resultHandler) throws SQLException {
// 根据参数生成动态SQL
BoundSql boundSql = ms.getBoundSql(parameterObject);
// 生成缓存key
CacheKey key = createCacheKey(ms, parameterObject, rowBounds, boundSql);
// 执行查询
return query(ms, parameterObject, rowBounds, resultHandler, key, boundSql);
}
query()
public <E> List<E> query(MappedStatement ms, Object parameterObject, RowBounds rowBounds, ResultHandler resultHandler, CacheKey key, BoundSql boundSql)
throws SQLException {
// 获取映射文件中的cache对象
Cache cache = ms.getCache();
if (cache != null) {
// 判断是否需要刷新缓存，如果需要，则刷新
flushCacheIfRequired(ms);
// 如果使用缓存，则从缓存中虎丘
if (ms.isUseCache() && resultHandler == null) {
// 确定没有输出参数
ensureNoOutParams(ms, boundSql);
@SuppressWarnings("unchecked")
// 根据缓存key获取缓存列表
List<E> list = (List<E>) 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);
}
这里我们知道，CachingExecutor是使用了代理模式，因此这里真正执行查询的是SimpleExecutor对象，因此我们查看SimpleExecutor对象的查询代码。
SimpleExecutor
这里查询最终还是会走BaseExecutor的模板方法，具体代码如下：
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.");
}
// 判断在同一个session下，查询被调用的次数，如果为0，并且需要清空缓存，则清空本地缓存
if (queryStack == 0 && ms.isFlushCacheRequired()) {
clearLocalCache();
}
List<E> list;
try {
// 查询栈递增
queryStack++;
// 如果ResultHandler为空，则从缓存中获取，否则为null
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) {
// 递归加载，主要用来处理夸namespace的关联查询逻辑
for (DeferredLoad deferredLoad : deferredLoads) {
deferredLoad.load();
}
// issue #601
deferredLoads.clear();
// 如果本地缓存类型为STATEMENT级别，则在执行完成后，清空缓存。默认为SESSION
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);
// 如果执行类型为Callable, 则加入输出参数缓存
if (ms.getStatementType() == StatementType.CALLABLE) {
localOutputParameterCache.putObject(key, parameter);
}
return list;
}
这里的doQuery()操作会调用到子类的实现方法上，我们查看doQuery()方法的逻辑实现：
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.query(stmt, resultHandler);
} finally {
closeStatement(stmt);
}
}
这里跟上面保持一样，我们只关注PreparedStatementHandler对象的实现，其他的类感兴趣可以查看对应的源码。
PreparedStatementHandler
query()
查询逻辑就是执行具体的查询逻辑实现, 具体代码如下:
public <E> List<E> query(Statement statement, ResultHandler resultHandler) throws SQLException {
PreparedStatement ps = (PreparedStatement) statement;
// 执行查询操作
ps.execute();
// 处理结果集
return resultSetHandler.handleResultSets(ps);
}
ResultSetHandler
结果集处理是从ResultSet中读取结果，并封装为对应的对象返回即可。
public List<Object> handleResultSets(Statement stmt) throws SQLException {
ErrorContext.instance().activity("handling results").object(mappedStatement.getId());
final List<Object> multipleResults = new ArrayList<>();
int resultSetCount = 0;
// 获取ResultSet, 并封装到ResultSetWrapper中
ResultSetWrapper rsw = getFirstResultSet(stmt);
// 获取映射配置中的结果集
List<ResultMap> resultMaps = mappedStatement.getResultMaps();
int resultMapCount = resultMaps.size();
// 判断结果集以及ResultMap配置是否合法
validateResultMapsCount(rsw, resultMapCount);
// 当配置中包含ResultMap时
while (rsw != null && resultMapCount > resultSetCount) {
// 获取ResultMap配置
ResultMap resultMap = resultMaps.get(resultSetCount);
// 处理ResultSet, 并按照ResultMap封装对象
handleResultSet(rsw, resultMap, multipleResults, null);
// 处理下一个结果集
rsw = getNextResultSet(stmt);
// 清空正在处理结果集信息
cleanUpAfterHandlingResultSet();
// 处理结果集数量+1
resultSetCount++;
}
// 获取结果集信息
String[] resultSets = mappedStatement.getResultSets();
// 如果结果集不为空
if (resultSets != null) {
// 开始处理结果集
while (rsw != null && resultSetCount < resultSets.length) {
// 获取ResultSet中配置的resultMapping信息
ResultMapping parentMapping = nextResultMaps.get(resultSets[resultSetCount]);
if (parentMapping != null) {
// 如果包含Result映射信息,获取嵌套结果集???
String nestedResultMapId = parentMapping.getNestedResultMapId();
// 获取结果集映射, 处理结果
ResultMap resultMap = configuration.getResultMap(nestedResultMapId);
handleResultSet(rsw, resultMap, null, parentMapping);
}
// 处理下一个结果集
rsw = getNextResultSet(stmt);
// 清楚正在处理的结果集
cleanUpAfterHandlingResultSet();
resultSetCount++;
}
}
// 当集合为1的时候，返回第一个元素，否则返回基本本身
return collapseSingleResultList(multipleResults);
}
这里对于结果的处理主要使用了handleResultSet()方法处理，并将结果加入到列表中，
handleResultSet()
private void handleResultSet(ResultSetWrapper rsw, ResultMap resultMap, List<Object> multipleResults, ResultMapping parentMapping) throws SQLException {
try {
// 是否包含父映射
if (parentMapping != null) {
handleRowValues(rsw, resultMap, null, RowBounds.DEFAULT, parentMapping);
} else {
if (resultHandler == null) {
// 如果ResultHandler为空，则使用默认结果处理器
DefaultResultHandler defaultResultHandler = new DefaultResultHandler(objectFactory);
handleRowValues(rsw, resultMap, defaultResultHandler, rowBounds, null);
multipleResults.add(defaultResultHandler.getResultList());
} else {
// 处理单行数据
handleRowValues(rsw, resultMap, resultHandler, rowBounds, null);
}
}
} finally {
// issue #228 (close resultsets)
closeResultSet(rsw.getResultSet());
}
}
这里可以知道，单行数据的处理使用了handleRowValues()来实现，因此着了我们具体看下该方法的实现。
handleRowValues()
public void handleRowValues(ResultSetWrapper rsw, ResultMap resultMap, ResultHandler<?> resultHandler, RowBounds rowBounds, ResultMapping parentMapping) throws SQLException {
// 判断结果集是否为前端结果集
if (resultMap.hasNestedResultMaps()) {
// 对于嵌套实现而言，不能有RowBounds, 除非将safeRowBoundsEnabled=false
ensureNoRowBounds();
// 检查ResultHandler
checkResultHandler();
// 处理嵌套结果集
handleRowValuesForNestedResultMap(rsw, resultMap, resultHandler, rowBounds, parentMapping);
} else {
handleRowValuesForSimpleResultMap(rsw, resultMap, resultHandler, rowBounds, parentMapping);
}
}
handleRowValuesForNestedResultMap()
该方法有兴趣的可以自己查看下源码....
handleRowValuesForSimpleResultMap()
处理结果继续，具体源码如下:
private void handleRowValuesForSimpleResultMap(ResultSetWrapper rsw, ResultMap resultMap, ResultHandler<?> resultHandler, RowBounds rowBounds, ResultMapping parentMapping)
throws SQLException {
// 结果集上下文
DefaultResultContext<Object> resultContext = new DefaultResultContext<>();
// 获取结果集
ResultSet resultSet = rsw.getResultSet();
// 这里实际上就是内存分页，当包含了rowBounds信息是，需要跳过Offset条记录
skipRows(resultSet, rowBounds);
// 这里是个条件，判断ResultSet还有数据，并且没有超过RowBounds限制的记录条数
while (shouldProcessMoreRows(resultContext, rowBounds) && !resultSet.isClosed() && resultSet.next()) {
// 获取结果映射集
ResultMap discriminatedResultMap = resolveDiscriminatedResultMap(resultSet, resultMap, null);
// 将行数据组装到ResultMap结果中
Object rowValue = getRowValue(rsw, discriminatedResultMap, null);
// 保存结果。
storeObject(resultHandler, resultContext, rowValue, parentMapping, resultSet);
}
}
getRowValue()
private Object getRowValue(ResultSetWrapper rsw, ResultMap resultMap, String columnPrefix) throws SQLException {
final ResultLoaderMap lazyLoader = new ResultLoaderMap();
// 创建ResultObject对象
Object rowValue = createResultObject(rsw, resultMap, lazyLoader, columnPrefix);
// 判断类型是否包含了ResultHandler的实现
if (rowValue != null && !hasTypeHandlerForResultObject(rsw, resultMap.getType())) {
final MetaObject metaObject = configuration.newMetaObject(rowValue);
// 是否包含了构造器参数映射
boolean foundValues = this.useConstructorMappings;
// 判断是否自动映射，这里根据ResultMap来做判断，
if (shouldApplyAutomaticMappings(resultMap, false)) {
// 自动映射，其实就是根据sql中的字段名称去匹配在resultObject中是否包含对应的属性
// 以及对应的setter方法，因此这里不做过多阐述
foundValues = applyAutomaticMappings(rsw, resultMap, metaObject, columnPrefix) || foundValues;
}
// 这里处理带有prefix的属性，以及嵌套查询的逻辑实现
foundValues = applyPropertyMappings(rsw, resultMap, metaObject, lazyLoader, columnPrefix) || foundValues;
foundValues = lazyLoader.size() > 0 || foundValues;
rowValue = foundValues || configuration.isReturnInstanceForEmptyRow() ? rowValue : null;
}
return rowValue;
}
createResultObject()
private Object createResultObject(ResultSetWrapper rsw, ResultMap resultMap, ResultLoaderMap lazyLoader, String columnPrefix) throws SQLException {
this.useConstructorMappings = false; // reset previous mapping result
final List<Class<?>> constructorArgTypes = new ArrayList<>();
final List<Object> constructorArgs = new ArrayList<>();
// 结果对象
Object resultObject = createResultObject(rsw, resultMap, constructorArgTypes, constructorArgs, columnPrefix);
// 是否包含ResultHandler, 不包含怎使用set方法设置属性
if (resultObject != null && !hasTypeHandlerForResultObject(rsw, resultMap.getType())) {
final List<ResultMapping> propertyMappings = resultMap.getPropertyResultMappings();
// 设置对象参数属性
for (ResultMapping propertyMapping : propertyMappings) {
// issue gcode #109 && issue #149
if (propertyMapping.getNestedQueryId() != null && propertyMapping.isLazy()) {
resultObject = configuration.getProxyFactory().createProxy(resultObject, lazyLoader, configuration, objectFactory, constructorArgTypes, constructorArgs);
break;
}
}
}
// 当对象创建成功，并且使用了构造器设置参数，则为true
this.useConstructorMappings = resultObject != null && !constructorArgTypes.isEmpty(); // set current mapping result
return resultObject;
}
createResultObject() 创建ResultObject
创建结果对象最终会执行到该方法，该方法中是对结果集的处理，具体源码如下：
private Object createResultObject(ResultSetWrapper rsw, ResultMap resultMap, List<Class<?>> constructorArgTypes, List<Object> constructorArgs, String columnPrefix)
throws SQLException {
// 获取结果对象类型
final Class<?> resultType = resultMap.getType();
// 获取对象的元数据信息
final MetaClass metaType = MetaClass.forClass(resultType, reflectorFactory);
// 获取结果集的构造器配置信息
final List<ResultMapping> constructorMappings = resultMap.getConstructorResultMappings();
// 判断是否对于结果类型，有对应的ResultHandler处理
if (hasTypeHandlerForResultObject(rsw, resultType)) {
// 如果有对应的类型处理，则穿件基本类型结果对象
return createPrimitiveResultObject(rsw, resultMap, columnPrefix);
} else if (!constructorMappings.isEmpty()) {
// 判断是否包含了构造器的映射，如果包含，则按照构造器映射创建对象
return createParameterizedResultObject(rsw, resultType, constructorMappings, constructorArgTypes, constructorArgs, columnPrefix);
} else if (resultType.isInterface() || metaType.hasDefaultConstructor()) {
// 如果对象是接口或者包含了默认构造器，则使用ObjecctFactory创建对象
return objectFactory.create(resultType);
} else if (shouldApplyAutomaticMappings(resultMap, false)) {
return createByConstructorSignature(rsw, resultType, constructorArgTypes, constructorArgs);
}
throw new ExecutorException("Do not know how to create an instance of " + resultType);
}
selectMap
该方法主要是返回结果集为Map对象，因此这里查看下对应源码即可：
这里要注意，selectMap并不是按照返回值为map时调用，而是使用了@MapKey注解的时候，才会走这个逻辑。
public <K, V> Map<K, V> selectMap(String statement, Object parameter, String mapKey, RowBounds rowBounds) {
// 这里和以上的查询类似，就不做过多阐述
final List<? extends V> list = selectList(statement, parameter, rowBounds);
final DefaultMapResultHandler<K, V> mapResultHandler = new DefaultMapResultHandler<>(mapKey,
configuration.getObjectFactory(), configuration.getObjectWrapperFactory(), configuration.getReflectorFactory());
final DefaultResultContext<V> context = new DefaultResultContext<>();
for (V o : list) {
// 遍历每一个元素，并放入到上下文中
context.nextResultObject(o);
// 处理单个对象结果
mapResultHandler.handleResult(context);
}
// 返回map的结果
return mapResultHandler.getMappedResults();
}
DefaultMapResultHandler
这里查看下这个是如何将一个对象映射成为map对象的。
public void handleResult(ResultContext<? extends V> context) {
// 获取结果对象
final V value = context.getResultObject();
// 获取结果对象的元数据信息
final MetaObject mo = MetaObject.forObject(value, objectFactory, objectWrapperFactory, reflectorFactory);
// TODO is that assignment always true?
// 这里获取mapKey, 这个mapKey是可能为null的
final K key = (K) mo.getValue(mapKey);
// 加入到结果集
mappedResults.put(key, value);
}
selectCursor
查询指针的是由mybatis实现的，在处理查询的逻辑的时候基本保持一致，这里主要看下对结果集的封装情况。
public <E> Cursor<E> handleCursorResultSets(Statement stmt) throws SQLException {
ErrorContext.instance().activity("handling cursor results").object(mappedStatement.getId());
ResultSetWrapper rsw = getFirstResultSet(stmt);
List<ResultMap> resultMaps = mappedStatement.getResultMaps();
int resultMapCount = resultMaps.size();
validateResultMapsCount(rsw, resultMapCount);
if (resultMapCount != 1) {
throw new ExecutorException("Cursor results cannot be mapped to multiple resultMaps");
}
ResultMap resultMap = resultMaps.get(0);
// 创建Cursor对象
return new DefaultCursor<>(this, resultMap, rsw, rowBounds);
}
这里就不详细介绍cursor的使用，如果有兴趣可以自己查看一下源码。
文章点赞
以上就是Mapper的执行原理，如果对你有帮助，请为文章点赞.
文章评论