MyBatis源码深度分析（一）：整体流程

已于 2023-07-01 22:50:18 修改
阅读量105 收藏
点赞数
文章标签： mybatis java
于 2023-07-01 16:36:24 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/u013244613/article/details/131488810
版权

工作原理

MyBatis通过解析mybatis-config.xml和Mapper.xml将所有的配置信息都保存在配置类Configuration中（其中XMLConfigBuilder负责解析mybatis-config.xml、XMLMapperBuilder负责解析Mapper.xml），并使用配置类Configuration创建SqlSessionFactory对象，然后通过SqlSessionFactory创建SqlSession对象，最终使用SqlSession创建Mapper代理对象MapperProxy，Mapper接口的所有方法都是由MapperProxy负责执行的。

整体流程

 示例代码
public static void main(String[] args) throws IOException {
    //1.读取mybatis-config.xml 文件
    InputStream inputStream = Resources.getResourceAsStream("mybatis-config.xml");
    //2.创建SqlSessionFactory(建造者设计模式)
    SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder().build(inputStream);
    //3.打开SqlSession
    try (SqlSession sqlSession = sqlSessionFactory.openSession()) {
        //4.JDK动态代理获取Mapper接口对象
        StDataMapper mapper = sqlSession.getMapper(StDataMapper.class);
        List<StData> resultList = mapper.findAll();
        for (StData item : resultList) {
            System.out.println("item:" + item.toString());
        }
    }
}

源码分析

1. 解析配置文件mybatis-config.xml
InputStream inputStream = Resources.getResourceAsStream("mybatis-config.xml");
SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder().build(inputStream);

SqlSessionFactoryBuilder类的build方法负责创建SqlSessionFactory对象

public SqlSessionFactory build(InputStream inputStream, String environment, Properties properties) {
  try {
    //使用XMLConfigBuilder解析mybatis-config.xml
    XMLConfigBuilder parser = new XMLConfigBuilder(inputStream, environment, properties);
    //将所有配置信息都封装在Configuration类中，并使用其创建SqlSessionFactory类
    return build(parser.parse());
  } catch (Exception e) {
    throw ExceptionFactory.wrapException("Error building SqlSession.", e);
  } finally {
    ErrorContext.instance().reset();
    try {
      if (inputStream != null) {
        inputStream.close();
      }
    } catch (IOException e) {
      // Intentionally ignore. Prefer previous error.
    }
  }
}

public SqlSessionFactory build(Configuration config) {
  return new DefaultSqlSessionFactory(config);
}

XMLConfigBuilder 对象继承 BaseBuider 抽象类，创建XMLConfigBuilder对象时会实例化配置类Configuration

private XMLConfigBuilder(Class<? extends Configuration> configClass, XPathParser parser, String environment,
    Properties props) {
  //创建配置类Configuration，并封装在XMLConfigBuilder
  super(newConfig(configClass));
  ErrorContext.instance().resource("SQL Mapper Configuration");
  this.configuration.setVariables(props);
  this.parsed = false;
  this.environment = environment;
  this.parser = parser;
}

private static Configuration newConfig(Class<? extends Configuration> configClass) {
  try {
    return configClass.getDeclaredConstructor().newInstance();
  } catch (Exception ex) {
    throw new BuilderException("Failed to create a new Configuration instance.", ex);
  }
}

其parse方法用来解析 mybatis-config.xml 配置文件，并将配置信息保存在配置类Configuration中

public Configuration parse() {
  if (parsed) {
    throw new BuilderException("Each XMLConfigBuilder can only be used once.");
  }
  parsed = true;
  //重点！解析mybatis-config.xml，将配置信息封装在Configuration
  parseConfiguration(parser.evalNode("/configuration"));
  //返回配置类Configuration，用于创建SqlSessionFactory
  return configuration;
}

parseConfiguration方法负责解析mybatis-config.xml配置中各个节点

