MyBatis源码解析

单用mybatis框架的执行sql步骤：

String resource = "mybatis-config.xml";
InputStream inputStream = Resources.getResourceAsStream(resource);
SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder().build(inputStream);
SqlSession session = sqlSessionFactory.openSession();
try {
    StudentMapper mapper = session.getMapper(StudentMapper.class);
    System.out.println(mapper.queryStudent());
} finally {
    session.close();
}

从以上步骤我们可以看到，第一步的是进行io操作，对xml的操作一个io操作，这一步是针对jdk来说的，而本次主要针对mybatis源码分析来说，所以这部分先不谈！
从第二步SqlsessionFactoryBuilder()类下谈起。我们先找到这个类。
这个类在org.apache.ibatis.session包下。调用的是build方法。

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

而在这个类中重写了build方法。

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

在这里，是通过XMLConfigBuilder进行的xml文件解析，这步之后再细究，最终这里是把xml配置信息保存在Configuration类中。而通过parse()进行的解析，最终重写返回DefaultSqlSessionFactory类。
在这步就可以得到一个SqlSessionFactory对象，而通过这个对象可以得到一个Sqlsession。
第二步是openSession。而openSession的最终调用在org.apache.ibatis.session.defaults包下的DefaultSqlsessionFactory中。

  public SqlSession openSession() {
    return openSessionFromDataSource(configuration.getDefaultExecutorType(), null, false);
  }

  private SqlSession openSessionFromDataSource(ExecutorType execType, TransactionIsolationLevel level, boolean autoCommit) {
    Transaction tx = null;
    try {
      final Environment environment = configuration.getEnvironment();
      final TransactionFactory transactionFactory = getTransactionFactoryFromEnvironment(environment);
      tx = transactionFactory.newTransaction(environment.getDataSource(), level, autoCommit);
      final Executor executor = configuration.newExecutor(tx, execType);
      return new DefaultSqlSession(configuration, executor, autoCommit);
    } catch (Exception e) {
      closeTransaction(tx); // may have fetched a connection so lets call close()
      throw ExceptionFactory.wrapException("Error opening session.  Cause: " + e, e);
    } finally {
      ErrorContext.instance().reset();
    }
  }

到这步，已经可以看出来了mybatis是通过executor执行sql的。而这步最终会返回一个新创建的对象DefaultSqlsession。也就是说在这步可以得到一个sqlsession。
得到sqlsession后，开始getMapper方法。在这里是通过MapperProxy来进行mapper的一个动态代理。而mapperProxy则是通过sqlsession在Configuration来获取的。
这是sqlsession中的：

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

从这步可以看出调用了configuration中的getMapper方法。

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

在这里，可以看到又将锅甩给了mapperRegistry。
我们来到org.apache.ibatis.binding包下的MapperRegistry中：

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

从这可以看出是通过MapperProxyFactory来进行代理的。代理后可以得到一个mapperProxy对象，之后在执行的时候，会触发invoke方法。
这里的invoke的话，是在org.apache.ibatis.binding里的MapperProxy方法中。

  public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
    try {
      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);
  }

而后去看MapperMethod中的方法了。

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

这里看着代码是不少，但是其实总的来说就是判断CRUD的类型，然后根据类型去选择到底执行sqlsession中的哪个方法。
回到sqlsession的话，我们就可以看其中的CRUD方法了，这里直接选择selectList方法来分析吧！

  public <E> List<E> selectList(String statement, Object parameter, RowBounds rowBounds) {
    try {
      MappedStatement ms = configuration.getMappedStatement(statement);
      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();
    }
  }

可以看到这里又交给了executor了，最终经过层层调用，来到doQuery中。而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());
      return handler.query(stmt, resultHandler);
    } finally {
      closeStatement(stmt);
    }
  }

在这的话，可以看StatementHandler的一个实现类，PreparedStatementHandler，封装的是PreparedStatement。看一下它的源码。

  public <E> List<E> query(Statement statement, ResultHandler resultHandler) throws SQLException {
    PreparedStatement ps = (PreparedStatement) statement;
    ps.execute();
    return resultSetHandler.handleResultSets(ps);
  }

这里的话，就是JDBC的操作了，将sql进行执行，之后将查询到的结果通过resultSetHandler映射到java实体中。
到此，一次sql执行流程就结束了。之后，会逐渐推出内部具体实现过程，以及设计模式。