Mybatis学习系列（八）：Insert,update,delete的执行

最新推荐文章于 2025-04-14 13:47:28 发布
最新推荐文章于 2025-04-14 13:47:28 发布
阅读量972 收藏
点赞数
分类专栏： Mybatis 文章标签： mybatis Insert update delete
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/jadebai/article/details/100073190
版权
本文详细解析了Mybatis中Insert、update、delete操作的执行过程，包括通过MapperMethod获取MappedStatement，处理集合参数，执行executor的update方法，重点介绍了SimpleExecutor的执行步骤，如获取数据库连接、预编译Statement、设置参数信息，以及最终执行update方法。通过这些步骤，全面了解Mybatis的 CRUD 操作流程。

摘要生成于 C知道 ，由 DeepSeek-R1 满血版支持， 前往体验 >

由于MapperMethod中Insert,update,delete这三个的执行方式是一样的，我们统一看一下

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

这里都是两步，①执行sqlsession的对应方法②对执行结果进行处理

1.执行sqlsession的对应方法：最终都是走的update方法

public int insert(String statement) {
    return insert(statement, null);
  }

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

  @Override
  public int update(String statement) {
    return update(statement, null);
  }

  @Override
  public int delete(String statement) {
    return update(statement, null);
  }

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


  @Override
  public int update(String statement, Object parameter) {
    try {
      dirty = true;
      //1.根据ID获取MappedStatement
      MappedStatement ms = configuration.getMappedStatement(statement);
      //2.对集合参数进行处理
      //3.执行executor的update方法
      return executor.update(ms, wrapCollection(parameter));
    } catch (Exception e) {
      throw ExceptionFactory.wrapException("Error updating database.  Cause: " + e, e);
    } finally {
      ErrorContext.instance().reset();
    }
  }

1.1根据ID获取MappedStatement 对象：缓存中获取

public MappedStatement getMappedStatement(String id) {
    return this.getMappedStatement(id, true);
  }

  public MappedStatement getMappedStatement(String id, boolean validateIncompleteStatements) {
    if (validateIncompleteStatements) {
      buildAllStatements();
    }
    return mappedStatements.get(id);
  }

1.2对集合参数进行处理

private Object wrapCollection(final Object object) {
    //如果是集合类型的参数
    if (object instanceof Collection) {
      //参数以，map形式返回
      StrictMap<Object> map = new StrictMap<Object>();
      //设置参数名称为collection
      map.put("collection", object);
      //如果是list类型
      if (object instanceof List) {
        //设置参数名称为list
        map.put("list", object);
      }
      return map;
    } else if (object != null && object.getClass().isArray()) {
      //如果是数组类型，以map形式返回
      //设置参数名称为array
      StrictMap<Object> map = new StrictMap<Object>();
      map.put("array", object);
      return map;
    }
    //不是集合和数组类型  原样返回
    return object;
  }

1.3执行executor（BaseExecutor）的update方法

//这里主要是检验执行器的状态和关闭本地缓存 
//真正的执行是调用的抽象方法  在实现类中
public int update(MappedStatement ms, Object parameter) throws SQLException {
    ErrorContext.instance().resource(ms.getResource()).activity("executing an update").object(ms.getId());
    if (closed) {
      throw new ExecutorException("Executor was closed.");
    }
    clearLocalCache();
    return doUpdate(ms, parameter);
  }

默认情况我们都是走的SimpleExecutor,我们看一下这里的update方法实现

 public int doUpdate(MappedStatement ms, Object parameter) throws SQLException {
    Statement stmt = null;
    try {
      //1.获取配置类
      Configuration configuration = ms.getConfiguration();
      //2.获取StatementHandler 执行器
      StatementHandler handler = configuration.newStatementHandler(this, ms, parameter, RowBounds.DEFAULT, null, null);
      //3.获取Statement
      stmt = prepareStatement(handler, ms.getStatementLog());
      //4.StatementHandler 执行 update方法
      return handler.update(stmt);
    } finally {
      closeStatement(stmt);
    }
  }

1.3.1获取配置类：ms.getConfiguration()，直接获取MappedStatement 中的Configuration变量

1.3.2获取StatementHandler 执行器

