MyBatis源码解析--加载流程（8）

最新推荐文章于 2024-09-25 10:59:43 发布
最新推荐文章于 2024-09-25 10:59:43 发布
阅读量118 收藏
点赞数
分类专栏： jdbc与mybatis 文章标签： java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/jacobbbbbbbb/article/details/106978475
版权

上篇讲完了Executor接口及其实现类，接下来分析StatementHandler，这是Executor用来处理Statement的。
首先是StatementHandler的接口

public interface StatementHandler {

 //从连接中获取一个Statement
  Statement prepare(Connection connection, Integer transactionTimeout)
      throws SQLException;

  //占位符处理，绑定statement执行时需要的实参
  void parameterize(Statement statement)
      throws SQLException;
 //批量执行sql语句
  void batch(Statement statement)
      throws SQLException;
//执行update/insert/delete语句
  int update(Statement statement)
      throws SQLException;

//执行select语句
  <E> List<E> query(Statement statement, ResultHandler resultHandler)
      throws SQLException;

  <E> Cursor<E> queryCursor(Statement statement)
      throws SQLException;

  //获取sql语句
  BoundSql getBoundSql();

  //获取封装的参数处理器
  ParameterHandler getParameterHandler();

}

RoutingStatementHandler 负责将不同的Statement类型路由到三个不同的实现类上。

public class RoutingStatementHandler implements StatementHandler {

  private final StatementHandler delegate;//底层封装的真正的StatementHandler对象

  public RoutingStatementHandler(Executor executor, MappedStatement ms, Object parameter, RowBounds rowBounds, ResultHandler resultHandler, BoundSql boundSql) {
    //RoutingStatementHandler最主要的功能就是根据mappedStatment的配置，生成一个对应的StatementHandler对象并赋值给delegate
    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.<E>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 实现了StatementHandler的基类，提供了骨架（模版模式）

public abstract class BaseStatementHandler implements StatementHandler {

  protected final Configuration configuration;
  protected final ObjectFactory objectFactory;
  protected final TypeHandlerRegistry typeHandlerRegistry;
  //结果处理器，对数据库返回的结果集（ResultSet）进行封装，返回用户指定的实体类型；
  protected final ResultSetHandler resultSetHandler;
  //sql占位符处理器，对预编译的SQL语句进行参数设置
  protected final ParameterHandler parameterHandler;
  //记录执行语句的executor对象
  protected final Executor executor;
  //sql语句对应的MappedStatement
  protected final MappedStatement mappedStatement;
  //分页信息
  protected final RowBounds rowBounds;
  //sql语句
  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();
//一般为写类操作
    if (boundSql == null) { 
    //获得自增主键
      generateKeys(parameterObject);
      //创建boundSql对象
      boundSql = mappedStatement.getBoundSql(parameterObject);
    }

    this.boundSql = boundSql;

    this.parameterHandler = configuration.newParameterHandler(mappedStatement, parameterObject, boundSql);
    this.resultSetHandler = configuration.newResultSetHandler(executor, mappedStatement, rowBounds, parameterHandler, resultHandler, boundSql);
  }

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

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

  @Override
  //使用模板模式，定义了获取Statement的步骤，其子类实现实例化Statement的具体的方式；
  public Statement prepare(Connection connection, Integer transactionTimeout) throws SQLException {
    ErrorContext.instance().sql(boundSql.getSql());
    Statement statement = null;
    try {
      //通过不同的子类实例化不同的Statement，分为三类：simple(statment)、prepare(prepareStatement)、callable(CallableStatementHandler)
      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);
    }
  }
//由子类实现具体的statement
  protected abstract Statement instantiateStatement(Connection connection) throws SQLException;
//设置超时时间
  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);
  }
//设置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);
    }
  }

  protected void closeStatement(Statement statement) {
    try {
      if (statement != null) {
        statement.close();
      }
    } catch (SQLException e) {
      //ignore
    }
  }
//获得自增主键
  protected void generateKeys(Object parameter) {
  //获得KeyGenerator对象
    KeyGenerator keyGenerator = mappedStatement.getKeyGenerator();
    ErrorContext.instance().store();
    //将自增编号到parameter中
    keyGenerator.processBefore(executor, mappedStatement, null, parameter);
    ErrorContext.instance().recall();
  }

}

SimpleStatementHandler Statement的StatementHandler实现类

