1.初窥Mybatis初始化

引言

这篇文章呢，主要是讲Mybtais的两种方式的源码剖析：传统方式以及Mapper代理方式，初次探索Mybatis源码，希望大佬勿喷并且指正错误，谢谢！

个人博客：www.fqcoder.cn

一、Mybatis架构原理

1.架构图

首先，让我们来看看下面这张图：

我们吧Mybtais功能架构可以分为三层：

1.接口层：提供给外部使用的接口API，开发人员通过这些本地API来操作数据库。接口一层接收到调用请求就会调用数据处理来完成具体的数据处理。

MyBatis和数据库交互有两种方式：（也是我们接下来需要死磕的目标）

a.使用传统的Mybatis提供的API

b.使用Mapper代理的方式

2.数据处理层：负责具体的SQL查找、SQL解析、SQL执行、结果处理和映射等，它主要的目的是根据调用的请求完成一次数据库的操作。

3.框架支撑层：负责最基础的功能支撑，包括连接管理、事务管理、配置加载和缓存处理，这些都是共用的东西，将他们抽取出来作为最基础的组件。为上层的数据处理层提供最基础的支撑。

2.主要构件及其相互关系

构件	描述
SqlSession	作为MyBatis工作主要顶层API，表示和数据库交互的会话，完成必要数据库 增删改查功能
Executor	Mybatis执行器，是Mybatis调度的核心，负责SQL语句的生成和查询缓存的维护
StatementHandler	封装了JDBC Statemenet操作，负责对JDBC Statement的操作，如设置参数、 将Statement结果集转换成List集合
ParameterHandler	负责对用户传递的参数转换成JDBC Statement所需要的参数
ResultSetHandler	负责将JDBC返回的ResultSet结果集对象转换成List类型的集合
TypeHandler	负责java数据类型和jdbc数据类型之间的映射和转换
MappedStatement	MappedStatement维护了一条<select | update | delete | insert>节点的封装
SqlSource	负责根据用户传递的parameterObject，动态的生成SQL语句，将信息分封装到 BoundSql对象中，并返回
BoundSql	表示动态生成的SQL语句以及相应的参数信息

3.层次结构图

下面这张图就是Mybatis流程的层次结构图，建议读源码的时候记得打开这张图，思路才不会乱呢

4.总体流程

（1）加载配置文件并初始化

配置来源两个地方，一个是配置文件（主配置文件confi.xml，Mapper文件.xml）,一个是Java代码中的注解，将主配置为恩建内容解析封装到Configuration,将sql的配置信息加载成为一个mappedStatement对象，存储在内存之中

（2）接收调用请求

将请求传递给下层的请求处理层进行处理

（3）处理操作请求

A.根据SQL的ID查找对一个的MappedStatement对象

B.根据传入参数对象解析MappedStatement对象，得到最终要执行的SQL和执行传入参数

C.获取数据库连接，根据得到的最终SQL语句执行传入参数到数据库执行，并得到执行结果

D.根据MappedStatement对象中的结果映射配置对得到的执行结果进行转换处理，并得到最终的处理结果

E.释放连接资源

（4）返回处理结果

将最终的处理结果返回

二、死磕Mybatis源码剖析

1）传统方式的源码剖析

读取配置文件就不进去看了，第二行代码，才是初始化工作的开始

  //1.读取配置文件，读成字节输入流：还未解析
    InputStream resourceAsStream = Resources.getResourceAsStream("sqlMapConfig.xml");
    
  //2.解析XMl配置文件，封装成Configuration对象，创建DefaultSqlSessionFactory对象
  SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder().build(resourceAsStream);

我们进入build（）方法里看看：

  //1.我们最初调用的build
  public SqlSessionFactory build(InputStream inputStream) {
   
    //调用了重载方法
    return build(inputStream, null, null);
  }

发现调用了一个重载的方法，我们点进build()去看看：

//2.调用的重载方法
  public SqlSessionFactory build(InputStream inputStream, String environment, Properties properties) {
   
    try {
   
      //创建XML ConfigBuilder,XML configBuilder 是专门解析MyBatis的配置文件的类
      XMLConfigBuilder parser = new XMLConfigBuilder(inputStream, environment, properties);
      //执行XML解析
      //创建DefaultSqlSessionFactory对象
      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.
      }
    }
  }

