java web之mybatis（三）---Update操作执行流程

最新推荐文章于 2024-08-14 17:15:36 发布
最新推荐文章于 2024-08-14 17:15:36 发布
阅读量1.8k 收藏
点赞数
分类专栏： JavaWeb mybatis

(1) 会话Session的创建

  • 通过初始化获取的SessionFactory创建会话对象
SqlSession session = sessionFactory.openSession();
  •  
  • 调用openSessionFromDataSource()方法执行创建逻辑
public SqlSession openSession() {
    return this.openSessionFromDataSource(this.configuration.getDefaultExecutorType(), (TransactionIsolationLevel)null, false);
}

  • 在openSessionFromDataSource()方法中创建Executor实例，具体的SQL操作都是通过executor执行的

    • 首先从Configuration中获取Encironment对象，其中包含了数据源和相应的事务的配置

    • 根据Encironment对象创建事务工厂transactionFactory，进而创建事务对象transaction

    • 根据产生的事务对象创建executor执行器对象，用来执行具体的SQL操作；

    • 将executor封装到DefaultSqlSession对象中返回中

private SqlSession openSessionFromDataSource(ExecutorType execType, TransactionIsolationLevel level, boolean autoCommit) {
    Transaction tx = null;

    DefaultSqlSession var8;
    try {
        Environment e = this.configuration.getEnvironment();
        TransactionFactory transactionFactory = this.getTransactionFactoryFromEnvironment(e);
        tx = transactionFactory.newTransaction(e.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;
}

  • 根据传入的transaction事务实例创建executor实例，DefaultSqlSession将主要的操作交给executor执行；

    • executor有三种类型：BatchExecutor，ReuseExecutor和simpleExecutor；BatchExecutor专门用来执行批处理；ReuseExecutor会重用statement执行sqi操作；simpleExecutor只是简单执行sql语句；默认是simpleExecutor；

    • 如果开启catch缓存的话会利用装饰器模式创建CachingExecutor，CachingExecutor在查询数据库之前会先查询缓存；

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

    Executor executor1 = (Executor)this.interceptorChain.pluginAll(executor);
    return executor1;
}

(2) Insert方法执行流程

1. 创建执行器Executor

  • 通过openSession()方法创建一个SqlSession的实例DefaultSqlSession作为具体SQL执行的入口,DefaultSqlSession对象中封装着属性Configuration，Executor，autoCommit等；
public int insert(String statement) {
    return this.insert(statement, (Object)null);
}
public int insert(String statement, Object parameter) {
    return this.update(statement, parameter);
}

  • insert操作是通过调用update语句进行的相关逻辑，delete操作也是通过调用update实现的具体逻辑；

  • 根据statement从configuration中获取到相应的MappedStatement对象（在初始化中已经解析加载到configuration中）

  • 对参数parameter中的集合进行处理；

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

    return var4;
}

  • Executor最终将MapperStatement的执行委托给了StatementHandler；具体的执行流程：

    • 获取一个connection数据库连接；

    • 调用StatementHandler.prepare()方法获取一个statement

    • 调用StatementHandler.parameterize方法设置sql执行时候需要的参数

    • 调用StatementHandler.update()方法执行具体sql指令

public int doUpdate(MappedStatement ms, Object parameter) throws SQLException {
    Statement stmt = null;

    int var6;
    try {
        Configuration configuration = ms.getConfiguration();
        StatementHandler handler = configuration.newStatementHandler(this, ms, parameter, RowBounds.DEFAULT, (ResultHandler)null, (BoundSql)null);
        stmt = this.prepareStatement(handler, ms.getStatementLog());
        var6 = handler.update(stmt);
    } finally {
        this.closeStatement(stmt);
    }

    return var6;
}
  • 调用prepareStatement()方法获取statement，类似于JDBC的conn.getStatement();
private Statement prepareStatement(StatementHandler handler, Log statementLog) throws SQLException {
    Connection connection = this.getConnection(statementLog);
    Statement stmt = handler.prepare(connection, this.transaction.getTimeout());
    handler.parameterize(stmt);
    return stmt;
}

