目录

启动Mybatis

Resources.getResourceAsStream

SqlSessionFactoryBuilder.build

XMLConfigBuilder.parse

DefaultSqlSessionFactory.openSession

Configuration.newExecutor

DefaultSqlSession.getMapper

MapperMethod.execute

SimpleExecutor.query

获取数据库连接

预编译SQL

参数化

执行SQL处理结果集

启动Mybatis

在了解mybatis的原理之前，一定得知道它是如何运行起来的，它运行的入口在哪里？回到最原始的时期，在不使用Spring或SpringBoot的情况下，想要使用mybatis，一般都得按如下方式编写。

    public static void main(String[] args) throws Exception{
        // 读取 mybatis 的配置文件为输入流
        InputStream inputStream = Resources.getResourceAsStream("mybatis-config.xml");
        // 通过配置文件输入流创建 SqlSession工厂
        SqlSessionFactory factory = new SqlSessionFactoryBuilder().build(inputStream);
        // 通过SqlSession 工厂创建一个SqlSession
        SqlSession sqlSession = factory.openSession();
        // 通过SqlSession找到对应的 mapper 接口类
        UserDao userDao = sqlSession.getMapper(UserDao.class);
        // 执行sql
        userDao.get("1");
    }

短短五行代码就完成了mybatis的初始化和使用过程，下面就来剖析一下每行代码背后都做了什么。

Resources.getResourceAsStream

这个没什么好说的，就是将mybatis-config.xml这个文件读取成流。

SqlSessionFactoryBuilder.build

该方法就是创建了一个xml的解析器，然后将xml解析为Configuration对象后，设置到创建的DefaultSqlSessionFactory对象中，最后将DefaultSqlSessionFactory对象返回。

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


  public SqlSessionFactory build(InputStream inputStream, String environment, Properties properties) {
    try {
      // 创建XMLConfigBuilder 对象
      XMLConfigBuilder parser = new XMLConfigBuilder(inputStream, environment, properties);
      // 调用XMLConfigBuilder.parse方法，返回一个Configuration对象
      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.
      }
    }
  }

  // 将Configuration 对象设置到DefaultSqlSessionFactory对象属性中
  // 将DefaultSqlSessionFactory对象返回
  public SqlSessionFactory build(Configuration config) {
    return new DefaultSqlSessionFactory(config);
  }

XMLConfigBuilder.parse

解析xml文件，并将其中的配置设置到configuration对象中。具体xml中有哪些配置，可以到MYBATIS官网参考。

    // 从父类继承的
    protected final Configuration configuration;

  public XMLConfigBuilder(InputStream inputStream, String environment, Properties props) {
    this(new XPathParser(inputStream, true, props, new XMLMapperEntityResolver()), environment, props);
  }

  private XMLConfigBuilder(XPathParser parser, String environment, Properties props) {
    // 实例化Configuration对象，并调用父类构造器设置到configuration属性中
    super(new Configuration());
    ErrorContext.instance().resource("SQL Mapper Configuration");
    this.configuration.setVariables(props);
    this.parsed = false;
    this.environment = environment;
    this.parser = parser;
  }

  public Configuration parse() {
    if (parsed) {
      throw new BuilderException("Each XMLConfigBuilder can only be used once.");
    }
    parsed = true;
    parseConfiguration(parser.evalNode("/configuration"));
    return configuration;
  }

  // 解析xml中的节点设置到configuration属性中
  private void parseConfiguration(XNode root) {
    try {
      propertiesElement(root.evalNode("properties")); //issue #117 read properties first
      typeAliasesElement(root.evalNode("typeAliases"));
      pluginElement(root.evalNode("plugins"));
      objectFactoryElement(root.evalNode("objectFactory"));
      objectWrapperFactoryElement(root.evalNode("objectWrapperFactory"));
      settingsElement(root.evalNode("settings"));
      environmentsElement(root.evalNode("environments")); // read it after objectFactory and objectWrapperFactory issue #631
      databaseIdProviderElement(root.evalNode("databaseIdProvider"));
      typeHandlerElement(root.evalNode("typeHandlers"));
      mapperElement(root.evalNode("mappers"));
    } catch (Exception e) {
      throw new BuilderException("Error parsing SQL Mapper Configuration. Cause: " + e, e);
    }
  }

