14-Mybatis源码和设计模式-5(Executor组件与模板模式，装饰器模式)

最新推荐文章于 2024-05-07 07:54:33 发布
最新推荐文章于 2024-05-07 07:54:33 发布
阅读量890 收藏 2
点赞数 1
分类专栏： Mybatis
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/my_momo_csdn/article/details/94290472
版权

文章目录

Executor组件与模板模式

一、Executor组件

  • Executor是Mybatis中用于执行数据库操作的核心接口，定义了数据库操作的基本方法。我们知道SqlSession是对用户暴露的核心接口，用户通过SqlSession来操作数据库，但实际上底层调用的就是Executor组件的接口。在数据库的查询操作过程中，Mybatis中定义的整体操作流程是差不多的，以查询为例：大体分为SqlSession执行sql->获取sql信息->拼装缓存key->判断是否需要清空一级缓存->查找一级缓存->根据是否命中判断是否需要查询数据库->查询结果->缓存会写->执行完毕，但是具体的执行会有所不同，比如有simple、reuse、batch三种方式，但是从这个固定的步骤来看，非常适合使用模板模式来实现，由父类实现固定的方法流程骨架，具体的不同的步骤留给子类重写。Executor组件就使用到了模板方法，具体关于模板方法可以参考：03-行为型模式(上)

  • 三种类型对比

类型描述
simple默认；使用PreparedStatement访问数据库，每次访问都创建新的PreparedStatement对象
reuse使用预编译的PreparedStatement访问数据库，会重用Statement对象
batch批量执行
  • 实际上除了上面几种之外，还有存储过程的执行，具体在后面分析

二、使用方式

  • 三种类型如下：
//Executor操作数据库的方式
public enum ExecutorType {
  SIMPLE, REUSE, BATCH
}
//打开姿势；openSession支持多种传参方式，主要包括事物提交参数和执行类型参数
SqlSession sqlSession = SqlSessionFactoryUtil.getSqlSessionFactoryInstaceByConfig(CONFIG_FILE_PATH).openSession(ExecutorType.BATCH);

public interface SqlSessionFactory {

  SqlSession openSession();

  SqlSession openSession(boolean autoCommit);
  SqlSession openSession(Connection connection);
  SqlSession openSession(TransactionIsolationLevel level);

  SqlSession openSession(ExecutorType execType);
  SqlSession openSession(ExecutorType execType, boolean autoCommit);
  SqlSession openSession(ExecutorType execType, TransactionIsolationLevel level);
  SqlSession openSession(ExecutorType execType, Connection connection);
 
}

三、目录结构

  • 包：org.apache.ibatis.executor

image

类名作用
Executor是顶层接口定义了基本的数据库操作方法
BaseExecutor抽象类，继承自Executor并实现了大部分方法，主要实现了缓存管理和事物管理的方法，其他的方法需要不同类型的子类实现
SimpleExecutor继承自BaseExecutor，是默认配置使用PreparedStatement访问数据库，每次访问都创建新的PreparedStatement对象
ReuseExecutor继承自BaseExecutor，使用预编译的PreparedStatement访问数据库，会重用Statement对象
BatchExecutor继承自BaseExecutor，提供批量执行Sql语句的能力
CachingExecutor装饰器类，内部持有具体实现类的对象，实现了Executor接口，添加了二级缓存的功能

四、源码解析

4.1 Executor接口

  • 顶层接口，定义了数据库操作的基本方法，
/**
 * @author Clinton Begin
 * 顶层接口，定义了数据库操作的基本方法，
 */
public interface Executor {

  //部分已经省略
  int update(MappedStatement ms, Object parameter) throws SQLException;

  <E> List<E> query(MappedStatement ms, Object parameter, RowBounds rowBounds, ResultHandler resultHandler, CacheKey cacheKey, BoundSql boundSql) throws SQLException;

  <E> List<E> query(MappedStatement ms, Object parameter, RowBounds rowBounds, ResultHandler resultHandler) throws SQLException;

  <E> Cursor<E> queryCursor(MappedStatement ms, Object parameter, RowBounds rowBounds) throws SQLException;

  List<BatchResult> flushStatements() throws SQLException;

  void commit(boolean required) throws SQLException;

  void rollback(boolean required) throws SQLException;
}

4.2 BaseExecutor抽象类

  • 继承自Executor并实现了大部分方法，主要实现了缓存管理和事物管理的方法。因为源码很多，我们省去部分源码，重点看看查询方法