2. 获取Connection数据库连接

  • MyBatis在底层维护了一个简单的数据库连接池用来管理数据库连接，用来复用数据库连接避免连接的重复创建造成的资源浪费；

  • SimpleExecutor中的getConnection()方法最终通过调用openConnection()实现，openConnection()方法中调用dataSource中的getConnection()方法获取连接

protected void openConnection() throws SQLException {

    if (log.isDebugEnabled()) {

      log.debug("Opening JDBC Connection");

    }

    connection = dataSource.getConnection();

    if (level != null) {

      connection.setTransactionIsolation(level.getLevel());

    }

    setDesiredAutoCommit(autoCommmit);

}
  • 调用datasource中的popConnection()方法从数据库连接池中获取连接
return popConnection(dataSource.getUsername(), dataSource.getPassword()).getProxyConnection();

  • MyBatis底层维护了一个数据库连接池主要类是datasource包下的PoolDataSource和PoolConnection，通过调用popConnection()方法从数据库连接池中尝试获取连接；

  • 在数据库连接池中idleConnections用于存放空闲数据库连接，c用于存放创建完成可以使用的数据库连接；

  • 调用popConnenction()方法会尝试先从idleConnections中获取空闲连接，如果idleConnections为空，则判断创建的数据库连接是否超过连接池最大连接数，如果未超过则创建一个新连接并放入activeConnections中；如果超过则从activeConnections列表中取出第一个判断是否超时，如果超时则回滚具体操作，然后创建一个新的数据连接放入activeConnections中；如果未超时则当前线程await()等待等待被唤醒；

private PooledConnection popConnection(String username, String password) throws SQLException {
  boolean countedWait = false;
  PooledConnection conn = null;
  long t = System.currentTimeMillis();
  int localBadConnectionCount = 0;

  while (conn == null) {
    synchronized (state) {
      if (!state.idleConnections.isEmpty()) {
        // Pool has available connection
        conn = state.idleConnections.remove(0);
        if (log.isDebugEnabled()) {
          log.debug("Checked out connection " + conn.getRealHashCode() + " from pool.");
        }
      } else {
        // Pool does not have available connection
        if (state.activeConnections.size() < poolMaximumActiveConnections) {
          // Can create new connection
          conn = new PooledConnection(dataSource.getConnection(), this);
          if (log.isDebugEnabled()) {
            log.debug("Created connection " + conn.getRealHashCode() + ".");
          }
        } else {
          // Cannot create new connection
          PooledConnection oldestActiveConnection = state.activeConnections.get(0);
          long longestCheckoutTime = oldestActiveConnection.getCheckoutTime();
          if (longestCheckoutTime > poolMaximumCheckoutTime) {
            // Can claim overdue connection
            state.claimedOverdueConnectionCount++;
            state.accumulatedCheckoutTimeOfOverdueConnections += longestCheckoutTime;
            state.accumulatedCheckoutTime += longestCheckoutTime;
            state.activeConnections.remove(oldestActiveConnection);
            if (!oldestActiveConnection.getRealConnection().getAutoCommit()) {
              try {
                oldestActiveConnection.getRealConnection().rollback();
              } catch (SQLException e) {
                log.debug("Bad connection. Could not roll back");
              }  
            }
            conn = new PooledConnection(oldestActiveConnection.getRealConnection(), this);
            conn.setCreatedTimestamp(oldestActiveConnection.getCreatedTimestamp());
            conn.setLastUsedTimestamp(oldestActiveConnection.getLastUsedTimestamp());
            oldestActiveConnection.invalidate();
            if (log.isDebugEnabled()) {
              log.debug("Claimed overdue connection " + conn.getRealHashCode() + ".");
            }
          } else {
            // Must wait
            try {
              if (!countedWait) {
                state.hadToWaitCount++;
                countedWait = true;
              }
              if (log.isDebugEnabled()) {
                log.debug("Waiting as long as " + poolTimeToWait + " milliseconds for connection.");
              }
              long wt = System.currentTimeMillis();
              state.wait(poolTimeToWait);
              state.accumulatedWaitTime += System.currentTimeMillis() - wt;
            } catch (InterruptedException e) {
              break;
            }
          }
        }
      }
      if (conn != null) {
        if (conn.isValid()) {
          if (!conn.getRealConnection().getAutoCommit()) {
            conn.getRealConnection().rollback();
          }
          conn.setConnectionTypeCode(assembleConnectionTypeCode(dataSource.getUrl(), username, password));
          conn.setCheckoutTimestamp(System.currentTimeMillis());
          conn.setLastUsedTimestamp(System.currentTimeMillis());
          state.activeConnections.add(conn);
          state.requestCount++;
          state.accumulatedRequestTime += System.currentTimeMillis() - t;
        } else {
          if (log.isDebugEnabled()) {
            log.debug("A bad connection (" + conn.getRealHashCode() + ") was returned from the pool, getting another connection.");
          }
          state.badConnectionCount++;
          localBadConnectionCount++;
          conn = null;
          if (localBadConnectionCount > (poolMaximumIdleConnections + 3)) {
            if (log.isDebugEnabled()) {
              log.debug("PooledDataSource: Could not get a good connection to the database.");
            }
            throw new SQLException("PooledDataSource: Could not get a good connection to the database.");
          }
        }
      }
    }

  }

  if (conn == null) {
    if (log.isDebugEnabled()) {
      log.debug("PooledDataSource: Unknown severe error condition.  The connection pool returned a null connection.");
    }
    throw new SQLException("PooledDataSource: Unknown severe error condition.  The connection pool returned a null connection.");
  }

  return conn;
}
  • 如果idleConnections列表为空且activeConnections列表长度小于连接池最大连接数，则创建新的PoolConnection对象；具体的数据库连接的创建逻辑在doGetConnection()方法中,从dataSource取出数据库配置信息创建相应的数据库连接；
