mybatis工作原理_万字好文！MyBatis 的工作原理，你了解过吗？

最新推荐文章于 2022-08-09 16:04:03 发布
最新推荐文章于 2022-08-09 16:04:03 发布
阅读量74 收藏
点赞数
文章标签： mybatis工作原理 mybatis的工作原理
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_39614675/article/details/111276169
版权

94d2d1db2773b10de46c79c78c7ea2c7.png

回复 1024 有特别礼包

作者：江南入直 | 来源：cnblogs.com/scuury/p/10371246.html

上一篇：微信支付的架构到底有多牛？

近来想写一个mybatis的分页插件，但是在写插件之前肯定要了解一下mybatis具体的工作原理吧，于是边参考别人的博客，边看源码就开干了。

核心部件：

  • SqlSession
  • Executor
  • StatementHandler
  • ParameterHandler
  • ResultSetHandler
  • TypeHandler
  • MappedStatement
  • Configuration

在分析工作原理之前，首先看一下我的mybatis全局配置文件

<?xml  version="1.0" encoding="UTF-8" ?>
configuration
PUBLIC "-//mybatis.org//DTD Config 3.0//EN"
"http://mybatis.org/dtd/mybatis-3-config.dtd">
default="development">"development">"JDBC" />"POOLED">"driver" value="com.mysql.jdbc.Driver" />"url"
                    value="jdbc:mysql://localhost:3306/test?characterEncoding=utf-8" />"username" value="root" />"password" value="123456" />"sqlMapper/userMapper.xml"/>

第一步：创建一个sqlSessionFactory

在了解如何创建sqlSessionFactory之前，先看一下mybatis是如何加载全局配置文件，解析xml文件生成Configuration的

public Configuration parse() {
    if (parsed) {
      throw new BuilderException("Each XMLConfigBuilder can only be used once.");
    }
    parsed = true;
    parseConfiguration(parser.evalNode("/configuration"));
    return 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);
    }
  }

在上面的第二段代码中有一句

mapperElement(root.evalNode("mappers"));

刚好我们的全局配置文件中有一个mapper的配置，由此可见，mapperElemet()方法是解析mapper映射文件的，具体代码如下

private void mapperElement(XNode parent) throws Exception {
    if (parent != null) {
      for (XNode child : parent.getChildren()) {
        if ("package".equals(child.getName())) {
          String mapperPackage = child.getStringAttribute("name");
          configuration.addMappers(mapperPackage);
        } else {
          String resource = child.getStringAttribute("resource");
          String url = child.getStringAttribute("url");
          String mapperClass = child.getStringAttribute("class");
          if (resource != null && url == null && mapperClass == null) {//进入该判断
            ErrorContext.instance().resource(resource);
            InputStream inputStream = Resources.getResourceAsStream(resource);
            XMLMapperBuilder mapperParser = new XMLMapperBuilder(inputStream, configuration, resource, configuration.getSqlFragments());
            mapperParser.parse();
          } else if (resource == null && url != null && mapperClass == null) {
            ErrorContext.instance().resource(url);
            InputStream inputStream = Resources.getUrlAsStream(url);
            XMLMapperBuilder mapperParser = new XMLMapperBuilder(inputStream, configuration, url, configuration.getSqlFragments());
            mapperParser.parse();
          } else if (resource == null && url == null && mapperClass != null) {
            Class> mapperInterface = Resources.classForName(mapperClass);
            configuration.addMapper(mapperInterface);
          } else {
            throw new BuilderException("A mapper element may only specify a url, resource or class, but not more than one.");
          }
        }
      }
    }
  }

根据以上代码可以分析，在写mapper映射文件的地址时不仅可以写成resource，还可以写成url和mapperClass的形式，由于我们用的是resource，所以直接进入第一个判断，最后解析mapper映射文件的方法是

private void configurationElement(XNode context) {
    try {
      String namespace = context.getStringAttribute("namespace");
      if (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);
    }
  }

其中具体解析每一个sql语句节点的是

buildStatementFromContext(context.evalNodes("select|insert|update|delete"));

进入这个方法一层层深究，最后到这里可以知道MappedStatement是由builderAssistant(即MapperBuildAssistant)创建的。

