前言

Mybatis中可以使用一个interface加上一个xml文件，通过这两种东西可以操纵数据库，其中xml文件写着sql语句。达到优化JDBC的目地。

那么是如何做到接口调用就可以执行相应的sql语句呢？而且注意这里的接口没有任何的实体，也就是说没有任何实现这个接口的类(其实也不需要这样的一个类)。

可以用一个代理。这个代理实现了这个相应的接口，比如下面的UserDao接口。但是代理对每一个UserDao的方法的控制和实现，或者说做的事情是这么一回事：就是将接口调用的相应的方法名找到对应的sql语句，然后执行这个sql语句。这件事情在源代码中的实现其实是MapperProxy来实现的。

通过上面这种代理实现就可以将接口和sql语句进行了分离。虽然这里实现的动态代理没有使用到RealSubject这种东西与我原来想的有点不同呢。最后可以像下面这样来写，用一个接口UserDao来声明，然后用一个代理user去执行。代理需要的只是这个方法名字和参数。最后可以通过名字找到想对应命名空间(与Dao类同名)中的sql语句(与方法同名)。

UserDao userMapper = sqlSession.getMapper(UserDao.class);
User user = userMapper = findUserById(2);

但是数据源或者说数据库的打开和关闭以及参数传递和结果集的映射还没有看到具体的源代码在哪里。

首先来宏观的把握一下，涉及到的类的作用。

binding包

mybatis中的binding包.png

• BindException：定义了一些这个包中自己的异常。
• MapperMethod：当动态代理执行相应的方法时，会使用到。封装了方法中的一些东西，比如返回类型，个数。
• MapperProxy：动态代理中需要的InvocationHandler类
• MapperProxyFactory：产生动态代理的工厂
• MapperRegistry：？

执行流程

执行时序图.png

Mybatis中，通过MapperProxy动态代理我们的dao，也就是说执行自己写的dao的方法时候，实际对应的是mapperProxy在代理，这里使用的是Java内置的动态代理技术。那么，源代码是怎么获取MapperProxy对象的呢？
（1）通过SqlSession从Configuration中获取。源码如下：

/** * 什么都不做，直接去configuration中找， 哥就是这么任性 */ 
@Override
public <T> T getMapper(Class<T> type) 
{ 
     return configuration.<T>getMapper(type, this);
}

（2）SqlSession把包袱甩给了Configuration, 接下来就看看Configuration。源码如下：

/**
   * 烫手的山芋，俺不要，你找mapperRegistry去要
   * @param type
   * @param sqlSession
   * @return
   */
  public <T> T getMapper(Class<T> type, SqlSession sqlSession) {
    return mapperRegistry.getMapper(type, sqlSession);
  }

（3）Configuration不要这烫手的山芋，接着甩给了MapperRegistry， 那咱看看MapperRegistry。 源码如下：

/**
   * 烂活净让我来做了，没法了，下面没人了，我不做谁来做
   * @param type
   * @param sqlSession
   * @return
   */
  @SuppressWarnings("unchecked")
  public <T> T getMapper(Class<T> type, SqlSession sqlSession) {
    //能偷懒的就偷懒，俺把粗活交给MapperProxyFactory去做、
    //注意这个类的作用，产生了一个MapperProxyFactory的东西，也就是说本来就存了一个相应type的工厂？？
    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);
    }
  }

(4)MapperProxyFactory是个苦B的人，粗活最终交给它去做了。咱们看看源码：

/**
   * 别人虐我千百遍，我待别人如初恋
   * @param mapperProxy
   * @return
   */
  @SuppressWarnings("unchecked")
  protected T newInstance(MapperProxy<T> mapperProxy) {
    //动态代理我们写的dao接口
    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);
  }

通过以上的动态代理，咱们就可以方便地使用dao接口啦， 就像之前咱们写的demo那样：

UserDao userMapper = sqlSession.getMapper(UserDao.class); User insertUser = new User();

这下方便多了吧， 呵呵， 貌似mybatis的源码就这么一回事儿啊。

别急，还没完， 咱们还没看具体是怎么执行sql语句的呢。

执行sql语句.png

接下来，咱们才要真正去看sql的执行过程了。