private Connection doGetConnection(String username, String password) throws SQLException {
  Properties props = new Properties();
  if (driverProperties != null) {
    props.putAll(driverProperties);
  }
  if (username != null) {
    props.setProperty("user", username);
  }
  if (password != null) {
    props.setProperty("password", password);
  }
  return doGetConnection(props);
}

private Connection doGetConnection(Properties properties) throws SQLException {
  initializeDriver();
  Connection connection = DriverManager.getConnection(url, properties);
  configureConnection(connection);
  return connection;
}

3. 为Connection生成代理对象

  • 创建新的PoolConnection对象，生成connection的代理
public PooledConnection(Connection connection, PooledDataSource dataSource) {
  this.hashCode = connection.hashCode();
  this.realConnection = connection;
  this.dataSource = dataSource;
  this.createdTimestamp = System.currentTimeMillis();
  this.lastUsedTimestamp = System.currentTimeMillis();
  this.valid = true;
  this.proxyConnection = (Connection) Proxy.newProxyInstance(Connection.class.getClassLoader(), IFACES, this);
}

  • 对Connection生成JDK动态代理，PooledConnection本身就是实现了invocationHandler接口，在调用Connection的方法时候会通过invoke()方法直接调用生成的代理类的方法；

  • 在代理数据库连接类中会判断调用方法是否为close()，则会调用pushConnection()代理原来的close()方法；

@Override
public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
  String methodName = method.getName();
  if (CLOSE.hashCode() == methodName.hashCode() && CLOSE.equals(methodName)) {
    dataSource.pushConnection(this);
    return null;
  } else {
    try {
      if (!Object.class.equals(method.getDeclaringClass())) {
        // issue #579 toString() should never fail
        // throw an SQLException instead of a Runtime
        checkConnection();
      }
      return method.invoke(realConnection, args);
    } catch (Throwable t) {
      throw ExceptionUtil.unwrapThrowable(t);
    }
  }
}
  • pushConnection()方法主要处理数据库连接关闭问题，当数据库连接用完后从activeConnections列表中移除connection，同时判断空闲列表idleConnections中的连接数量对否少于最大空闲数量，如果少于将connection放入idleConnections；如果大于最大空闲连接数目则调用原connection的close()方法，使连接失效；