4.2.1 BaseExecutor#query()
 @Override
  public <E> List<E> query(MappedStatement ms, Object parameter, RowBounds rowBounds, ResultHandler resultHandler) throws SQLException {
    //1.获取sql语句信息，包括占位符，参数等信息
    BoundSql boundSql = ms.getBoundSql(parameter);
    //2.拼装缓存的key值
    CacheKey key = createCacheKey(ms, parameter, rowBounds, boundSql);
    return query(ms, parameter, rowBounds, resultHandler, key, boundSql);
 }

  @SuppressWarnings("unchecked")
  @Override
  public <E> List<E> query(MappedStatement ms, Object parameter, RowBounds rowBounds, ResultHandler resultHandler, CacheKey key, BoundSql boundSql) throws SQLException {
    ErrorContext.instance().resource(ms.getResource()).activity("executing a query").object(ms.getId());
    //检查当前executor是否关闭
    if (closed) {
      throw new ExecutorException("Executor was closed.");
    }
    //3.非嵌套查询，并且FlushCache配置为true，则需要清空一级缓存
    if (queryStack == 0 && ms.isFlushCacheRequired()) {
      clearLocalCache();
    }
    List<E> list;
    try {
      //查询层次加一
      queryStack++;
      //4.查询一级缓存
      list = resultHandler == null ? (List<E>) localCache.getObject(key) : null;
      if (list != null) {
        //针对调用存储过程的结果处理
        handleLocallyCachedOutputParameters(ms, key, parameter, boundSql);
      } else {
        //5.缓存未命中，从数据库加载数据,如果加载到数据，会保存到一级缓存
        list = queryFromDatabase(ms, parameter, rowBounds, resultHandler, key, boundSql);
      }
    } finally {
      queryStack--;
    }
    if (queryStack == 0) {
      //延迟加载处理
      for (DeferredLoad deferredLoad : deferredLoads) {
        deferredLoad.load();
      }
      // issue #601
      deferredLoads.clear();
      //如果当前sql的一级缓存配置为STATEMENT，查询完既清空一集缓存
      if (configuration.getLocalCacheScope() == LocalCacheScope.STATEMENT) {
        // issue #482
        clearLocalCache();
      }
    }
    return list;
  }
4.2.1 BaseExecutor#queryFromDatabase
  • BaseExecutor#queryFromDatabase是查询数据库的方法，里面可能会有多种方式，比如simple、reuse、batch，因此这里的第二步的doQuery方法是在子类实现的，这就是典型的模板方法。 这里 如果查询到数据会将数据写到一级缓存。
    /**
     * 查询数据库
     * */
    private <E> List<E> queryFromDatabase(MappedStatement ms, Object parameter, RowBounds rowBounds, ResultHandler resultHandler, CacheKey key, BoundSql boundSql) throws SQLException {
        List<E> list;
        //1.到一级缓存占一个位置
        localCache.putObject(key, EXECUTION_PLACEHOLDER);
        try {
            //2.查询数据库，调用抽象方法doQuery，方法查询数据库并返回结果，可选的实现包括：simple、reuse、batch
            list = doQuery(ms, parameter, rowBounds, resultHandler, boundSql);
        } finally {
            //3.在缓存中删除占位符
            localCache.removeObject(key);
        }
        //4.将查询结果放入一级缓存
        localCache.putObject(key, list);
        //5.如果是调用存储过程
        if (ms.getStatementType() == StatementType.CALLABLE) {
            //6.缓存输出类型结果参数
            localOutputParameterCache.putObject(key, parameter);
        }
        return list;
    }
  • 在第二步中的doQuery在BaseExecutor是没有实现的抽象方法，由后面的三个子类实现，在BaseExecutor主要是实现了主体的流程骨架，这就是模板模式的体现。

4.3 三种子类

4.3.1 SimpleExecutor
  • SimpleExecutor继承自BaseExecutor，默认情况就是该Executor，该模式下每次访问数据库都创建新的PreparedStatement对象。我们看看主要的doQuery方法实现。
public class SimpleExecutor extends BaseExecutor {

    //省略了部分方法和属性
    
