Mybatis 查询 流程分析

最新推荐文章于 2023-07-08 15:13:25 发布
最新推荐文章于 2023-07-08 15:13:25 发布
阅读量342 收藏 1
点赞数
分类专栏： mybatis学习 文章标签： Mybatis 数据库
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/anLA_/article/details/102965064
版权

前面知道了SqlSession 初始化过程，那么下一步就看看Mybatis具体的增删改查逻辑。

本文以以下几个问题开展：

  1. Mybatis Mapper 代理对象获取流程
  2. 动态sql查询时，if，foreach等节点是怎么处理的？
  3. Mybatis动态Sql对如何读取参数的？
  4. @Param注解什么作用，什么情况没有@Param注解会读取不到参数？
  5. 对于结果集，Mybatis是如何处理的？
  6. Mybatis 一级二级缓存如何使用？

Mybatis代理对象

当使用 Mybatis是，我们只需要定义接口，而后定义对应 xml文件，就可以完成增删改查，接口对象怎么创建呢？

  1. 通过SqlSession 的 getMapper ：
  public <T> T getMapper(Class<T> type) {
    return configuration.getMapper(type, this);
  }
  1. Configuration中 的getMapper ：
  public <T> T getMapper(Class<T> type, SqlSession sqlSession) {
    return mapperRegistry.getMapper(type, sqlSession);
  }

MapperRegistry 中保存了来自 xml配置下所有Mappers，并放到一个 Map<Class<?>, MapperProxyFactory<?>> 保存所有接口文件对应的 Mapper 构造器。

  1. 最后在 MapperRegistry 的 通过 在初始化中构造好的 MapperProxyFactory 的 newInstance，生成一个 由MapperProxy 包装的动态对象。
  public T newInstance(SqlSession sqlSession) {
    final MapperProxy<T> mapperProxy = new MapperProxy<>(sqlSession, mapperInterface, methodCache);
    return newInstance(mapperProxy);
  }

而后通过JDK 反射获取对应接口：

  protected T newInstance(MapperProxy<T> mapperProxy) {
    return (T) Proxy.newProxyInstance(mapperInterface.getClassLoader(), new Class[] { mapperInterface }, mapperProxy);
  }

以上返回了一个动态代理类，该类实现了 mapperInterface 接口，并且以 MapperProxy 作为默认包装代理。
所以当使用 执行代理类方法，首先会进入 MapperProxy 的invoke方法。

Select 查询分析