public class SimpleStatementHandler extends BaseStatementHandler {

  public SimpleStatementHandler(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 {
    String sql = boundSql.getSql();
    Object parameterObject = boundSql.getParameterObject();
    KeyGenerator keyGenerator = mappedStatement.getKeyGenerator();
    int rows;
    //如果是 Jdbc3KeyGenerator 类型
    if (keyGenerator instanceof Jdbc3KeyGenerator) {
   //执行写操作
      statement.execute(sql, Statement.RETURN_GENERATED_KEYS);
      //获得更新数量
      rows = statement.getUpdateCount();
      //执行keyGenerator的后置处理逻辑
      keyGenerator.processAfter(executor, mappedStatement, statement, parameterObject);
    } else if (keyGenerator instanceof SelectKeyGenerator) {
    //执行写操作
      statement.execute(sql);
      //获得更新数量
      rows = statement.getUpdateCount();
      keyGenerator.processAfter(executor, mappedStatement, statement, parameterObject);
    } else {
      statement.execute(sql);
      rows = statement.getUpdateCount();
    }
    return rows;
  }

  @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();//获取sql语句
    statement.execute(sql);//执行sql语句
    return resultSetHandler.<E>handleResultSets(statement);//使用resultSetHandler处理查询结果
  }

  @Override
  public <E> Cursor<E> queryCursor(Statement statement) throws SQLException {
    String sql = boundSql.getSql();
    statement.execute(sql);
    return resultSetHandler.<E>handleCursorResultSets(statement);
  }

  @Override
  //使用底层的statment对象来完成对数据库的操作
  protected Statement instantiateStatement(Connection connection) throws SQLException {
    if (mappedStatement.getResultSetType() != null) {
    	//设置结果集是否可以滚动以及其游标是否可以上下移动，设置结果集是否可更新
      return connection.createStatement(mappedStatement.getResultSetType().getValue(), ResultSet.CONCUR_READ_ONLY);
    } else {
      return connection.createStatement();
    }
  }

  @Override
  //无需做占位符参数处理
  public void parameterize(Statement statement) throws SQLException {
    // N/A
  }

}

PreparedStatementHandler PreparedStatement 的 StatementHandler 实现类

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;
    ps.execute();
    int rows = ps.getUpdateCount();
    //获得更新数目
    Object parameterObject = boundSql.getParameterObject();
     // 执行 keyGenerator 的后置处理逻辑
    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.<E> handleResultSets(ps);
  }

  @Override
  public <E> Cursor<E> queryCursor(Statement statement) throws SQLException {
    PreparedStatement ps = (PreparedStatement) statement;
    ps.execute();
    return resultSetHandler.<E> handleCursorResultSets(ps);
  }

  @Override
  //使用底层的prepareStatement对象来完成对数据库的操作
  protected Statement instantiateStatement(Connection connection) throws SQLException {
    String sql = boundSql.getSql();
    //根据mappedStatement.getKeyGenerator字段，创建prepareStatement
    if (mappedStatement.getKeyGenerator() instanceof Jdbc3KeyGenerator) {//对于insert语句
      String[] keyColumnNames = mappedStatement.getKeyColumns();
      if (keyColumnNames == null) {
    	//返回数据库生成的主键
        return connection.prepareStatement(sql, PreparedStatement.RETURN_GENERATED_KEYS);
      } else {
    	//返回数据库生成的主键填充至keyColumnNames中指定的列
        return connection.prepareStatement(sql, keyColumnNames);
      }
    } else if (mappedStatement.getResultSetType() != null) {
     //设置结果集是否可以滚动以及其游标是否可以上下移动，设置结果集是否可更新
      return connection.prepareStatement(sql, mappedStatement.getResultSetType().getValue(), ResultSet.CONCUR_READ_ONLY);
    } else {
      //创建普通的prepareStatement对象
      return connection.prepareStatement(sql);
    }
  }

  @Override
  //使用parameterHandler对sql语句的占位符进行处理
  public void parameterize(Statement statement) throws SQLException {
    parameterHandler.setParameters((PreparedStatement) statement);
  }

}

CallableStatementHandler 不分析
创建StatementHandler对象是在Configuration中

