mybatis源码学习------StatementHandler

最新推荐文章于 2024-09-15 22:14:18 发布
最新推荐文章于 2024-09-15 22:14:18 发布
阅读量560 收藏
点赞数
分类专栏： mybatis 源码学习 文章标签： mybatis StateHandler
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_35835624/article/details/109658221
版权

StatementHandler接口

StatementHandler接口提供了很多功能(从接口的定义中可以看出)，是sql执行器接口的基础。

接口定义

public interface StatementHandler {
  //从连接对象中获取一个Statement
  Statement prepare(Connection connection, Integer transactionTimeout)
      throws SQLException;
  //给Statement绑定实参
  void parameterize(Statement statement)
      throws SQLException;
  //批量执行
  void batch(Statement statement)
      throws SQLException;
  //执行增删改语句
  int update(Statement statement)
      throws SQLException;
  //执行查询，返回一个结果集合
  <E> List<E> query(Statement statement, ResultHandler resultHandler)
      throws SQLException;
  //执行查询，返回一个游标
  <E> Cursor<E> queryCursor(Statement statement)
      throws SQLException;
  //获取绑定的BoundSql对象
  BoundSql getBoundSql();
  //获取ParameterHandler的实例
  ParameterHandler getParameterHandler();

}

StatementHandler的类图

在这里插入图片描述

RoutingStatementHandler

RoutingStatementHandler实现了StatementHandler接口，使用了策略设计模式实现，帮调用者屏蔽了不同实现的差异，简化调用。

在RoutingStatementHandler的构造函数中对delegate属性进行了初始化，其他方法的调用都是通过委派者完成的。

public class RoutingStatementHandler implements StatementHandler {
  //持有一个StatementHandler的具体实现
  private final StatementHandler delegate;

  //构造函数根据MappedStatement的类型为其创建不同的StatementHandler实例
  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());
    }

  }

  @Override
  public Statement prepare(Connection connection, Integer transactionTimeout) throws SQLException {
    return delegate.prepare(connection, transactionTimeout);
  }

  @Override
  public void parameterize(Statement statement) throws SQLException {
    delegate.parameterize(statement);
  }

  @Override
  public void batch(Statement statement) throws SQLException {
    delegate.batch(statement);
  }

  @Override
  public int update(Statement statement) throws SQLException {
    return delegate.update(statement);
  }

  @Override
  public <E> List<E> query(Statement statement, ResultHandler resultHandler) throws SQLException {
    return delegate.query(statement, resultHandler);
  }

  @Override
  public <E> Cursor<E> queryCursor(Statement statement) throws SQLException {
    return delegate.queryCursor(statement);
  }

  @Override
  public BoundSql getBoundSql() {
    return delegate.getBoundSql();
  }

  @Override
  public ParameterHandler getParameterHandler() {
    return delegate.getParameterHandler();
  }
}

BaseStatementHandler

BaseStatementHandler及其子类使用了模板设计模式，模板设计模式有以下优点：

  1. 它封装了不变部分，扩展可变部分。它把认为是不变部分的算法封装到父类中实现，而把可变部分算法由子类继承实现，便于子类继续扩展。
  2. 在父类中提取了公共的部分代码，便于代码复用。
  3. 分方法是由子类实现的，因此子类可以通过扩展方式增加相应的功能，符合开闭原则。

属性

//全局配置对象
protected final Configuration configuration;
//默认对象工厂
protected final ObjectFactory objectFactory;
//类型处理器注册中心
protected final TypeHandlerRegistry typeHandlerRegistry;
//结果集处理器
protected final ResultSetHandler resultSetHandler;
//参数处理器
protected final ParameterHandler parameterHandler;
//sql执行器
protected final Executor executor;
protected final MappedStatement mappedStatement;
protected final RowBounds rowBounds;

protected BoundSql boundSql;

构造函数