Mybatis 整体流程是比较好理解的，好理解的前提起始是我们都忽略了 其强大的XML解析配置，以及对动态SQL的强大支持。下面看看查询：

  1. 执行对应查询方法，例如 mapper.listAllActivedUsers(actived, list);
  2. 进入MapperProxy 的 invoke方法：期间会创建一个 MapperMethod 类，用于构建 代表增删改查的 SqlComand;以及方法签名包装类 MethodSignature，里面放着其返回值，是否返回list，是否返回的Cursor 等。
  3. MapperMethod 中，主要是判断 SqlComand 类型，增删改还是查，最后返回查询初的结果。
  4. 当Mybatis 判断为查询多个时候，则会进入 MapperMethod 的 excuteForMany 方法，这里面重要的代码是 Object param = method.convertArgsToSqlCommandParam(args);，param是解析 参数后的 Map。
    它会将传入参数以<key,value> 存储，以 @Param 的值作为key，并且还会固定以参数顺序存储一份 param1, param2, param3等固定名字参数，所以param中容量是实际传入的一倍
  5. 判断是否有传入 RowBounds分页参数，有则加载进入。
  private <E> Object executeForMany(SqlSession sqlSession, Object[] args) {
    List<E> result;
    Object param = method.convertArgsToSqlCommandParam(args);
    if (method.hasRowBounds()) {
      RowBounds rowBounds = method.extractRowBounds(args);
      result = sqlSession.selectList(command.getName(), param, rowBounds);
    } else {
      result = sqlSession.selectList(command.getName(), param);
    }
    ...
  1. 在 DefaultSqlSession 对其进行 查询，其中会如果参数是collection或者数组，则会进行封装一层。
  2. 动态sql 拼装逻辑看下一节
  3. 查询时，首先会执行 CachingExecutor 的 query，这一层主要对 一级缓存进行相应逻辑判断，一级缓存默认开启：
  @Override
  public <E> List<E> query(MappedStatement ms, Object parameterObject, RowBounds rowBounds, ResultHandler resultHandler, CacheKey key, BoundSql boundSql)
      throws SQLException {
      // 判断 MappedStatement 是否有缓存
    Cache cache = ms.getCache();
    if (cache != null) {
     // 有cache 判断是否要删除缓存
      flushCacheIfRequired(ms);
      if (ms.isUseCache() && resultHandler == null) {
        ensureNoOutParams(ms, boundSql);
        @SuppressWarnings("unchecked")
        // 从 TransactionalCacheManager 加载缓存
        List<E> list = (List<E>) tcm.getObject(cache, key);
        if (list == null) {
        // 查询后加入缓存
          list = delegate.query(ms, parameterObject, rowBounds, resultHandler, key, boundSql);
          tcm.putObject(cache, key, list); // issue #578 and #116
        }
        return list;
      }
    }
    return delegate.query(ms, parameterObject, rowBounds, resultHandler, key, boundSql);
  }

  1. 而后拿着句柄就往下执行 BaseExecutor 的query 方法， 在 里面有个 对 ErrorContext 进行的设定，关于 ErrorContext 可以看下下节。

  2. 如果第一次 查询，则会清除 localCache 和 localOutputParameterCache 缓存，而下面对该次查询进行了重入性判断，当再次查询时则会直接从 localCache 获取。
    list = resultHandler == null ? (List<E>) localCache.getObject(key) : null;

  3. 下一步即从数据库中查询，默认使用 SimpleExecutor进行 操作，应此Statement 也是一次性使用

  @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();
      // 获取一个 StatementHandler， 也包括其中对过滤器链的操作
      StatementHandler handler = configuration.newStatementHandler(wrapper, ms, parameter, rowBounds, resultHandler, boundSql);
      // 执行 prepare，即预检查
      stmt = prepareStatement(handler, ms.getStatementLog());
      return handler.query(stmt, resultHandler);
    } finally {
      closeStatement(stmt);
    }
  }

prepareStatement：

  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;
  }
  1. 最后就是在 PreparedStatementHandler执行 sql，执行完后 使用 DefaultResultSetHandler.handleResultSets 处理结果。
  2. 处理查询结果主要将 查出结果 ResultSet 封装成结果返回，中途还会 处理 自定义 ResultSet 以及Lazy Loading 相关。下面基于 DefaultResultSetHandler的handleResultSets：
  @Override
  public List<Object> handleResultSets(Statement stmt) throws SQLException {
  // 设置当前动作
    ErrorContext.instance().activity("handling results").object(mappedStatement.getId());
    final List<Object> multipleResults = new ArrayList<>();
	// 设置检索
    int resultSetCount = 0;
    // 从 Statment 中获取 ResultSet 并封装
    ResultSetWrapper rsw = getFirstResultSet(stmt);
  // 获取ResultMap
    List<ResultMap> resultMaps = mappedStatement.getResultMaps();
    // 计算resultMaps 数量
    int resultMapCount = resultMaps.size();
    // 简单校验result map 数量
    validateResultMapsCount(rsw, resultMapCount);
    while (rsw != null && resultMapCount > resultSetCount) {
    // 获取resultMap
      ResultMap resultMap = resultMaps.get(resultSetCount);
      // 处理结果成 resultMap形式，并放入multipleResult
      handleResultSet(rsw, resultMap, multipleResults, null);
      // 下一个resultSetWrapper
      rsw = getNextResultSet(stmt);
      // 将当前nestedResultObjects 内容
      cleanUpAfterHandlingResultSet();
      // 如果有则下一个
      resultSetCount++;
    }

    String[] resultSets = mappedStatement.getResultSets();
    if (resultSets != null) {
    // 嵌套查询
      while (rsw != null && resultSetCount < resultSets.length) {
        ResultMapping parentMapping = nextResultMaps.get(resultSets[resultSetCount]);
        if (parentMapping != null) {
          String nestedResultMapId = parentMapping.getNestedResultMapId();
          ResultMap resultMap = configuration.getResultMap(nestedResultMapId);
          handleResultSet(rsw, resultMap, null, parentMapping);
        }
        rsw = getNextResultSet(stmt);
        cleanUpAfterHandlingResultSet();
        resultSetCount++;
      }
    }
	// 封装成list返回
    return collapseSingleResultList(multipleResults);
  }