public void parseStatementNode() {
    ...
    builderAssistant.addMappedStatement(id, sqlSource, statementType, sqlCommandType,
        fetchSize, timeout, parameterMap, parameterTypeClass, resultMap, resultTypeClass,
        resultSetTypeEnum, flushCache, useCache, resultOrdered,
        keyGenerator, keyProperty, keyColumn, databaseId, langDriver, resultSets);
  }

最后进入方法addMappedStatement()，mappedStatement最后以id为键保存在了Configuration中的一个map变量mappedStatements中。

public MappedStatement addMappedStatement(
      String id,
      SqlSource sqlSource,
      StatementType statementType,
      SqlCommandType sqlCommandType,
      Integer fetchSize,
      Integer timeout,
      String parameterMap,
      Class> parameterType,
      String resultMap,
      Class> resultType,
      ResultSetType resultSetType,boolean flushCache,boolean useCache,boolean resultOrdered,
      KeyGenerator keyGenerator,
      String keyProperty,
      String keyColumn,
      String databaseId,
      LanguageDriver lang,
      String resultSets) {

    if (unresolvedCacheRef) throw new IncompleteElementException("Cache-ref not yet resolved");

    id = applyCurrentNamespace(id, false);
    boolean isSelect = sqlCommandType == SqlCommandType.SELECT;

    MappedStatement.Builder statementBuilder = new MappedStatement.Builder(configuration, id, sqlSource, sqlCommandType);
    statementBuilder.resource(resource);
    statementBuilder.fetchSize(fetchSize);
    statementBuilder.statementType(statementType);
    statementBuilder.keyGenerator(keyGenerator);
    statementBuilder.keyProperty(keyProperty);
    statementBuilder.keyColumn(keyColumn);
    statementBuilder.databaseId(databaseId);
    statementBuilder.lang(lang);
    statementBuilder.resultOrdered(resultOrdered);
    statementBuilder.resulSets(resultSets);
    setStatementTimeout(timeout, statementBuilder);

    setStatementParameterMap(parameterMap, parameterType, statementBuilder);
    setStatementResultMap(resultMap, resultType, resultSetType, statementBuilder);
    setStatementCache(isSelect, flushCache, useCache, currentCache, statementBuilder);

    MappedStatement statement = statementBuilder.build();
    configuration.addMappedStatement(statement);
    return statement;
  }

最后回到我们的创建sqlSessionFactory上，之前的一切都是为了生成一个sqlSessionFactory服务的

搜索公众号顶级架构师回复关键字“offer”，获取一份算法面试题和答案惊喜礼包。

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

从上面的代码可以看出最后是通过以Configuration为参数build()方法生成DefautSqlSessionFactory。

第二步：创建sqlSession

 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();
    }
  }
//返回一个SqlSession，默认使用DefaultSqlSession
 public DefaultSqlSession(Configuration configuration, Executor executor, boolean autoCommit) {
    this.configuration = configuration;
    this.executor = executor;
    this.dirty = false;
    this.autoCommit = autoCommit;
  }

executor在这一步得到创建，具体的使用在下一步。

第三步：执行具体的sql请求

在我的代码里执行的是

User user = sqlSession.selectOne("test.findUserById", 1);

具体到里面的方法就是

public  List selectList(String statement, Object parameter, RowBounds rowBounds) {try {//1.根据Statement Id，在mybatis 配置对象Configuration中查找和配置文件相对应的MappedStatement
      MappedStatement ms = configuration.getMappedStatement(statement);//2. 将查询任务委托给MyBatis 的执行器 Executor
      List result = executor.query(ms, wrapCollection(parameter), rowBounds, Executor.NO_RESULT_HANDLER);return result;
    } catch (Exception e) {throw ExceptionFactory.wrapException("Error querying database.  Cause: " + e, e);
    } finally {
      ErrorContext.instance().reset();
    }
  }

在这里通过statementId拿到了我们在第一步存在map里面的MappedStatement。在这里引用参考博客的一句话：

SqlSession根据Statement ID, 在mybatis配置对象Configuration中获取到对应的MappedStatement对象，然后调用mybatis执行器来执行具体的操作。

再继续看query()和queryFromDatabase()这两个方法

