Mybatis源码分析-配置模块

最新推荐文章于 2023-04-20 13:23:18 发布

houjinimei

最新推荐文章于 2023-04-20 13:23:18 发布

阅读量350

点赞数

分类专栏： mybatis 文章标签： mybatis

本文链接：https://blog.csdn.net/houjinimei/article/details/74095169

版权

mybatis 专栏收录该内容

11 篇文章 0 订阅

订阅专栏

楼主比较菜，肯定有很多说的不对的地方，主要还是写给自己看的！！
比起spring来说，mybatis实在是简单，所以就先来聊聊mybatis！
先来张mybatis整体的结构图瞧瞧
Mybatis设计结构如下

从MyBatis代码实现的角度来看，MyBatis的主要的核心部件有以下几个：
1 SqlSession 作为MyBatis工作的主要顶层API，表示和数据库交互的会话，完成必要数据库增删改查功能
2 Executor MyBatis执行器，是MyBatis 调度的核心，负责SQL语句的生成和查询缓存的维护
3 StatementHandler 封装了JDBC Statement操作，负责对JDBC statement 的操作，如设置参数、将Statement结果集转换成List集合。
4 ParameterHandler 负责对用户传递的参数转换成JDBC Statement 所需要的参数，
5 ResultSetHandler 负责将JDBC返回的ResultSet结果集对象转换成List类型的集合；
6 TypeHandler 负责java数据类型和jdbc数据类型之间的映射和转换
7 MappedStatement MappedStatement维护了一条select|update|delete|insert节点的封装
8 SqlSource 负责根据用户传递的parameterObject，动态地生成SQL语句，将信息封装到BoundSql对象中，并返回
9 BoundSql 表示动态生成的SQL语句以及相应的参数信息
10 Configuration MyBatis所有的配置信息都维持在Configuration对象之中。

我们用一个列子来看下mybatis 的配置模块

String resource = "configs/mybatis-config.xml";
        Reader reader = Resources.getResourceAsReader(resource);
        SqlSessionFactoryBuilder sqlSessionFactoryBuilder = new SqlSessionFactoryBuilder();
        SqlSessionFactory sqlSessionFactory = sqlSessionFactoryBuilder.build(reader);
        SqlSession session = sqlSessionFactory.openSession();

1 根据配置文件或者注解，生成和数据库交互的必要的数据，存储于Map中，以供后续使用；
1.1 我们来看下 Reader reader = Resources.getResourceAsReader(resource);
resource 地址我是直接用的resrouces文件夹中的相对地址，作用就是根据地址加载配置文件信息，输出Reader；

  ClassLoader[] getClassLoaders(ClassLoader classLoader) {
    return new ClassLoader[]{
        classLoader,
        defaultClassLoader,
        Thread.currentThread().getContextClassLoader(),
        getClass().getClassLoader(),
        systemClassLoader};
  }

类加载器为上述5种，可以看出，以传入的classLoader和默认的defaultClassLoader为主，下面三个大家都很熟悉了，那么一般我们用第三个；这里用到的两个为 org.apache.ibatis.io.Resources(主要用来解析文件，还可以返回Class)和org.apache.ibatis.io.ClassLoaderWrapper（主要是涉及到类加载器的用途，无非是加载文件和加载类），
这里主要涉及到org.apache.ibatis.io包，看包名就知道，该包下面都是关于io的类
这里写图片描述
包中就这么几个类，其中vfs类（虚拟文件系统,用来读取服务器里的资源），提供了2个实现 JBoss6VFS 和 DefaultVFS，并提供了用户扩展点，可定义VFS实现；加载顺序：自定义VFS实现 > 默认VFS实现取第一个加载成功的
1.2 根据Reader解析成mybatis必须数据

    SqlSessionFactoryBuilder sqlSessionFactoryBuilder = new SqlSessionFactoryBuilder();
        SqlSessionFactory sqlSessionFactory = sqlSessionFactoryBuilder.build(reader);

 1.2.1 好了，来看下SqlSessionFactoryBuilder 这个类，主要集中在build方法中，该方法提供了很多的重载方法，不一一说，重点说下下面的方法

  public SqlSessionFactory build(Reader reader, String environment, Properties properties) {
    try {
      XMLConfigBuilder parser = new XMLConfigBuilder(reader, environment, properties);
      return build(parser.parse());
    } catch (Exception e) {
      throw ExceptionFactory.wrapException("Error building SqlSession.", e);
    } finally {
      ErrorContext.instance().reset();
      try {
        reader.close();
      } catch (IOException e) {
        // Intentionally ignore. Prefer previous error.
      }
    }
  }

看出，不仅仅可以传reader，还可以自定义environment（jdbc连接条件）和properties（变量）这两个配置信息，可以看出重点又在XMLConfigBuilder这个类中了

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

