Mybatis源码解析

基础应用

//1. 构建SqlSessionFactory对象
String resource = "mybatis/mybatis-config.xml";
InputStream inputStream = Resources.getResourceAsStream(resource);
Properties properties = new Properties();
properties.setProperty("driver","com.mysql.cj.jdbc.Driver");
properties.setProperty("url","jdbc:mysql://???");
properties.setProperty("username","zozo");
properties.setProperty("password","???");
SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder().build(inputStream,properties);

//2. 构建SqlSession对象
SqlSession sqlSession = sqlSessionFactory.openSession();

//3. 构建Mapper对象
RoleMapperEx mapper = sqlSession.getMapper(RoleMapperEx.class);
//4. 通过Mapper对象执行对应数据库执行方法
List<Result> ids = mapper.getList("112123123","1231231231231");

步骤：

1. 利用SqlSessionFactoryBuilder构建SqlSessionFactory对象
2. 利用SqlSessionFactory对象构建SqlSession对象
3. 构建Mapper对象
4. 通过Mapper对象执行对应数据库执行方法

步骤1

/**
 * 主要用于从不同的资源中加载配置，进而创建一个 SqlSessionFactory 实例
 */
public class SqlSessionFactoryBuilder {
  /**
   * 最主要的目的对主要几个不同资源的支持和整合，然后通过调用XMLConfigBuilder对象解析资源生成Configuration对象，最后新建一个SqlSessionFactory对象持有该Configuration对象并返回
   **/
  public SqlSessionFactory build(){}
}

/**
 * 从不同的资源中将配置加载出来并初始化为Configuration对象的具体实现类
 **/
public class XMLConfigBuilder{
  /**
   * 对象的入口方法，该对象仅会利用（parseConfiguration）方法解析一遍资源，第二次将会报错
   **/
    public Configuration parse(){}
  
  /**
   * 解析资源，为Configuration进行环境配置，这里初始化了以下配置
   1. 动态环境变量设置到Configuration中：Properties
   2. 初始化VFS对象，并被Configuration对象持有
   3. 初始化log对象，并被Configuration对象持有
   4. 通过configuration的别名注册器typeAliasRegistry注册自定义别名
   5. 通过configuration的插件管理器interceptorChain添加插件（Interceptor）
   6. 初始化objectFactory对象，并被Configuration对象持有
   7. 初始化objectWrapperFactory对象，并被Configuration对象持有
   8. 初始化reflectorFactory对象，并被Configuration对象持有
   9. 初始化setting中的一些配置，并被Configuration对象持有，由于数量十分多，这里列几个在初始化流程中会影响到的参数，cacheEnabled（缓存开关），
   10. 解析environments节点，如果是特殊的环境，将会初始化一个持有transactionManager，dataSource的environment对象，并被Configuration对象持有
   11. 解析databaseIdProvider节点，databaseIdProvider->configuration.databaseId
   12. 通过configuration的类型处理器注册器typeHandlerRegistry注册类型处理器
   13. 解析Mapper节点，解析mapper节点处理过程比较复杂
   **/
  private void parseConfiguration(XNode root) {}
  
  /**
   * 解析Mapper节点，通过XMLMapperBuilder对象，解析mapper.xml文件
   * 大部分步骤是初始化配置，最重要的步骤如下
   * 1. 根据每个Mapper.class对象，生成mapper.class的代理工程对象，并在configuration的mapper代理工程注册类mapperRegistry注册
   * 2. 根据每个Mapper.class对象，生成对应的Cache对象，这个对象是一层一层包裹起来的装饰类对象，每一层都实现了一层缓存策略，然后将这个对象
   * 3. 根据每个mapper.xml的SQL语句，生成一个SqlSource对象，其中如果语句中没有#{}语句，则返回RawSqlSource对象，有#{}则返回DynamicSqlSource对象。（两个对象的区别在于是否使用PreparedStatement进行动态查询）
   * 4. 根据每个mapper.xml的SQL语句，生成MappedStatement对象，并持有SqlSource对象，Cache对象，与其他参数配置，同时添加configuration的语句管理器mappedStatements
   **/
  private void mapperElement(XNode parent){}
}

