Mybatis刨析（mapper实现）

今日无事就研究研究mybatis这个mapper实现方式，一直都知道这就是通过java动态代理实现的，但却不清楚具体的流程，今个就一点点debug看看源码理一理。

先来段java动态代理回顾下

• 先定义个UserMapper接口

// ...
public interface UserMapper {
    @Select({"select username from user where id = #{id}"})
    @ResultType(String.class)
    String findUsername(@Param("id") String id);
}

• 然后一个小巧的动态代理

public static void main(String[] args) {
    ClassLoader classLoader = UserMapper.class.getClassLoader();
    UserMapper instance = (UserMapper) Proxy.newProxyInstance(classLoader, new Class[]{UserMapper.class}, new InvocationHandler() {
        @Override
        public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
            return args[0];
        }
    });
    System.out.println(instance.findUsername("hello, dynamic proxy"));
}

解释下Proxy.newProxyInstance(ClassLoader,Class[],InvocationHandler)方法的三个参数哈
ClassLoader：这是类加载器，用来加载这个类的，一般使用该接口的加载器就行
Class[]：这是参数是指要动态代理的类所实现的所有接口，这里因为就一个UserMapper接口就直接构建个数组就行
InvocationHandler：这是个重点。这里需要传入一个实现java.lang.reflect.InvocationHandler接口的类，该接口里面只有一个invoke方法，每次通过代理类执行方法时都必然调用该方法。也正因此我们才能利用动态代理实现各种增强。
上面那段代码如果执行的话，会看到打印出hello, dynamic proxy。这里并没有usermapper接口的实现类，因为并不需要有对应方法的实际操作。以上可以算是mybatis实现将接口方法与xml或注解的sql语句绑定执行的核心之处了。

下面看看mybtias是怎么做的

• 首先mybatis会借助org.apache.ibatis.binding.MapperRegistry类将所有的接口注册到容器保存
  核心代码

  public <T> void addMapper(Class<T> 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)); // 在mapper容器中新加一个MapperProxyFactory对象
        MapperAnnotationBuilder parser = new MapperAnnotationBuilder(config, type);
        parser.parse();
        loadCompleted = true;
      } finally {
        if (!loadCompleted) {
          knownMappers.remove(type);
        }
      }
    }
  }

• 通过org.apache.ibatis.binding.MapperProxyFactory实例化接口的代理对象

  protected T newInstance(MapperProxy<T> mapperProxy) {
    return (T) Proxy.newProxyInstance(mapperInterface.getClassLoader(), new Class[] { mapperInterface }, mapperProxy);
  }
  public T newInstance(SqlSession sqlSession) {
    final MapperProxy<T> mapperProxy = new MapperProxy<>(sqlSession, mapperInterface, methodCache); // 该类实现了InvocationHandler接口
    return newInstance(mapperProxy);
  }

• 在执行接口方法时，实际是调用MapperProxy中的invoke方法

  @Override
  public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
    try { // 判断下被执行的方法是不是Object对象或接口的默认方法(j8引入的)
      if (Object.class.equals(method.getDeclaringClass())) { 
        return method.invoke(this, args);
      } else if (isDefaultMethod(method)) {
        return invokeDefaultMethod(proxy, method, args);
      }
    } catch (Throwable t) {
      throw ExceptionUtil.unwrapThrowable(t);
    }
    final MapperMethod mapperMethod = cachedMapperMethod(method); 
    return mapperMethod.execute(sqlSession, args); // 执行指定的方法
  }

• 最终被执行的方法长这样

  public Object execute(SqlSession sqlSession, Object[] args) {
    Object result;
    switch (command.getType()) {  // 根据不同的sql语句类型执行对应的方法
      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); // 查询出来结果，这里会对语句进行解析，生成有问号?的sql，并将参数传递
          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;
  }

在这个过程中会通过执行器org.apache.ibatis.executor.SimpleExecutor执行sql语句，语句返回的结果通过结果集处理器org.apache.ibatis.executor.resultset.DefaultResultSetHandler进行处理，最终完成查询以及数据的绑定。