发现创建了parser.parse()的返回值是configuration对象，是专门解析Mybatis的配置文件的类，

Mybatis在初始化的时候，会将Mybatis的配置信息全部加载到内存中，使用org.apache.ibatis.session.Configuration实例来维护，我们在进去parse()方法里看看：

  /**
   * 解析XML 成 Configuration对象
   * @return Configuration对象
   */
  public Configuration parse() {
   
    //若已解析，抛出BuilderException异常
    if (parsed) {
   
      throw new BuilderException("Each XMLConfigBuilder can only be used once.");
    }
    //标记已经解析
    parsed = true;
    //parser是XPathParser解析器对象，读取节内数据，<configuration>是Mybatis配置文件的顶层标签
    //解析XML configuration节点
    parseConfiguration(parser.evalNode("/configuration"));
    return configuration;
  }

我们看看是怎么解析configuration节点的，我们再点进parseConfiguration()方法里看看：

/**
   * 解析 XML
   *
   * 具体 My
   * @param root 根节点
   */
  private void parseConfiguration(XNode root) {
   
    try {
   
      //issue #117 read properties first
      //解析<properties/>标签
      propertiesElement(root.evalNode("properties"));
      //解析<settings>标签
      Properties settings = settingsAsProperties(root.evalNode("settings"));
      //加载自定义的VFS实现类
      loadCustomVfs(settings);
      //加载自定义的LOG实现类
      loadCustomLogImpl(settings);
      //解析<typeAliases/>标签
      typeAliasesElement(root.evalNode("typeAliases"));
      //解析<plugins/>标签
      pluginElement(root.evalNode("plugins"));
      //解析<objectFactory/>标签
      objectFactoryElement(root.evalNode("objectFactory"));
      //解析<objectWrapperFactory/>标签
      objectWrapperFactoryElement(root.evalNode("objectWrapperFactory"));
      //解析<reflectorFactory/>标签
      reflectorFactoryElement(root.evalNode("reflectorFactory"));
      //赋值<settings/>到 Configuration 属性
      settingsElement(settings);
      // read it after objectFactory and objectWrapperFactory issue #631
      //解析<environments/>标签
      environmentsElement(root.evalNode("environments"));
      //解析<databaseIdProvider/>标签
      databaseIdProviderElement(root.evalNode("databaseIdProvider"));
      //解析<typeHandlers/>标签
      typeHandlerElement(root.evalNode("typeHandlers"));
      //解析<mappers/>解析
      mapperElement(root.evalNode("mappers"));
    } catch (Exception e) {
   
      throw new BuilderException("Error parsing SQL Mapper Configuration. Cause: " + e, e);
    }
  }

是不是发现这里面都是解析配置文件里的标签，我们随便点进一个方法里，以propertiesElement()方法为例，我们再进去看看：

/**
   * 1.解析 <properties/> 标签,成 Properties 对象
   * 2.覆盖 configuration 中的 Properties 对象到上面的结果
   * 3.设置结果到 parser 和 configuration 中
   *
   * @param context 节点
   * @throws Exception 解析发生异常
   */
  private void propertiesElement(XNode context) throws Exception {
   
    if (context != null) {
   
      //读取子标签们，为 Properties对象
      Properties defaults = context.getChildrenAsProperties();
      //读取 resource 和 url 属性
      String resource = context.getStringAttribute("resource");
      String url = context.getStringAttribute("url");
      //resource 和 url 都存在的情况下,抛出 BuilderException 异常
      if (resource != null && url != null) {
   
        throw new BuilderException("The properties element cannot specify both a URL and a resource based property file reference.  Please specify one or the other.");
      }
      //读取本地 properties 配置文件到 defaults 中
      if (resource != null) {
   
        defaults.putAll(Resources.getResourceAsProperties(resource));
        //读取远程 properties 配置文件到defaults中
      } else if (url != null) {
   
        defaults.putAll(Resources.getUrlAsProperties(url