@SuppressWarnings("unchecked")
  public  List query(MappedStatement ms, Object parameter, RowBounds rowBounds, ResultHandler resultHandler, CacheKey key, BoundSql boundSql) throws SQLException {
    ErrorContext.instance().resource(ms.getResource()).activity("executing a query").object(ms.getId());if (closed) throw new ExecutorException("Executor was closed.");if (queryStack == 0 && ms.isFlushCacheRequired()) {
      clearLocalCache();
    }
    List list;try {
      queryStack++;
      list = resultHandler == null ? (List) localCache.getObject(key) : null;if (list != null) {
        handleLocallyCachedOutputParameters(ms, key, parameter, boundSql);
      } else {
        list = queryFromDatabase(ms, parameter, rowBounds, resultHandler, key, boundSql);
      }
    } finally {
      queryStack--;
    }if (queryStack == 0) {for (DeferredLoad deferredLoad : deferredLoads) {
        deferredLoad.load();
      }
      deferredLoads.clear(); // issue #601if (configuration.getLocalCacheScope() == LocalCacheScope.STATEMENT) {
        clearLocalCache(); // issue #482
      }
    }return list;
  }
private  List queryFromDatabase(MappedStatement ms, Object parameter, RowBounds rowBounds, ResultHandler resultHandler, CacheKey key, BoundSql boundSql) throws SQLException {
    List list;
    localCache.putObject(key, EXECUTION_PLACEHOLDER);try {
      list = doQuery(ms, parameter, rowBounds, resultHandler, boundSql);
    } finally {
      localCache.removeObject(key);
    }
    localCache.putObject(key, list);if (ms.getStatementType() == StatementType.CALLABLE) {
      localOutputParameterCache.putObject(key, parameter);
    }return list;
  }

在这两个方法里面会为当前的查询创建一个缓存key，如果缓存中没有值，直接从数据库中读取，执行查询后将得到的list结果放入缓存之中。

紧接着看doQuery()在SimpleExecutor类中重写的方法

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

Statement连接对象就是在这里创建的，因此Executor的作用之一就是创建Statement了，创建完后又把Statement丢给StatementHandler返回List查询结果。

接下来再看一下这里的两个方法prepareStatement()和query()的具体实现

private Statement prepareStatement(StatementHandler handler, Log statementLog) throws SQLException {
    Statement stmt;
    Connection connection = getConnection(statementLog);
    stmt = handler.prepare(connection);
    handler.parameterize(stmt);
    return stmt;
  }

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

prepareStatement()是创建Statement的具体实现方法，调用parameterize()对创建的Statement对象设置参数，即为我们设为占位符的地方赋上指定的参数，parameterize()方法再深入进去就是调用ParameterHandler的setParameters()方法具体赋值了。

搜索公众号顶级架构师回复关键字“架构整洁”，获取一份惊喜礼包。

这里的query()是调用了ResultSetHandler的handleResultSets(Statement) 方法。作用就是把ResultSet结果集对象转换成List类型的集合。

总结以上步骤就是：

  1. 根据具体传入的参数，动态地生成需要执行的SQL语句，用BoundSql对象表示
  2. 为当前的查询创建一个缓存Key
  3. 缓存中没有值，直接从数据库中读取数据
  4. 执行查询，返回List 结果，然后 将查询的结果放入缓存之中
  5. 根据既有的参数，创建StatementHandler对象来执行查询操作
  6. 将创建Statement传递给StatementHandler对象,调用parameterize()方法赋值
  7. 调用StatementHandler.query()方法，返回List结果集

总结

以上三个步骤所有流程大体可以用一张图来总结

bb46f5005520a3dd019c5ee66dccbe2d.png PS：如果觉得我的分享不错，欢迎大家随手点赞、在看。

大家一起在评论区聊聊呗~

9d10b319918c0a87c3249d5d66afd01b.png 公众号后台回复 架构 或者 架构整洁 有惊喜礼包！ 顶级架构师交流群

 「顶级架构师」建立了读者架构师交流群，大家可以添加小编微信进行加群。欢迎有想法、乐于分享的架构师们一起交流学习。

e672b9c44644e6a191891a7d3ef05e18.png