XPathParser 解析类，主要封装通过javax.xml.xpath.XPath来生成Document，具体怎么解析就不说了，不是本文重点；

  private XMLConfigBuilder(XPathParser parser, String environment, Properties props) {
    super(new Configuration());
    ErrorContext.instance().resource("SQL Mapper Configuration");
    this.configuration.setVariables(props);
    this.parsed = false;
    this.environment = environment;
    this.parser = parser;
  }

出现Configuration 这个类，上面讲到过， MyBatis所有的配置信息都维持在Configuration对象之中。从这里才真正的开始解析配置文件至mybatis中；Configuration 默认构造函数中就注册了很多别名，其实就是放进map中，这种方式在很多地方都会见到；
1.2.2 parser.parse()
来看看，parse方法中发生了什么；

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

重点是parseConfiguration这个方法，可以看出，先从configuration开始解析了；

     private void parseConfiguration(XNode root) {
    try {
      //issue #117 read properties first
      propertiesElement(root.evalNode("properties"));
      Properties settings = settingsAsProperties(root.evalNode("settings"));
      loadCustomVfs(settings);
      typeAliasesElement(root.evalNode("typeAliases"));
      pluginElement(root.evalNode("plugins"));
      objectFactoryElement(root.evalNode("objectFactory"));
      objectWrapperFactoryElement(root.evalNode("objectWrapperFactory"));
      reflectorFactoryElement(root.evalNode("reflectorFactory"));
      settingsElement(settings);
      // read it after objectFactory and objectWrapperFactory issue #631
      environmentsElement(root.evalNode("environments"));
      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);
    }
  }

很明显，所有的配置信息全部在改方法中生成，我们挑些讲讲；
1.2.2.1 propertiesElement(root.evalNode(“properties”));

     Properties defaults = context.getChildrenAsProperties();
      String resource = context.getStringAttribute("resource");
      String url = context.getStringAttribute("url");

由上可知，属性变量有三种方式可以加载进来，节点子集、resource和url节点属性，其中resource和url只能存在一个，最终合并放进配置文件中

 parser.setVariables(defaults);
 configuration.setVariables(defaults);

    1.2.2.2
    typeAliasesElement(root.evalNode("typeAliases"));
    注册别名，简单点说就是以别名为key，class为value存放于对应的map中，以便后续用
    1.2.2.3 pluginElement(root.evalNode("plugins"));
    注册插件；先注册进别名，然后放入插件链中
    1.2.2.4 objectFactoryElement(root.evalNode("objectFactory"));
    类创建工程，该类作用仅仅是生成实例，默认是DefaultObjectFactory；我们可以实现我们自定义的工厂，实现ObjectFactory接口即可，可以用于类初始化的作用
    1.2.2.5 objectWrapperFactoryElement(root.evalNode("objectWrapperFactory"));
    动态获取和设置属性的值，默认使用DefaultObjectWrapperFactory，mybatis基本考虑会很全，自定义的很少使用
    对象包装工程
    1.2.2.6 reflectorFactoryElement(root.evalNode("reflectorFactory"));
    反射工厂，功能很简单，就是生成一个反射配置数据，存储Reflector类（里面包含了该类涉及到方法、构造函数、字段、类型很全的一套反射信息，赋值、取值都可以通过他来操作。我们以后自己项目也可以直接拿来使用）数据，默认使用DefaultReflectorFactory类
      1.2.2.7 environmentsElement
      主要配置连接执行环境，里面包含了事务（JdbcTransactionFactory还有ManagedTransactionFactory,一般使用前者）及数据源（POOL、UNPOOL，JNDI之分，一般肯定选择池）的配置信息的生成；最终生成Environment；Environment这个类比较奇怪，里面实现了内部类Builder，但是内部类和外部类区别不大 ，何必呢。。
      1.2.2.8   typeHandlerElement(root.evalNode("typeHandlers"));
      类型转换器，该配置可以根据包名，进而解析整个包获取，也可以指定转换类，因为typeHandlerRegistry类中可以对包进行注册
      1.2.2.9    mapperElement(root.evalNode("mappers"));
          xml配置文件解析，同.1.2.2.8 可以对包（只能在mapper类同包名下才行），也可以其他方式

     String resource = child.getStringAttribute("resource");
          String url = child.getStringAttribute("url");
          String mapperClass = child.getStringAttribute("class");

由上可以看出是三种方式，其中数resource和url复杂，class是很简单的，
我们这里举resource的例子，这里涉及到XMLMapperBuilder类

            InputStream inputStream = Resources.getResourceAsStream(resource);
            XMLMapperBuilder mapperParser = new XMLMapperBuilder(inputStream, configuration, resource, configuration.getSqlFragments());
            mapperParser.parse();