private void parseConfiguration(XNode root) {
  try {
    // issue #117 read properties first
    //1.解析<properties>节点
    propertiesElement(root.evalNode("properties"));
    //2.解析<settings>节点
    Properties settings = settingsAsProperties(root.evalNode("settings"));
    loadCustomVfs(settings);
    loadCustomLogImpl(settings);
    //3.解析<typeAliases>节点
    typeAliasesElement(root.evalNode("typeAliases"));
    //4.解析<plugins>节点
    pluginElement(root.evalNode("plugins"));
    //5.解析<objectFactory>节点
    objectFactoryElement(root.evalNode("objectFactory"));
    //6.解析<objectWrapperFactory>节点
    objectWrapperFactoryElement(root.evalNode("objectWrapperFactory"));
    //7.解析<reflectorFactory>节点
    reflectorFactoryElement(root.evalNode("reflectorFactory"));
    settingsElement(settings);
    // read it after objectFactory and objectWrapperFactory issue #631
    //8.解析<environments>节点
    environmentsElement(root.evalNode("environments"));
    //9.解析<databaseIdProvider>节点
    databaseIdProviderElement(root.evalNode("databaseIdProvider"));
    //10.解析<typeHandlers>节点
    typeHandlerElement(root.evalNode("typeHandlers"));
    //11.解析<mappers>节点 重点！！！
    mapperElement(root.evalNode("mappers"));
  } catch (Exception e) {
    throw new BuilderException("Error parsing SQL Mapper Configuration. Cause: " + e, e);
  }
}

mapperElement方法负责解析mybatis-config.xml中的mappers节点，MyBatis支持4种Mapper注册方式，这在mapperElement方法中可以得到验证。

<mappers>  
    <!-- 通过package元素将指定包下面的所有Mapper接口进行注册 -->  
    <package name="com.izx.mapper"/>  
    <!-- 通过mapper元素的resource属性指定一个相对于类路径的Mapper.xml文件 -->  
    <mapper resource="com/izx/mapper/StDataMapper.xml"/>  
    <!-- 通过mapper元素的url属性指定一个通过URL请求道的Mapper.xml文件 -->  
     <mapper url="file:com/izx/mapper/StDataMapper.xml"/>
    <!-- 通过mapper元素的class属性指定一个Mapper接口进行注册 -->  
    <mapper class="com.izx.mapper.StDataMapper"/>  
</mappers>

下面将重点分析通过package元素注册指定包下的所有Mapper接口的方式，对于mapperElement方法有两个作用：

  1. 将Mapper接口至Mapper代理工厂MapperProxyFactory的映射添加至Mapper注册器MapperRegistry的 knownMappers集合中（knownMappers是Map<Class<?>, MapperProxyFactory<?>>集合）。
  2. 解析mapper.xml，创建对应的MappedStatement，将其保存在Configration类的mappedStatements集合中
//重点分析通过package元素注册指定包下的所有Mapper接口
private void mapperElement(XNode parent) throws Exception {
  if (parent != null) {
    for (XNode child : parent.getChildren()) {
      //1.通过package元素将指定包下面的所有Mapper接口进行注册
      if ("package".equals(child.getName())) {
        String mapperPackage = child.getStringAttribute("name");
        //重点！ 
        //将Mapper接口映射添加至Mapper注册器MapperRegistry
        //解析mapper.xml创建MappedStatement，保存至Configuration.mappedStatements
        configuration.addMappers(mapperPackage);
      } else {
        String resource = child.getStringAttribute("resource");
        String url = child.getStringAttribute("url");
        String mapperClass = child.getStringAttribute("class");
        if (resource != null && url == null && mapperClass == null) {
          //2.通过mapper元素的resource属性指定一个相对于类路径的Mapper.xml文件
          ErrorContext.instance().resource(resource);
          try (InputStream inputStream = Resources.getResourceAsStream(resource)) {
            XMLMapperBuilder mapperParser = new XMLMapperBuilder(inputStream, configuration, resource,
                configuration.getSqlFragments());
            mapperParser.parse();
          }
        } else if (resource == null && url != null && mapperClass == null) {
          //3.通过mapper元素的url属性指定一个通过URL请求获取的Mapper.xml文件
          ErrorContext.instance().resource(url);
          try (InputStream inputStream = Resources.getUrlAsStream(url)) {
            XMLMapperBuilder mapperParser = new XMLMapperBuilder(inputStream, configuration, url,
                configuration.getSqlFragments());
            mapperParser.parse();
          }
        } else if (resource == null && url == null && mapperClass != null) {
          //4.通过mapper元素的class属性指定一个Mapper接口进行注册
          Class<?> mapperInterface = Resources.classForName(mapperClass);
          configuration.addMapper(mapperInterface);
        } else {
          throw new BuilderException(
              "A mapper element may only specify a url, resource or class, but not more than one.");
        }
      }
    }
  }
}