/**
 * mybatis中十分重要的类，不仅持有所有的环境变量，还持有别名注册器，类型转换注册器，mapper的代理工厂注册器等，是一个十分庞大而复杂的类，这里将列举出在初始化过程中，被初始化的属性
 **/
public class Configuration {
  /*
   * 主要用于将基本类型和用户自定义的类型进行别名注册；
   * 将别名及其对应类类型保存在一个HashMap中，方便存取，是映射器映射功能实现的基础
   * key 别名/类名，value 类对象
   * 默认设置了大量的默认k-v，同时在Configuration对象初始化过程中也注册了大量的k-v，需要请查阅
   */
  protected final TypeAliasRegistry typeAliasRegistry = new TypeAliasRegistry();
  
  /**
   * 动态环境变量Map
   **/
  protected Properties variables = new Properties();
  
  /**
   * vfsImpl，指定 VFS 的实现未详细了解
   **/
  protected Class<? extends VFS> vfsImpl;
  
  /**
   * logImpl，MyBatis 所用日志的具体实现对象，在setting参数中配置
   * SLF4J | LOG4J | LOG4J2 | JDK_LOGGING | COMMONS_LOGGING | STDOUT_LOGGING | NO_LOGGING
   * 这些Log的实现都在Configuration实例化的过程中注册到别名注册器中，需要研究请自寻查阅
   **/
  protected Class<? extends Log> logImpl;
  
  /**
   * 插件管理器，十分重要的对象，插件是我们针对mybatis四大对象进行拦截并实现自定义支持的主要途径
   * mybatis提供的四大对象：Excutor，StatementHandler，parameterHandler，resultSetHandler
   **/
  protected final InterceptorChain interceptorChain = new InterceptorChain();
  
  /**
   * 对象工厂对象，MyBatis 每次创建结果对象的新实例时，它都会使用一个对象工厂（ObjectFactory）实例来完成。 默认的对象工厂需要做的仅仅是实例化目标类，要么通过默认构造方法，要么在参数映射存在的时候通过参数构造方法来实例化。 如果想覆盖对象工厂的默认行为，则可以通过创建自己的对象工厂来实现
   待研究
   **/
  protected ObjectFactory objectFactory = new DefaultObjectFactory();
  
  /**
   * 待研究
   **/
  protected ObjectWrapperFactory objectWrapperFactory = new DefaultObjectWrapperFactory();
  /**
   * 待研究
   **/
  protected ReflectorFactory reflectorFactory = new DefaultReflectorFactory();
  
  /**
   * environment节点下所有参数
   **/
  protected Environment environment;
  
  /**
   * 待研究
   **/
  protected String databaseId;
  
  /*
  * 类型处理器注册器
  * 类型处理器：用于处理javaType与jdbcType之间类型转换用的处理器
  * 作用：既能完成类型处理器的注册功能，同时也能对类型处理器进行统筹管理；
  * 其内部定义了集合来进行类型处理器的存取，同时定义了存取方法。
  */
  protected final TypeHandlerRegistry typeHandlerRegistry = new TypeHandlerRegistry(this);
  
  /**
   * mapper的代理工厂的注册类
   */
  protected final MapperRegistry mapperRegistry = new MapperRegistry(this);
  
  
  /**
   * 已经加载过的Resources，包含 mapper.xml ，namespace
   **/
  protected final Set<String> loadedResources = new HashSet<>();
  
  /**
   * 缓存实例管理器
   * key 命名空间（nameSpace） value Cache
   * 即每个缓存对象缓存的是对应的单个命名空间的对应SQL请求
   **/
  protected final Map<String, Cache> caches = new StrictMap<>("Caches collection");
  
 /**
  * SQL语句管理器
  * key 命名空间+语句id  value MappedStatement(语句对象，拥有语句节点包括具体SQL语句内容在内的所有信息)
  **/
  protected final Map<String, MappedStatement> mappedStatements = new StrictMap<MappedStatement>("Mapped Statements collection")
      .conflictMessageProducer((savedValue, targetValue) ->
          ". please check " + savedValue.getResource() + " and " + targetValue.getResource());
}

