mybatis源码分析（三）：mybaits是如何执行一条sql语句的

mybatis代理对象的创建过程

在上一遍 mybatis源码分析（二）：mybatis在执行SQL语句之前都做了什么 中我们通过源码分析看到mybatis是如何构建SqlSessionFactory和SqlSession的。其中我们看到SqlSession在构建的过程中构建了一个Executor，在Executor里包含了大量的数据库操作，于是猜测Executor就是mybatis执行SQL语句的核心组件。

这篇文章我们将继续深入mybatis源码来研究一下mybatis是如何执行一条sql语句的，同时mybatis又是如何处理输入参数和输出结果的。

首先我们写一段测试代码：

执行sql语句的mapper接口：

public interface DistrictMapper {

    District getById(Integer id);
}

mapper对应的sql xml文件：

    
        select * from district where id = #{id}
    

测试用例：

    @Test
    public void testMyBatis() throws IOException {
        //1、得到 SqlSessionFactory
        SqlSessionFactory sqlSessionFactory = getSqlSessionFactory();
        //2、得到 sqlSession ,代表和数据库一次回话
        SqlSession sqlSession = sqlSessionFactory.openSession();
        //3、得到真正操作数据库的Mapper
        DistrictMapper mapper = sqlSession.getMapper(DistrictMapper.class);
        //4.执行方法方法并得到结果
        District district = mapper.getById(1);
        System.out.println(district);
        //5.关闭sqlSession
        sqlSession.close();
    }

上面三段代码我们上一篇文章已经分析过了，今天我们主要是Debug这两段代码：

    //3、得到真正操作数据库的Mapper
    DistrictMapper mapper = sqlSession.getMapper(DistrictMapper.class);
    //4.执行方法方法并得到结果
    District district = mapper.getById(1);

要知道DistrictMapper是一个接口，接口是没办法执行的。

DistrictMapper mapper = sqlSession.getMapper(DistrictMapper.class);

那么这段代码一定是mybatis为我们生成了一个代理对象，我们进去看一下。

public class DefaultSqlSession implements SqlSession {
  @Override
  public  T getMapper(Class type) {
    return configuration.getMapper(type, this);
  }
  ......
}

public class Configuration {

  protected final MapperRegistry mapperRegistry = new MapperRegistry(this);

  public  T getMapper(Class type, SqlSession sqlSession) {
    return mapperRegistry.getMapper(type, sqlSession);
  }
  ......
}

public class MapperRegistry {

  private final Map, MapperProxyFactory> knownMappers = new HashMap<>();

 @SuppressWarnings("unchecked")
 public  T getMapper(Class type, SqlSession sqlSession) {
    final MapperProxyFactory mapperProxyFactory = (MapperProxyFactory) knownMappers.get(type);
    if (mapperProxyFactory == null) {
      throw new BindingException("Type " + type + " is not known to the MapperRegistry.");
    }
    try {
      return mapperProxyFactory.newInstance(sqlSession);
    } catch (Exception e) {
      throw new BindingException("Error getting mapper instance. Cause: " + e, e);
    }
  }
......
}

我把mybatis生成代理对象核心的三个方法摘录下来了，可以看到mybatis并没有直接生成代理对象，而是使用MapperProxyFactory来生成DistrictMapper的代理对象。而MapperProxyFactory是mybatis在构建SqlSessionFactory的时候就已经创建好，并且放入到MapperRegistry这个类的knownMappers属性Map中的。

那么我们可以再来回溯一下MapperProxyFactory的创建过程：

public class XMLMapperBuilder extends BaseBuilder {

  public void parse() {
    if (!configuration.isResourceLoaded(resource)) {
      configurationElement(parser.evalNode("/mapper"));
      configuration.addLoadedResource(resource);
      //用xml的namespace构建mapper
      bindMapperForNamespace();
    }

    parsePendingResultMaps();
    parsePendingCacheRefs();
    parsePendingStatements();
  }

  private void bindMapperForNamespace() {
    String namespace = builderAssistant.getCurrentNamespace();
    if (namespace != null) {
      Class boundType = null;
      try {
        boundType = Resources.classForName(namespace);
      } catch (ClassNotFoundException e) {
        // ignore, bound type is not required
      }
      if (boundType != null && !configuration.hasMapper(boundType)) {
        // Spring may not know the real resource name so we set a flag
        // to prevent loading again this resource from the mapper interface
        // look at MapperAnnotationBuilder#loadXmlResource
        configuration.addLoadedResource("namespace:" + namespace);
        configuration.addMapper(boundType);
      }
    }
  }

 public  void addMapper(Class type) {
    mapperRegistry.addMapper(type);
  }
......
}

public class MapperRegistry {

private final Map, MapperProxyFactory> knownMappers = new HashMap<>();

public  void addMapper(Class type) {
    if (type.isInterface()) {
      if (hasMapper(type)) {
        throw new BindingException("Type " + type + " is already known to the MapperRegistry.");
      }
      boolean loadCompleted = false;
      try {
        knownMappers.put(type, new MapperProxyFactory<>(type));
        // It's important that the type is added before the parser is run
        // otherwise the binding may automatically be attempted by the
        // mapper parser. If the type is already known, it won't try.
        MapperAnnotationBuilder parser = new MapperAnnotationBuilder(config, type);
        parser.parse();
        loadCompleted = true;
      } finally {
        if (!loadCompleted) {
          knownMappers.remove(type);
        }
      }
    }
  }
......
}