通过package元素注册Mapper接口时使用configuration.addMappers方法将Mapper接口注册工作委托给MapperRegistry

public void addMappers(String packageName) {
  mapperRegistry.addMappers(packageName);
}
1.1. Mapper注册器MapperRegistry

MapperRegistry有两个主要属性：config和KnownMappers

  1. config:  MyBatis全局配置类Configuration
  2. KnownMappers: Map<Class<?>, MapperProxyFactory<?>>类型的集合，实现Mapper类到MapperProxyFactory的映射，将Mapper类添加至集合后必须完成一次Mapper.xml配置解析,如果解析不成功,那么仍然会将mapper接口移除
private final Configuration config;
private final Map<Class<?>, MapperProxyFactory<?>> knownMappers = new HashMap<>();

//注册Mapper接口
public <T> void addMapper(Class<T> type) {
  if (type.isInterface()) {
    if (hasMapper(type)) {
      throw new BindingException("Type " + type + " is already known to the MapperRegistry.");
    }
    boolean loadCompleted = false;
    try {
      //添加Mapper接口至MapperProxyFactory的映射
      knownMappers.put(type, new MapperProxyFactory<>(type));
      // It's important that the type is added before the parser is run
      // otherwise the binding may automatically be attempted by the
      // mapper parser. If the type is already known, it won't try.
      //重点！ 解析mapper.xml生成MappedStatement，保存至Configuration
      MapperAnnotationBuilder parser = new MapperAnnotationBuilder(config, type);
      parser.parse();
      loadCompleted = true;
    } finally {
      //解析mapper.xml失败时，会将Mapper接口从knownMappers中移除
      if (!loadCompleted) {
        knownMappers.remove(type);
      }
    }
  }
}
2. 解析一系列Mapper.xml配置文件
2.1. MapperAnnotationBuilder类

MapperAnnotationBuilder的parse方法将会加载mapper.xml配置文件，并使用XMLMapperBuilder解析mapper.xml

public void parse() {
  String resource = type.toString();
  if (!configuration.isResourceLoaded(resource)) {
    //加载mapper.xml，并使用XMLMapperBuilder解析
    loadXmlResource();
    configuration.addLoadedResource(resource);
    assistant.setCurrentNamespace(type.getName());
    parseCache();
    parseCacheRef();
    for (Method method : type.getMethods()) {
      if (!canHaveStatement(method)) {
        continue;
      }
      if (getAnnotationWrapper(method, false, Select.class, SelectProvider.class).isPresent()
          && method.getAnnotation(ResultMap.class) == null) {
        parseResultMap(method);
      }
      try {
        parseStatement(method);
      } catch (IncompleteElementException e) {
        configuration.addIncompleteMethod(new MethodResolver(this, method));
      }
    }
  }
  parsePendingMethods();
}

loadXmlResource()方法负责加载并解析mapper.xml

private void loadXmlResource() {
  // Spring may not know the real resource name so we check a flag
  // to prevent loading again a resource twice
  // this flag is set at XMLMapperBuilder#bindMapperForNamespace
  if (!configuration.isResourceLoaded("namespace:" + type.getName())) {
    String xmlResource = type.getName().replace('.', '/') + ".xml";
    // #1347 1.从src目录下加载mapper.xml
    InputStream inputStream = type.getResourceAsStream("/" + xmlResource);
    if (inputStream == null) {
      //2.src目录下不存在，从resource目录下加载mapper.xml
      // Search XML mapper that is not in the module but in the classpath.
      try {
        inputStream = Resources.getResourceAsStream(type.getClassLoader(), xmlResource);
      } catch (IOException e2) {
        // ignore, resource is not required
      }
    }
    if (inputStream != null) {
      //解析mapper.xml，创建一组MappedStatement，保存在Configuration的mappedStatements
      XMLMapperBuilder xmlParser = new XMLMapperBuilder(inputStream, assistant.getConfiguration(), xmlResource,
          configuration.getSqlFragments(), type.getName());
      xmlParser.parse();
    }
  }
}

2.2. MappedStatement类