public StatementHandler newStatementHandler(Executor executor, MappedStatement mappedStatement, Object parameterObject, RowBounds rowBounds, ResultHandler resultHandler, BoundSql boundSql) {
    //1.根据mappedStatement的Statementtype获取对应的StatementHandler
    StatementHandler statementHandler = new RoutingStatementHandler(executor, mappedStatement, parameterObject, rowBounds, resultHandler, boundSql);
    //2.在StatementHandler上添加插件拦截器
    statementHandler = (StatementHandler) interceptorChain.pluginAll(statementHandler);
    return statementHandler;
  }

上图是StatementHandler 的实现关系图：我们看一下如何生成需要的真实对象的（是在RoutingStatementHandler初始化的时候完成的），一般情况我们都是预编译的StatementHandler（PreparedStatementHandler）

public RoutingStatementHandler(Executor executor, MappedStatement ms, Object parameter, RowBounds rowBounds, ResultHandler resultHandler, BoundSql boundSql) {

    switch (ms.getStatementType()) {
      case STATEMENT:
        delegate = new SimpleStatementHandler(executor, ms, parameter, rowBounds, resultHandler, boundSql);
        break;
      case PREPARED:
        delegate = new PreparedStatementHandler(executor, ms, parameter, rowBounds, resultHandler, boundSql);
        break;
      case CALLABLE:
        delegate = new CallableStatementHandler(executor, ms, parameter, rowBounds, resultHandler, boundSql);
        break;
      default:
        throw new ExecutorException("Unknown statement type: " + ms.getStatementType());
    }

  }

1.3.3获取Statement：调用SimpleExecutor的prepareStatement方法

private Statement prepareStatement(StatementHandler handler, Log statementLog) throws SQLException {
    Statement stmt;
    //1.获取数据库连接
    Connection connection = getConnection(statementLog);
    //2.调用StatementHandler生成Statement 
    stmt = handler.prepare(connection, transaction.getTimeout());
    //3.设置参数信息
    handler.parameterize(stmt);
    return stmt;
  }

1.3.3.1获取数据库连接：transaction --> dataSource

protected Connection getConnection(Log statementLog) throws SQLException {
    //通过transaction事务里面的配置获取数据库连接
    Connection connection = transaction.getConnection();
    if (statementLog.isDebugEnabled()) {
      //如果开启了日志debug模式 生成一个带有日志的连接
      return ConnectionLogger.newInstance(connection, statementLog, queryStack);
    } else {
      return connection;
    }
  }

public Connection getConnection() throws SQLException {
    if (connection == null) {
      openConnection();
    }
    return connection;
  }

protected void openConnection() throws SQLException {
    if (log.isDebugEnabled()) {
      log.debug("Opening JDBC Connection");
    }
    //调用的是dataSource的方法
    connection = dataSource.getConnection();
    if (level != null) {
      connection.setTransactionIsolation(level.getLevel());
    }
    setDesiredAutoCommit(autoCommmit);
  }

1.3.3.2调用StatementHandler生成Statement

public Statement prepare(Connection connection, Integer transactionTimeout) throws SQLException {
    ErrorContext.instance().sql(boundSql.getSql());
    Statement statement = null;
    try {
      //根据数据库连接 初始化Statement
      statement = instantiateStatement(connection);
      //设置Statement的超时时间
      setStatementTimeout(statement, transactionTimeout);
      //设置Statement执行批量的大小
      setFetchSize(statement);
      return statement;
    } catch (SQLException e) {
      closeStatement(statement);
      throw e;
    } catch (Exception e) {
      closeStatement(statement);
      throw new ExecutorException("Error preparing statement.  Cause: " + e, e);
    }
  }

//根据数据库连接 初始化Statement  最终都是通过Connection 去获取的Statement
protected Statement instantiateStatement(Connection connection) throws SQLException {
    //获取执行的sql
    String sql = boundSql.getSql();
    //主键如果自增的话
    if (mappedStatement.getKeyGenerator() instanceof Jdbc3KeyGenerator) {
      //获取主键字段
      String[] keyColumnNames = mappedStatement.getKeyColumns();
      //没有字段
      if (keyColumnNames == null) {
        return connection.prepareStatement(sql, PreparedStatement.RETURN_GENERATED_KEYS);
      } else {
        return connection.prepareStatement(sql, keyColumnNames);
      }
    } else if (mappedStatement.getResultSetType() != null) {
      //返回类型不为空
      return connection.prepareStatement(sql, mappedStatement.getResultSetType().getValue(), ResultSet.CONCUR_READ_ONLY);
    } else {
      return connection.prepareStatement(sql);
    }
  }