protected BaseStatementHandler(Executor executor, MappedStatement mappedStatement, Object parameterObject, RowBounds rowBounds, ResultHandler resultHandler, BoundSql boundSql) {
  this.configuration = mappedStatement.getConfiguration();
  this.executor = executor;
  this.mappedStatement = mappedStatement;
  this.rowBounds = rowBounds;

  this.typeHandlerRegistry = configuration.getTypeHandlerRegistry();
  this.objectFactory = configuration.getObjectFactory();
  //boundSql为空表示当前为修改类操作，即增删改操作，则先生成对应的主键再创建BoundSql对象
  if (boundSql == null) {
    generateKeys(parameterObject);
    boundSql = mappedStatement.getBoundSql(parameterObject);
  }

  this.boundSql = boundSql;
  //创建ParameterHandler对象
  this.parameterHandler = configuration.newParameterHandler(mappedStatement, parameterObject, boundSql);
  //创建ResultSetHandler对象
  this.resultSetHandler = configuration.newResultSetHandler(executor, mappedStatement, rowBounds, parameterHandler, resultHandler, boundSql);
}

接口方法

prepare

代码中有设置fetchSize属性的逻辑，关于Statement的fetchSize属性可以参考这篇文章学习：https://blog.csdn.net/seven_3306/article/details/9303879

@Override
public Statement prepare(Connection connection, Integer transactionTimeout) throws SQLException {
  ErrorContext.instance().sql(boundSql.getSql());
  Statement statement = null;
  try {
    //创建Statement对象
    statement = instantiateStatement(connection);
    //设置超时时间
    setStatementTimeout(statement, transactionTimeout);
    //设置statement的FetchSize属性 
    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);
  }
}

getBoundSql

@Override
public BoundSql getBoundSql() {
  return boundSql;
}

getParameterHandler

@Override
public ParameterHandler getParameterHandler() {
  return parameterHandler;
}

instantiateStatement

抽象方法，交由具体子类实现

protected abstract Statement instantiateStatement(Connection connection) throws SQLException;

setStatementTimeout

用于设置查询超时时间。如果sql语句的配置中设置了查询超时时间，则以sql语句的配置中设置的为准，否则以全局配置的查询超时时间为准。如果上面两个地方都没有设置查询超时时间，则以事务的超时时间为兜底方案。具体代码如下：

protected void setStatementTimeout(Statement stmt, Integer transactionTimeout) throws SQLException {
  Integer queryTimeout = null;
  if (mappedStatement.getTimeout() != null) {
    queryTimeout = mappedStatement.getTimeout();
  } else if (configuration.getDefaultStatementTimeout() != null) {
    queryTimeout = configuration.getDefaultStatementTimeout();
  }
  if (queryTimeout != null) {
    stmt.setQueryTimeout(queryTimeout);
  }
  StatementUtil.applyTransactionTimeout(stmt, queryTimeout, transactionTimeout);
}

setFetchSize

设置FetchSize属性，如果sql语句的配置中设置了fetchSize的大小，则以sql语句的配置中设置的为准，否则以全局配置的fetchSize大小为准。

protected void setFetchSize(Statement stmt) throws SQLException {
  Integer fetchSize = mappedStatement.getFetchSize();
  if (fetchSize != null) {
    stmt.setFetchSize(fetchSize);
    return;
  }
  Integer defaultFetchSize = configuration.getDefaultFetchSize();
  if (defaultFetchSize != null) {
    stmt.setFetchSize(defaultFetchSize);
  }
}

closeStatement

关闭statement，JDBC的模板代码

protected void closeStatement(Statement statement) {
  try {
    if (statement != null) {
      statement.close();
    }
  } catch (SQLException e) {
    //ignore
  }
}

generateKeys

生成自增主键

protected void generateKeys(Object parameter) {
  KeyGenerator keyGenerator = mappedStatement.getKeyGenerator();
  ErrorContext.instance().store();
  keyGenerator.processBefore(executor, mappedStatement, null, parameter);
  ErrorContext.instance().recall();
}

ParameterHandler接口