DefaultSqlSessionFactory.openSession

  private final Configuration configuration;

  public DefaultSqlSessionFactory(Configuration configuration) {
    this.configuration = configuration;
  }

  public SqlSession openSession() {
    // defaultExecutorType = ExecutorType.SIMPLE;
    return openSessionFromDataSource(configuration.getDefaultExecutorType(), null, false);
  }

  // execType = ExecutorType.SIMPLE
  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);
      // 创建DefaultSqlSession对象并返回
      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();
    }
  }

  private TransactionFactory getTransactionFactoryFromEnvironment(Environment environment) {
    // 未配置则使用ManagedTransactionFactory，这个事务管理器几乎什么都不做
    if (environment == null || environment.getTransactionFactory() == null) {
      return new ManagedTransactionFactory();
    }
    // 配置了则使用配置的，默认有JdbcTransactionFactory和ManagedTransactionFactory可配置
    return environment.getTransactionFactory();
  }

在mybatis-config.xml配置文件中，通常environments是这样配置的。这里transactionManager的类型可以是JDBC和MANAGED。

这里以JDBC为例，TranscationFactory就是JdbcTransactionFactory。方法也很简单，直接创建一个JdbcTransaction对象返回即可。

  public Transaction newTransaction(DataSource ds, TransactionIsolationLevel level, boolean autoCommit) {
    return new JdbcTransaction(ds, level, autoCommit);
  }

Configuration.newExecutor

  protected boolean cacheEnabled = true;

  public Executor newExecutor(Transaction transaction, ExecutorType executorType) {
    // executorType未传则使用SIMPLE
    executorType = executorType == null ? defaultExecutorType : executorType;
    executorType = executorType == null ? ExecutorType.SIMPLE : executorType;
    Executor executor;
    // 根据ExecutorType来创建对应的执行器
    if (ExecutorType.BATCH == executorType) {
      executor = new BatchExecutor(this, transaction);
    } else if (ExecutorType.REUSE == executorType) {
      executor = new ReuseExecutor(this, transaction);
    } else {
      executor = new SimpleExecutor(this, transaction);
    }
    // mybatis-config.xml里的settings中是否设置了cacheEnabled（true or false）
    // 未设置默认为true
    if (cacheEnabled) {
      // 代理模式
      // 创建CachingExecutor对象作为原执行器的代理对象
      executor = new CachingExecutor(executor);
    }
    // 为该执行器装载插件
    executor = (Executor) interceptorChain.pluginAll(executor);
    return executor;
  }

DefaultSqlSession.getMapper

通过DefaultSqlSession.getMapper方法获取我们自定义的接口。

public class DefaultSqlSession {
  public  T getMapper(Class type) {
    return configuration.getMapper(type, this);
  }
}

public class Configuration {

    protected MapperRegistry mapperRegistry = new MapperRegistry(this);

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

public class MapperRegistry {
  
  // 在解析mybatis-config.xml时，其中的mappers标签下的mapper标签经过解析之后会存在这里
  private final Map, MapperProxyFactory> knownMappers = new HashMap, MapperProxyFactory>();

  public  T getMapper(Class type, SqlSession sqlSession) {
    final MapperProxyFactory mapperProxyFactory = (MapperProxyFactory) knownMappers.get(type);
    if (mapperProxyFactory == null)
      throw new BindingException("Type " + type + " is not known to the MapperRegistry.");
    try {
      // 通过mapperProxyFactory获取具体实例
      return mapperProxyFactory.newInstance(sqlSession);
    } catch (Exception e) {
      throw new BindingException("Error getting mapper instance. Cause: " + e, e);
    }
  }
}

public class MapperProxyFactory{

  protected T newInstance(MapperProxy mapperProxy) {
    // JDK动态代理
    return (T) Proxy.newProxyInstance(mapperInterface.getClassLoader(), new Class[] { mapperInterface }, mapperProxy);
  }

  public T newInstance(SqlSession sqlSession) {
    // 创建一个JDK的动态代理对象
    final MapperProxy mapperProxy = new MapperProxy(sqlSession, mapperInterface, methodCache);
    return newInstance(mapperProxy);
  }
}

public class MapperProxy implements InvocationHandler, Serializable {

  private static final long serialVersionUID = -6424540398559729838L;
  private final SqlSession sqlSession;
  private final Class mapperInterface;
  private final Map methodCache;

  public MapperProxy(SqlSession sqlSession, Class mapperInterface, Map methodCache) {
    this.sqlSession = sqlSession;
    this.mapperInterface = mapperInterface;
    this.methodCache = methodCache;
  }

  // 对原接口的方法调用，会触发invoke方法
  public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
    // 调用的方法是继承自Object，则直接调用
    if (Object.class.equals(method.getDeclaringClass())) {
      try {
        return method.invoke(this, args);
      } catch (Throwable t) {
        throw ExceptionUtil.unwrapThrowable(t);
      }
    }
    // 从缓存中取MapperMethod对象
    final MapperMethod mapperMethod = cachedMapperMethod(method);
    // 通过MapperMethod对象进行执行
    return mapperMethod.execute(sqlSession, args);
  }