MappedStatement 类存储了一个 sql 语句的所有信息，Mybatis 通过解析mapper.xml文件 和 mapper 接口上的注解，生成 sql 对应的 MappedStatement 实例， 保存在Configuration 类属性mappedStatements中。

public class Configuration {
  //StrictMap继承自ConcurrentHashMap
  protected final Map<String, MappedStatement> mappedStatements = new StrictMap<MappedStatement>(
      "Mapped Statements collection")
          .conflictMessageProducer((savedValue, targetValue) -> ". please check " + savedValue.getResource() + " and "
              + targetValue.getResource());
}

真正执行 mapper 接口中的方法时，会从 Configuration 中找到对应的 MappedStatement，然后进行后续的操作。

3.创建Mapper代理对象MapperProxy
//3.打开SqlSession
try (SqlSession sqlSession = sqlSessionFactory.openSession()) {
    //4.JDK动态代理获取Mapper接口对象
    StDataMapper mapper = sqlSession.getMapper(StDataMapper.class);
    List<StData> resultList = mapper.findAll();
    for (StData item : resultList) {
        System.out.println("item:" + item.toString());
    }
}

SqlSession.getMapper(StDataMapper.class)方法内部调用configuration.getMapper()方法，最终调用mapperRegistry.getMapper()方法

public class DefaultSqlSession implements SqlSession {
  @Override
  public <T> T getMapper(Class<T> type) {
    return configuration.getMapper(type, this);
  }
}

public class Configuration {

  protected final MapperRegistry mapperRegistry = new MapperRegistry(this);

  public <T> T getMapper(Class<T> type, SqlSession sqlSession) {
    //获取Mapper对象代理类MapperProxy
    return mapperRegistry.getMapper(type, sqlSession);
  }
}

MapperRegistry的getMapper方法使用MapperProxyFactory类创建Mapper代理对象

@SuppressWarnings("unchecked")
public <T> T getMapper(Class<T> type, SqlSession sqlSession) {
  //上面解析mappers节点时，创建Mapper类至MapperProxyFactory的映射
  final MapperProxyFactory<T> mapperProxyFactory = (MapperProxyFactory<T>) knownMappers.get(type);
  if (mapperProxyFactory == null) {
    throw new BindingException("Type " + type + " is not known to the MapperRegistry.");
  }
  try {
    //使用JDK动态代理创建MapperProxy代理对象
    return mapperProxyFactory.newInstance(sqlSession);
  } catch (Exception e) {
    throw new BindingException("Error getting mapper instance. Cause: " + e, e);
  }
}

MapperProxyFactory使用JDK动态代理生成Mapper代理对象MapperProxy

public class MapperProxyFactory<T> {

  private final Class<T> mapperInterface;
  private final Map<Method, MapperMethodInvoker> methodCache = new ConcurrentHashMap<>();

  public MapperProxyFactory(Class<T> mapperInterface) {
    this.mapperInterface = mapperInterface;
  }

  public Class<T> getMapperInterface() {
    return mapperInterface;
  }

  public Map<Method, MapperMethodInvoker> getMethodCache() {
    return methodCache;
  }

  @SuppressWarnings("unchecked")
  protected T newInstance(MapperProxy<T> mapperProxy) {
    //JDK动态代理创建MapperProxy，Mapper接口的方法都由MapperProxy负责执行
    return (T) Proxy.newProxyInstance(mapperInterface.getClassLoader(), new Class[] { mapperInterface }, mapperProxy);
  }

  public T newInstance(SqlSession sqlSession) {
    final MapperProxy<T> mapperProxy = new MapperProxy<>(sqlSession, mapperInterface, methodCache);
    return newInstance(mapperProxy);
  }

}
 4.Mapper代理对象MapperProxy
MapperProxy实现了InvocationHandler接口，负责执行Mapper接口定义的方法
public class MapperProxy<T> implements InvocationHandler, Serializable {
  //代理过的方法会缓存在methodCache中
  private final Map<Method, MapperMethodInvoker> methodCache;

