MyBatis 源码学习 | Day 3 | 数据读写阶段

置顶 已于 2024-08-11 16:36:14 修改
阅读量1.4k 收藏 13
点赞数 51
分类专栏： MyBatis 文章标签： mybatis 学习
于 2024-08-09 19:01:52 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_59271089/article/details/141004567
版权

前情提要

在上一篇 MyBatis 源码学习 | Day 2 | MyBatis 初始化 中，我们探究了使用 MyBatis 操作数据库过程中 MyBatis 的第一阶段——初始化阶段，今天我们将探究数据的读写阶段。

MyBatis 操作数据库 Demo ↓

/**
 * 使用 MyBatis 操作数据库
 *
 * @author nx-xn2002
 * @date 2024-08-02
 */
public class QueryWithMyBatis {
    public static void main(String[] args) throws IOException {
        //第一阶段：MyBatis初始化
        String resource = "mybatis-config.xml";
        InputStream inputStream = Resources.getResourceAsStream(resource);
        SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder().build(inputStream);

        //第二阶段：数据读写阶段
        SqlSession sqlSession = sqlSessionFactory.openSession();
        UserMapper mapper = sqlSession.getMapper(UserMapper.class);
        List<User> users = mapper.listAll();
        users.forEach(System.out::println);
        User user = mapper.selectUserById(1L);
        System.out.println(user);
        sqlSession.close();
    }
}

数据读写阶段

在上一阶段中，通过 Resources 类读取解析配置文件，SqlSessionFactoryBuilder 类使用配置文件，我们获得了能够对数据库连接和相关操作进行管理的 SqlSessionFactory 工厂类对象。在数据读写阶段，我们需要一个 SqlSession 对象来执行命令、获取 mapper 映射、管理事务，在源码中原话就是这样说的：

/**
 * The primary Java interface for working with MyBatis.
 * Through this interface you can execute commands, get mappers and manage transactions.
 *
 * @author Clinton Begin
 */
public interface SqlSession extends Closeable {
	// ...
}

在我们的程序里，是调用了 SqlSessionFactory 对象的 openSession 方法来获取 SqlSession 对象

SqlSession sqlSession = sqlSessionFactory.openSession();

而在上一篇最后，我们提到 SqlSessionFactory 实际上是一个接口，此处使用的是它的一个默认的实现类 DefaultSqlSessionFactory 的对象，所以我们进入到这个实现类的 openSession 方法，看一下具体是如何创建 SqlSession 对象的。
方法源码如下：

@Override
public SqlSession openSession() {
	return openSessionFromDataSource(configuration.getDefaultExecutorType(), null, false);
}

可以看到，openSession 方法实际上是调用了 openSessionFromDataSource 方法，我们再进入到这个核心方法中：

private SqlSession openSessionFromDataSource(ExecutorType execType, TransactionIsolationLevel level, boolean autoCommit) {
	Transaction tx = null;
	DefaultSqlSession var8;
	try {
	    Environment environment = this.configuration.getEnvironment();
	    TransactionFactory transactionFactory = this.getTransactionFactoryFromEnvironment(environment);
	    tx = transactionFactory.newTransaction(environment.getDataSource(), level, autoCommit);
	    Executor executor = this.configuration.newExecutor(tx, execType);
	    var8 = new DefaultSqlSession(this.configuration, executor, autoCommit);
	} catch (Exception var12) {
	    this.closeTransaction(tx);
	    throw ExceptionFactory.wrapException("Error opening session.  Cause: " + var12, var12);
	} finally {
	    ErrorContext.instance().reset();
	}
	return var8;
}

可以看到，在这里面，之前读取的配置信息被用来创建事务工厂 TransactionFactory、执行器 Executor 和 DefaultSqlSession 对象，而其中的 DefaultSqlSession 提供了一系列的增删改查、提交、回滚的方法。在读写阶段中，我们只需要创建一次 SqlSession 对象就可以供我们进行多次的数据库操作复用。
继续往下看，UserMapper mapper = sqlSession.getMapper(UserMapper.class) 一句通过刚刚的 DefaultSqlSession 类对象的 getMapper 方法，获取到了一个 UserMapper 接口的实现类对象，我们进入源码查看细节

@Override
public <T> T getMapper(Class<T> type) {
	return configuration.getMapper(type, this);
}

可以看到，这里是调用了 Configuration 类对象的 getMapper 方法，在一路向下走，会注意到实际上最后调用的是 MapperRegistry 类的同名方法