这个过程中，初始化了所有的环境，生成了该框架中最重要的对象是Configuration对象，这个对象持有了大量必要的工具引用和环境引用。之后将其交予SqlSessionFactory所持有，SqlSessionFactory更像是为了将Configuration对象做封装，暴露SqlSession对象的创建api的对象，主要是一个工具对象被使用。

步骤2

/**
 * SqlSessionFactory更像是为了将Configuration对象做封装，暴露SqlSession对象的创建api的对象，主要是一个工具对象被使用，所有的实现基本上都是通过configuration提供的方法进行实现
 **/
public class DefaultSqlSessionFactory implements SqlSessionFactory {
  /**
   * 1. 生成Transaction（事务）对象，
   * 2. 然后根据ExecutorType生成对应的Executor，其中如果加了二级缓存（cacheEnabled），将会生成装饰对象CachingExecutor装饰对应的Executor；
            BATCH  BatchExecutor
            REUSE  ReuseExecutor
            SIMPLE SimpleExecutor
   * 3. 同时将configuration的interceptorChain中，添加的有关executor的插件（Interceptor）代理该Executor，生成新的代理对象。
   * 4. 最后用上面的参数生成对象DefaultSqlSession（仅有这么一个实现）。
   **/
  private SqlSession openSessionFromDataSource(ExecutorType execType, TransactionIsolationLevel level, boolean autoCommit){}
}

这个过程中，需要关注的是Executor的初始化，这是我们通过控件可控的四大对象之一，不过我们可控制的方法并不在这个阶段。同时这里初始的事务对象，如果我们使用spring框架，mybatis的事务将不会有什么效果，也不需要过多的关注

步骤3

/**
 * SqlSession主要提供的是方法的执行语句（可以不依靠mapper对象执行语句）和事务是否自动提交的控制，以及mapper代理对象（MapperProxy）的生成。
 **/
public class DefaultSqlSession implements SqlSession {
    /**
     * Mapper代理对象（MapperProxy）的生成是通过在configuration的Mapper代理工程注册器MapperRegistry中查找到对应的代理工程MapperProxyFactory，然后借由MapperProxyFactory生成的，该对象主要持有了sqlSession对象，mapperInterface类对象（即我们编写的Mapper接口），methodCache （暂时不清楚是什么东西）
     **/
    public <T> T getMapper(Class<T> type){}
}

这个过程我们可以知道，MapperProxy—持有—>SqlSession—持有—>Executor，这个关系必须理清楚

步骤4

/**
 * MapperProxy作为代理对象响应每一次方法的调用。
 * 针对每一条Sql方法，将会生成一个MapperMethod对象，然后全权通过该对象中执行对应的方法，所以调用的主角还是应该将目光放到MapperMethod对象中。
 **/
public class MapperProxy<T> implements InvocationHandler, Serializable {}

/**
 * MapperMethod的作用
 * 1. 处理参数，构造成SqlSession支持的参数，
 * 2. 通过调用SqlSession执行语句获取的结果,返回
 **/
public class MapperMethod {
  /**
   * 该对象持有（全限定名+方法名），以及SQL请求的类型（select/update、delete、insert），这个请求的类型，将与具体调用什么方法以及判断是否缓存的处理有关
   **/
  private final SqlCommand command;
  
  /**
   * 该对象持有该方法所有信息，这里就不一一赘述
   **/
  private final MethodSignature method;
  
  /**
   * 1.通过method.convertArgsToSqlCommandParam方法构造成对应的参数
   * 2.根据SQL请求的类型，调用不同的sqlSession.xx((全限定名+方法名),参数)方法
   * 3.处理结果
   **/
  public Object execute(SqlSession sqlSession, Object[] args){}
  
  public static class MethodSignature {
    /**
     * 参数转化规则
     * 1. 没有参数返回null；
     * 2. 只有一个，直接返回
     * 3. 有参数则返回map，同时key值为该参数名或注解名，并额外追加param+第几位参数的键值对到参数Map中
     **/
    public Object convertArgsToSqlCommandParam(Object[] args){}    
  }
}

