【mybatis源码解析】(一)mybatis执行流程以及实现原理

系列文章目录

第一章 mybatis执行流程以及实现原理

---

---

前言

---

不多说，直接开始

提示：以下是本篇文章正文内容，下面案例可供参考

一、先搭建样例demo测试，这里参考了另一篇文章简单搭建测试环境

https://mp.weixin.qq.com/s/x8UKwuOFg5laSGrJH1L2tQ

二、开始解析

1.先看这段代码执行过程

第一步就不用说了，加载配置文件

打断点开始源码，从第二步开始，创建SqlSessionFactoryBuilder工厂类

那么这个SqlSessionFactoryBuilder工厂类是干什么的么
这里用到了工厂模式用来创建SqlSessionFactory，我们看下SqlSessionFactoryBuilder源码

/**
 * Builds {@link SqlSession} instances.
 *
 * @author Clinton Begin
 */
public class
SqlSessionFactoryBuilder {

  public SqlSessionFactory build(Reader reader) {
    return build(reader, null, null);
  }
	
  public SqlSessionFactory build(Reader reader, String environment) {
    return build(reader, environment, null);
  }

  public SqlSessionFactory build(Reader reader, Properties properties) {
    return build(reader, null, properties);
  }

  public SqlSessionFactory build(Reader reader, String environment, Properties properties) {
    try {
      XMLConfigBuilder parser = new XMLConfigBuilder(reader, environment, properties);
      return build(parser.parse());
    } catch (Exception e) {
      throw ExceptionFactory.wrapException("Error building SqlSession.", e);
    } finally {
      ErrorContext.instance().reset();
      try {
        reader.close();
      } catch (IOException e) {
        // Intentionally ignore. Prefer previous error.
      }
    }
  }

  public SqlSessionFactory build(InputStream inputStream) {
    return build(inputStream, null, null);
  }

  public SqlSessionFactory build(InputStream inputStream, String environment) {
    return build(inputStream, environment, null);
  }

  public SqlSessionFactory build(InputStream inputStream, Properties properties) {
    return build(inputStream, null, properties);
  }

  public SqlSessionFactory build(InputStream inputStream, String environment, Properties properties) {
    try {
      XMLConfigBuilder parser = new XMLConfigBuilder(inputStream, environment, properties);
      return build(parser.parse());
    } catch (Exception e) {
      throw ExceptionFactory.wrapException("Error building SqlSession.", e);
    } finally {
      ErrorContext.instance().reset();
      try {
        inputStream.close();
      } catch (IOException e) {
        // Intentionally ignore. Prefer previous error.
      }
    }
  }

  public SqlSessionFactory build(Configuration config) {
    return new DefaultSqlSessionFactory(config);
  }

}

其实是提供了几种不同的创建SqlSessionFactory的方法
来看一下相关uml图，有助于后面理解

下面我们看build(in)方法都做了什么，进入断点

到这一步，又调了其他build方法，继续进入

发现创建了通过xml方式生成的XMLConfigBuilder类，里面存的有相关配置，继续往下，看build（parser）方法

发现有点用了下面的方法

到这里我们可以看出来最终通过配置创建了DefaultSqlSessionFactory对象，也就是mybatis默认生成的工厂

factory.openSession()方法做了什么

进入该方法

这里的configuration.getDefaultExecutorType()返货默认的执行器类型为SIMPLE
继续往下

这里创建了Transaction，然后最主要的是创建了DefaultSqlSession对象，这个对象比较关键。
Transaction留到后面文章讲解

这是DefaultSqlSession对象的一些属性

session.getMapper(IUserDao.class)方法做了什么

首先我们应该知道IUserDao是一个接口，没有实现类
进入该方法

发现调用的configuration的方法，继续往下

发现configuration又掉用了mapperRegistry.getMapper。并且mapperRegistry属性上有个knownMappers
，其实configuration和mapperRegistry都是再上一步加载配置文件时初始化过，所以这里都有相关属性，初始化加载这里不做说明了
knownMappers是一个Map
进入该方法

这里knownMappers通过key（就是接口类对象） 来获取MapperProxyFactory，若果没有就抛出异常
继续往下，查看mapperProxyFactory.newInstance方法

发现这里通过sqlSession, mapperInterface, methodCache创建了MapperProxy对象sqlSession就是上面创建的DefaultSqlSession。mapperInterface就是接口类对象
查看DefaultSqlSession源码

/**
 * @author Clinton Begin
 * @author Eduardo Macarron
 */
public class MapperProxy<T> implements InvocationHandler, Serializable {

  private static final long serialVersionUID = -4724728412955527868L;
  private static final int ALLOWED_MODES = MethodHandles.Lookup.PRIVATE | MethodHandles.Lookup.PROTECTED
      | MethodHandles.Lookup.PACKAGE | MethodHandles.Lookup.PUBLIC;
  private static final Constructor<Lookup> lookupConstructor;
  private static final Method privateLookupInMethod;
  private final SqlSession sqlSession;
  private final Class<T> mapperInterface;
  private final Map<Method, MapperMethodInvoker> methodCache;