好嘛,mapper.xml解析入口在这里了。好复杂。。
XMLMapperBuilder（解析mapper.xml配置信息类）和XmlConfigBuilder类似，都继承BaseBuilder，同样都有parse 解析方法，只是XMLMapperBuilder更复杂些，因为mapper.xml中的节点更多更复杂。

  public void parse() {
    if (!configuration.isResourceLoaded(resource)) {
      configurationElement(parser.evalNode("/mapper"));
      configuration.addLoadedResource(resource);
      bindMapperForNamespace();
    }

    parsePendingResultMaps();
    parsePendingCacheRefs();
    parsePendingStatements();
  }

  private void configurationElement(XNode context) {
    try {
      String namespace = context.getStringAttribute("namespace");
      if (namespace == null || namespace.equals("")) {
        throw new BuilderException("Mapper's namespace cannot be empty");
      }
      builderAssistant.setCurrentNamespace(namespace);
      cacheRefElement(context.evalNode("cache-ref"));
      cacheElement(context.evalNode("cache"));
      parameterMapElement(context.evalNodes("/mapper/parameterMap"));
      resultMapElements(context.evalNodes("/mapper/resultMap"));
      sqlElement(context.evalNodes("/mapper/sql"));
      buildStatementFromContext(context.evalNodes("select|insert|update|delete"));
    } catch (Exception e) {
      throw new BuilderException("Error parsing Mapper XML. Cause: " + e, e);
    }
  }

从configurationElement方法可以看出，xml直接关联唯一mapper类，那么可以以此作为key,进而为后续调用获取配置信息打下基础。
MapperBuilderAssistant用于缓存、sql参数、查询返回的结果集处理。

SQL 映射文件有很少的几个顶级元素（按照它们应该被定义的顺序）：

cache – 给定命名空间的缓存配置。可以配置
映射语句文件中的所有 select 语句将会被缓存。
映射语句文件中的所有 insert,update 和 delete 语句会刷新缓存。
缓存会使用 Least Recently Used(LRU,最近最少使用的)算法来收回。
根据时间表(比如 no Flush Interval,没有刷新间隔), 缓存不会以任何时间顺序来刷新。
缓存会存储列表集合或对象(无论查询方法返回什么)的 1024 个引用。
缓存会被视为是 read/write(可读/可写)的缓存,意味着对象检索不是共享的,而且可以安全地被调用者修改,而不干扰其他调用者或线程所做的潜在修改。
cache-ref – 其他命名空间缓存配置的引用。共用一个namespace缓存
resultMap – 是最复杂也是最强大的元素，用来描述如何从数据库结果集中来加载对象。
这里解析的resultMap中的数据，其中涉及到ResultMapping类，主要记录对应的表及实体类相关配置数据，存进resultMappings 中
parameterMap – 已废弃！老式风格的参数映射。内联参数是首选,这个元素可能在将来被移除，这里不会记录。
sql – 可被其他语句引用的可重用语句块。
这块仅仅是将配置信息存入，而没有进一步去解析
insert – 映射插入语句
update – 映射更新语句
delete – 映射删除语句
select – 映射查询语句
上面四种都是一样处理，仅仅是类型不一样而已；
其中涉及到XMLStatementBuilder类，该类主要记录Statement相关的配置信息MappedStatement

好了最麻烦的也处理完成了！！返回Configuration，所有的配置信息全在里面了

  public SqlSessionFactory build(Configuration config) {
    return new DefaultSqlSessionFactory(config);
  }

返回DefaultSqlSessionFactory
接下来是下面这段代码

SqlSession session = sqlSessionFactory.openSession();

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

开启会话，来看看到底干什么了！
看代码，初始化了事务Transaction，根据例子，其实这里真实的对象应该是JdbcTransaction
也初始化了Executor ，mybatis的执行器

public Executor newExecutor(Transaction transaction, ExecutorType executorType) {
    executorType = executorType == null ? defaultExecutorType : executorType;
    executorType = executorType == null ? ExecutorType.SIMPLE : executorType;
    Executor executor;
    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);
    }
    if (cacheEnabled) {
      executor = new CachingExecutor(executor);
    }
    executor = (Executor) interceptorChain.pluginAll(executor);
    return executor;
  }

看代码，executor 最终被CachingExecutor装饰了，执行时，先执行CachingExecutor，再执行SimpleExecutor（我们例子里是simple）

  public CachingExecutor(Executor delegate) {
    this.delegate = delegate;
    delegate.setExecutorWrapper(this);
  }

额，构造函数里又把CachingExecutor传递给SimpleExecutor了，这是要干啥，没看到什么用途，先不管，继续继续！
executor = (Executor) interceptorChain.pluginAll(executor);
将执行器放入插件链中，判断是否符合自定义插件类型，符合则生成代理，则以后凡是到了执行器这里，则优先进入自定义插件执行！
这就是制作插件的原理，使用代理！
最终返回DefaultSqlSession，又是个Default
好了，会话成功开启！

总结：
mybatis配置阶段，使用了共享模式、装饰模式、代理模式、工厂模式、模板模式、外观模式。
插件的原理是使用代理（jdk代理（必须要有接口）或者cglib代理（类），两者性能都很高），用jdk的动态代理实现了拦截器和Mapper接口。这种动态代理和注解的运用也是非常值得学习的。
好吧！写的很烂，连图都没画！
下一篇准备mybatis执行部分解析