/**
 * DefaultSqlSession所做的事情如下：
 * 1. 通过key(全限定名+方法名)从configuration的语句信息管理者（mappedStatements）取出相对应的语句信息（mappedStatement）
 * 2. 将语句信息交给持有的executor并执行对应的方法
 *   2.1 update、delete、insert执行的都是executor.update方法
 *   2.2 query 根据结果不同调用不同的query方法
 **/
public class DefaultSqlSession implements SqlSession {}

/**
 * CachingExecutor是其他Executor的缓存实现的装饰器对象
 * 1. 提供的是二级缓存的策略
 * 2. 二级缓存由Cache对象，Cache由mappedStatement提供，他缓存的同一命名空间的SQL请求
 * 3. 根据每条请求的设置，决定清不清空缓存
 * 4. 根据每条请求的设置，判断是否使用缓存
 * 5. ensureNoOutParams？
 * 6. 通过TransactionalCacheManager获取数据，获取不到就调用所装饰Executor执行SQL语句，然后TransactionalCacheManager通过进行缓存处理
 
 * 7. 使用插件改变sql语句，需要在这里做捕获，防止cache生效
 */
public class CachingExecutor implements Executor {
  
}

/**
 * 这是所有Executor的基础类，由这个类实现一级缓存
 * update   清空缓存
 * query    添加缓存
 * 如果设置请求的时候清空缓存，将在当前executor的请求栈中没有请求的时候清空
 * 具体的请求过程看下面的类
 **/
public abstract class BaseExecutor implements Executor {}

/**
 * 1. 调用doQuery或doUpdate方法，常用插件捕获该行为
 * 2. 创建StatementHandler对象，这又是一个四大对象，重点关注
            2.1 STATEMENT  SimpleStatementHandler
            2.2 PREPARED   PreparedStatementHandler
            2.3 CALLABLE   CallableStatementHandler
     3. 创建StatementHandler对象的同时，StatementHandler对象的构造方法创建了parameterHandler对象和resultSetHandler对象，这是另外的两个四大对象
 * 3. 与数据库建立连接，连接建立的时间和位置需要关注
 * 4. 调用statementHandler.prepare获取Statement对象，常用插件捕获该行为
 * 5. 调用StatementHandler.setParameters设置参数，插件捕获
 * 6. 调用ParameterHandler.setParameters设置参数，插件捕获
 * 7. 调用StatementHandler.query执行请求，获取结果，插件捕获，这里是请求前插件捕获的最后一环。
 * 8. 调用resultSetHandler处理结果，插件捕获，这里整个调用后插件捕获的最后一环
 * 9. 回到StatementHandler，回到executor，回到SqlSession，回到MapperMethod，回到MapperProyx，回复结果
 **/
public class SimpleExecutor extends BaseExecutor {}

整条请求链：

MapperProyx—>MapperMethod—>SqlSession—>StatementHandler—>ParameterHandler—>StatementHandler—>resultSetHandler—>StatementHandler—>SqlSession—>MapperMethod—>MapperProyx

插件

/**
 * mybatis的插件使用的是代理技术,上面的四大对象都是如果被插件捕获，实际调用的都是代理对象，这里仅讨论下代理对象，如何根据注解捕获方法
 **/
public interface Interceptor {
  default Object plugin(Object target) {
    /**
     * 代理对象的生成工具
     **/
    return Plugin.wrap(target, this);
  }
}

public class Plugin implements InvocationHandler {
  /**
     * 根据注解，捕获的方法将会放到该位置
     * key 捕获的类(Signature.type)  value 能捕获的方法集
     **/
  private final Map<Class<?>, Set<Method>> signatureMap;
  
    /**
     * 该方法是处理注解，无非就是遍历该类的所有方法，然后将其添加的结果集
     **/
  private static Map<Class<?>, Set<Method>> getSignatureMap(Interceptor interceptor){}  
  
  /**
   * 从signatureMap中拿出方法集，再鉴定当前方法是否存在于方法集中，是就执行，不是就执行原代码
   **/
  public Object invoke(Object proxy, Method method, Object[] args){}
}