ParameterHandler接口提供了为sql语句绑定实参的功能

public interface ParameterHandler {
  //获取实参对象
  Object getParameterObject();
  //为sql语句绑定实参
  void setParameters(PreparedStatement ps) throws SQLException;
}

ParameterHandler接口类图如下
在这里插入图片描述

从其类图中可以看出，该接口只有一个实现DefaultParameterHandler，其代码如下：

DefaultParameterHandler

属性

//类型处理器注册中心
private final TypeHandlerRegistry typeHandlerRegistry;
private final MappedStatement mappedStatement;
//实参对象
private final Object parameterObject;
private final BoundSql boundSql;
//全局配置对象
private final Configuration configuration;

构造函数

public DefaultParameterHandler(MappedStatement mappedStatement, Object parameterObject, BoundSql boundSql) {
  this.mappedStatement = mappedStatement;
  this.configuration = mappedStatement.getConfiguration();
  this.typeHandlerRegistry = mappedStatement.getConfiguration().getTypeHandlerRegistry();
  this.parameterObject = parameterObject;
  this.boundSql = boundSql;
}

接口方法

getParameterObject

获取实参对象

@Override
public Object getParameterObject() {
  return parameterObject;
}
setParameters

通过TypeHandler为sql语句绑定实参。

@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) {//OUT表示出参，这里只处理入参
        Object value;
        String propertyName = parameterMapping.getProperty();
        if (boundSql.hasAdditionalParameter(propertyName)) {//属性存在于additionalParameters属性中(可以通过<bind/>传入)
          value = boundSql.getAdditionalParameter(propertyName);
        } else if (parameterObject == null) {//实参为空
          value = null;
        } else if (typeHandlerRegistry.hasTypeHandler(parameterObject.getClass())) {//可以转换为对应的JDBC类型
          value = parameterObject;
        } else {//其余情况直接将其包装为MetaObject对象
          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实现为sql语句绑定实参
          typeHandler.setParameter(ps, i + 1, value, jdbcType);
        } catch (TypeException | SQLException e) {
          throw new TypeException("Could not set parameters for mapping: " + parameterMapping + ". Cause: " + e, e);
        }
      }
    }
  }
}

Statement和PreparedStatement的区别

1、Statement用于执行静态SQL语句，在执行时，必须指定一个事先准备好的SQL语句。
2、PrepareStatement是预编译的SQL语句对象，sql语句被预编译并保存在对象中。被封装的sql语句代表某一类操作，语句中可以包含动态参数“?”，在执行时可以为“?”动态设置参数值。
3、使用PrepareStatement对象执行sql时，sql被数据库进行解析和编译，然后被放到命令缓冲区，每当执行同一个PrepareStatement对象时，它就会被解析一次，但不会被再次编译。在缓冲区可以发现预编译的命令，并且可以重用。
4、PrepareStatement可以减少编译次数提高数据库性能。

SimpleStatementHandler

继承自抽象类BaseStatementHandler，底层使用JDBC的Statement对象来完成数据库操作。

update

@Override
public int update(Statement statement) throws SQLException {
  String sql = boundSql.getSql();
  Object parameterObject = boundSql.getParameterObject();
  //获取配置的主键生成器
  KeyGenerator keyGenerator = mappedStatement.getKeyGenerator();
  int rows;
  //如果是自增主键
  if (keyGenerator instanceof Jdbc3KeyGenerator) {
    //执行sql
    statement.execute(sql, Statement.RETURN_GENERATED_KEYS);
    //获取受影响的行数
    rows = statement.getUpdateCount();
    //执行后处理逻辑，将自增主键保存到入参中
    keyGenerator.processAfter(executor, mappedStatement, statement, parameterObject);
  } else if (keyGenerator instanceof SelectKeyGenerator) {//通过<selectKey>配置的主键生成器
    //执行sql
    statement.execute(sql);
    //获取受影响的行数
    rows = statement.getUpdateCount();
    //执行后处理逻辑
    keyGenerator.processAfter(executor, mappedStatement, statement, parameterObject);
  } else {//没有配置主键生成器
    statement.execute(sql);
    rows = statement.getUpdateCount();
  }
  return rows;
}