public StatementHandler newStatementHandler(Executor executor, MappedStatement mappedStatement, Object parameterObject, RowBounds rowBounds, ResultHandler resultHandler, BoundSql boundSql) {
	//创建RoutingStatementHandler对象，实际由statmentType来指定真实的StatementHandler来实现
	StatementHandler statementHandler = new RoutingStatementHandler(executor, mappedStatement, parameterObject, rowBounds, resultHandler, boundSql);
    statementHandler = (StatementHandler) interceptorChain.pluginAll(statementHandler);
    return statementHandler;
  }

接下来介绍KeyGenerator 主键生成器接口

public interface KeyGenerator {
//sql执行前，order="BEFORE"
  void processBefore(Executor executor, MappedStatement ms, Statement stmt, Object parameter);
//sql执行后,order="AFTER"
  void processAfter(Executor executor, MappedStatement ms, Statement stmt, Object parameter);

}

Jdbc3KeyGenerator 适用于MySQL、H2主键生成。

public class Jdbc3KeyGenerator implements KeyGenerator {
//单例模式
  public static final Jdbc3KeyGenerator INSTANCE = new Jdbc3KeyGenerator();

  @Override
  //空实现，因为该类主键都是SQL执行后才生成。
  public void processBefore(Executor executor, MappedStatement ms, Statement stmt, Object parameter) {
    // do nothing
  }

  @Override
  //处理返回的自增主键，单个parameter参数可以认为是批量的一个特例
  public void processAfter(Executor executor, MappedStatement ms, Statement stmt, Object parameter) {
    processBatch(ms, stmt, getParameters(parameter));
  }

  public void processBatch(MappedStatement ms, Statement stmt, Collection<Object> parameters) {
    ResultSet rs = null;
    try {
    //获得返回的自增主键
      rs = stmt.getGeneratedKeys();
      final Configuration configuration = ms.getConfiguration();
      final TypeHandlerRegistry typeHandlerRegistry = configuration.getTypeHandlerRegistry();
      //获得keyProperties属性指定的属性名称，表示主键对应的属性名称
      final String[] keyProperties = ms.getKeyProperties();
      //得到ResultSet的元数据信息
      final ResultSetMetaData rsmd = rs.getMetaData();
      TypeHandler<?>[] typeHandlers = null;
      //检测数据库生成的主键的列数与keyProperties属性指定的列数是否匹配
      if (keyProperties != null && rsmd.getColumnCount() >= keyProperties.length) {
        for (Object parameter : parameters) {
          if (!rs.next()) {
            break;
          }
          final MetaObject metaParam = configuration.newMetaObject(parameter);
          if (typeHandlers == null) {
            typeHandlers = getTypeHandlers(typeHandlerRegistry, metaParam, keyProperties, rsmd);
          }
          //将生成的主键设置到用户传入的参数的对应位置
          populateKeys(rs, metaParam, keyProperties, typeHandlers);
        }
      }
    } catch (Exception e) {
      throw new ExecutorException("Error getting generated key or setting result to parameter object. Cause: " + e, e);
    } finally {
    //关闭ResultSet对象
      if (rs != null) {
        try {
          rs.close();
        } catch (Exception e) {
          // ignore
        }
      }
    }
  }
//将用户传入的实参转换成Collection类型对象
  private Collection<Object> getParameters(Object parameter) {
    Collection<Object> parameters = null;
    if (parameter instanceof Collection) {
      parameters = (Collection) parameter;
      //如果parameter是map类型，就获取其中的key
    } else if (parameter instanceof Map) {
      Map parameterMap = (Map) parameter;
      if (parameterMap.containsKey("collection")) {
        parameters = (Collection) parameterMap.get("collection");
      } else if (parameterMap.containsKey("list")) {
        parameters = (List) parameterMap.get("list");
      } else if (parameterMap.containsKey("array")) {
        parameters = Arrays.asList((Object[]) parameterMap.get("array"));
      }
    }
    if (parameters == null) {
      parameters = new ArrayList<>();
      parameters.add(parameter);
    }
    return parameters;
  }