动态SQL解析

下一个关键点就在 Mybatis的ongl表达式解析了，或许会有这样一个问题，为什么传入的参数mybatis可以理解，并且可以以动态sql形式解析，支持 if 和 foreach 等逻辑？
在 MappedStatement 的 getBoundSql 可以获取一个BoundSql，BoundSql 对象是一个从 SqlSource 中分析之后获取的 动态对象。最终 能从 xml 对象中将 动态sql解析出含有 ？ 和 参数的字段。

  1. 从 sqlSource中获取对象：
  public BoundSql getBoundSql(Object parameterObject) {
    BoundSql boundSql = sqlSource.getBoundSql(parameterObject);
  1. 而后，在DynamicSqlSource中的 getBoundSql 进行进一步解析，在 DynamicSqlSource 中有变量 SqlNode， 动态sql主要组装逻辑就在 SqlNode 子类中。
    在这里插入图片描述
    上面 SqlNode大致作用如下：
  • StaticTextSqlNode： 里面有个String 类型 text，主要是匹配xml中静态sql
  • MixedSqlNode ： 里面有 List<SqlNode> ，主要是装载多种混合类型SqlNode，即可以为多种 SqlNode 的组合
  • TextSqlNode：用于存储解析 包含 ${} 占位符的动态SQL节点。将动态SQL，带 ${} 解析完成SQL语句的解析其，即将${}占位符替换成实际的变量值。
  • ForEachSqlNode：用于存储解析 <foreach> 节点值。
  • IfSqlNode ： 用于解析 <if> 节点值，由于<if> 下面可能又是一个节点，所以里面还有一个 SqlNode contents。
  • VarDeclSqlNode ：处理动态xml标签<bind>的SqlNode类。
  • TrimSqlNode： 用于处理 <trim> 节点 的 SqlNode。
  • ChooseSqlNode： 用于处理 <choose> 标签的工具类。
    DynamicSqlSource 的 getBoundSql：
  @Override
  public BoundSql getBoundSql(Object parameterObject) {
    DynamicContext context = new DynamicContext(configuration, parameterObject);
    // 递归的处理动态sql节点
    rootSqlNode.apply(context);
    SqlSourceBuilder sqlSourceParser = new SqlSourceBuilder(configuration);
    Class<?> parameterType = parameterObject == null ? Object.class : parameterObject.getClass();
    SqlSource sqlSource = sqlSourceParser.parse(context.getSql(), parameterType, context.getBindings());
    BoundSql boundSql = sqlSource.getBoundSql(parameterObject);
    context.getBindings().forEach(boundSql::setAdditionalParameter);
    return boundSql;
  }

上面代码中，使用 rootSqlNode.apply(context); 解析动态sql节点，而后使用 SqlSourceBuilder，将 # 开头的占位符，全部使用 ? 替代，而后将解析出来参数设置到上下文 DynamicContext 中。
另外，对于处理 <foreach> 的逻辑，是将所有参数都以 ? 填充，而增加相应个数参数从而可以适配循环参数。

ErrorContext 作用

当使用Mybatis时候，是否会发现这样的感觉，如果哪个环节出错，能够迅速的找出问题，或者sql少写了一个点，或者 哪个 <if> 标签判断出错导致参数错误，或者是参数或者结果解析出问题，都能马上定位到问题。
这不是你厉害，而是Mybatis告诉你哪里出错了>-<

Mybatis就是使用ErrorContext 来帮你记录你sql运行的过程。
例如 ： ErrorContext.instance().resource(ms.getResource()).activity("executing a query").object(ms.getId());

  private static final String LINE_SEPARATOR = System.getProperty("line.separator","\n");
  private static final ThreadLocal<ErrorContext> LOCAL = new ThreadLocal<>();

  private ErrorContext stored;
  private String resource;
  private String activity;
  private String object;
  private String message;
  private String sql;
  private Throwable cause;

看到 static 的 ThreadLocal<ErrorContext> LOCAL = new ThreadLocal<>(); 是一个很典型的 ThreadLocal 用法，每一次与数据库交互的查询，都能够被当前上下文保存下来。
ErrorContext 的构造方法是私有的，使用 instance 创建而成的 单例模式。

  1. resource：说明是加载哪一个资源，主要为 xml的Mapper文件
  2. activity：说明什么动作，例如查询就是 executing a query
  3. object：说明是执行mapper文件中，哪个语句，例如 anla.learn.mybatis.interceptor.dao.UserMapper.listAllActivedUsers
  4. message： 用于保存出错信息，调用点为 ExceptionFactory，而传入的message主要为 特定错误类型：
    在这里插入图片描述
  5. sql：存入 boundSql中的sql，也就是通过动态sql解析过后的sql。在 BaseStatementHandler 中的 prepare 调用，所以所有与数据库交互语句都会在这里初始化 sql。
  6. cause : 主要存储错误栈，配合 上面 message 使用。

在每次执行完并且没有错，都会将当前 ErrorContext 清除。

一级缓存和二级缓存

其实一级缓存二级缓存命名比较别扭，因为事实上，如果开启了二级缓存，则最终缓存调用顺序为：
二级缓存->一级缓存->数据库。因为二级默认不开启，所以一般是一级缓存，如果一级缓存中没有，则到数据库。
一二级缓存这样区分，主要是Mybatis上有相关注释说明了 TransactionalCacheManager 为二级缓存。

  • 一级缓存：MyBatis提供了一级缓存的方案优化这部分场景，如果是相同的SQL语句，会优先命中一级缓存，避免直接对数据库进行查询，提高性能。
  • 二级缓存：
    二级缓存存储位置是 CachingExecutor 的 TransactionalCacheManager 中，默认不开启。

下面简单分析下一二级缓存及其原理：

一级缓存

一级缓存在BaseExecutor 的 PerpetualCache 中，默认开启。作用域默认是 SESSION，可以选择为STATEMENT。如果为SESSION，则在整个SqlSession中都会共享该缓存，而如果为Statement，则本次查询结束，则会清除该缓存。

  @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());
    if (closed) {
      throw new ExecutorException("Executor was closed.");
    }
    // 看是否需要清空缓存
    if (queryStack == 0 && ms.isFlushCacheRequired()) {
      clearLocalCache();
    }
    List<E> list;
    try {
      queryStack++;
      // 尝试从缓存中读取
      list = resultHandler == null ? (List<E>) localCache.getObject(key) : null;
      if (list != null) {
        handleLocallyCachedOutputParameters(ms, key, parameter, boundSql);
      } else {
      // 直接查询数据库
        list = queryFromDatabase(ms, parameter, rowBounds, resultHandler, key, boundSql);
      }
    } finally {
      queryStack--;
    }
    if (queryStack == 0) {
      for (DeferredLoad deferredLoad : deferredLoads) {
        deferredLoad.load();
      }
      // issue #601
      deferredLoads.clear();
      // 如果是STATEMENT 域缓存，则用完直接清空
      if (configuration.getLocalCacheScope() == LocalCacheScope.STATEMENT) {
        // issue #482
        clearLocalCache();
      }
    }
    return list;
  }