  // MapperMethod的缓存
  private MapperMethod cachedMapperMethod(Method method) {
    MapperMethod mapperMethod = methodCache.get(method);
    if (mapperMethod == null) {
      mapperMethod = new MapperMethod(mapperInterface, method, sqlSession.getConfiguration());
      methodCache.put(method, mapperMethod);
    }
    return mapperMethod;
  }

}

我们都知道，接口是不能被实例化的，只能实例化它的实现类。但是接口是可以被JDK动态代理的，这里可以很明显的看到，我们的接口类被MapperProxy给代理了，所有对原始接口类的方法调用都会执行MapperProxy的invoke方法。

在invoke方法中，如果调用的是接口继承自Object的方法，那么会直接调用；否则会根据调用的方法创建一个MapperMethod对象来调用其execute方法，这个方法才是真正干活的。

MapperMethod.execute

  public MapperMethod(Class mapperInterface, Method method, Configuration config) {
    // 实例化SqlCommand对象，包括该方法对应的sql标签时什么类型等属性
    this.command = new SqlCommand(config, mapperInterface, method);
    // 实例化方法签名对象，包括方法的全部信息
    this.method = new MethodSignature(config, method);
  }


public Object execute(SqlSession sqlSession, Object[] args) {
    Object result;
    if (SqlCommandType.INSERT == command.getType()) {
      // insert 语句执行insert逻辑
      Object param = method.convertArgsToSqlCommandParam(args);
      result = rowCountResult(sqlSession.insert(command.getName(), param));
    } else if (SqlCommandType.UPDATE == command.getType()) {
      // update 语句执行update逻辑       
      Object param = method.convertArgsToSqlCommandParam(args);
      result = rowCountResult(sqlSession.update(command.getName(), param));
    } else if (SqlCommandType.DELETE == command.getType()) {
      // delete 语句执行delete逻辑
      Object param = method.convertArgsToSqlCommandParam(args);
      result = rowCountResult(sqlSession.delete(command.getName(), param));
    } else if (SqlCommandType.SELECT == command.getType()) {
      // select 语句执行select逻辑
      if (method.returnsVoid() && method.hasResultHandler()) {
        // 方法返回值是void，且该方法参数有ResultHandler类型
        executeWithResultHandler(sqlSession, args);
        result = null;
      } else if (method.returnsMany()) {
        // 方法返回值是集合或数组
        result = executeForMany(sqlSession, args);
      } else if (method.returnsMap()) {
        // 方法返回值是Map，且加有@MapKey注解
        result = executeForMap(sqlSession, args);
      } else {
        // 方法返回值是普通类型
        // 参数值
        Object param = method.convertArgsToSqlCommandParam(args);
        // command.getName: 接口的全限定类名 + '.' + 方法名
        // 如果该方法是继承来的则使用的是父类的全限定类名
        result = sqlSession.selectOne(command.getName(), param);
      }
    } else {
      throw new BindingException("Unknown execution method for: " + command.getName());
    }
    if (result == null && method.getReturnType().isPrimitive() && !method.returnsVoid()) {
      // sql语句执行结果为null，且方法返回值是基本类型
      throw new BindingException("Mapper method '" + command.getName() 
          + " attempted to return null from a method with a primitive return type (" + method.getReturnType() + ").");
    }
    return result;
  }

execute方法里对四种类型的SQL语句都做了相应的处理，这里仅挑选SELECT语句的返回单条结果加以分析，即selectOne的逻辑；

在执行selectOne之前，需要先将方法的执行参数进行一个解析，这样才能对应上XML中写的变量名。

    public MethodSignature(Configuration configuration, Method method) throws BindingException {
      ...
      this.hasNamedParameters = hasNamedParams(method);
      this.params = Collections.unmodifiableSortedMap(getParams(method, this.hasNamedParameters));
    }

    // 得到参数名和参数值得绑定关系Map，仅一个有效参数时则直接返回该参数值
    public Object convertArgsToSqlCommandParam(Object[] args) {
      final int paramCount = params.size();
      if (args == null || paramCount == 0) {
        // 没有参数则返回null
        return null;
      } else if (!hasNamedParameters && paramCount == 1) {
        // 未使用@Param注解且仅一个有效参数
        return args[params.keySet().iterator().next()];
      } else {
        // key： paramName， value：参数值
        final Map param = new ParamMap