Mybatis源码动态代理调用

解析xml讲完之后，我们开始讲调用了。因为mybatis实际使用了动态代理（阉割版），不过这里的动态代理没有实现类。有关这块设计模式可以找一下看看。

public class Test {

    public static void main(String[] args) throws IOException {
        String resource = "mybatis-config.xml";
        InputStream inputStream = Resources.getResourceAsStream(resource);
        SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder().build(inputStream);
        //获取代理
        PageArticlesMapper pageArticles = sqlSessionFactory.openSession().getMapper(PageArticlesMapper.class);
        //查询
        pageArticles.selectBlog(101);

    }
}

大家在这里注意到了proxy代理了吧，因为在之前解析xml的时候已经对每个xxMapper接口都包装了一个MapperProxyFactory,当从sqlSessionFactory.openSession().getMapper(PageArticlesMapper.class);获取对应的xxMapper时，会进行代理实例化。来看一下

DefaultSqlSession#getMapper

public <T> T getMapper(Class<T> type) {
  return configuration.<T>getMapper(type, this);
}

MapperRegistry#getMapper

//在这里获取对应xxxMapper的代理对象
public <T> T getMapper(Class<T> type, SqlSession sqlSession) {
  //获取的类包装了一层代理工厂
  final MapperProxyFactory<T> mapperProxyFactory = (MapperProxyFactory<T>) 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);
  }
}

正好找到了之前对bean封装的MapperProxyFactory类

public <T> void addMapper(Class<T> type) {
  if (type.isInterface()) {
    //如果已经存在则报错  interface com.telecom.BlogMapper
    if (hasMapper(type)) {
      throw new BindingException("Type " + type + " is already known to the MapperRegistry.");
    }
    boolean loadCompleted = false;
    try {
      //放入map中，并对类型包装一个代理工厂
      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);
      }
    }
  }
}

继续MapperProxyFactory#newInstance

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<T>(sqlSession, mapperInterface, methodCache);
  return newInstance(mapperProxy);
}

然后进入 java.lang.reflect.Proxy#newProxyInstance，大家可以滤过下面这个代码

public static Object newProxyInstance(ClassLoader loader,
                                      Class[] interfaces,
                                      InvocationHandler h)
    throws IllegalArgumentException
{
    Objects.requireNonNull(h);

    final Class[] intfs = interfaces.clone();
    final SecurityManager sm = System.getSecurityManager();
    if (sm != null) {
        checkProxyAccess(Reflection.getCallerClass(), loader, intfs);
    }

    /*
     * Look up or generate the designated proxy class.
     */
    Class cl = getProxyClass0(loader, intfs);

    /*
     * Invoke its constructor with the designated invocation handler.
     */
    try {
        if (sm != null) {
            checkNewProxyPermission(Reflection.getCallerClass(), cl);
        }

        final Constructor cons = cl.getConstructor(constructorParams);
        final InvocationHandler ih = h;
        if (!Modifier.isPublic(cl.getModifiers())) {
            AccessController.doPrivileged(new PrivilegedAction() {
                public Void run() {
                    cons.setAccessible(true);
                    return null;
                }
            });
        }
        return cons.newInstance(new Object[]{h});
    } catch (IllegalAccessException|InstantiationException e) {
        throw new InternalError(e.toString(), e);
    } catch (InvocationTargetException e) {
        Throwable t = e.getCause();
        if (t instanceof RuntimeException) {
            throw (RuntimeException) t;
        } else {
            throw new InternalError(t.toString(), t);
        }
    } catch (NoSuchMethodException e) {
        throw new InternalError(e.toString(), e);
    }
}

继续到Test.java中

MapperProxy实现了InvocationHandler，那当调用这个接口的时候就会触发invoke方法。

MapperProxy#invoke

public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
  try {

    if (Object.class.equals(method.getDeclaringClass())) {
      //如果是从Object继承的方法，直接执行
      return method.invoke(this, args);
      //判断是否是默认方法，默认方法是Java8的新特性，判断逻辑与Java8 Method类的isDefault方法一样
    } else if (isDefaultMethod(method)) {
      //调用默认方法，这里面用到了Java7的API，有兴趣的读者可以自行了解
      return invokeDefaultMethod(proxy, method, args);
    }
  } catch (Throwable t) {
    throw ExceptionUtil.unwrapThrowable(t);
  }
  /*构建并缓存MapperMethod*/
  final MapperMethod mapperMethod = cachedMapperMethod(method);
  /*执行*/
  return mapperMethod.execute(sqlSession, args);
}

private MapperMethod cachedMapperMethod(Method method) {
  //从缓存中获取信息 public abstract com.telecom.Blog com.telecom.BlogMapper.selectBlog(int)
  MapperMethod mapperMethod = methodCache.get(method);
  if (mapperMethod == null) {
    //加入缓存
    mapperMethod = new MapperMethod(mapperInterface, method, sqlSession.getConfiguration());
    methodCache.put(method, mapperMethod);
  }
  return mapperMethod;
}

MapperMethod#execute

//根据type类型执行
public Object execute(SqlSession sqlSession, Object[] args) {
  Object result;
  switch (command.getType()) {
    case INSERT: {
      /*将参数转换为sql命令的参数*/
      Object param = method.convertArgsToSqlCommandParam(args);
      /*插入，返回影响行数的结果*/
      result = rowCountResult(sqlSession.insert(command.getName(), param));
      break;
    }
    case UPDATE: {
      /*将参数转换为sql命令的参数*/
      Object param = method.convertArgsToSqlCommandParam(args);
      /*更新，返回影响行数的结果*/
      result = rowCountResult(sqlSession.update(command.getName(), param));
      break;
    }
    case DELETE: {
      /*将参数转换为sql命令的参数*/
      Object param = method.convertArgsToSqlCommandParam(args);
      /*删除，返回影响行数的结果*/
      result = rowCountResult(sqlSession.delete(command.getName(), param));
      break;
    }
    case SELECT:
      //下面几个分支判断的条件，我们在分析构造MapperMethod的过程时看到了这些波尔条件的赋值过程
      if (method.returnsVoid() && method.hasResultHandler()) {
        /*返回void并且方法包含ResultHandler的查询的执行*/
        executeWithResultHandler(sqlSession, args);
        result = null;
      } else if (method.returnsMany()) {
        /*多个返回值的查询的执行*/
        result = executeForMany(sqlSession, args);
      } else if (method.returnsMap()) {
        /*@MapKey注解的Map类型的返回值的查询的执行*/
        result = executeForMap(sqlSession, args);
      } else if (method.returnsCursor()) {
        /*Cursor游标类型的返回值的查询的执行*/
        result = executeForCursor(sqlSession, args);
      } else {
        /*将参数转换为sql命令的参数*/
        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());
  }
  //命令执行结果为null，并且方法返回值是基本类型抛出异常
  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;
}

到这里，大家看到了增删改查的判断了吧。测试方法走select.

public Object getNamedParams(Object[] args) {
  final int paramCount = names.size();
  if (args == null || paramCount == 0) {
    return null; //解析的参数名称为空，返回null
  } else if (!hasParamAnnotation && paramCount == 1) {
    //没有注解@Param的参数并且解析的参数名称只有一个，根据下标返回参数
    return args[names.firstKey()];
  } else {
    final Map, Object> param = new ParamMap