上面，咱们拿到了MapperProxy, 每个MapperProxy对应一个dao接口， 那么咱们在使用的时候，MapperProxy是怎么做的呢？ 源码奉上：
MapperProxy:

/**
   * MapperProxy在执行时会触发此方法
   */
  @Override
  public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
    if (Object.class.equals(method.getDeclaringClass())) {
      try {
        return method.invoke(this, args);
      } catch (Throwable t) {
        throw ExceptionUtil.unwrapThrowable(t);
      }
    }
    //找到具体是执行select还是其他的一些类型,封装在MapperMethod类中command对象中。
    //这个mapperMethod很重要呀，有关于参数映射之类应该在这里
    final MapperMethod mapperMethod = cachedMapperMethod(method);
    //由MapperMethod中具体的根据type来判断怎么执行
    return mapperMethod.execute(sqlSession, args);
  }

MapperMethod:

/**
   * 看着代码不少，不过其实就是先判断CRUD类型，然后根据类型去选择到底执行sqlSession中的哪个方法，绕了一圈，又转回sqlSession了
   * @param sqlSession
   * @param args
   * @return
   */
  public Object execute(SqlSession sqlSession, Object[] args) {
    Object result;
    if (SqlCommandType.INSERT == command.getType()) {
      Object param = method.convertArgsToSqlCommandParam(args);
      result = rowCountResult(sqlSession.insert(command.getName(), param));
    } else if (SqlCommandType.UPDATE == command.getType()) {
      Object param = method.convertArgsToSqlCommandParam(args);
      result = rowCountResult(sqlSession.update(command.getName(), param));
    } else if (SqlCommandType.DELETE == command.getType()) {
      Object param = method.convertArgsToSqlCommandParam(args);
      result = rowCountResult(sqlSession.delete(command.getName(), param));
    } else if (SqlCommandType.SELECT == command.getType()) {
      if (method.returnsVoid() && method.hasResultHandler()) {
       //如果有结果处理器，自定义的？
        executeWithResultHandler(sqlSession, args);
        result = null;
      } else if (method.returnsMany()) {
        //如果有多条记录
        result = executeForMany(sqlSession, args);
      } else if (method.returnsMap()) {
        //如果是一个Map
        result = executeForMap(sqlSession, args);
      } else {
        //否则就是一条记录
        Object param = method.convertArgsToSqlCommandParam(args);
        result = sqlSession.selectOne(command.getName(), param);
      }
    } else {
      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;
  }

既然又回到SqlSession了， 那么咱们就看看SqlSession的CRUD方法了，为了省事，还是就选择其中的一个方法来做分析吧。这儿，咱们选择了selectList方法：

public <E> List<E> selectList(String statement, Object parameter, RowBounds rowBounds) {
    try {
      MappedStatement ms = configuration.getMappedStatement(statement);
      //CRUD实际上是交给Excetor去处理， excutor其实也只是穿了个马甲而已，小样，别以为穿个马甲我就不认识你嘞！
      return executor.query(ms, wrapCollection(parameter), rowBounds, Executor.NO_RESULT_HANDLER);
    } catch (Exception e) {
      throw ExceptionFactory.wrapException("Error querying database.  Cause: " + e, e);
    } finally {
      ErrorContext.instance().reset();
    }
  }

然后，通过一层一层的调用，最终会来到doQuery方法， 这儿咱们就随便找个Excutor看看doQuery方法的实现吧，我这儿选择了SimpleExecutor:

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());
      //StatementHandler封装了Statement, 让 StatementHandler 去处理
      return handler.<E>query(stmt, resultHandler);
    } finally {
      closeStatement(stmt);
    }
  }

接下来，咱们看看StatementHandler 的一个实现类 PreparedStatementHandler（这也是我们最常用的，封装的是PreparedStatement）, 看看它使怎么去处理的：

public <E> List<E> query(Statement statement, ResultHandler resultHandler) throws SQLException {
     //到此，原形毕露， PreparedStatement, 这个大家都已经滚瓜烂熟了吧
    PreparedStatement ps = (PreparedStatement) statement;
    ps.execute();
    //结果交给了ResultSetHandler 去处理
    return resultSetHandler.<E> handleResultSets(ps);
  }

转自：深入浅出Mybatis系列（十）---SQL执行流程分析（源码篇）(加一些自己的思考)