可以看到mybatis创建MapperProxyFactory过程是：

1. 加载mybatis配置文件对应的所有mapper.xml路径
2. 解析mapper.xml里所有的namespace标签，根据标签生成对应接口的Class对象
3. 把Class对象作为key，创建MapperProxyFactory对象作为value，然后放进knownMappers里面

同时我们还可以看到mybatis在初始化阶段不光解析了mapper.xml里namespace标签，还解析了ResultMaps、CacheRefs、Statements具体有什么左右我们后面再研究。可以看到mybatis这么设计的好处是可以在项目启动阶段就可以帮你检查出xml和接口对应关系是否正确，同时提前把MapperProxyFactory构建好缓存起来还可以加快后面程序运行的效率。

mybatis是如何为执行SQL语句做准备的

MapperProxyFactory对象已经有了，那么接下来就是mybatis如何执行SQL语句了。

public class MapperProxyFactory {

  private final Class mapperInterface;
  private final Map methodCache = new ConcurrentHashMap<>();

  @SuppressWarnings("unchecked")
  protected T newInstance(MapperProxy mapperProxy) {
    return (T) Proxy.newProxyInstance(mapperInterface.getClassLoader(), new Class[] { mapperInterface }, mapperProxy);
  }

 ......
}

动态代理newProxyInstance核心参数是InvocationHandler，而MapperProxy就是mybatis为InvocationHandler提供的实现类。我们主要去看MapperProxy类的invoke()方法，这个方法就是mybatis执行sql语句的入口。

public class MapperProxy implements InvocationHandler, Serializable {
 @Override
  public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
    try {
      if (Object.class.equals(method.getDeclaringClass())) {
        return method.invoke(this, args);
      } else {
        return cachedInvoker(method).invoke(proxy, method, args, sqlSession);
      }
    } catch (Throwable t) {
      throw ExceptionUtil.unwrapThrowable(t);
    }
  }

  private MapperMethodInvoker cachedInvoker(Method method) throws Throwable {
    try {
      return MapUtil.computeIfAbsent(methodCache, method, m -> {
        if (m.isDefault()) {
          try {
            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 {
          return new PlainMethodInvoker(new MapperMethod(mapperInterface, method, sqlSession.getConfiguration()));
        }
      });
    } catch (RuntimeException re) {
      Throwable cause = re.getCause();
      throw cause == null ? re : cause;
    }
  }

  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);
    }
  }

......
}

可以看到mybatis缓存很多，调用invoke方法的时候mybatis会把目标方法对象给缓存起来，每一个目标方法对应一个私有静态类PlainMethodInvoker再去执行。

public class MapperMethod {

  private final SqlCommand command;
  private final MethodSignature method;

  public MapperMethod(Class mapperInterface, Method method, Configuration config) {
    this.command = new SqlCommand(config, mapperInterface, method);
    this.method = new MethodSignature(config, mapperInterface, method);
  }

  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);
          if (method.returnsOptional()
              && (result == null || !method.getReturnType().equals(result.getClass()))) {
            result = Optional.ofNullable(result);
          }
        }
        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;
  }
......
}

PlainMethodInvoker再去调用MapperMethod的execute方法去执行SQL语句，mybatis的MapperMethod方法相当于整个框架的分拣车间的作用，分拣过程大概做了这几件事：
1.MapperMethod实例化方法会把目标方法的所有信息包装成一个SqlCommand对象
2.根据目标方法执行的SQL类型做判断，通过不同类型去执行对应的SQL逻辑
3.根据查询方法的返回值类型去调用不同查询方法从而可以把查询结果包装成目标方法定义的返回类型
4.根据入参的类型和个数把入参包装成框架方便解析的包装类型

这里可以看到mybatis的一个核心组件：ParamNameResolver参数解析器。

public class ParamNameResolver {
  public static final String GENERIC_NAME_PREFIX = "param";

  public Object getNamedParams(Object[] args) {
    final int paramCount = names.size();
    if (args == null || paramCount == 0) {
      return null;
    } else if (!hasParamAnnotation && paramCount == 1) {
      Object value = args[names.firstKey()];
      return wrapToMapIfCollection(value, useActualParamName ? names.get(0) : null);
    } else {
      final Map param = new ParamMap<>();
      int i = 0;
      for (Map.Entry entry : names.entrySet()) {
        param.put(entry.getValue(), args[entry.getKey()]);
        // add generic param names (param1, param2, ...)
        final String genericParamName = GENERIC_NAME_PREFIX + (i + 1);
        // ensure not to overwrite parameter named with @Param
        if (!names.containsValue(genericParamName)) {
          param.put(genericParamName, args[entry.getKey()]);
        }
        i++;
      }
      return param;
    }
  }


public static Object wrapToMapIfCollection(Object object, String actualParamName) {
    if (object instanceof Collection) {
      ParamMap