  @Override
  public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
    try {
      //Object中定义的方法直接执行，如toString(),hashCode()等
      if (Object.class.equals(method.getDeclaringClass())) {
        return method.invoke(this, args);
      }
      //其他Mapper接口定义的方法交由MapperMethodInvoker来执行
      return cachedInvoker(method).invoke(proxy, method, args, sqlSession);
    } catch (Throwable t) {
      throw ExceptionUtil.unwrapThrowable(t);
    }
  }

  private MapperMethodInvoker cachedInvoker(Method method) throws Throwable {
    try {
       //如果method方法已经代理过则从methodCache直接获取，否则创建MethodInvoker并缓存至methodCache
      return MapUtil.computeIfAbsent(methodCache, method, m -> {
        if (!m.isDefault()) {
          return new PlainMethodInvoker(new MapperMethod(mapperInterface, method, sqlSession.getConfiguration()));
        }
        try {
          if (privateLookupInMethod == null) {
            return new DefaultMethodInvoker(getMethodHandleJava8(method));
          } else {
            return new DefaultMethodInvoker(getMethodHandleJava9(method));
          }
        } catch (IllegalAccessException | InstantiationException | InvocationTargetException
            | NoSuchMethodException e) {
          throw new RuntimeException(e);
        }
      });
    } catch (RuntimeException re) {
      Throwable cause = re.getCause();
      throw cause == null ? re : cause;
    }
  }
}

下一篇将会分析MapperMethod具体执行Sql语句流程，并引入MyBatis的四大对象

  1. 执行器Executor
  2. JDBC Statement处理类StatementHandler
  3. SQL参数处理类ParameterHandler
  4. 查询结果集处理类ResultSetHandler