@SuppressWarnings("unchecked")
  public <T> T getMapper(Class<T> type, SqlSession sqlSession) {
    final MapperProxyFactory<T> mapperProxyFactory = (MapperProxyFactory<T>) knownMappers.get(type);
    if (mapperProxyFactory == null) {
      throw new BindingException("Type " + type + " is not known to the MapperRegistry.");
    }
    try {
      return mapperProxyFactory.newInstance(sqlSession);
    } catch (Exception e) {
      throw new BindingException("Error getting mapper instance. Cause: " + e, e);
    }
  }

此处我们传入的是想要构造的 UserMapper.class 和刚刚的 DefaultSqlSession 对象，在这里面，final MapperProxyFactory<T> mapperProxyFactory = (MapperProxyFactory<T>) knownMappers.get(type) 中 knownMappers 是一个 HashMap 对象，可以定位到，在 MyBatis 初始化阶段中解析配置文件时调用了相关的 addMapper 方法来将对应的 <Class<?>, MapperProxyFactory<?>> 键值对放入到这个哈希表中，此时如果传入的 type 是之前正确解析过的，就能够正常拿到对应的 MapperProxyFactory 对象

我们再来看到最后返回值部分的 return mapperProxyFactory.newInstance(sqlSession) 里的 newInstance 方法，源代码如下：

@SuppressWarnings("unchecked")
protected T newInstance(MapperProxy<T> mapperProxy) {
	return (T) Proxy.newProxyInstance(mapperInterface.getClassLoader(), new Class[] { mapperInterface }, mapperProxy);
}

public T newInstance(SqlSession sqlSession) {
	final MapperProxy<T> mapperProxy = new MapperProxy<>(sqlSession, mapperInterface, methodCache);
	return newInstance(mapperProxy);
}

显然，我们可以知道，最后是返回了一个基于反射的动态代理对象 MapperProxy 类对象，于是我们可以直接去到 MapperProxy 类的 invoke 方法中去查看相关实现，这是一个动态代理方法，用于拦截并调用接口的实现方法，看到源代码如下

@Override
public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
	try {
		if (Object.class.equals(method.getDeclaringClass())) {
			return method.invoke(this, args);
		} else if (method.isDefault()) {
			return invokeDefaultMethod(proxy, method, args);
		}
	} catch (Throwable t) {
		throw ExceptionUtil.unwrapThrowable(t);
	}
	final MapperMethod mapperMethod = cachedMapperMethod(method);
	return mapperMethod.execute(sqlSession, args);
}

可以看到，如果调用的只是 Object 类的方法，或者使用 default 修饰的方法，就会直接去运行。而除此之外，则会执行以下两句代码

final MapperMethod mapperMethod = cachedMapperMethod(method);
return mapperMethod.execute(sqlSession, args);

第一句执行的是尝试从缓存中获取一个 MapperMethod 对象，观察一下 cachedMapperMethod 方法

private MapperMethod cachedMapperMethod(Method method) {
    return methodCache.computeIfAbsent(method, k -> new MapperMethod(mapperInterface, method, sqlSession.getConfiguration()));
}

可以看到，这里是尝试从一个 Map 对象中去取出一个 MapperMethod 对象，如果对象不存在，就创建并返回。这里有点类似本地缓存里的 LoadingCache，我觉得根据实际需求，其实可以考虑使用 Caffine 的缓存实现来提升性能。
在获取到 MapperMethod 对象后，将会执行它的 execute 方法并返回结果，可以看到具体的方法实现如下：

public Object execute(SqlSession sqlSession, Object[] args) {
  Object result;
  switch (command.getType()) {
    case INSERT: {
      Object param = method.convertArgsToSqlCommandParam(args);
      result = rowCountResult(sqlSession.insert(command.getName(), param));
      break;
    }
    case UPDATE: {
      Object param = method.convertArgsToSqlCommandParam(args);
      result = rowCountResult(sqlSession.update(command.getName(), param));
      break;
    }
    case DELETE: {
      Object param = method.convertArgsToSqlCommandParam(args);
      result = rowCountResult(sqlSession.delete(command.getName(), param));
      break;
    }
    case SELECT:
      if (method.returnsVoid() && method.hasResultHandler()) {
        executeWithResultHandler(sqlSession, args);
        result = null;
      } else if (method.returnsMany()) {
        result = executeForMany(sqlSession, args);
      } else if (method.returnsMap()) {
        result = executeForMap(sqlSession, args);
      } else if (method.returnsCursor()) {
        result = executeForCursor(sqlSession, args);
      } else {
        Object param = method.convertArgsToSqlCommandParam(args);
        result = sqlSession.selectOne(command.getName(), param);
        if (method.returnsOptional()
          && (result == null || !method.getReturnType().equals(result.getClass()))) {
          result = Optional.ofNullable(result);
        }
      }
      break;
    case FLUSH:
      result = sqlSession.flushStatements();
      break;
    default:
      throw new BindingException("Unknown execution method for: " + command.getName());
  }
  if (result == null && method.getReturnType().isPrimitive() && !method.returnsVoid()) {
    throw new BindingException("Mapper method '" + command.getName()
      + " attempted to return null from a method with a primitive return type (" + method.getReturnType() + ").");
  }
  return result;
}