一级缓存实现原理较为简单， PerpetualCache里面主要 定义一个 Map<Object, Object> cache 类型全局变量，实现了缓存操作。
总结：

  1. 一级缓存默认开启，默认为 SESSION级别
  2. Mybatis 一级缓存声明周期和 SqlSession一致，数据只在 SqlSession内部（配置为SESSION时）
  3. Mybatis一级缓存设计为一个没有容量的HashMap。
  4. 以及缓存范围为SqlSession，在多个SqlSession或者分布式下，会引起脏数据，建议设定为 STATEMENT。
二级缓存

二级缓存主要使用实际上在一级缓存之前就会调用，在 CachingExecutor 的 query 中，但是需要设置Setting：

<setting name="cacheEnabled" value="true"/>

实际在 3.5.2 中， 这个默认是开启。
第二个是需要在xml中增加 <cache/> 标签。并配置好namespace

从而在 读取配置时，会初始化 MappedStatement 中Cache，在 CachingExecutor 中会进行引用：

  @Override
  public <E> List<E> query(MappedStatement ms, Object parameterObject, RowBounds rowBounds, ResultHandler resultHandler, CacheKey key, BoundSql boundSql)
      throws SQLException {
      // 如果配置了 二级缓存以及相应namespace，则会有Cache
    Cache cache = ms.getCache();
    if (cache != null) {
      flushCacheIfRequired(ms);
      if (ms.isUseCache() && resultHandler == null) {
        ensureNoOutParams(ms, boundSql);
        @SuppressWarnings("unchecked")
        List<E> list = (List<E>) tcm.getObject(cache, key);
        if (list == null) {
          list = delegate.query(ms, parameterObject, rowBounds, resultHandler, key, boundSql);
          tcm.putObject(cache, key, list); // issue #578 and #116
        }
        return list;
      }
    }
    // 没有则需要进行查询
    return delegate.query(ms, parameterObject, rowBounds, resultHandler, key, boundSql);
  }