扫描添加好友邀你进架构师群，加我时注明【姓名+公司+职位】

版权申明：内容来源网络，版权归原作者所有。如有侵权烦请告知，我们会立即删除并表示歉意。谢谢。

猜你还想看

Java基于Swing和Netty仿QQ界面聊天小项目
图解 Docker 架构
Java压缩20M文件从30秒到1秒的优化过程
MyBatis 如何兼容所有日志框架？

weixin_39614675
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
mybatis_test09_mybatis_Mine!_
10-04
本项目“mybatis_test09_mybatis_Mine!”显然是一份关于个人学习MyBatis的资料，旨在帮助用户深入理解和实践MyBatis的核心特性。 首先，MyBatis的安装与配置是入门的第一步。通常，我们需要在项目的pom.xml文件中...
八大排序算法
小白宫城诗的博客
06-29 285
排序算法 最近学习数据结构算法，学习了简书上一篇博客python的八大排序算法，想着试着通过不同语言去实现一下各种排序算法，由于语法不一样，实现起来也有很大差异（感觉js和python语法风格上非常近似），相比之下，python真是简洁便利和通俗易懂啊 1 冒泡法 冒泡排序(Bubble Sort)是一种简单的排序算法。它重复地走访过要排序的数列，一次比较两个元素，如果他们的顺序错误就把他们交换过来。走访数列的工作是重复地进行直到没有再需要交换，也就是说该数列已经排序完成。这个算法的名字由来是因为越小的元素
PyQt逻辑调用的通用脚本模板
神芷迦蓝寺
06-12 499
在当前的GUI编程里，一般我们把需要不断调试调优，不断变化的文件称为界面文件，由于界面文件每次编译时都会初始化，所以需要新建一个py文件来调用界面文件，这个新建的文件就叫做逻辑文件。 逻辑文件一般不需要改动，改动的是界面文件，这两个文件是相互独立的，如此我们就做到了界面与逻辑的分离 逻辑文件是有固定模板的，如下： 调用模块 # -*- coding: utf-8 -*- # 需要调用的模块，这些只是通用的，如缺失可自行添加 import sys from PyQt5.QtWidgets impor
方法解析顺序(MRO)
bbbeoy的专栏
12-12 722
方法解析顺序(Method Resolution Order - MRO)，是一种在多重继承中用于确定方法搜索顺序的算法，又称 C3 超类线性化(superclass linearization)。Python 会计算出每一个类的 MRO 列表。一个类的 MRO 列表是一个包含了其继承链上所有基类的线性顺序列，并且列表中的每一项均保持唯一。当需要在继承链中寻找某个属性时，Python会在 MRO ...
python多继承顺序及分配_Python中多重继承时方法解析顺序MRO(C3算法的应用)
weixin_39657300的博客
12-22 206
在计算机科学中，C3算法主要用于确定多重继承时，子类应该继承哪一个父类的方法，即方法解析顺序(Method Resolution Order，MRO)。C3算法实现了三种重要特性：保持继承拓扑图的一致性，保证局部优先原则(比如A继承B和C，C继承B，那么A读取父类方法，应该优先使用C的方法而不是B的方法)保证单调性原则(即子类不改变父类的方法搜索顺序)1996年的OOPSLA会议上，论文"A Mo...
Qt 笔记: QWidget，QDialog
Qiuery的博客
09-14 1517
QWidget类继承自QObject类和QpaintDevice类 - QObject是所有支持Qt对象模型的基类 - QPaintDevice是Qt中所有可绘制组件的基类 QWidget能够绘制自己和处理用户的输入 -QWidget是Qt中所有窗口组件类的父类（super class） -QWidget是所有窗口组件的抽象 -Qt中的每个窗口组件都是一个QWidget -QWidg...
Mybatis之工作原理
02-24
mybatis底层还是采用原生jdbc来对数据库进行操作的，只是通过SqlSessionFactory，SqlSessionExecutor,StatementHandler，ParameterHandler,ResultHandler和TypeHandler等几个处理器封装了这些过程执行器：Executor...
Mybatis Mapper接口工作原理实例解析
08-24
"Mybatis Mapper接口工作原理实例解析" Mybatis 作为一款优秀的持久层框架，它支持定制化 SQL、存储过程以及高级映射。MyBatis 避免了几乎所有的 JDBC 代码和手动设置参数以及获取结果集。在使用 Mybatis 进行开发...
mybatis_log_plugin.zip
02-22
MyBatis Log Plugin 这款插件是直接将Mybatis执行的sql脚本显示出来，把 mybatis 输出的sql日志还原成完整的sql语句 1、本地安装 2、Tools 》mybatis_log_plugin
PyQt5自制GUI的使用笔记（二）
Vccp_1M的博客
03-15 1391
一.继承 上一次我们使用了Qt UIC工具将自制的界面转化为了Image.py代码如下： # -*- coding: utf-8 -*- # Form implementation generated from reading ui file 'Image.ui' # # Created by: PyQt5 UI code generator 5.15.4 # # WARNING: Any manual changes made to this file will be lost when pyuic5
python多重继承MRO浅析
zsy_1991的博客
11-21 240
待补充
Python3多继承时的方法解析顺序
raymond531的博客
02-24 615
文章目录Python3中使用的MROC3线性化线性化计算方法 对于支持继承的编程语言来说，其方法（属性）可能定义在当前类，也可能来自于基类，所以在方法调用时就需要对当前类和基类进行搜索以确定方法所在的位置。而搜索的顺序就是所谓的「方法解析顺序」（Method Resolution Order，或MRO）。对于只支持单继承的语言来说，MRO 一般比较简单；而对于 Python 这种支持多继承的语言来...
Python语言中 reshape排序参数order详解
rongqing168的博客
08-09 8239
使用Pyton时发现网上关于reshape方法的文章一般都比较简单，尤其是关于排序的问题很少涉及或讲解的不清楚，所以特整理了reshape的用法，供大家参考。
python多继承mro_Python的多继承问题-MRO和C3算法
weixin_42172972的博客
01-15 165
Python 中的方法解析顺序(Method Resolution Order, MRO)定义了多继承存在时 Python 解释器查找函数解析的正确方式。当 Python 版本从 2.2 发展到 2.3 再到现在的 Python 3，MRO算法也随之发生了相应的变化。这种变化在很多时候影响了我们使用不同版本 Python 编程的过程。什么是 MROMRO 全称方法解析顺序(Method Resol...
Python 类继承，__bases__, __mro__, super
iCode0410的专栏
09-19 8734
Python是面向对象的编程语言，也支持类继承。 >>> class Base: ... pass ... >>> class Derived(Base): ... pass    这样就定义了两个类，Derived继承了Base。issubclass(a,b)可以测试继承关系： >>> issubclass(Derived, Base) True    在
TypeError: Cannot create a consistent method resolution order (MRO) for bases object, JavaModel, Jav
囧疼她的博客
08-12 3096
错误代码 错误：TypeError: Cannot create a consistent method resolution order (MRO) for bases object, JavaModel, JavaPredictionModel, JavaMLWritable, XGBoostReadable 错误程序 import numpy as np import pandas as pd import os import re from sklearn import metrics import
QMainWindow
hurryddd
09-06 210
目录 1、QWidget、QMainWindow、QDialog的关系 2、QMainWindow 3、创建可视化编辑的 QMainWindow 4、资源文件添加 1、QWidget、QMainWindow、QDialog的关系 2、QMainWindow #include "mainwindow.h" #include <QMenuBar> #include <QToolBar> #include <QStatusBar> #inclu.
Qt学习（六）—— QMainWindow
饭的笔记本
07-08 2704
菜单栏 菜单栏 要使用菜单栏控件，需要先引入<QMenuBar>和<QMenu>头文件。创建一个带菜单栏的QMainWindow语句如下： #include "MainWindow.h" #include "ui_MainWindow.h" #include <QMenuBar> #include <QMenu> MainWindow::MainWindow(QWidget *parent) : QMainWindow(parent),
mybatis工作原理
最新发布
05-20
MyBatis是一款持久层框架，它的工作原理是将 Java 对象映射到数据库表中的行，通过 SQL 语句实现数据的存取。下面是 MyBatis 的工作原理： 1.配置文件加载：MyBatis 首先会读取配置文件，即 mybatis-config.xml ...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值