在我们的程序里，具体执行的其实就是 SELECT 下的 result = executeForMany(sqlSession, args);这一句，过程较为复杂，我们直接看到两个核心方法，下面是 CachingExecutor 类的两个方法，执行查询时，最后是可以定位到这两个方法处

@Override
public <E> List<E> query(MappedStatement ms, Object parameterObject, RowBounds rowBounds,
                         ResultHandler resultHandler) throws SQLException {
  BoundSql boundSql = ms.getBoundSql(parameterObject);
  CacheKey key = createCacheKey(ms, parameterObject, rowBounds, boundSql);
  return query(ms, parameterObject, rowBounds, resultHandler, key, boundSql);
}

@Override
public <E> List<E> query(MappedStatement ms, Object parameterObject, RowBounds rowBounds,
                         ResultHandler resultHandler, CacheKey key, BoundSql boundSql)
  throws SQLException {
  Cache cache = ms.getCache();
  if (cache != null) {
    flushCacheIfRequired(ms);
    if (ms.isUseCache() && resultHandler == null) {
      ensureNoOutParams(ms, boundSql);
      @SuppressWarnings("unchecked")
      List<E> list = (List<E>) tcm.getObject(cache, key);
      if (list == null) {
        list = delegate.query(ms, parameterObject, rowBounds, resultHandler, key, boundSql);
        tcm.putObject(cache, key, list); // issue #578 and #116
      }
      return list;
    }
  }
  return delegate.query(ms, parameterObject, rowBounds, resultHandler, key, boundSql);
}

在 getBoundSql 方法中，会层层转化去掉 if、where 等标签，获取到 SQL 语句，然后 createCacheKey 为本次查询操作技术缓存键值，可以看到，在最后的实现里，如果命中缓存，就可以直接从缓存里获取结果，否则，就通过 delegate 对象调用 query 方法。通过分析，我们可以知道，这里是调用了 BaseExecutor 类对象的同名方法

@SuppressWarnings("unchecked")
@Override
public <E> List<E> 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<E> list;
  try {
    queryStack++;
    list = resultHandler == null ? (List<E>) 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();
    }
    // issue #601
    deferredLoads.clear();
    if (configuration.getLocalCacheScope() == LocalCacheScope.STATEMENT) {
      // issue #482
      clearLocalCache();
    }
  }
  return list;
}

此处表明 MyBatis 开始使用数据库展开查询操作，最终会定位到一个 PreparedStatement 对象执行 execute 方法进行查询，然后最后循环遍历结果对象的每一个属性为各个属性进行赋值操作，至此，数据读写完成。

总结

在这一阶段里，MyBatis 的工作流程大致如下：

  1. 建立数据库连接，获取 SqlSession 对象
  2. 获取当前映射接口对应的数据库操作节点，并生成接口实现类
  3. 接口实现类拦截对接口中方法的调用，完成其中数据操作方法的调用实现
  4. 将数据库操作节点中的语句进行处理，转换为标准的 SQL 语句
  5. 尝试从缓存中获得结果，如果找不到就继续从数据库中查询
  6. 从数据库查询结果
  7. 处理结果集
    • 建立输出对象
    • 对输出对象的属性进行赋值
  8. 在缓存中记录结果
  9. 返回查询结果