protected void pushConnection(PooledConnection conn) throws SQLException {

  synchronized (state) {
    state.activeConnections.remove(conn);
    if (conn.isValid()) {
      if (state.idleConnections.size() < poolMaximumIdleConnections && conn.getConnectionTypeCode() == expectedConnectionTypeCode) {
        state.accumulatedCheckoutTime += conn.getCheckoutTime();
        if (!conn.getRealConnection().getAutoCommit()) {
          conn.getRealConnection().rollback();
        }
        PooledConnection newConn = new PooledConnection(conn.getRealConnection(), this);
        state.idleConnections.add(newConn);
        newConn.setCreatedTimestamp(conn.getCreatedTimestamp());
        newConn.setLastUsedTimestamp(conn.getLastUsedTimestamp());
        conn.invalidate();
        if (log.isDebugEnabled()) {
          log.debug("Returned connection " + newConn.getRealHashCode() + " to pool.");
        }
        state.notifyAll();
      } else {
        state.accumulatedCheckoutTime += conn.getCheckoutTime();
        if (!conn.getRealConnection().getAutoCommit()) {
          conn.getRealConnection().rollback();
        }
        conn.getRealConnection().close();
        if (log.isDebugEnabled()) {
          log.debug("Closed connection " + conn.getRealHashCode() + ".");
        }
        conn.invalidate();
      }
    } else {
      if (log.isDebugEnabled()) {
        log.debug("A bad connection (" + conn.getRealHashCode() + ") attempted to return to the pool, discarding connection.");
      }
      state.badConnectionCount++;
    }
  }
}

4. 利用生成的Connection对象创建statement

  • 根据上文生成的数据库连接创建Statement实例对象；
private Statement prepareStatement(StatementHandler handler, Log statementLog) throws SQLException {
  Statement stmt;
  Connection connection = getConnection(statementLog);
  stmt = handler.prepare(connection, transaction.getTimeout());
  handler.parameterize(stmt);
  return stmt;
}
@Override
public Statement prepare(Connection connection, Integer transactionTimeout) throws SQLException {
  return delegate.prepare(connection, transactionTimeout);
}
  • prepare()方法调用instantiateStatement()方法从connection中获取Statement实例，并将超时时间绑定
@Override
public Statement prepare(Connection connection, Integer transactionTimeout) throws SQLException {
  ErrorContext.instance().sql(boundSql.getSql());
  Statement statement = null;
  try {
    statement = instantiateStatement(connection);
    setStatementTimeout(statement, transactionTimeout);
    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);
  }
}
  • 从boundSql中获取待执行的sql，调用connection.preparement(sql)生成Statement对象
@Override
protected Statement instantiateStatement(Connection connection) throws SQLException {
  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);
  }
}

5. 对生成的Statement实例进行参数设置

  • 通过connection实例获取statement后需要进行参数设置
private Statement prepareStatement(StatementHandler handler, Log statementLog) throws SQLException {
  Statement stmt;
  Connection connection = getConnection(statementLog);
  stmt = handler.prepare(connection, transaction.getTimeout());
  handler.parameterize(stmt);
  return stmt;
}
@Override
public void parameterize(Statement statement) throws SQLException {
  delegate.parameterize(statement);
}
@Override
public void parameterize(Statement statement) throws SQLException {
  parameterHandler.setParameters((PreparedStatement) statement);
}
  • 从boundSql中获取参数列表parameterMapping，调用setParameter()方法进行参数设置；
@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 (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);
        }
      }
    }
  }
}

6. 执行更新操作

  • 完成statement的获取和参数设置，接下来执行statement；
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);

      stmt = prepareStatement(handler, ms.getStatementLog());

      return handler.update(stmt);

    } finally {

      closeStatement(stmt);

    }

}