1.3.3.3设置参数信息

public void parameterize(Statement statement) throws SQLException {
    parameterHandler.setParameters((PreparedStatement) statement);
  }

这里调用的还是parameterHandler的方法，我们看一下parameterHandler是如何生成的：在初始化StatementHandler的时候，在构造方法中初始化了parameterHandler

this.parameterHandler = configuration.newParameterHandler(mappedStatement, parameterObject, boundSql);

public ParameterHandler newParameterHandler(MappedStatement mappedStatement, Object parameterObject, BoundSql boundSql) {
    //1.生成ParameterHandler 
    ParameterHandler parameterHandler = mappedStatement.getLang().createParameterHandler(mappedStatement, parameterObject, boundSql);
    //添加相应的插件拦截器链
    parameterHandler = (ParameterHandler) interceptorChain.pluginAll(parameterHandler);
    return parameterHandler;
  }

//1.生成ParameterHandler == DefaultParameterHandler
public ParameterHandler createParameterHandler(MappedStatement mappedStatement, Object parameterObject, BoundSql boundSql) {
    return new DefaultParameterHandler(mappedStatement, parameterObject, boundSql);
  }

下面就是设置参数了

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 (parameterMapping.getMode() != ParameterMode.OUT) {
          Object value;
          //获取参数字段名称
          String propertyName = parameterMapping.getProperty();
          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 {
            //设置参数的值
            typeHandler.setParameter(ps, i + 1, value, jdbcType);
          } catch (TypeException e) {
            throw new TypeException("Could not set parameters for mapping: " + parameterMapping + ". Cause: " + e, e);
          } catch (SQLException e) {
            throw new TypeException("Could not set parameters for mapping: " + parameterMapping + ". Cause: " + e, e);
          }
        }
      }
    }
  }

//设置参数的值 其实就是设置给PreparedStatement 
public void setParameter(PreparedStatement ps, int i, T parameter, JdbcType jdbcType) throws SQLException {
    if (parameter == null) {
      if (jdbcType == null) {
        throw new TypeException("JDBC requires that the JdbcType must be specified for all nullable parameters.");
      }
      try {
        ps.setNull(i, jdbcType.TYPE_CODE);
      } catch (SQLException e) {
        throw new TypeException("Error setting null for parameter #" + i + " with JdbcType " + jdbcType + " . " +
                "Try setting a different JdbcType for this parameter or a different jdbcTypeForNull configuration property. " +
                "Cause: " + e, e);
      }
    } else {
      try {
        setNonNullParameter(ps, i, parameter, jdbcType);
      } catch (Exception e) {
        throw new TypeException("Error setting non null for parameter #" + i + " with JdbcType " + jdbcType + " . " +
                "Try setting a different JdbcType for this parameter or a different configuration property. " +
                "Cause: " + e, e);
      }
    }
  }

1.3.4StatementHandler （PreparedStatementHandler）执行 update方法

public int update(Statement statement) throws SQLException {
    //这接执行PreparedStatement 的execute方法操作数据库
    PreparedStatement ps = (PreparedStatement) statement;
    ps.execute();
    //获取执行成功的条数
    int rows = ps.getUpdateCount();
    //处理selectKey的情况
    Object parameterObject = boundSql.getParameterObject();
    KeyGenerator keyGenerator = mappedStatement.getKeyGenerator();
    keyGenerator.processAfter(executor, mappedStatement, ps, parameterObject);
    return rows;
  }

2.对执行结果进行处理

private Object rowCountResult(int rowCount) {
    final Object result;
    //方法返回是void
    if (method.returnsVoid()) {
      result = null;
    } else if (Integer.class.equals(method.getReturnType()) || Integer.TYPE.equals(method.getReturnType())) {
      //返回的是Integer类型
      result = rowCount;
    } else if (Long.class.equals(method.getReturnType()) || Long.TYPE.equals(method.getReturnType())) {
      //返回的是Long类型
      result = (long)rowCount;
    } else if (Boolean.class.equals(method.getReturnType()) || Boolean.TYPE.equals(method.getReturnType())) {
      //返回的是Boolean类型
      result = rowCount > 0;
    } else {
      //抛出异常，返回的格式不正确
      throw new BindingException("Mapper method '" + command.getName() + "' has an unsupported return type: " + method.getReturnType());
    }
    return result;
  }