二级缓存开启后，同一个namespace下的所有操作语句，都影响着同一个Cache，即二级缓存被多个SqlSession共享，是一个全局的变量。

觉得博主写的有用，不妨关注博主公众号: 六点A君。
哈哈哈，一起研究Mybatis：
在这里插入图片描述

6点A君
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
【项目实战】MyBatis基本流程原理
本本本添哥
04-14 109
MyBatis 是一种流行的Java持久化框架，它可以帮助开发人员轻松地将数据库操作映射到Java对象。
自定义mybatis流程分析.rar
10-13
《深入解析MyBatis流程与自定义实现》 在Java Web开发中，MyBatis作为一个轻量级的持久层框架，因其灵活性、易用性以及强大的映射能力，深受开发者喜爱。本文将深入剖析MyBatis的核心流程，并探讨如何自定义实现...
分析MyBatis中查询流程_代码详细介绍
x瓜皮的博客
10-04 181
在第一次篇文章中，我们简单的编写运行了一个查询数据库中某一数据的大致流程，现在我们研究一下MyBatis的运行流程，他到底是以怎么样的运行方式进行运行呢？ 运行流程 1、测试类中代码详细流程 我们都知道在Java中一个程序的入口是main函数，在这里也不例外。所以我们先观察main函数，而main函数在我们的Test类中编写。代码如下： package com.rjxy.mybatis.shiyan1; import java.io.IOException; import jav...
mybatis查询过程源码解析
Lisam Blog
07-04 3760
本文只讲解mybatis的源码 ，不涉及过多的用法讲解，用法请百度。 mybatis查询执行步骤（举SELECT分析） 第一步：获取mapperProxy 第二步：获取mapperMethod 第三步：找到对应的执行类型(SELECT\UPDATE\INSERT\DELETE) 第四步：查询前的缓存处理，判断是否需要从二级、一级缓存中取数据（先二级再一级） 第五步：真正调用用jdbc调数据库，先预编译、再注入参数 第六步：进行结果集解析填充 ...
MyBatis查询数据库【秘籍宝典】
最新发布
Original0的博客
07-08 658
MyBatis 是⼀款优秀的持久层框架，它⽀持⾃定义 SQL、存储过程以及⾼级映射。MyBatis 去除了⼏乎所有的 JDBC 代码以及设置参数和获取结果集的⼯作。MyBatis 可以通过简单的 XML 或注解来配置和映射原始类型、接⼝和 Java POJO（Plain Old Java Objects，普通⽼式 Java 对象）作为数据库中的记录。通过使用MyBatis，开发人员可以方便地执行CRUD操作（创建、读取、更新和删除），以及复杂的数据库查询和存储过程的调用。
MyBatis操作数据库（查询功能）
qq_73471456的博客
06-13 3351
介绍使用MyBatis操作数据库来进行数据库查询
Mybatis源码分析.pdf
08-30
MyBatis的工作流程主要分为四个步骤： 1. 加载配置并初始化：MyBatis读取全局配置文件、Mapper XML文件等，将SQL配置信息转化为MappedStatement对象存储在内存中。 2. 接收调用请求：当调用MyBatis API时，传入SQL的...
Mybatis – 执行流程分析（源码分析）
12-21
在深入分析Mybatis的执行流程之前，我们先回顾一下Mybatis的基本操作。Mybatis是一个轻量级的持久层框架，它允许开发者通过XML或注解定义SQL语句，然后通过接口与数据库进行交互。在使用Mybatis时，我们通常会经历...
通过源代码分析Mybatis的功能流程详解
08-18
通过源代码分析Mybatis的功能流程详解 Mybatis是当前最流行的持久化层框架之一，它提供了许多功能强大且灵活的特性，例如动态SQL、缓存机制、事务管理等等。想要真正理解Mybatis的功能流程，仅仅依靠官方文档和API...
Mybatis源码分析.docx
07-08
Mybatis源码分析 Mybatis是一款流行的基于Java的持久层框架，它提供了一个简洁的方式来访问和操作数据库。为了更好地理解Mybatis的工作机制，我们需要对其源码进行分析。 连接数据库 Mybatis通过DataSource对象来...
MyBatis实现查询的操作
希望可以给你点帮助
08-15 1036
MyBatis实现查询的操作 查询所有数据 查询某一个的详情 条件查询 方式一 散装参数 方式二 对象参数 方式三 map集合参数 动态条件查询 1 多条件动态查询 2 单条件动态查询
Mybatis查询执行流程
liuqiang211的专栏
02-05 579
因为mapper是代理对象 所有执行目标方法会先执行代理类的 invoke方法 method.getDeclaringClass 是 Object里面的方法 不是我们写的接口中的方法 所有直接让他执行就可以了 我们写的方法执行 在红框中标注的 BoundSql里面包含了 sql语句 sql语句是带 占位符 ？的那种形式的sql语句 入：select * f...
Mybatis源码解析之查询流程
0xZzzz的博客
01-20 5627
阅读须知 Mybatis源码版本：3.4.4 注释规则： //单行注释做普通注释 /**/多行注释做深入分析 建议配合Mybatis源码阅读 正文 上篇文章中我们分析mapper的创建，Mybatis用JDK动态代理为mapper创建代理类，其中MapperProxy作为InvocationHandler角色，所以调用目标mapper方法时会执行其invoke方法，我们来分析Mapp
Mybatis执行查询过程源码分析
mashaokang1314的博客
05-18 444
看源码 正确方式：宏观>微观>画图 宏观：了解本质； 微观： 以查询一条记录为线索； public class SelectMapper { static SqlSessionFactory factory; static { try { InputStream in = Resources.getResourceAsStream...
Mybatis数据库操作流程
weixin_42350137的博客
09-12 127
1，创建项目 pom.xml： <?xml version="1.0" encoding="UTF-8"?> <project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.a
【Mybatis】二、Mybatis执行流程
qwertyuiopasdfghjklzxcvbnm
11-25 300
由于该图片画的好，描述的更好，拿来借鉴一下 前置：上篇文章已经介绍了初始化流程，此处就从已经生成SqlSessionFactory开始介绍 一.通过SqlSessionFactory生成SqlSession对象 DefaultSqlSessionFactory.java private SqlSession openSessionFromDataSource(ExecutorType e...
【深入理解MyBatis】- 01从数据库中读取数据过程
dengjili的专栏
06-21 996
初始化项目 执行命令从github上面拉取代码：git clone git@github.com:dengjili/mybatis-3-mybatis-3.4.6.git 执行mysql数据库脚本：mybatis-3-mybatis-3.4.6/src/test/java/priv/mybatis/example01/sql/role.sql 更改mysql数据库配置：/mybatis-3-mybatis-3.4.6/src/test/resources/priv/mybatis/example01/my
Mybatis源码解析二(请求处理过程解析)
AN_ERA的博客
12-12 262
测试示例: package com.lic.ibatis.test; import com.lic.ibatis.dao.UserMapper; import com.lic.ibatis.entity.User; import org.apache.ibatis.binding.MapperProxy; import org.apache.ibatis.io.Resources; imp...
《深入理解mybatis原理》 MyBatis的架构设计以及实例分析
热门推荐
我的程序人生(亦山札记)
11-04 17万+
MyBatis是目前非常流行的ORM框架，它的功能很强大，然而其实现却比较简单、优雅。本文主要讲述MyBatis的架构设计思路，并且讨论MyBatis的几个核心部件，然后结合一个select查询实例，深入代码，来探究MyBatis的实现。
03 mybatis高级（2） 4
08-03
"MyBatis高级技术讲解，包括核心流程分析、建造者模式和初始化过程" 在MyBatis这一强大的持久层框架中，其高级特性主要体现在对核心流程的深入理解和高效的设计模式应用上。本课程将由主讲老师Lison带领，详细剖析...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值