ztr007
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
spring源码合集spring源码合集
04-09
4. **MyBatis源码解析**：尽管"19-MyBatis源码—SQL操作执行流程源码深度剖析-徐庶"和"12-Spring之整合Mybatis底层源码解析-周瑜"主要关注MyBatis，但这两部分也是Spring生态的重要组成部分。我们将学习Spring如何与...
95ShoppingAchieve:95商城完成源码-商城
03-24
《95ShoppingAchieve: 一个深度解析的开源商城系统》 在当今互联网时代，电商平台已经成为商业运营的重要组成部分。开源的商城系统更是受到广大开发者和商家的青睐，因为它们提供了高度自定义、灵活扩展以及成本...
Mybatis源码解析
qq_35068291的博客
03-11 382
Mybatis源码解析
【MyBatis-Plus 源码分析】核心组件、工作流程、SQL执行过程、源码分析
最新发布
好好学习日记
05-29 1238
MyBatis-Plus 是一个增强版的 MyBatis 框架，它在 MyBatis 的基础上增加了许多实用的功能，例如乐观锁插件、字段自动填充、分页插件、条件构造器和 SQL 注入器等。MyBatis-Plus 允许开发者无需编写 XML 文件，直接通过继承 BaseMapper 接口的类来完成数据库操作。MyBatis-Plus 作为 MyBatis 的增强框架，其工作流程在继承 MyBatis 的基础上进行了优化和扩展。继承 BaseMapper。
mybatis源码解读篇
用针戳左手中指指头的博客
01-08 618
文章目录mybatis初始化原理mybatis执行流程1. 委托configuration获取mapper2. configuration通过mapperRegistry(type,sqlSession)获取mapper3. MapperRegistry.getMapper(type, sqlSession)4. mapperMethod构造（mapper参数解析）5. 实际执行通过SQLSession执行对应方法6. 执行前解析方法参数7. SQLSession里的执行又丢给executor8. 构造sq
转载：MyBatis 启动流程和源码分析
weixin_44871778的博客
04-19 239
相比于其他的组件就简单很多了，ParameterHandler 译为参数处理器，负责为 PreparedStatement 的 sql 语句参数动态赋值，这个接口很简单只有两个方法ParameterHandler 只有一个实现类， 它实现了这两个方法。getParameterObject： 用于读取参数setParameters: 用于对 PreparedStatement 的参数赋值ResultSetHandler 也是一个非常简单的接口。
Mybatis主要流程源码分析
stay_the_course的博客
03-01 309
源码debug截图，保姆级教程学会mybatis的主要流程源码分析
毕业设计源码之汽车销售管理系统.zip
09-20
《汽车销售管理系统——Java毕业设计深度解析》 在IT领域，毕业设计是学生们将理论知识转化为实际应用的重要环节。本文将深入探讨一个基于Java技术的汽车销售管理系统，该系统是计算机专业学生的一份毕业设计作品，...
网上书店项目【视频+源码+文档】.zip
06-26
三、小程序源码：针对微信小程序开发，项目提供了相应的源代码，让你了解小程序的开发流程。通过分析这些代码，可以掌握WXML、WXSS和JavaScript的结合使用，如何定义页面结构、样式以及逻辑，以及如何调用微信API...
Mybatis 源码 ② ：流程分析
猫吻鱼的博客
08-14 527
在Mybatis 源码 ① ：开篇中 我们整体简单介绍了下Mybatis ，下面我们来对SpringBoot 中 Mybatis 的源码做具体分析Mybatis 源码 ① ：开篇下面我们按照 SpringBoot 自动装配作为入口来进行分析。SpringBoot 自动装配会 将 AutoConfiguredMapperScannerRegistrar 装配到容器中。
Mybatis源码分析_解析大流程梳理_解析配置文件 （3）
街头小瘪三的专栏
06-25 1017
学习mybatis，绕不开一个核心类 Configuration。这个类相当于一个小型数据库，把mybatis里面所有的配置信息基本全部给存储起来了。 这里，我先介绍介个比较重要的变量： typeAliasRegistry ： 存放我们自定义的接口的别名 mapperRegistry ： 存放包装了我们业务接口的动态代理类 mappedStatements ： 增、删、改、查语句的包装类，即注册中心 resultMaps ： resultMap返回值类型 loadedResources : 存放我
Mybatis源码解析02-SQL执行概述
一斗水的专栏
02-04 208
一般在使用mybatis的时候，会在DAO层设计一个*Mapper的接口，然后会有与之对应的文件，其namespace为接口class的全限定名，而里面的这些操作标签对应接口里面的方法。我们在Mapper接口打断点，然后执行到断点的时候，如下图所示：可以看到此时的Mapper接口对应的是这明显是一个由MapperProxy派生出来的代理类。
MyBatis Plus 插件 动态数据源实现原理与源码讲解 (dynamic-datasource-spring-boot-starter-master)
深度
05-16 6681
多数据源即一个项目中同时存在多个不同的数据库连接池。 比如 127.0.0.1:3306/test 127.0.0.1:3307/test127.0.0.1:3308/test 总之项目存在需要操作多个库的需求。 具体在编码方面呢，具体就是一个service 中，方法1使用库1查询，方法2使用库2查询。
SpringBoot——MyBatis-Plus源码分析及开发实践详解
Andya_net的博客
04-25 792
  在上一家公司一直使用，它是对基于JPA的数据访问层的增强支持，底层使用框架，支持使用原生L或查询语言。是基于的，它把代码和分离，即在代码和之间增加了新的一层，从而间接操作，大家可能觉得这个学习成本比较高，但其实也还好，都用不到文件等。  而在新的公司，使用的是，面向基于的模式，复杂的需要通过写文件来操作可能更直观友好，当结合就原地起飞了。本文主要总结使用的一些实践经验及源码分析。  是的增强工具，可以简化开发，提高我们的开发效率。
mybatis-启动源码分析
PacosonSWJTU的博客
09-11 222
【1】代码 public static void main1() { /*1. 获取 SqlSessionFactory 对象*/ SqlSessionFactory sqlSessionFactory = MyBatisUtils.getSqlSessionFactory(); /*2.获取SqlSession对象, 不会自动提交数据*/ SqlSession session = sqlSessionFactory.openSession(); try { String flag
MybatisPlus源码分析
zwz541的博客
09-23 565
1.MybatisMapperProxy.invoke()的Mapper代理对象,走缓存的调用cachedInvoker(method).invoke(proxy,method,args,sqlSession);使用sqlSession执行 2.sqlSession调用Plugin的一个拦截器MybatisPlusInterceptor 3.拦截器中执行Excutor的MybatisCachingExecutor.doQuery()，并没走二级缓存，再委托调用另外一个实现Mybatis...
"MyBatis源码分析.pdf：深度剖析MyBatis框架及其数据库访问优势
"MyBatis源码分析.pdf"是一本深入探讨MyBatis框架的书籍，主要内容包括MyBatis的入门介绍、使用MyBatis的原因、MyBatis与其他数据库访问框架的比较以及MyBatis的实际应用。本书共分为多个章节，其中第1章介绍了...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值