Mybatis3.x 源码阅读-05 insert执行流程

最新推荐文章于 2024-07-09 23:07:25 发布
最新推荐文章于 2024-07-09 23:07:25 发布
阅读量735 收藏
点赞数
分类专栏： Mybatis 文章标签： mybatis源码 SqlSession BaseExecutor StatementHandler KeyGenerator
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq157538651/article/details/89063417
版权

1. 前言

上一篇讲了mapper的注册与获取，这一节一起看看MapperMethod类

2. 正文

2.1 案例

@Test
    public void test(){
        SqlSessionFactory sqlSessionFactory = SqlSessionFactoryUtil.getSqlSessionFactory();
        SqlSession sqlSession = sqlSessionFactory.openSession();
        PersonDao personDao =  sqlSession.getMapper(PersonDao.class);
        Person p = new Person();
        p.setAddress("广东省");
        p.setAge(12);
        p.setEmail("157538651@qq.com");
        p.setName("chen");
        p.setPhone("15345634565");
        personDao.insert(p);
        System.out.println(p.toString());
        sqlSession.commit();
        sqlSession.close();
    }

2.2 MapperMethod#execute

public Object execute(SqlSession sqlSession, Object[] args) {
    Object result;
    switch (command.getType()) {@1
      case INSERT: {
        Object param = method.convertArgsToSqlCommandParam(args);@2
        result = rowCountResult(sqlSession.insert(command.getName(), param));@3
        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;
  }

@1 判断你要执行的语句类型走不同是case
@2 获取你对象中的参数，上面案例中就是person的对象值
@3 调动sqlSession的insert方法，然后通过rowCountResult封装insert返回的对象，最终返回result，核心的流程就是这一行，进去看下具体的实现

2.3 常见的接口及实现类

在看具体实现之前，先理下几个核心的接口和实现类

2.3.1 SqlSession

首先是SqlSession，里面包含了经常操作数据库用到的一些方法，比如insert/update/selectOne/select/selectList 等等，默认有2个实现类，默认是DefaultSqlSession
在这里插入图片描述

2.3.2 Executor 执行器

BaseExecutor是抽象类，下面有3个要重点关注下：
SimpleExecutor 简单的执行器，就是执行完Statement会及时关掉，也是mybatis默认的执行器。
ReuseExecutor 复用的执行器，会把用过的Statement 用map存起来，key=sql，value=Statement
BatchExecutor 批量的执行器，为了提高性能，一次性操作多个Statement ，执行完，也会及时关闭。
这三个执行器，可以在mybatis 中配置，一种方式是在mybatis-config.xml 配置，另外一种是在spring xml 中配置sqlSession的时候配置。
还有一个特殊的，就是CachingExecutor ，它是把MappedStatement 缓存起来了。
在这里插入图片描述
注意：他里面持有了一个特殊的对象，private final Executor delegate;
还记得之前获取session的时候，构建的执行器吧，就是下面这个代码

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);@1
    } else if (ExecutorType.REUSE == executorType) {
      executor = new ReuseExecutor(this, transaction);@2
    } else {
      executor = new SimpleExecutor(this, transaction);@3
    }
    if (cacheEnabled) {
      executor = new CachingExecutor(executor);@4
    }
    executor = (Executor) interceptorChain.pluginAll(executor);
    return executor;
  }

@1、@2、@3 对象构建好后，只要是开启了缓存（默认开启），则会对executor 加一层包装，从而变成CachingExecutor，到这里就豁然开朗了吧，也就是上面案例中CachingExecutor 中的delegate 其实就是SimpleExecutor（默认是简单的执行器）;

2.3.2 StatementHandler

这几个子类其实就是对应jdbc里面的几种Statement
SimpleStatementHandler 简单SQL的处理;
PreparedStatementHandler 预编译SQL处理；
CallableStatementHandler JDBC中CallableStatement，执行存储过程相关的接口
RoutingStatementHandler 是核心，也是负责把上面三个handle串起来的关键类，主要负责上面三个handle的创建和调用，所以他也和CachingExecutor类似，持有一个
private final StatementHandler delegate;
## 2.4 常见的接口及实现类