到这里Insert,update,delete的执行全过程就解析结束了。

Mybatis执行sql核心方法增删改Executor.update,查询ResultSetHandler.handleResultSets
陈俊的马蹄印
01-16 2233
1.Mybatis执行增删改的底层核心接口是Executor.update，如果我们想对它进行拦截处理，则需要拦截此方法 2.Mybatis执行查询的底层核心接口是ResultSetHandler.handleResultSets，如果我们想对它进行拦截处理，则需要拦截此方法 定义增删改的拦截器： @Intercepts({ @Signature(type = Executo...
Mybatis Interceptor 拦截器的实现
lemonrel的博客
10-11 3564
Mybatis采用责任链模式，通过动态代理组织多个拦截器（插件），通过这些拦截器可以改变Mybatis的默认行为（诸如SQL重写之类的），由于插件会深入到Mybatis的核心，因此在编写自己的插件前最好了解下它的原理，以便写出安全高效的插件。 拦截器（Interceptor）在 Mybatis 中被当做插件（plugin）对待，官方文档提供了 Executor，ParameterHandler，R...
MyBatis源码笔记（七） -- insert、update、delete语句的执行
seasonLai的博客
09-30 1046
首先要了解MyBatis如何动态代理接口的方法的，和JDBC基本编程 参考：MyBatis源码笔记（四） – mapper动态代理 执行方法主要封装在MapperMethod public class MapperMethod { private final SqlCommand command; private final MethodSignature method; publ...
Mybatis执行sqlSession.insert()、sqlSession.update()、sqlSession.update()和sqlSession.select()
最新发布
2401_85322353的博客
04-14 372
mybatis-config.xml配置。
MyBatis拦截器对update,insert拦截.
cookie151的博客
08-22 1万+
1.自定义拦截器类实现org.apache.ibatis.plugin.Interceptor接口. import org.apache.ibatis.executor.Executor; import org.apache.ibatis.mapping.MappedStatement; import org.apache.ibatis.mapping.SqlCommandType; imp...
Mybatis拦截器Interceptor实现加解密
wind_chasing_boy的博客
06-13 7807
最近项目使用Mybatis拦截器对数据进行加解密，以下记录如何将拦截器集成到项目中以及在使用过程中踩过的一些小坑，与君共勉Configuration：初始化基础配置，比如MyBatis的别名等，一些重要的类型对象，如插件，映射器，ObjectFactory和typeHandler对象，MyBatis所有的配置信息都维持在Configuration对象之中。SqlSessionFactory：SqlSession工厂。
Mybatis中select、insert、update、delete用法总结
12-14
一、select用法示例 SELECT ST.STUDENT_ID, ST.STUDENT_NAME, ST.STUDENT_SEX, ST.STUDENT_BIRTHDAY, ST.CLASS_ID FROM STUDENT_TBL ST WHERE ST.STUDENT_ID = #{studentID} 这条语句就叫做‘getStudent...
auditlog-Oracle:mybatis oracle log insert delete update springboot Mybatis-Auditlog-oracle(数据修改日志插件)
05-14
本插件通过拦截器记录Mybatis下所有Mapper类在进行增删改动作时所影响数据的 oldValue（修改前，插入前，删除前），newValue（修改后，插入后，删除后），并将此类数据日志插入到audit_log数据审计表中，方便运维...
MyBatis sql-select-insert-update-delete
03-10
误点Uninject language or reference导致xml错误警告都不显示（恢复）
myBatis系列之一：搭建开发环境
08-14
本教程将引导你一步步搭建MyBatis的开发环境，为后续的深入学习和实践打下基础。 首先，我们需要了解MyBatis的核心概念。MyBatis是一个轻量级的框架，它不包含任何JDBC模板或实体管理功能，而是专注于SQL映射。通过...
MyBatis框架全面解析（四）mybatis插件原理+手写自定义插件delete转update
u013522165的博客
08-29 401
文章内容输出来源：拉勾教育Java高薪训练营； 系列文章连接： MyBatis框架全面解析（一）为何我们需要mybatis MyBatis框架全面解析（二）如何手写一个简易的mybatis框架 MyBatis框架全面解析（三）延迟加载的原理以及手写实现 文章目录前言一、基本原理二：使用示例三、手写插件 前言 Mybatis提供了一种简单易用得插件扩展机制，我们可以基于此拦截mybatis四大核心对象，从而进行功能扩展。 一、基本原理 Mybaits 存在四大核心对象： Executor 执行器 St
Executor 详解
weixin_38982591的博客
04-08 765
SqlSession 是 Mybatis 提供个的操作数据库的API ，但是真正执行SQL的是Executor组件，Executor接口定义了对数据库的增删改查方法。Executor 接口中有几种不同的实现类。 BaseExecutor 中定义的方法的执行流程以及通用的处理逻辑，具体交给子类来实现，是典型的模板模式的应用。 SimpleExecutor 是基础的Executor，能够完成...
Mybatis实现InsertOrUpdate功能
m0_67390788的博客
04-21 9616
需求 最近在项目开发中遇到这样一个需求：每天需要对相同的数据（也有可能是不同的）进行两次入库操作，数据不存在便insert，存在则update。于是就用到了Mybatis的InsertOrUpdate功能。 实现 每次操作数据库之前，先根据id查询有没有记录，有则进行update操作，没有则进行insert操作。 model类代码如下。其中count为非业务字段（也不是表sheet中的字段），只是方便Mybatis进行insertOrUpdate操作的附加字段。 import lombok.Data; @
Mybatis的Executor介绍（一）
热门推荐
Elim的博客
04-28 1万+
Mybatis的Executor介绍（一）        Mybatis中所有的Mapper语句的执行都是通过Executor进行的，Executor是Mybatis的一个核心接口，其定义如下。从其定义的接口方法我们可以看出，对应的增删改语句是通过Executor接口的update方法进行的，查询是通过query方法进行的。虽然Executor接口的实现类有BaseExecutor和Ca
mybatis 接口代理源码分析
91奔跑的蜗牛
05-28 332
SqlSession.getMapper 该方法会生成一个动态代理对象，调用的是MapperProxyFactory中的 newInstance 查看jdk动态代理的处理类MapperProxy 看下MapperProxy的具体处理逻辑 invoke 最终是执行mapperMethod.execute(this.sqlSession, args)，我看跟进代码看下， public Object execute(SqlSession sqlSession, Object[] args) { ...
MyBatis 学习笔记（七）---源码分析篇---SQL的执行过程（一）
qq_44597856的博客
05-02 182
MyBatis 学习笔记（七）---源码分析篇---SQL的执行过程（一）
Mybatis源码学习一（Executor)
weixin_44815682的博客
03-19 816
Executor架构 Caching Executor的作用就是实现二级缓存，使用的是装饰者模式。 装饰者模式：在不改变原有类继承结构的情况下，新建一个对象来扩展原有功能。 Executor具体实现 maven依赖 <dependency> <groupId> org.mybatis </groupId> <artifactId> mybatis </artifactId> <version&...
实现Mybatis拦截器
vevin的博客
05-17 982
身为一个没发过任何博客的小白女程序员，要开始写博客啦！ 最近在做公司项目时，Client端做资源缓存时候需要根据Server端的数据库表是否更新来刷新，因此在Server端如果某个表内容发生改变，那么这个表的版本号需要+1。需要监控的业务核心表不多，因此采用了通过实现Mybatis拦截器获取sql内容来实现对表版本的更新，更新的版本号存储位置可根据业务场景来决定，redis或者数据库等等。 因为是如果表内容更新，所以本次业务需要拦截的是insert\update\delete三种情况。 项目是SpringB
Mybatis之@ResultMap，@Results，@Result注解
q蓝色Tu耳其
10-08 2141
文章目录Mybatis注解之@Results、@Result、@ResultMap问题方法一方法二 Mybatis注解之@Results、@Result、@ResultMap 问题 在使用mybatis时发现，mybatis能自动匹配实体名和数据库字段名相同的字段。当有实体名与数据库的字段名不同时该如何解决？？ 数据库的表对应的列名： springboot项目中建的实体类为： public class MapModel { private Long key; private String
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值