  /**
   * 查询的实现
   * */
  @Override
  public <E> List<E> doQuery(MappedStatement ms, Object parameter, RowBounds rowBounds, ResultHandler resultHandler, BoundSql boundSql) throws SQLException {
    Statement stmt = null;
    try {
      Configuration configuration = ms.getConfiguration();
      //1.创建StatementHandler
      StatementHandler handler = configuration.newStatementHandler(wrapper, ms, parameter, rowBounds, resultHandler, boundSql);
      //2.用StatementHandler对象创建stmt,并使用StatementHandler对占位符进行处理
      stmt = prepareStatement(handler, ms.getStatementLog());
      //3.通过statementHandler对象调用ResultSetHandler将结果集转化为指定对象返回
      return handler.<E>query(stmt, resultHandler);
    } finally {
      closeStatement(stmt);
    }
  }
 
  /**
   * 创建Statement
   * */
  private Statement prepareStatement(StatementHandler handler, Log statementLog) throws SQLException {
    Statement stmt;
    //1.获取connection对象的动态代理，添加日志能力；(这里参考日志模块的代理模式)
    Connection connection = getConnection(statementLog);
    //2.使用StatementHandler，利用connection创建（prepare）Statement
    stmt = handler.prepare(connection, transaction.getTimeout());
    //3.使用StatementHandler处理占位符
    handler.parameterize(stmt);
    return stmt;
  }
}

image

4.3.2 ReuseExecutor
  • ReuseExecutor使用预编译的PreparedStatement访问数据库，并且会重用Statement对象，这是和SimpleExecutor最大的区别
public class ReuseExecutor extends BaseExecutor {
/**
   * 查询的实现,和SimpleExecutor的doQuery是一样的
   * */
  @Override
  public <E> List<E> doQuery(MappedStatement ms, Object parameter, RowBounds rowBounds, ResultHandler resultHandler, BoundSql boundSql) throws SQLException {
    Configuration configuration = ms.getConfiguration();
      //1.创建StatementHandler
    StatementHandler handler = configuration.newStatementHandler(wrapper, ms, parameter, rowBounds, resultHandler, boundSql);
      //2.用StatementHandler对象创建stmt,并使用StatementHandler对占位符进行处理
    Statement stmt = prepareStatement(handler, ms.getStatementLog());
      //3.通过statementHandler对象调用ResultSetHandler将结果集转化为指定对象返回
    return handler.<E>query(stmt, resultHandler);
  }


  private Statement prepareStatement(StatementHandler handler, Log statementLog) throws SQLException {
    Statement stmt;
    BoundSql boundSql = handler.getBoundSql();
    String sql = boundSql.getSql();
    //1.判断statementMap是否已经保存过sql，保存过直接取出，sql是key，value就是之前缓存好的Statement对象
    if (hasStatementFor(sql)) {
      stmt = getStatement(sql);
      applyTransactionTimeout(stmt);
    } else {
        //2.没有保存，那么就生成新的，并且保存到statementMap，这一步的逻辑和SimpleExecutor是一样的，
        //相比于SimpleExecutor，ReuseExecutor最大特点就是会重用sql
      Connection connection = getConnection(statementLog);
      stmt = handler.prepare(connection, transaction.getTimeout());
      putStatement(sql, stmt);
    }
      //3.使用StatementHandler处理占位符
    handler.parameterize(stmt);
    return stmt;
  }
}
  • prepareStatement方法是ReuseExecutor和SimpleExecutor最大的区别。该方法里面我们可以看到他会使用一个Map缓存下来sql的预编译得到的Statement对象，在Map中sql是key，Statement对象是value。如果缓存中没有，则编译之后还会放进去。而doQuery方法和SimpleExecutor是一样的。
4.3.3 BatchExecutor
  • BatchExecutor提供批量执行Sql语句的能力。我们看到在七内部维护了2个List集合分别存储批量执行的Statement对象和BatchResult结果对象。在每次的查询方法都会将这两个集合清除因此批量语句里面不要有查询(这里到时候通过代码调试一下)。
  • 另外批量更新的语句是在哪个时机调用的，这里调试一下，因为看源码doFlushStatements的注释2的地方会调用执行语句，但是doUpdate里面并没有调用doFlushStatements，，到时候调试看看
public class BatchExecutor extends BaseExecutor {

  public static final int BATCH_UPDATE_RETURN_VALUE = Integer.MIN_VALUE + 1002;

  //保存批量执行的Statement
  private final List<Statement> statementList = new ArrayList<Statement>();
  //保存批量执行的BatchResult
  private final List<BatchResult> batchResultList = new ArrayList<BatchResult>();
 