  private TypeHandler<?>[] getTypeHandlers(TypeHandlerRegistry typeHandlerRegistry, MetaObject metaParam, String[] keyProperties, ResultSetMetaData rsmd) throws SQLException {
    TypeHandler<?>[] typeHandlers = new TypeHandler<?>[keyProperties.length];
    for (int i = 0; i < keyProperties.length; i++) {
      if (metaParam.hasSetter(keyProperties[i])) {
        Class<?> keyPropertyType = metaParam.getSetterType(keyProperties[i]);
        typeHandlers[i] = typeHandlerRegistry.getTypeHandler(keyPropertyType, JdbcType.forCode(rsmd.getColumnType(i + 1)));
      } else {
        throw new ExecutorException("No setter found for the keyProperty '" + keyProperties[i] + "' in '"
            + metaParam.getOriginalObject().getClass().getName() + "'.");
      }
    }
    return typeHandlers;
  }
//将主键参数注入到对象中
  private void populateKeys(ResultSet rs, MetaObject metaParam, String[] keyProperties, TypeHandler<?>[] typeHandlers) throws SQLException {
    for (int i = 0; i < keyProperties.length; i++) {
      String property = keyProperties[i];
      TypeHandler<?> th = typeHandlers[i];
      if (th != null) {
        Object value = th.getResult(rs, i + 1);
        metaParam.setValue(property, value);
      }
    }
  }

}

SelectKeyGenerator 对于不支持自动生成自增主键的数据库，例如Oracle数据库。

public class SelectKeyGenerator implements KeyGenerator {
  
  public static final String SELECT_KEY_SUFFIX = "!selectKey";
  //是否在before阶段执行
  private final boolean executeBefore;
  //MappedStatement 对象
  private final MappedStatement keyStatement;

  public SelectKeyGenerator(MappedStatement keyStatement, boolean executeBefore) {
    this.executeBefore = executeBefore;
    this.keyStatement = keyStatement;
  }

  @Override
  //调用processGeneratedKeys
  public void processBefore(Executor executor, MappedStatement ms, Statement stmt, Object parameter) {
    if (executeBefore) {
      processGeneratedKeys(executor, ms, parameter);
    }
  }

  @Override
  //调用processGeneratedKeys
  public void processAfter(Executor executor, MappedStatement ms, Statement stmt, Object parameter) {
    if (!executeBefore) {
      processGeneratedKeys(executor, ms, parameter);
    }
  }

  private void processGeneratedKeys(Executor executor, MappedStatement ms, Object parameter) {
    try {
    //有查询主键的SQL语句，即keyStatement对象非空
      if (parameter != null && keyStatement != null && keyStatement.getKeyProperties() != null) {
        String[] keyProperties = keyStatement.getKeyProperties();
        final Configuration configuration = ms.getConfiguration();
        final MetaObject metaParam = configuration.newMetaObject(parameter);
        //创建执行器，类型为SimpleExecutor
        if (keyProperties != null) {
          Executor keyExecutor = configuration.newExecutor(executor.getTransaction(), ExecutorType.SIMPLE);
          //获得SQL语句的查询结果
          List<Object> values = keyExecutor.query(keyStatement, parameter, RowBounds.DEFAULT, Executor.NO_RESULT_HANDLER);
          if (values.size() == 0) {
            throw new ExecutorException("SelectKey returned no data.");            
          } else if (values.size() > 1) {
            throw new ExecutorException("SelectKey returned more than one value.");
          } else {
          //单个主键，将属性设置到parameter中
            MetaObject metaResult = configuration.newMetaObject(values.get(0));
            if (keyProperties.length == 1) {
              if (metaResult.hasGetter(keyProperties[0])) {
                setValue(metaParam, keyProperties[0], metaResult.getValue(keyProperties[0]));
              } else {
                // no getter for the property - maybe just a single value object
                // so try that
                setValue(metaParam, keyProperties[0], values.get(0));
              }
            } else {
            //多个主键就遍历赋值
              handleMultipleProperties(keyProperties, metaParam, metaResult);
            }
          }
        }
      }
    } catch (ExecutorException e) {
      throw e;
    } catch (Exception e) {
      throw new ExecutorException("Error selecting key or setting result to parameter object. Cause: " + e, e);
    }
  }
//多个主键遍历赋值
  private void handleMultipleProperties(String[] keyProperties,
      MetaObject metaParam, MetaObject metaResult) {
    String[] keyColumns = keyStatement.getKeyColumns();
      
    if (keyColumns == null || keyColumns.length == 0) {
      // no key columns specified, just use the property names
      for (String keyProperty : keyProperties) {
        setValue(metaParam, keyProperty, metaResult.getValue(keyProperty));
      }
    } else {
      if (keyColumns.length != keyProperties.length) {
        throw new ExecutorException("If SelectKey has key columns, the number must match the number of key properties.");
      }
      for (int i = 0; i < keyProperties.length; i++) {
        setValue(metaParam, keyProperties[i], metaResult.getValue(keyColumns[i]));
      }
    }
  }