2.3.3 KeyGenerator

KeyGenerator的功能是生成数据库主键和将insert 生成的主键设置到pojo中
在这里插入图片描述
重点关注2个实现类：Jdbc3KeyGenerator、SelectKeyGenerator
Jdbc3KeyGenerator表示自增的，也就是数据库自增后如果需要知道值，比如mysql 表主键自增。
这个是将自增结果回填到对象中是从返回的Statement中获取id值。配置方式：在 insert 标签中配置了keyProperty="id" useGeneratedKeys="true"属性

<insert id="insert" parameterType="Person" keyProperty="id" useGeneratedKeys="true">
        INSERT INTO person (name, age, phone, email, address)
        VALUES(#{name},#{age},#{phone},#{email},#{address})
    </insert>

SelectKeyGenerator 是通过insert后，再查询一次，来获取id的值，Oracle 需要结合sequence 来设置主键，就可以用SelectKeyGenerator方式配置。配置方式：在insert标签内，配置selectKey标签

<insert id="insert" parameterType="Person" keyProperty="id" useGeneratedKeys="true">
		<selectKey resultType="int" keyProperty="id" order="BEFORE">
     				SELECT LAST_INSERT_ID()  AS id 
  		</selectKey>
        INSERT INTO person (name, age, phone, email, address)
        VALUES(#{name},#{age},#{phone},#{email},#{address})
    </insert>

BEFORE 表示在插入之前，先查询一次获取到id

2.4 核心流程

2.4.1 继续回到上面2.2

        Object param = method.convertArgsToSqlCommandParam(args);@2
        result = rowCountResult(sqlSession.insert(command.getName(), param));@3

进入到insert中

@Override
public int insert(String statement, Object parameter) {
  return update(statement, parameter);
}

@Override
public int update(String statement, Object parameter) {
  try {
    dirty = true;
    MappedStatement ms = configuration.getMappedStatement(statement);@1
    return executor.update(ms, wrapCollection(parameter));@2
  } catch (Exception e) {
    throw ExceptionFactory.wrapException("Error updating database.  Cause: " + e, e);
  } finally {
    ErrorContext.instance().reset();
  }
}

@1 从config中获取mapper的信息
@2 这里的executor是CachingExecutor，原因上面解释过了。进入到CachingExecutor#update

2.4.2 CachingExecutor#update

@Override
  public int update(MappedStatement ms, Object parameterObject) throws SQLException {
    flushCacheIfRequired(ms);@1
    return delegate.update(ms, parameterObject);@2
  }
private void flushCacheIfRequired(MappedStatement ms) {
    Cache cache = ms.getCache();
    if (cache != null && ms.isFlushCacheRequired()) {
      tcm.clear(cache);
    }
  }

@1 刚刚说过的， MappedStatement 是有缓存的，这里需要进行是否需要clear，isFlushCacheRequired 参数是在创建缓存的时候，就需要设置的。
@2 调用抽象类BaseExecutor的update方法

2.4.3 BaseExecutor#update

 @Override
  public int update(MappedStatement ms, Object parameter) throws SQLException {
    ErrorContext.instance().resource(ms.getResource()).activity("executing an update").object(ms.getId());@1
    if (closed) {
      throw new ExecutorException("Executor was closed.");
    }
    clearLocalCache();@2
    return doUpdate(ms, parameter);@3
  }

@1 记录上下文信息，用于抛异常的时候，获取信息。内部通过ThreadLocal来存储
@2 清除本地缓存
@3 调用子类的doUpdate方法

2.4.4 SimpleExecutor#doUpdate

@Override
public int doUpdate(MappedStatement ms, Object parameter) throws SQLException {
  Statement stmt = null;
  try {
    Configuration configuration = ms.getConfiguration();
    StatementHandler handler = configuration.newStatementHandler(this, ms, parameter, RowBounds.DEFAULT, null, null);@1
    stmt = prepareStatement(handler, ms.getStatementLog());@2
    return handler.update(stmt);@3
  } finally {
    closeStatement(stmt);
  }
}

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

@1 构建StatementHandler 对象，这里会根据配置的Statement拦截器，执行所有的拦截后，返回StatementHandler
@2 构建Statement对象，进入到prepareStatement方法，里面有@4，这里是设置参数处理handle
最终的执行方法如下：
DefaultParameterHandler#setParameters

@Override
  public void setParameters(PreparedStatement ps) {
    //记录上下文
    ErrorContext.instance().activity("setting parameters").object(mappedStatement.getParameterMap().getId());
    //获取需要填充的参数的个数（就是？的个数）
    List<ParameterMapping> parameterMappings = boundSql.getParameterMappings();
    if (parameterMappings != null) {
      for (int i = 0; i < parameterMappings.size(); i++) {
        ParameterMapping parameterMapping = parameterMappings.get(i);
        //？是输入参数，进入if
        if (parameterMapping.getMode() != ParameterMode.OUT) {
          Object value;
          String propertyName = parameterMapping.getProperty();
          //判断SQL中是否包含此属性 
          if (boundSql.hasAdditionalParameter(propertyName)) { // issue #448 ask first for additional params
            //取值
            value = boundSql.getAdditionalParameter(propertyName);
          } else if (parameterObject == null) {
            value = null;
          } else if (typeHandlerRegistry.hasTypeHandler(parameterObject.getClass())) {
            value = parameterObject;
          } else {
            MetaObject metaObject = configuration.newMetaObject(parameterObject);
            value = metaObject.getValue(propertyName);
          }
          //获取参数类型
          TypeHandler typeHandler = parameterMapping.getTypeHandler();
          JdbcType jdbcType = parameterMapping.getJdbcType();
          if (value == null && jdbcType == null) {
            jdbcType = configuration.getJdbcTypeForNull();
          }
          try {
            //给pre 设置值
            typeHandler.setParameter(ps, i + 1, value, jdbcType);
          } catch (TypeException | SQLException e) {
            throw new TypeException("Could not set parameters for mapping: " + parameterMapping + ". Cause: " + e, e);
          }
        }
      }
    }
  }

进入PreparedStatementHandle update 方法

2.4.5 PreparedStatementHandle#update

@Override
public int update(Statement statement) throws SQLException {
  PreparedStatement ps = (PreparedStatement) statement;
  ps.execute();@1
  int rows = ps.getUpdateCount();@2
  Object parameterObject = boundSql.getParameterObject();@3
  KeyGenerator keyGenerator = mappedStatement.getKeyGenerator();@4
  keyGenerator.processAfter(executor, mappedStatement, ps, parameterObject);@5
  return rows;
}

@1 执行jdbc execute
@2 返回受影响的记录条数
@3 获取插入的对象，上述案例中的person对象
@4 获取主键生成器,设置person id字段的值为刚刚插入的主键

2.4.6 继续回到

        Object param = method.convertArgsToSqlCommandParam(args);
        result = rowCountResult(sqlSession.insert(command.getName(), param));

接下来是sqlSession.insert 返回受影响的记录条数，然后通过rowCountResult 返回一个通用的result.
处理逻辑如下：

private Object rowCountResult(int rowCount) {
    final Object result;
    if (method.returnsVoid()) {
      result = null;
    } else if (Integer.class.equals(method.getReturnType()) || Integer.TYPE.equals(method.getReturnType())) {
      result = rowCount;
    } else if (Long.class.equals(method.getReturnType()) || Long.TYPE.equals(method.getReturnType())) {
      result = (long)rowCount;
    } else if (Boolean.class.equals(method.getReturnType()) || Boolean.TYPE.equals(method.getReturnType())) {
      result = rowCount > 0;
    } else {
      throw new BindingException("Mapper method '" + command.getName() + "' has an unsupported return type: " + method.getReturnType());
    }
    return result;
  }

根据方法的要求的返回类型，处理返回值。

3. 总结

insert 时序图
在这里插入图片描述

  1. 发起insert 请求，获取mapper代理对象
  2. 调用代理对象的invoke
  3. 执行MapperMethod的execute，根据sql语句类型，执行不同case
  4. DefaultSqlSession#insert 底层调用的也是DefaultSqlSession#update(可以参考DefaultSqlSession.java 183行),调用执行器的update方法
  5. 获取默认开启了缓存，所以是调用CachingExecutor#update
  6. 调用抽象类的BaseExecutor#update
  7. 调用子类的具体实现SimpleExecutor#doUpdate
  8. 执行后，逐步返回受影响的记录条数

4. 参考

[1] https://blog.csdn.net/Roger_CoderLife/article/details/88835765
[2] https://blog.csdn.net/yangliuhbhd/article/details/80982254

不积跬步无以致千里
关注
专栏目录
mybatis-plus_batch_insert：mybatis_plus添加批量插入
02-14
mybatis-plus_batch_insert：mybatis_plus添加批量插入
ibatis2.X升级mybatis3.X之曲径通幽处
03-25
在映射器接口方面，Mybatis3.x允许开发者直接在接口方法上使用@Select、@Insert、@Update、@Delete等注解，使得接口更加清晰，降低了学习成本。同时，3.x版本引入了MapperFactoryBean，使得Spring集成更加简便，无需...
* MyBatis - 3、源码流程分析
qq_38946877的博客
06-25 148
目录： 1、开发重点知识 MyBatis快速入门 result 与 resultMap 怎么样传递多个参数 获取主键 SQL 的参数 代码生成器 关联查询 缓存 与 spring 的集成 2、源码骨架分析 整体架构 日志模块分析 数据源模块分析 缓存模块分析 反射模块分析 3、源码流程分析 流程整体分析 配置加载阶段 代理阶段分析 数据读写阶段 4、知识拾遗 与 spring 的结合源码分析 插件开发 手写 MyBatis MyBatis 源码流程分析 1，流程整体分析 1.1 MyBati
Mybatis Plus 3.X版本的insert填充自增id的IdType.ID_WORKER策略源码分析
最新发布
朱季谦
07-09 1679
例如，我们设置的id策略是这个 @TableId(value = "id",type = IdType.ID_WORKER)，当代码执行到populateKeys方法里时，就会判断是否为 IdType.ID_WORKER策略，如果是，就会执行对应的生存id的方法。我愣了一下，脑海里只想到，当在POJO类的id设置一个自增策略后，例如@TableId(value = "id",type = IdType.ID_WORKER)的注解策略时，就能实现在每次数据插入数据库时，实现id的自增，例如以下形式——
【MyBatis源码分析】insert方法、update方法、delete方法处理流程（下篇）
weixin_34293246的博客
06-07 171
Configuration的newStatementHandler分析 SimpleExecutor的doUpdate方法上文有分析过： 1 public int doUpdate(MappedStatement ms, Object parameter) throws SQLException { 2 Statement stmt = null; 3 try {...
MyBatis_3
sinat_50855580的博客
03-31 89
MyBatis_3 MyBatis相关的配置文件 1.1.MyBatis的核心配置文件 1.1.1.名称--我们可以自己定义，推荐大家使用【mybatis-config.xml】 1.1.2.位置 IntelliJ IDEA中通过Maven创建项目，一般都保存在src/main/resources目录下。 1.1.3.文件中的配置元素及其属性 例如： <?xml version="1.0" encoding="UTF-8"?> <!DOCTYPE configuration
mybatis insert返回对象_Mybatis源码分析（一）Mybatis的架构设计简介
weixin_39539764的博客
11-28 174
前言相对Spring而言，Mybatis就显得短小精悍。在本系列源码开始之前，我们先来一起了解下Mybatis的相关知识点。什么是 MyBatis MyBatis 是一款优秀的持久层框架，它支持定制化 SQL、存储过程以及高级映射。MyBatis 避免了几乎所有的 JDBC 代码和手动设置参数以及获取结果集。MyBatis 可以使用简单的 XML 或注解来配置和映射原生信息，将接口和 Java 的...
mybatis-3.5.9 源码（mybatis-3-mybatis-3.5.9.zip）
02-07
MyBatis 是一款著名的持久层框架...通过对 MyBatis-3.5.9 源码的阅读和分析，我们可以深入了解其实现原理，为日常开发和性能优化提供有力支持。同时，这也有助于我们更好地理解和定制 MyBatis，使其更加符合项目需求。
mybatis-3-mybatis-3.5.8.zip源码
04-27
在mybatis-3-mybatis-3.5.8.zip源码中，我们可以深入理解MyBatis的工作原理和设计模式。这个版本的MyBatis包含以下几个主要模块： 1. **SqlSessionFactoryBuilder**: 用于构建SqlSessionFactory，它是MyBatis的核心...
mybatis-3-config.dtd mybatis-3-mapper.dtd
04-08
在MyBatis中，`mybatis-3-config.dtd` 和 `mybatis-3-mapper.dtd` 是两个至关重要的DTD（Document Type Definition）文件，它们定义了MyBatis配置文件和映射文件的结构和规则。 首先，让我们深入了解一下`mybatis-3...
2022.9.26-mybatis-源码.rar
11-16
《深入剖析Mybatis源码：2022.9.26更新》 在软件开发领域，Mybatis作为一款优秀的持久层框架，以其简洁、灵活的特性深受开发者喜爱。了解并掌握Mybatis的源码，不仅可以帮助我们更好地利用这个框架，还能提升我们的...
mybatis-3.3.0.jar 下载
09-21
MyBatis 是一款优秀的持久层框架，它支持定制化 SQL、存储过程以及高级映射。MyBatis 避免了几乎所有的 JDBC 代码和手动设置参数以及获取结果集
mybatis源码之执行insert代码分析
xuguofeng2016的博客
01-05 1679
通过阅读源码分析mybatis的insert执行流程
Mybatis源码分析(五) - insert, update 和 delete常用属性
日薪灬越亿的博客
06-08 328
useGeneratedKeys与keyProperty 的使用 mysql的情况下：设置主键自增长：AUTO_INCREMENT <insert id="insert1" parameterType="TUser" useGeneratedKeys="true" keyProperty="id"> insert into t_user (id, user_name,...
MyBatis 3.5.4源码之旅九之insert案例分析三
王伟王胖胖的博客
04-03 224
MyBatis 3.5.4源码之旅九之insert案例分析三SimpleExecutor的prepareStatement做了什么BaseExecutor的getConnection获取连接PooledDataSource的popConnection弹出一个连接 SimpleExecutor的prepareStatement做了什么 获取连接，准备数据，然后处理Statement 。 priv...
MyBatis 3.5.4源码之旅八之insert案例分析二
王伟王胖胖的博客
04-03 319
MyBatis 3.5.4源码之旅八之insert案例分析二MapperProxy的invoke做了什么MapperMethod的executeDefaultSqlSession的insertDefaultSqlSession的updateCachingExecutor的updateSimpleExecutor的updateSimpleExecutor的doUpdateConfiguration的...
Mybatis3 insert 和 SqlBuilder
个人站点： macrotea.cn/nav
09-26 264
/** * 插入 且返回影响行数 * 且实体保存新增编号 * @param entity * @return */ @InsertProvider(method = "insert", type = UserTypeSqlBuilder.class) Integer insert(UserType entity);   import static o...
Mybatis3
weixin_33725272的博客
04-30 95
2019独角兽企业重金招聘Python工程师标准>>> ...
Mybatis工作机制源码分析—一次insert请求处理流程
探索java技术、web技术
01-15 1960
本文从源码分析的角度分析Mybatis一次insert请求处理流程。 insert整体处理流程 时序图 相关源码 /** SqlSessionTemplate.java */ public int insert(String statement, Object parameter) { return this.sqlSessionProxy.insert(statement, p
Mybatis执行流程深度解析：源码剖析
"Mybatis 的执行流程分析主要涉及其核心组件的工作原理，包括 Resources、InputStream、SqlSessionFactoryBuilder、SqlSessionFactory、SqlSession 和动态代理Mapper接口。本文将深入源码，揭示 Mybatis 在处理 CRUD...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值