  @Override
  public int doUpdate(MappedStatement ms, Object parameterObject) throws SQLException {
    final Configuration configuration = ms.getConfiguration();
    final StatementHandler handler = configuration.newStatementHandler(this, ms, parameterObject, RowBounds.DEFAULT, null, null);
    final BoundSql boundSql = handler.getBoundSql();
    final String sql = boundSql.getSql();
    final Statement stmt;
      //1.判断当前使用sql和statement是否是上一次的statement和sql
    if (sql.equals(currentSql) && ms.equals(currentStatement)) {
      //2.如果是则取出
      int last = statementList.size() - 1;
      stmt = statementList.get(last);
      applyTransactionTimeout(stmt);
        //3.StatementHandler占位符赋值
     handler.parameterize(stmt);//fix Issues 322
      BatchResult batchResult = batchResultList.get(last);
      //batchResult里面添加批量执行的参数列表
      batchResult.addParameterObject(parameterObject);
    } else {
        //3.如果不是则创建一个Statement
      Connection connection = getConnection(ms.getStatementLog());
      stmt = handler.prepare(connection, transaction.getTimeout());
        //  StatementHandler占位符赋值
      handler.parameterize(stmt);    //fix Issues 322
        //记录下当前的sql和Statement,下一个语句会对比这两个对象
      currentSql = sql;
      currentStatement = ms;
      //将Statement添加到list
      statementList.add(stmt);
      batchResultList.add(new BatchResult(ms, sql, parameterObject));
    }
  // handler.parameterize(stmt);
      //不管是那种逻辑，这个语句都要执行，因此都使用batch方法处理
    handler.batch(stmt);
    //返回值是-2147482646，据说可以防止无限循环
    return BATCH_UPDATE_RETURN_VALUE;
  }

  /**
   * batchExecutor查询实现
   * */
  @Override
  public <E> List<E> doQuery(MappedStatement ms, Object parameterObject, RowBounds rowBounds, ResultHandler resultHandler, BoundSql boundSql)
      throws SQLException {
    Statement stmt = null;
    try {
      flushStatements();//会调用doFlushStatements方法刷新两个集合
      Configuration configuration = ms.getConfiguration();
      StatementHandler handler = configuration.newStatementHandler(wrapper, ms, parameterObject, rowBounds, resultHandler, boundSql);
      Connection connection = getConnection(ms.getStatementLog());
      stmt = handler.prepare(connection, transaction.getTimeout());
      handler.parameterize(stmt);
      return handler.<E>query(stmt, resultHandler);
    } finally {
      closeStatement(stmt);
    }
  }

  /**
   * 刷新Statement，记录执行次数
   */
  @Override
  public List<BatchResult> doFlushStatements(boolean isRollback) throws SQLException {
    try {
      List<BatchResult> results = new ArrayList<BatchResult>();
      if (isRollback) {
        return Collections.emptyList();
      }
      //1.如果进行了批量处理，size不为0
      for (int i = 0, n = statementList.size(); i < n; i++) {
        Statement stmt = statementList.get(i);
        applyTransactionTimeout(stmt);
        BatchResult batchResult = batchResultList.get(i);
        try {
          //2.执行批处理，并跟新处理后的结果数组
          batchResult.setUpdateCounts(stmt.executeBatch());
          //3.获取MappedStatement，它是保存sql语句的数据结构
          MappedStatement ms = batchResult.getMappedStatement();
          //4.获取参数
          List<Object> parameterObjects = batchResult.getParameterObjects();
          //5.获取KeyGenerator，处理主键会写
          KeyGenerator keyGenerator = ms.getKeyGenerator();
          if (Jdbc3KeyGenerator.class.equals(keyGenerator.getClass())) {
              //6.1 Jdbc3KeyGenerator的情况
            Jdbc3KeyGenerator jdbc3KeyGenerator = (Jdbc3KeyGenerator) keyGenerator;
            jdbc3KeyGenerator.processBatch(ms, stmt, parameterObjects);
          } else if (!NoKeyGenerator.class.equals(keyGenerator.getClass())) { //issue #141
            //6.2 SelectKeyGenerator的情况
              for (Object parameter : parameterObjects) {
              keyGenerator.processAfter(this, ms, stmt, parameter);
            }
          }
        } catch (BatchUpdateException e) {
          StringBuilder message = new StringBuilder();
          message.append(batchResult.getMappedStatement().getId())
              .append(" (batch index #")
              .append(i + 1)
              .append(")")
              .append(" failed.");
          if (i > 0) {
            message.append(" ")
                .append(i)
                .append(" prior sub executor(s) completed successfully, but will be rolled back.");
          }
          throw new BatchExecutorException(message.toString(), e, results, batchResult);
        }
          //记录操作
        results.add(batchResult);
      }
      return results;
    } finally {
      for (Statement stmt : statementList) {
        closeStatement(stmt);
      }
      currentSql = null;
      //刷新完毕要清除集合
      statementList.clear();
      batchResultList.clear();
    }
  }
}