  private void setValue(MetaObject metaParam, String property, Object value) {
    if (metaParam.hasSetter(property)) {
      metaParam.setValue(property, value);
    } else {
      throw new ExecutorException("No setter found for the keyProperty '" + property + "' in " + metaParam.getOriginalObject().getClass().getName() + ".");
    }
  }
}
jacobbbbbbbb
关注
专栏目录
Mybatis源码分析-上课笔记1
08-03
在分析MyBatis源码时，可以采用宏观和微观两种视角。宏观上理解整个框架的架构和流程，微观上深入到具体的类和方法，通过阅读和调试代码来理解其实现细节。同时，绘制流程图或UML图能帮助更好地梳理组件间的交互。 ...
关于getFetchSize()的问题及想要获取分页查询个数的方法
qq_28080659的博客
11-27 5012
最近学习数据库，查看API，本想用getFetchSize()返回获取resultSet的记录数，结果每次返回的都是0，上网查询，发现，getFetchSize()返回的是resultset一次从数据库取出的纪录数的buffer的大小，此大小默认是0，需要先setFetchSize，因此，为了实现获得记录数的方法，参考了其他博客的内容 参考文章： getFetchSize()方法不是获得记录数
MyBatis源码笔记（六） -- 解析SQL语句节点封装为MappedStatement
seasonLai的博客
09-28 1312
MyBatis解析XML的SQL语句节点或注解@Select等,最终会封装成MappedStatement对象，存进configuration里，本篇分析XML解析方式 从XMLMapperBuilder类的buildStatementFromContext方法开始 private void buildStatementFromContext(List&amp;amp;amp;amp;lt;XNode&amp;amp;amp;amp;gt; list) { ...
mybatis源码解析十三之MappedStatement
a314773862的博客
08-12 7089
介绍 MappedStatement类在Mybatis框架中用于表示XML文件中一个sql语句节点，即一个、或者标签。Mybatis框架在初始化阶段会对XML配置文件进行读取，将其中的sql语句节点对象化为一个个MappedStatement对象。 若是使用注解，则类似注解中的@Select等描述。 public final class MappedStatement { //节点中的i...
MyBatis主键生成器SelectKeyGenerator（三）
井底之蛙
09-26 6831
前面两篇博客我们介绍了MyBatis主键生成器KeyGenerator（一）和MyBatis主键生成器Jdbc3KeyGenerator（二），接下来我们介绍SelectKeyGenerator， 如在Oraclee中并不提供自增组件，提供了Sequence主键，我们就需要执行它的Sequence主键，如在mysql中如下配置： SELECT LAST_INSERT_ID() AS
Mybatis源码解析之写流程
0xZzzz的博客
01-21 1775
阅读须知 Mybatis源码版本：3.4.4 列表内容 注释规则： //单行注释做普通注释 /**/多行注释做深入分析 建议配合Mybatis源码阅读 正文承接上文，我们继续来分析写操作： DefaultSqlSession：public int insert(String statement, Object parameter) { return update(statement,
mybatis-3-mybatis-3.4.1源码
08-24
解析XML配置文件后，所有的配置信息都会被加载到这个类中。 2. **Executor**：执行器负责执行SQL，它是MyBatis的执行核心。它有多种实现，如SimpleExecutor、ReusedExecutor和BatchExecutor，分别对应不同的执行...
mybatis-3-mybatis-3.5.4-src-read.zip
04-28
在本压缩包“mybatis-3-mybatis-3.5.4-src-read.zip”中，包含了作者对MyBatis 3.5.4版本源码的阅读理解，特别进行了关键部分的注解和流程解析，对于学习和深入理解MyBatis的工作原理非常有帮助。 1. **MyBatis架构...
mybatis-3-mybatis-3.3.0-SNAPSHOT.zip
02-13
在MyBatis源码中，你可以看到如何解析XML配置文件，如何加载Mapper接口，以及如何根据注解或XML定义的SQL语句进行动态SQL生成。此外，还有事务管理、缓存机制、插件扩展等方面的知识。 学习MyBatis源码有助于理解其...
Mybatis源码分析.pdf
08-30
总结起来，MyBatis源码分析涵盖了从配置加载到数据库操作的全过程，涉及到了配置解析、SQL执行、结果映射等多个关键环节，以及Executor、StatementHandler等核心组件。通过深入学习MyBatis的源码，开发者不仅可以...
mybatis自定义拦截器
全栈攻城狮JSON的博客
09-23 1360
*** mybatis自定义拦截器/*** 数据权限注解/*** 数据权限集合//执行的目标对象、方法、参数 Object target = invocation . getTarget();//区分执行目标对象 if(target instanceof Executor && method . getName() . equals("query") && args . length == 4) {
Mybatis源码阅读（三）：结果集映射3.3 —— 主键生成策略
qq_36403693的博客
03-03 1735
前言 在前面两篇博客中，我们介绍了对于select语句的简单映射和嵌套映射。mybatis中使用ResultHandler等一系列的类，将查询结果封装到实体类中，可以说是mybatis中最复杂的过程，而剩下的insert、update、delete语句的操作则显得较为简单，没有复杂的映射逻辑。这里需要提的是在insert语句中，关于主键自增的问题。 KeyGenerator 在我们实际的开发...
mybatis的插入与批量插入的返回ID的原理
陈晨_软件五千言
03-07 3032
文章目录背景底层调用方法单个对象插入直接保存实体的对象作为参数传入（给伪代码示例）多个对象，实体对象作为其中一个对象传入列表批量插入直接保存实体的对象作为参数传入（给伪代码示例）多个对象，实体对象作为其中一个对象传入完成 背景 最近正在整理之前基于mybatis的半ORM框架。原本的框架底层类ORM操作是通过StringBuilder的append拼接的，这次打算用JsqlParser重写一遍，一...
Mybatis源码解析 KeyGenerator
z69183787的专栏
08-04 1797
KeyGenerator接口定义了2个函数： //执行insert之前 void processBefore(Executor executor, MappedStatement ms, Statement stmt, Object parameter); //执行insert之后 void processAfter(Executor executor, MappedStatement ms,
mybatis源码学习（三）：MappedStatement的解析过程
weixin_33754913的博客
06-08 844
我们之前介绍过MappedStatement表示的是XML中的一个SQL。类当中的很多字段都是SQL中对应的属性。我们先来了解一下这个类的属性： public final class MappedStatement { private String resource; private Configuration configuration; //sql的ID ...
mybatis 源码分析（七）KeyGenerator 详解
weixin_30258901的博客
09-02 241
一、KeyGenerator 概述 在平时开发的时候经常会有这样的需求，插入数据返回主键，或者插入数据之前需要获取主键，这样的需求在 mybatis 中也是支持的，其中主要的逻辑部分就在 KeyGenerator 中，下面是他的类图： 其中： NoKeyGenerator：默认空实现，不需要对主键单独处理； Jdbc3KeyGenerator：主要用于数据库的自增主键，比如 MySQ...
mybatis框架下物理分页的实现（整个工程采用的是springmvc、spring、mybatis框架，数据库是mysql数据库）
u011991249的专栏
11-21 1827
整个工程采用的是springmvc、spring、mybatis框架，数据库是mysql数据库，本工程采用的是拦截器机制实现物理分页。   工程目录结构是：     因为文章最后会有完整的工程资源文件，这里就不把详细代码贴出来了，只是把拦截器和相关的配置文件的代码跟大家详细探讨下。 （一）拦截器类PageIntercepter.java： package cn.zyy.paging.i
工厂模式的介绍及实现
最新发布
户伟伟的博客
09-25 121
工厂模式（Factory Pattern）是一种创建型设计模式，提供了一种创建对象的接口，而无需显式指定对象的具体类。在这种模式中，我们通过定义一个工厂类，专门负责生产各种类型的对象，这样我们可以避免直接在代码中实例化具体类，使代码更具扩展性、灵活性和维护性。解耦：客户端代码与具体的类解耦，避免了对象创建逻辑的重复。简化对象创建：通过工厂统一管理对象的创建逻辑，使代码更清晰易懂。扩展性强：新增类时，只需在工厂中增加创建逻辑，而不必修改现有的业务代码。
Mybatis源码解析：执行流程与核心组件
"这篇内容主要讲解了Mybatis的源码分析，包括JDBC执行流程、Mybatis的会话和执行器，以及二级缓存和预处理器的相关知识，还涉及到了Mybatis的配置体系。" 在Mybatis中，了解JDBC执行流程是理解其工作原理的基础。...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值