其余方法

因为SimpleStatementHandler底层使用的是Statement完成对数据库的操作，所以parameterize方法是一个空实现。

其中ResultSetType枚举类的意思如下：

枚举值含义
ResultSet.TYPE_FORWARD_ONLY默认的cursor 类型，仅仅支持结果集forward ，不支持backforward ，random ，last ，first 等操作
ResultSet.TYPE_SCROLL_INSENSITIVE支持结果集backforward ，random ，last ，first 等操作，对其它session 对数据库中数据做出的更改是不敏感的。
ResultSet.TYPE_SCROLL_SENSITIVE支持结果集backforward ，random ，last ，first 等操作，对其它session 对数据库中数据做出的更改是敏感的，即其他session 修改了数据库中的数据，会反应到本结果集中。
ResultSet.DEFAULT默认类型，依赖不同的驱动
@Override
public void batch(Statement statement) throws SQLException {
  String sql = boundSql.getSql();
  statement.addBatch(sql);
}

@Override
public <E> List<E> query(Statement statement, ResultHandler resultHandler) throws SQLException {
  String sql = boundSql.getSql();
  statement.execute(sql);
  //通过ResultSetHandler组装结果
  return resultSetHandler.handleResultSets(statement);
}

@Override
public <E> Cursor<E> queryCursor(Statement statement) throws SQLException {
  String sql = boundSql.getSql();
  statement.execute(sql);
  //通过ResultSetHandler组装结果
  return resultSetHandler.handleCursorResultSets(statement);
}

@Override
protected Statement instantiateStatement(Connection connection) throws SQLException {
  if (mappedStatement.getResultSetType() == ResultSetType.DEFAULT) {//结果类型未设置
    return connection.createStatement();
  } else {//设置结果集为只读的
    return connection.createStatement(mappedStatement.getResultSetType().getValue(), ResultSet.CONCUR_READ_ONLY);
  }
}

@Override
public void parameterize(Statement statement) {
  // N/A
}

PreparedStatementHandler

继承自抽象类BaseStatementHandler，底层使用JDBC的PreparedStatement完成对数据库的操作。实现逻辑与SimpleStatementHandler类似，看看就ok。

public class PreparedStatementHandler extends BaseStatementHandler {
  //调用父类构造器
  public PreparedStatementHandler(Executor executor, MappedStatement mappedStatement, Object parameter, RowBounds rowBounds, ResultHandler resultHandler, BoundSql boundSql) {
    super(executor, mappedStatement, parameter, rowBounds, resultHandler, boundSql);
  }

  @Override
  public int update(Statement statement) throws SQLException {
    //预编译语句
    PreparedStatement ps = (PreparedStatement) statement;
    //执行sql
    ps.execute();
    //受影响的行数
    int rows = ps.getUpdateCount();
    //获取实参
    Object parameterObject = boundSql.getParameterObject();
    //获取主键生成器
    KeyGenerator keyGenerator = mappedStatement.getKeyGenerator();
    //后置处理逻辑
    keyGenerator.processAfter(executor, mappedStatement, ps, parameterObject);
    return rows;
  }

  @Override
  public void batch(Statement statement) throws SQLException {
    PreparedStatement ps = (PreparedStatement) statement;
    ps.addBatch();
  }

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