4.4 装饰器CachingExecutor

  • CachingExecutor使用了装饰器模式来给具体的Executor添加缓存功能，他实现了Executor接口，同时内部持有某一个Executor的具体实现类(4.3中的某一个)，在主流程方法的执行过程中添加缓存相关的读取流程。CachingExecutor再实现的缓存是二级缓存，因此在整个Mybatis的查询过程中，是嫌查询二级缓存的再查询一级缓存的，因为二级缓存是通过这个装饰器类实现的，那么会在真正的Executor查询之前访问二级缓存，如果没有命中，那么就会会真正的走Executor的查询流程(比如SimpleExecutor的),在SimpleExecutor里面才会再去查询一级缓存(流程是在BaseExecutor中实现的)。下面是CachingExecutor代码。
/**
 * 二级缓存实现
 * CachingExecutor使用装饰器模式实现二级缓存，内部持有真正的Executor对象(SimpleExecutor，ReuseExecutor或者BatchExecutor)
 * 它继承Executor类，并重写了全部的Executor方法，内部调用对应Executor的方法，前后增加了一些缓存读取相关的逻辑
 */
public class CachingExecutor implements Executor {
 
 //继承Executor并重写了全部Executor的方法

  @Override
  public <E> List<E> query(MappedStatement ms, Object parameterObject, RowBounds rowBounds, ResultHandler resultHandler) throws SQLException {
      //获取sql语句信息，包括占位符，参数等信息
    BoundSql boundSql = ms.getBoundSql(parameterObject);
      //拼装缓存的key值
    CacheKey key = createCacheKey(ms, parameterObject, rowBounds, boundSql);
    return query(ms, parameterObject, rowBounds, resultHandler, key, boundSql);
  }
 
  /**
   * 查询的真正控制流程
   * */
  @Override
  public <E> List<E> query(MappedStatement ms, Object parameterObject, RowBounds rowBounds, ResultHandler resultHandler, CacheKey key, BoundSql boundSql)
      throws SQLException {
    Cache cache = ms.getCache();
    //1.先尝试读取缓存，缓存为空则直接走最后的BaseExecutor.query
    if (cache != null) {
        //2.如果需要就清除缓存
      flushCacheIfRequired(ms);
      //3.如果配置允许使用缓存，才访问缓存
      if (ms.isUseCache() && resultHandler == null) {
        ensureNoOutParams(ms, parameterObject, boundSql);
        @SuppressWarnings("unchecked")
        //4.从二级缓存中获取数据
        List<E> list = (List<E>) tcm.getObject(cache, key);
        if (list == null) {
          //5.二级缓存为空，才会调用BaseExecutor.query
          list = delegate.<E> query(ms, parameterObject, rowBounds, resultHandler, key, boundSql);
          //6.查询到数据则放入缓存
          tcm.putObject(cache, key, list); // issue #578 and #116
        }
        return list;
      }
    }
    //如果缓存为null，就走真正的Executor实现类的查询方法，(BaseExecutor.query)
    return delegate.<E> query(ms, parameterObject, rowBounds, resultHandler, key, boundSql);
  }

 //其他的继承自Executor的方法，基本上都是调用delegate的方法，有些稍微家里一点简单的控制，就不展示了
}

4.5 辅助类

  • 在前面的三种子类的代码中我们看到了很多辅助类，在不了解这些辅助类的作用时，有些代码会有点困难，其实先看4.4再回过头看4.3会好很多。最主要的三个辅助类是StatementHandler，ParameterHandler和ResultHandler。
4.5.1 StatementHandler
  • StatementHandler是一个接口，它完成Mybatis最核心的工作，代表使用数据库的Statement或者PrepareStatement执行操作，也是Executor实现的基础。包括创建Statement对象，为sql绑定参数，执行sql，结果集映射等。它是一个接口，使用不同的实现类来处理不同的情况，并且也采用了模板模式，使用BaseStatementHandler来完成基本骨架，子类继承然后实现具体方法细节。更多关于StatementHandler的部分，请参考: 17-Mybatis源码分析(StatementHandler数据库访问)