@Override
public int update(Statement statement) throws SQLException {
  return delegate.update(statement);
}
  • 调用statement.execute()方法执行数据库操作，并调用processAfter()方法处理后置操作；
@Override
public int update(Statement statement) throws SQLException {
  PreparedStatement ps = (PreparedStatement) statement;
  ps.execute();
  int rows = ps.getUpdateCount();
  Object parameterObject = boundSql.getParameterObject();
  KeyGenerator keyGenerator = mappedStatement.getKeyGenerator();
  keyGenerator.processAfter(executor, mappedStatement, ps, parameterObject);
  return rows;
}

(3) 总结

MyBatis具体执行SQL的流程：1.根据statement字符串从configuration中获取对应的mappedStatement；2.根据获取的mappedStatement创建相应的Statement实例；3.根据传入的参数对statement实例进行参数设置；4.执行statement并执行后置操作；

Eric010101
关注
专栏目录
【SpringBoot】26、SpringBoot中整合MyBatis-Plus实现数据库操作
Asurplus
07-23 21万+
MyBatis 框架相信大家都用过，虽然 MyBatis 可以直接在 xml 中通过 SQL 语句操作数据库，很是灵活。但正其操作都要通过 SQL 语句进行，就必须写大量的 xml 文件，很是麻烦。于是 MyBatis-Plus 应运而生，作为 MyBatis 的增强工具，更是为我们开发效率得到了质的飞跃。 一、简介 1、MyBatis MyBatis 是一款优秀的持久层框架，它支持自定义 SQL、存储过程以及高级映射。MyBatis 免除了几乎所有的 JDBC 代码以及设置参数和获取结果集的工作。MyBa
深入理解MyBatis（三）—MyBatis的Update操作执行流程
tuzhenyu的博客
09-08 8587
深入理解MyBatis（三）—MyBatis的Update操作执行流程 通过配置文件的解析以及Configuration对象的生成，MyBatis完成了初始化；初始化完成后通过获取的SqlSessionFactory，可以得到SqlSession用来进行动态操作； MyBatis中的insert操作，delete操作，update操作实质上底层都是调用update；本文以inse
Mybatis中进行批量更新（updateBatch）
10-16 3825
更新多条数据,每条数据都不一样 背景描述：通常如果需要一次更新多条数据有两个方式，（1）在业务代码中循环遍历逐条更新。（2）一次性更新所有数据（更准确的说是一条sql语句来更新所有数据，逐条更新的操作放到数据库端，在业务代码端展现的就是一次性更新所有数据）。两种方式各有利弊，下面将会对两种方式的利弊做简要分析，主要介绍第二种方式在mybatis中的实现。 逐条更新(效率低)(方法一) 这种方式显然是最简单，也最不容易出错的，即便出错也只是影响到当条出错的数据，而且可以对每条数据都比较可控，更新失败或.
一条Update语句的执行流程。
最新发布
Delete_wang的博客
08-14 304
一条Update语句的执行过程
Mybatis-基础操作-更新
ADCvbV的博客
06-02 1876
2.Mybatis演示:更新操作需要注解@Update 2.测试类: 3.运行结果:
04-MyBatis-更新操作
yk10010的博客
04-20 1984
MyBatis修改操作 单笔更新 根据用户id修改用户名 使用的sql： UPDATE `user`SET username = ‘赵云’ WHERE id = 26 映射文件 在User.xml配置文件中添加如下内容： <!-- 更新用户 --> <update id="updateUserById" parameterType="cn.itcast.mybatis.pojo...
MyBatis-Plus_更新操作
Gblfy_Blog
06-23 9166
3
mybatis-plus-generator-ui
03-28
Mybatis-Plus-Generator-UI 是一个基于 Mybatis-Plus 的图形化代码生成工具，它为开发者提供了便捷的创建数据库表的 CRUD（Create、Read、Update、Delete）操作的前端界面。这个工具大大简化了开发过程，使得开发者...
SpringBoot集成MyBatis-Plus-Join
04-23
在现代Java Web开发中，Spring Boot以其简洁、快速的特性受到了广泛欢迎。而MyBatis-Plus（简称MP）作为MyBatis的增强工具，极大地简化了数据库操作。本篇文章将深入探讨如何在Spring Boot项目中集成MyBatis-Plus，...
资料-全面学习Mybatis插件之Mybatis-Plus.rar
05-18
Mybatis-Plus是一个基于Mybatis框架的扩展工具，旨在简化常见的CRUD操作，提供更强大的...同时，随着对Mybatis-Plus的深入，你将能够更好地利用其高级特性，如动态SQL、缓存管理等，进一步优化你的Java Web应用程序。
Spring Boot入门(14)：使用Mybatis-Plus轻松实现高效自定义SQL操作！
**My Coding Family**
08-20 3万+
如何使用Mybatis-Plus执行自定义SQL，一文教会你。
Mybatis 中的insertOrUpdate操作
08-31
主要介绍了Mybatis 中的insertOrUpdate操作，代码简单易懂，非常不错需要的的朋友参考下
mybatis update和事务
qq_41799291的博客
03-30 1974
1.修改的时候不仅要按id修改 ，还有加上查询时候的update的时间，不然就是一条脏数据。 @Override public Integer updateTVarBasic(TVarBasic tVarBasic) { //多条件查询 Example example =new Example(TVarBasic.class); Exa...
【Mybatis小白从0到90%精讲】06：三步搞定Mybatis更新(update)操作
天罡gg的专栏
11-05 1510
MyBatis是一个优秀的持久层框架，今天我们来实战Mybatis更新(update)操作，通过前面的积累，只要三步即可稳稳的搞定！
java mybatis update_Java-MyBatis-MyBatis3-XML映射文件：insert, update 和 delete
weixin_42378374的博客
02-26 250
insert, update 和 delete数据变更语句 insert，update 和 delete 的实现非常接近：Insert, Update, Delete 元素的属性属性描述id命名空间中的唯一标识符，可被用来代表这条语句。parameterType将要传入语句的参数的完全限定类名或别名。这个属性是可选的，因为 MyBatis 可以通过类型处理器推断出具体传入语句的参数，默认值为未设置...
Mybatis-Plus中update更新操作用法
怪咖@的博客
06-12 5万+
在Mybatis-Plus官网当中并没有对于update进行针对性的详细讲解以及其使用，很多初级小白都用不明白，包括我有时候都迷迷糊糊的，基于这个问题我也是下定决心好好整理一篇。本篇文章重点是通过多个案例来进行讲解，每一个案例执行出来的sql我都会放到文章当中，方便大家快速掌握并使用！
Mybatis 批量更新update详解
weixin_42926863的博客
03-03 9160
mybatis
15.Mybatis 更新操作-update
热门推荐
Java 程序源
08-27 7万+
1. update 标签 update 标签是用于定义更新 语句的. 1.1 常用属性 update 有几个常用的属性, 但是通常只需要设置id 即可. id: sql 片段在命名空间内的唯一标识. 和mapper 中方法名保持一致 parameterType: 参数类型, 通常都可以省略. flushCache: 是否刷新(清空)一级缓存和二级缓存, 默认为true. 笔者尝试设置为false...
6.Mybatis事务
代码搬运工
12-07 237
事务，Transaction MyBatis里默认开启了事务，在执行insert, update, delete之后，要记得commit ，形如， try (SqlSession session = sqlSessionFactory.openSession()) { session.insert (…) session.update(…) session.commit(true); } 在官方文档里...
Java项目开发实战：SpringBoot+MyBatis-Plus集成MySQL与APIFox端口测试
MyBatis-Plus能够省去手动编写大量的模板代码，且具备通用的CRUD（创建(Create)、检索(Retrieve)、更新(Update)和删除(Delete)）操作。同时，它还提供了如分页、性能分析、SQL注入防护、代码生成等特性。使用MyBatis...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值