nx__xn
关注
专栏目录
Mybatis 源码学习type 包
专注Java（全栈）应用开发，求知若渴，虚心若愚，talk is cheap, show me the code.
05-13 245
Mybatis 源码学习type 包目录概 述类型处理器类型注册表TypeHandlerRegistry小结参考资料和推荐阅读 LD is tigger forever，CG are not brothers forever， throw the pot and shine forever. Modesty is not false, solid is not naive, treacherous but not deceitful, stay with good people, and stay aw
MyBatis 源码学习 | Day 4 | 了解MyBatis源码
nx__xn的博客
08-11 528
在前几天的学习中，我们通过一个 MyBatis 操作数据库的 Demo，了解了 MyBatis 的整体运行流程，接下来我们将深入到 MyBatis 源码的各个包和类进行源码阅读，今天将先对各个包从功能上进行归类划分，方便我们后续的阅读学习。
MyBatis 源码学习 | Day 2 | MyBatis 初始化
nx__xn的博客
08-05 819
以上就是解析配置文件的基本流程，最后通过尝试调用各个类加载器的解析配置文件的方法，来对配置文件进行解析，在这个过程中，大量使用了方法重载，使得程序变得灵活。可以看到在这里就是配置文件的解析过程，从配置文件的根节点开始，逐层进行解析，也包括其中相关的映射文件，解析过程里，不断把解析结果放入到。这个方法返回当前线程的上下文类加载器，上下文类加载器可以被设置为任何类加载器，但默认情况下，它通常是指向应用程序类加载。这个方法返回加载当前类的类加载器，对于大多数非基本类来说，这将是应用程序类加载器。
Day680.大佬如何学习源码 -深入拆解 Tomcat & Jetty
阿昌爱Java
07-17 871
带着这些问题去分析相关的源码效率会更高，同时你在寻找答案的过程中，也会碰到更多问题，等你把这些问题都弄清楚了，你获得的不仅仅是知识，更重要的是你会树立起攻克难关的信心。当你对知识有了一定的积累，这时再来学一个新的系统，往往你只需要瞧上几眼，就能明白它所用的架构，而且你会自然联想到系统存在哪些角色，以及角色之间的关系，包括静态的依赖关系和动态的协作关系，甚至你会不由自主带着审视的眼光，来发现一些可以改进的地方。当然在这个过程中，你还可以看看产品的官方文档，熟悉一下大概的设路。...
mybatis_day03
xiaoppt的博客
08-04 148
1 mybatis中的连接池 1.1 什么是连接池 数据库连接是一项有限的昂贵资源，一个数据库连接对象均对应一个物理数据库连接，每次操作都打开一个物理连接，使用完都关闭连接，这样造成系统的性能低下。 数据库连接池的解决方案是在应用程序启动时建立足够的数据库连接，并将这些连接组成一个连接池，由应用程序动态地对池中的连接进行申请、使用和释放。 对于多于连接池中连接数的并发请求，应该在请求队列中排队等待。并且应用程序可以根据池中连接的使用率，动态增加或减少池中的连接数。 总结： 连接池是面向数据库
MyBatis-Plus学习笔记
MEITOUMEINAOA的博客
03-11 525
一、简介 MyBatis-Plus是MyBatis的增强工具，在 MyBatis 的基础上只做增强不做改变，为简化开发、提高效率而生。 1、特性 无侵入：只做增强不做改变，引入它不会对现有工程产生影响，如丝般顺滑 损耗小：启动即会自动注入基本 CURD，性能基本无损耗，直接面向对象操作 强大的 CRUD 操作：内置通用 Mapper、通用 Service，仅仅通过少量配置即可实现单表大部分 CRUD 操作，更有强大的条件构造器，满足各类使用需求 支持 Lambda 形式调用：通过 Lambda 表达式，方
致力微服务 SpringCloud 篇六 springboot+mybatis+mysql读写分离初试排坑经历
huofuman960209的博客
08-16 3260
1.引言 读写分离就是把一条SQL放到自己想要的那个数据库去执行，我们要做的就是实现SQL怎么自己去对应的数据库执行。 两种实现方式。第一种是依靠中间件（比如：MyCat），也就是说应用程序连接到中间件，中间件帮我们做SQL分离；第二种是应用程序自己去做分离。目前只做了第二种，主要是利用Spring提供的路由数据源，以及AOP；后续会利用mycat来做，我想无非是集成配置吧。 在这里有所感悟...
SpringBoot3 全栈指南教程——尚硅谷学习笔记 2023年
末影小黑xh的博客
09-15 4641
Java17Maven、IDEA1、Spring 使用作为内部日志，但底层日志实现是开放的。可对接其他日志框架。① spring5 及以后 commons-logging 被 spring 直接自己实现了。2、支持jullog4j2logback。SpringBoot 提供了默认的控制台输出配置，也可以配置输出为文件。3、logback是默认使用的。4、虽然日志框架很多，但是不用担心，使用 SpringBoot 的默认配置就能工作的很好。SpringBoot 怎么把日志默认配置好的。1、每个。
day38 02-Spring快速入门
04-26
4. **数据访问/集成**：Spring提供了JDBC抽象层，简化了数据库操作，同时也支持ORM框架如Hibernate和MyBatis的集成。 5. **Web层**：Spring MVC是Spring的Web应用模型-视图-控制器实现，它提供了处理HTTP请求和响应...
淘淘商城19-20.rar
04-27
在day19的学习计划中，"新增课程01_回顾SpringMVC、Mybatis"，这是针对两大主流Java Web开发框架的复习。SpringMVC是Spring框架的一部分，主要用于构建可维护、松耦合的Web应用程序。它通过模型-视图-控制器（MVC）...
BAT 大厂Java 面试题集锦之核心篇附参考答案
热门推荐
程序员光剑
11-05 1万+
核心篇数据结构与算法网路:TCP/IP,HTTP操作系统, 文件, shell, CPU, IO, epoll, 非阻塞IO,进程/线程/协程,锁HashMap, Co...
xxljob从入门到精通-全网段最全解说
lifetragedy的专栏
06-05 1万+
XXL-JOB特性一览 基本概念 xxljob解决的是以下几个痛点： 1） 跑批处理监控无法可视化，当前跑批的状态是：成功？失败？挂起？进度？为什么失败/原因？ 2）批处理任务不可重用，特别是无法对批处理任务做：定时？重复使用？频次？其中路由调度？ 3）批处理任务无法做到网格计算（特别像：websphere ibm grid computing）即批处理任务本身可以做成集群、fail over、sharding 由其是批处理任务可以做成“网格计算”这个功能，有了xxljob后你会发觉特别强大
MybatisPlus的LambdaQueryWrapper用法
2301_79693537的博客
08-21 4881
【代码】MybatisPlus的LambdaQueryWrapper用法。
Redis 入门 - 五大基础类型及其指令学习
IT规划师
09-11 791
学习Redis基础类型：字符串、集合、有序集合、列表、哈希，每种类型有各自的特点和常用指令。掌握这些基础是熟练使用Redis的关键。更多指令需自行尝试。
计算几何学习
网安小白
09-12 421
学习计算几何过程中对经典算法的记录
看Threejs好玩示例，学习创新与技术(二)
最新发布
htsitr2的专栏
09-14 163
它的主要特点是确保生成的点之间保持一定的最小距离，从而避免点的聚集。这种方法在计算机图形学、游戏开发、物理模拟等领域中非常有用，尤其是在需要生成自然分布的对象（如树木、石头等）时。如果不进行裁剪，那么效果如下（初步的锯齿感是因为矩形内采样的结果）。为啥这么复杂呢，为啥不开始存储每个方块的UV呢？下面代码的vTexCoords（=savedModelMatrix，已修改）记录方块所在的位置，vWorldPosition表示方块中像素的偏移。在上面那副图中，聪明的你一定初步猜到了每个方块的纹理是怎么得到的。
qmt量化交易策略小白学习笔记第61期【qmt编程之期权行情数据--get_market_data_ex函数】
fanglue3705的博客
09-09 729
获取期权行情数据 获取期权最新数据，首先需要进行数据订阅。完成合约订阅后，用get_market_data_ex函数即可提取相关信息。这个过程包含两大步骤： 第一，通过订阅操作确保能接收到你感兴趣的期权合约的更新； 第二，调用get_market_data_ex函数来实际获取并处理这些订阅到的数据,如果需要用到历史数据或过期合约数据，需要使用download_history_data进行下载。
网络工程师学习笔记——网络互连与互联网
2301_77279557的博客
09-14 540
网络互连相关技术
mybatis中 || 可以拼接字符串么
12-10
根据提供的引用内容，MyBatis中可以使用||进行字符串拼接。具体实现方法如下所示： ```xml <select id="getUserByName" parameterType="String" resultType="User"> SELECT * FROM user WHERE name = #{name} || ' is a good man' </select> ``` 上述代码中，使用了||将查询条件中的字符串进行了拼接。其中，#{name}是MyBatis中的占位符，表示从Java代码中传入的参数值。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值