4.5.2 ParameterHandler
  • ParameterHandler对预编译的sql进行参数赋值，更多关于ParameterHandler的部分，请参考: 17-Mybatis源码分析(ParameterHandler参数读取)
4.5.3 ResultHandler
  • ResultHandler将数据库返回记录封装为用户指定的实体类，更多关于ResultHandler的部分，请参考: 18-Mybatis源码分析(ResultHandler结果集映射)
惑边
关注
专栏目录
java框架篇--MyBatis 使用了哪些设计模式？在源码中是如何体现的？
爱分享的淘金达人
06-22 275
MyBatis 的前身是 IBatis，IBatis 是由 Internet 和 Abatis 组合而成，其目的是想当做互联网的篱笆墙，围绕着数据库提供持久化服务的一个框架，2010 年正式改名为 MyBatis。它是一款优秀的持久层框架，支持自定义 SQL、存储过程及高级映射。MyBatis 免除了几乎所有的 JDBC 代码以及设置参数和获取结果集的工作，还可以通过简单的 XML 或注解来配置和映射原始类型、接口和 Java POJO（Plain Ordinary Java Object，普通 Java
Mybatis源码解析（六）-数据执行阶段Executor（模板模式）
xqqTechnology的博客
06-11 227
@[TOC] Executor—》 模板模式 #当前阶段可以说是MyBatis 最神秘的阶段，要理解它，就需要对 Mybatis 的接口层和 binding模块数据源模块进行深入的学习。首先mybatis内部虽然有各种配置文件解析，数据封装，sql执行等复杂的流程，但是基本上都可以通过SqlSession接口进行操作，这种设计就是运用了门面模式；另外mybatis支持通过配置文件灵活配置连接数据库的时候是否使用连接池，这种对操作的封装也是运用了策略模式来实现。下面来详细介绍。 part1：模板模式 模板
mybatis中经典的9种设计模式
wh柒八九的博客
03-28 363
mybatis中用到了9种设计模式，学习mybatis的源码以及设计模式，可以提高开发人员软件设计以及开发的水平，写出更加优雅的代码。 文章目录建造者模式 建造者模式 Builder模式，例如SqlSessionFactoryBuilder、XMLConfigBuilder、 XMLMapperBuilder、XMLStatementBuilder、CacheBuilder； Builder模式的定义是“将一个复杂对象的构建与它的表示分离，使得同样的构建过程可以创建不同的表示。”，它属于创建类模式。一.
Mybatis源码：Executor 模板模式
xyzroundo的专栏
03-01 316
by yan 20220301 Mybatis insert 时序图
mybatis设计模式-模板方法模式-BaseExecutor类
Jam_T的博客
05-31 538
如果所示，以duUpdate方法为例 在BaseExecutor中是这样调用的 当调用到这个方法时，会根据是哪个子类的对象，调用子类的duUpdate方法。 当然，像doFlushStatements，doQuery也是这样调用的 下面我们仔细说一下模板方法 https://www.runoob.com/design-pattern/template-pattern.html https://...
MyBatis框架中的设计模式
恐龙弟旺仔的博客
08-06 2406
前言：     前几篇文章从源码角度分析了Mybatis框架，当然，作为一个优秀的框架，设计模式的使用也是必不可少的。     本文，作者便简单介绍下Mybatis设计模式的使用场景     关于设计模式的相关知识，读者可自行查看网上相关资料。推荐下菜鸟教程 http://www.runoob.com/design-pattern/design-pattern-tutorial.html  ...
mybatis-3.5.9 源码（mybatis-3-mybatis-3.5.9.tar.gz）
02-07
MyBatis 是一款著名的持久层框架，它支持定制化 SQL、存储过程以及高级映射。...这份源码不仅包含了 MyBatis 的核心功能，还反映了设计模式和最佳实践，对于提升个人的 Java 和数据库编程技能大有裨益。
mybatis-3-mybatis-3.5.8.zip源码
04-27
在mybatis-3-mybatis-3.5.8.zip源码中，我们可以深入理解MyBatis的工作原理和设计模式。这个版本的MyBatis包含以下几个主要模块： 1. **SqlSessionFactoryBuilder**: 用于构建SqlSessionFactory，它是MyBatis的核心...
mybatis-3-mybatis-3.5.7.zip源码
04-27
MyBatis是一个流行的Java...通过对MyBatis 3.5.7源码的深入学习，我们可以了解到其实现细节，包括反射、AOP、设计模式等多方面的知识，这对于提升Java开发能力、优化数据库操作和设计高效的数据访问层有着极大的帮助。
mybatis-3-mybatis-3.4.5 源码
02-23
MyBatis是一个优秀的Java持久层框架，它支持定制化SQL、存储过程以及高级映射...在阅读源码的过程中，我们还能发现很多设计模式的运用，比如工厂模式、代理模式、装饰者模式等，这对于我们提升编程技艺也是非常有益的。
Mybatis源码和设计模式(Executor组件与模板模式，装饰器模式)
最新发布
smart_an的专栏
05-07 905
作者简介：大家好，我是哥，前中兴通讯、美团架构师，现某互联网公司联系qq：184480602，加我进群，大家一起学习，一起进步，一起对抗互联网寒冬学习必须往深处挖，挖的越深，基础越扎实！
执行器设计模式
ElendaLee的专栏
05-10 554
执行器设计模式
原 MyBatis源码阅读——装饰器模式在MyBatis中的应用
u014368614的博客
02-15 245
Executor 首先我们看下Executor，打开MyBatis的源码org.apache.ibatis.session.Configuration   public Executor newExecutor(Transaction transaction, ExecutorType executorType) {     executorType = executorType == nul...
mybatis中 Executor的设计与实现
多看多听多总结
10-09 383
Executor的接口定义为 public interface Executor { ResultHandler NO_RESULT_HANDLER = null; int update(MappedStatement ms, Object parameter) throws SQLException; <E> List<E> query(MappedStatement ms, Object parameter, RowBounds rowBounds, Res
Mybatis源码设计模式(装饰器模式)
qq_40569427的博客
09-20 316
装饰器模式背景定义源码说明 背景 写了一篇关于mybatis缓存的文章，发现里面的executor和cache都用到了装饰器模式，所以准备专门写一篇装饰器模式的文章，以cache为例 定义 动态地给一个对象添加一些额外的职责。 就增加功能来说，装饰模式相比生成子类更为灵活 使用场景: 需要扩展一个类的功能，或给一个类增加附加功能。 需要动态地给一个对象增加功能，这些功能可以再动态地撤销。 需要为一批的兄弟类进行改装或加装功能，当然是首选装饰模式。 源码说明 现在用源码类说明一下是怎么实现的,我们来看一下
Mybatis 之 设计模式
凉茶铺的博客
06-12 346
接下来对Builder构建者模式、工厂模式、代理模式进行解读，先介绍模式自身的知识，然后解读在Mybatis中怎样应用了该模式。
装饰者模式源码解析(spring-session mybatis jdk servlet)
Leon_Jinhai_Sun的博客
06-04 405
那在JDK中体现最明显的,就是JAVA IO方面的一些类,那在JAVA IO中,我们为了增加缓存,我们使用BufferedReader, 那现在我们来看一下,那因为增加缓存的功能,类有很多,子类也就需要很多,那现在我们看一下,BufferedReader public class BufferedReader extends Reader 看一下,他首先继承了Reader,进来 publ...
Mybatis深入源码分析之基于装饰模式纯手写一级，二级，三级缓存
chuanyingcao2675的博客
06-19 122
写在前面：设计模式源于生活，而又高于生活！ 什么是装饰者模式 在不改变原有对象的基础上附加功能，相比生成子类更灵活。 装饰者模式应用场景 Mybatis缓存，过滤器，网关控制，P2P分控审批 装饰者模式定义 （1）抽象组件:定义一个抽象接口，来规范准备附...
Mybatis源码解读（六）--Executor组件（模板模式）
zwt122755527的博客
07-16 729
Executor是Mybatis核心接口之一，定义了数据库操作最基础的方法，SqlSession都是基于它来实现的。Executor包位于org.apache.ibatis.executor，这里采用模板模式实现。 模板模式 模板模式（Template Pattern）：一个抽象类公开定义了执行它的方法的方式/模板。它的子类可以按需要重写方法实现，但调用将以抽象类中定义的方式进行。定义了一个操作中算法的骨架，而将一些步骤延迟到子类中。模板方法使得子类可以不改变算法的结构即可重定义该算法的某些实现。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值