  public MapperProxy(SqlSession sqlSession, Class<T> mapperInterface, Map<Method, MapperMethodInvoker> methodCache) {
    this.sqlSession = sqlSession;
    this.mapperInterface = mapperInterface;
    this.methodCache = methodCache;
  }

  static {
    Method privateLookupIn;
    try {
      privateLookupIn = MethodHandles.class.getMethod("privateLookupIn", Class.class, MethodHandles.Lookup.class);
    } catch (NoSuchMethodException e) {
      privateLookupIn = null;
    }
    privateLookupInMethod = privateLookupIn;

    Constructor<Lookup> lookup = null;
    if (privateLookupInMethod == null) {
      // JDK 1.8
      try {
        lookup = MethodHandles.Lookup.class.getDeclaredConstructor(Class.class, int.class);
        lookup.setAccessible(true);
      } catch (NoSuchMethodException e) {
        throw new IllegalStateException(
            "There is neither 'privateLookupIn(Class, Lookup)' nor 'Lookup(Class, int)' method in java.lang.invoke.MethodHandles.",
            e);
      } catch (Exception e) {
        lookup = null;
      }
    }
    lookupConstructor = lookup;
  }

  @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 MethodHandle getMethodHandleJava9(Method method)
      throws NoSuchMethodException, IllegalAccessException, InvocationTargetException {
    final Class<?> declaringClass = method.getDeclaringClass();
    return ((Lookup) privateLookupInMethod.invoke(null, declaringClass, MethodHandles.lookup())).findSpecial(
        declaringClass, method.getName(), MethodType.methodType(method.getReturnType(), method.getParameterTypes()),
        declaringClass);
  }

  private MethodHandle getMethodHandleJava8(Method method)
      throws IllegalAccessException, InstantiationException, InvocationTargetException {
    final Class<?> declaringClass = method.getDeclaringClass();
    return lookupConstructor.newInstance(declaringClass, ALLOWED_MODES).unreflectSpecial(method, declaringClass);
  }

  interface MapperMethodInvoker {
    Object invoke(Object proxy, Method method, Object[] args, SqlSession sqlSession) throws Throwable;
  }

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

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

发现它实现了InvocationHandler。也就是这里用到的就是java动态代理相关的知识

关键方法先简单看看，后面执行要用到

继续往下

可以看到创建了mapper接口的代理对象

userDao.findAll()方法怎么执行的

上一步我们知道了userDao其实就是个代理对象
我们打断点继续往下

发现他来到了这一步，其实就是MapperProxy的invoke方法，作用如下

  @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 {//cachedInvoker返回MapperMethodInvoker队形用于执行
        return cachedInvoker(method).invoke(proxy, method, args, sqlSession);
      }
    } catch (Throwable t) {
      throw ExceptionUtil.unwrapThrowable(t);
    }
  }

我们看下MapperMethodInvoker源码

private MapperMethodInvoker cachedInvoker(Method method) throws Throwable {
    try {
      return MapUtil.computeIfAbsent(methodCache, method, m -> {
        if (m.isDefault()) {//如果是default方法
          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 {//不是的话就创建PlainMethodInvoker
          return new PlainMethodInvoker(new MapperMethod(mapperInterface, method, sqlSession.getConfiguration()));
        }
      });
    } catch (RuntimeException re) {
      Throwable cause = re.getCause();
      throw cause == null ? re : cause;
    }
  }

可以看出对于非default方法cachedInvoker(method)返回了一个PlainMethodInvoker
所以继续往下就进入了PlainMethodInvoker的invoke方法

继续往下


如果是查询多个就到了这个方法，继续

这里解释一下

  private <E> Object executeForMany(SqlSession sqlSession, Object[] args) {
    List<E> result;
    Object param = method.convertArgsToSqlCommandParam(args);//将 Args 转换为 Sql 命令参数
    if (method.hasRowBounds()) {//如果有分页之类的
      RowBounds rowBounds = method.extractRowBounds(args);
      result = sqlSession.selectList(command.getName(), param, rowBounds);
    } else {
      result = sqlSession.selectList(command.getName(), param);//执行sqlSession的selectlist方法
    }
    // 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;
  }

进入sqlSession.selectList方法

继续

继续

MappedStatement对象封装了执行的sql语句，具体实现后面文章讲解
继续往下


这里判断是否走缓存

最终到了BaseExecutor的query方法

判断是否有缓存，没有就到了这个方法，进入

又调用了子类SimpleExecutor的doquery方法，继续

继续往下

继续往下

这里实际上就是JDBC的相关查询调用了
resultSetHandler.handleResultSets(ps)处理结果转化为实体类返回，具体实现篇幅原因这里先不介绍了
，后面再说

总结

至此一次完整的查询流程大概就这么多步骤吧，要详细讲完估计后面还得几篇文章