  @Override
  public <E> Cursor<E> queryCursor(Statement statement) throws SQLException {
    PreparedStatement ps = (PreparedStatement) statement;
    ps.execute();
    return resultSetHandler.handleCursorResultSets(ps);
  }
  //底层通过JDBC的Connection完成PrepareStatement的创建
  @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() == ResultSetType.DEFAULT) {
      return connection.prepareStatement(sql);
    } else {
      return connection.prepareStatement(sql, mappedStatement.getResultSetType().getValue(), ResultSet.CONCUR_READ_ONLY);
    }
  }

  @Override
  public void parameterize(Statement statement) throws SQLException {
    //通过parameterHandler完成实参的绑定
    parameterHandler.setParameters((PreparedStatement) statement);
  }

}
A股慈善家
关注
专栏目录
【Mybatis】Mybatis三大组件之StatementHandler
qq_34501351的博客
02-11 593
Executor是涉及到缓存及创建Statement的策略，StatementHandler是创建statement和给statement赋值。 Configuration根据参数创建不同的StatementHandler public RoutingStatementHandler(Executor executor, MappedStatement ms, Object parameter, RowBounds rowBounds, ResultHandler resultHandler, Boun
Mybatis3源码分析(14)-Sql解析执行-StatementHandler
ashan
12-22 2827
SimpleExecutor执行sql过程 BoundSql加载完成之后，下一步就可以执行select/update/insert/delete语句了。在SimpleExecutor中执行语句最终会由doQuery和doUpdate方法完成。 public int doUpdate(MappedStatement ms, Object parameter) throws SQLExcep
MyBatis(三)：StatementHandler
GDUT_Trim的博客
09-09 737
回顾三部分对应关系StatementHandlerStatementHandler结构PrepareStatementHandler执行流程构建StatementHandlerquery方法实现parameter方法实现 回顾 MyBatis的执行流程 Sqlsession （会话层面，门面模式）-》 Executor（执行器，模板方法，doQuery和query）-》 StatementHandler（JDBC处理器） JDBC分为三部分 获取Statement，声明Statement 设置Sql参.
Mybatis源码学习（五）——StatementHandler
最新发布
weixin_63445802的博客
09-15 1365
StatementHandler 类为 mybatis 执行 Statement 对象核心类，从之前的 Executor 的解析中可以看出所有与数据库交互的方法底层都是通过 StatementHandler 对象与其进行交互；因此为了继续探索 mybatis 与数据库的交互过程，本文将继续对 StatementHandler 进行分析。
StatementHandler
yang_yang_6666的博客
01-15 354
继承关系 RoutingStatementHandler会根据MappedStatement中StatementType属性进行创建StatementHandler RoutingStatementHandler中StatementHandler的类型 真正与数据库交互的StatementHandler SimpleStatementHandler 中执行数据库查询后把查询结果交给resul...
【MyBatis】MyBatis 核心配置综述之StatementHandler
九师兄
05-14 1982
1.概述 转载：核心配置综述之StatementHandler 2.MyBatis 四大组件之StatementHandler StatementHandler 是四大组件中最重要的一个对象，负责操作 Statement 对象与数据库进行交流，在工作时还会使用 ParameterHandler 和 ResultSetHandler 对参数进行映射，对结果进行实体类的绑定 我们在搭建原生JDBC的时候，会有这样一行代码 Statement stmt = conn.createStatement(); //也可
7.StatementHandler
wangbo199308的博客
09-21 443
1.StatementHandler概要 MyBatis一个基于JDBC的Dao框架，会话、执行器半点没有提到jdbc，原因是MyBatis把所有跟JDBC相关的操作全部都放到了StatementHandler中。 一个SQL请求会经过会话，然后是执行器，最由StatementHandler执行jdbc最终到达数据库。其关系如下图： 这里要注意这三者之间比例是1：1：n。也就是说多个SQL操作对应一个会话，和唯一的执行器以及N个StatementHandler。这里的N取决于通过会话调用了多少次Sql（命
mybatis源码之StatementHandler
井底之蛙
01-07 925
/** * @author Clinton Begin */ public interface StatementHandler { Statement prepare(Connection connection) throws SQLException; void parameterize(Statement statement) throws SQLEx
Mybatis源码学习(25)-StatementHandler解析
向心行者
01-18 1215
一、简介   StatementHandler是Mybatis最核心的接口之一， 他完成了Mybatis和数据库交互的相关工作（Mybatis与JDBC之间关于Statement的交互工作）。StatementHandler主要作用： 创建Statement对象 为SQL 语句绑定实参 执行select、insert 、update 、delete 等多种类型的SQL语句 批量执行SQL语句 结...
Mybatis源码--StatementHandler源码分析
ONROAD0612的博客
10-31 396
1 概述 在上一篇文章(Mybatis源码分析--Executor源码分析),我们分析Executor源码的时候就提到了StatementHandler的作用是和数据库对话。当然StatementHandler和数据库对话是依赖于Statement来完成的。在这里随便说一下ParameterHandler和ResultHandler的作用分别是绑定SQL参数和组装最后的结果返回。 2 生成St...
mybatis-3.5.9 源码（mybatis-3-mybatis-3.5.9.tar.gz）
02-07
通过对 MyBatis-3.5.9 源码的学习，开发者可以深入理解其工作原理，从而更好地优化自己的代码，解决潜在的问题，甚至为 MyBatis 做出贡献。这份源码不仅包含了 MyBatis 的核心功能，还反映了设计模式和最佳实践，...
Mybatis-StatementHandler源码解析（三）
pyd950812的博客
05-10 648
StatementHandler StatementHandler接口的实现大致有四个，其中三个实现类都是和JDBC中的Statement响对应的： SimpleStatementHandler，这个很简单了，就是对应我们JDBC中常用的Statement接口，用于简单SQL的处理； PreparedStatementHandler，这个对应JDBC中的PreparedStatement，...
MyBatis（技术NeiMu）：核心处理层（StatementHandler）
GDUT_Trim的博客
12-12 1306
回顾StatementHandlerRoutingStatementHandlerBaseStatementHandlerParameterHandlerDefaultParameterHandlerSimpleStatementHandler创建Statement执行查询执行修改PrepareStatementHandler创建Statement执行查询执行修改绑定实参CallableStatementHandler 回顾 StatementHandler StatementHandler接口是MyBa.
Mybatis的SqlSession下的四大对象之一：StatementHandler
西风烈马
08-16 674
Mybatis的SqlSession下的四大对象：Executor、StatementHandler、ParameterHandler、ResultHandler
MyBatis源码系列——处理器StatementHandler
m0_47623367的博客
12-17 436
原创 鲁班大叔 源码阅读网 文本学习目的是弄清楚StatementHandler设计理念，以及它的实现结构。 一、定义 顾名思议，StatementHandler 就是用于封装JDBC中Statement的操作。即声明SQL、设置参数、执行SQL等。通常一次SQL执行完之后就要关闭它，最多它的生命周期也不会超过一次事务的范围。StatementHandler 也是一样，执行器中每执行一次SQL操作，都会通过Configuration 构建一个新的StatementHandler，用完就丢弃了。它们是1比N
【手撕MyBatis源码】JDBC处理器StatementHandler
十八岁讨厌编程的博客
05-25 1408
本文涉及StatemenHandler的定义与结构、PreparedStatemenHandler的执行流程、参数处理、结果集处理等内容。
mybatis-3-mybatis-3.5.8.zip源码
04-27
通过对mybatis-3-mybatis-3.5.8源码的学习，开发者可以更好地理解和优化MyBatis的使用，包括但不限于动态SQL的实现、事务控制、缓存处理等方面，从而提升应用程序的性能和可维护性。同时，源码阅读也是提升自身编程...
Mybatis源码解析——StatementHandler
Mutou_ren的博客
10-28 305
StatementHandler 用于创建statement对象，SQL语句绑定实参，执行SQL语句 RoutingStatementHandler 根据mappedStatement中指定的stateType创建对应的statementHandler接口实现类，并设置到自身的delegate字段中，该类的其余所有方法均委托给delegate执行。 比较像根据反射的动态策略模式的方式 BaseSt...
Mybatis核心-StatementHandler
MAX_VALUE的博客
04-26 239
Mybatis核心-StatementHandler
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值