『手撕 Mybatis 源码』02 - 加载配置文件

已于 2023-05-21 09:43:53 修改
阅读量296 收藏
点赞数
分类专栏： 『数据库』 文章标签： mybatis java spring
于 2023-05-16 10:11:47 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/zzz805/article/details/130666087
版权

加载配置文件

获取输入流

  1. myBatis 的配置文档层次架构
    在这里插入图片描述
  2. 首先从读入开始查看是怎么加载配置文件的，现在从这里打个断点
public class MybatisTest {
  @Test
  public void test1() throws IOException {
     // 1. 通过类加载器对配置文件进行加载，加载成了字节输入流，存到内存中
    // 注意：配置文件并没有被解析
    InputStream resourceAsStream = Resources.getResourceAsStream("SqlMapConfig.xml");
    ...
  }
}
  1. 然后发现会通过一个 classLoaderWrapper： ClassLoader 的包装器来把数据源读入，返回输入流
public class Resources {

  private static ClassLoaderWrapper classLoaderWrapper = new ClassLoaderWrapper();
  ...
  public static InputStream getResourceAsStream(ClassLoader loader, String resource) throws IOException {
	InputStream in = classLoaderWrapper.getResourceAsStream(resource, loader);
    ...
  }
}
  1. 继续进入会发现其实会通过 getClassLoaders(classLoader) 返回对应加载器之后再进行读取。现在的 classLoader 是 null
public class ClassLoaderWrapper {
  // 默认类加载器
  ClassLoader defaultClassLoader;
  // 系统类加载器
  ClassLoader systemClassLoader;
  ...
  public InputStream getResourceAsStream(String resource, ClassLoader classLoader) {
    return getResourceAsStream(resource, getClassLoaders(classLoader));
  }
}
  1. 其中 getClassLoaders(classLoader) 代码如下
public class ClassLoaderWrapper {
  ...
  ClassLoader[] getClassLoaders(ClassLoader classLoader) {
    return new ClassLoader[]{
        // 参数指定的类加载器
        classLoader,
        // 系统指定的默认加载器
        defaultClassLoader,
        // 当前线程绑定的类加载器
        Thread.currentThread().getContextClassLoader(),
        // 当前类使用的类加载器
        getClass().getClassLoader(),
        systemClassLoader};
  }
}
  1. 拿到加载器集合之后才正在的调用读取源方法，最后返回输入流，判断方法如下
public class ClassLoaderWrapper {
  ...
  InputStream getResourceAsStream(String resource, ClassLoader[] classLoader) {
    // 循环 ClassLoader，通过指定或默认的 ClassLoader 读取文件
    for (ClassLoader cl : classLoader) {
      // 如果加载器不是空的
      if (null != cl) {
        // 先用这个加载器尝试读一下
        InputStream returnValue = cl.getResourceAsStream(resource);

        // 如果返回没结果，有可能是因为缺少个 "/"，添加后再读一下
        if (null == returnValue) {
          returnValue = cl.getResourceAsStream("/" + resource);
        }
        
        if (null != returnValue) {
          // 如果读取到，终止循环，返回结果
          return returnValue;
        }
      }
    }
    return null;
  }
}
  1. 当输入流读成功之后，就返回
public class Resources {
  ...
  public static InputStream getResourceAsStream(ClassLoader loader, String resource) throws IOException {
	InputStream in = classLoaderWrapper.getResourceAsStream(resource, loader);
	// 找到输入流之后，就返回了
    if (in == null) {
      throw new IOException("Could not find resource " + resource);
    }
    return in;
  }
}
  1. 问题：为什么需要 ClassLoaderWrapper 包装器，而不直接使用 ClassLoader?
  • 因为它需要拿来判断资源路径是否为空
  • 根据路径加载好的输入流是否为空
  • 使用的类加载器是否为空
  • 异常处理
  1. 总结
  • 获取输入流在这里插入图片描述

解析配置文件

  1. 首先先通过 SqlSessionFactoryBuilder 构建 sqlSessionFactory，我们能知道 sqlSessionFactory 肯定包含了所有配置文件信息
public class MybatisTest {

  @Test
  public void test1() throws IOException {
    ...
    // 2. (1) 解析了配置文件，封装 configuration 对象
    // （2）创建了 DefaultSqlSessionFactory 工厂对象
    SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder().build(resourceAsStream);
    ...
  }
}
  1. 首先是调用 build() 方法，发现我们 environment 输入的是 null
public class SqlSessionFactoryBuilder {
  ...
  public SqlSessionFactory build(InputStream inputStream) {
    return build(inputStream, null, null);
  }
  // environment 运行环境信息的 id 值
  public SqlSessionFactory build(InputStream inputStream, String environment) {
    return build(inputStream, environment, null);
  }
  ...
}
  • 其实正常来说，我们可以自己配置 environment 参数，因为我们知道 Mybatis 是支持多环境配置，定义就在 sqlMapConfig.xml 中
<configuration>
  ...
    <environment id="development">
	...
    </environment>
  ...
</configuration>
  1. 然后就需要通过 XMLConfigBuilder 来将输入流创建成 document 对象
public class SqlSessionFactoryBuilder {
  ...
  public SqlSessionFactory build(InputStream inputStream, String environment, Properties properties) {
    try {
      // XMLConfigBuilder：用来解析XML配置文件
      // 使用构建者模式：
      // 	- 好处：降低耦合、分离复杂对象的创建
      // 1. 创建 XPathParser 解析器对象，根据 inputStream 解析成了 document 对象 
      // 2. 创建全局配置对象 Configuration 对象
      XMLConfigBuilder parser = new XMLConfigBuilder(inputStream, environment, properties);
      ...
	}
}

注意：对于返回至少 4 个参数以上的对象，最好使用 构建者模式

  1. 在 XMLConfigBuilder 的构造器中就会通过创建一个 XPathParser 对象，里面就会包含一个 document 对象，也就是 XPathParser 其实只会专门负责解析配置文件而已
public class XMLConfigBuilder extends BaseBuilder {
  ...
  protected final Configuration configuration; // 这个是 BaseBuilder 里面得属性
  private boolean parsed;
  private final XPathParser parser;
  private String environment;
  ...
  public XMLConfigBuilder(InputStream inputStream, String environment, Properties props) {
    // XPathParser 基于 Java XPath 解析器，用于解析  MyBatis 中的配置文件
    this(new XPathParser(inputStream, true, props, new XMLMapperEntityResolver()), environment, props);
  }
}
  • createDocument() 的东西过于细节，就先不关注了，反正最终就是，通过 dom 解析，获取 Document 对象，然后赋值到成员变量中
public class XPathParser {
  ...
  private final Document document;
  ...
  public XPathParser(InputStream inputStream, boolean validation, Properties variables, EntityResolver entityResolver) {
    commonConstructor(validation, variables, entityResolver);
    // 解析 XML 文档为 Document 对象
    this.document = createDocument(new InputSource(inputStream));
  }
}
  1. 然后开始初始化 XMLConfigBuilder，首先会创建一个 Configuration 对象
public class XMLConfigBuilder extends BaseBuilder {
  private XMLConfigBuilder(XPathParser parser, String environment, Properties props) {
    //  创建全局 Configuration 对象，并通过 TypeAliasRegistry 注册一些 Mybatis 内部相关类的别名
    super(new Configuration());
    ...
  }
}
  1. 简单来看看 Configuration 的构造方法，可以看到注册了一堆别名器
public class Configuration {
  ...
  protected Environment environment;
  // 类型注册器, 用于在执行 sql 语句的出入参映射以及 mybatis-config 文件里的各种配置
  // 比如 <transactionManager type="JDBC"/><dataSource type="POOLED"> 时使用简写
  protected final TypeAliasRegistry typeAliasRegistry = new TypeAliasRegistry();
  ...
  // 为什么使用 JDBC 别名就能使用 jdbc 事务管理呢？ sqlConfig.xml，原因就是在这
  public Configuration() {
   
    // TypeAliasRegistry（类型别名注册器）
    // 注册事务工厂的别名
    typeAliasRegistry.registerAlias("JDBC", JdbcTransactionFactory.class);
    typeAliasRegistry.registerAlias("MANAGED", ManagedTransactionFactory.class);
    ...
  }
}
  • 问题：为什么使用 JDBC 别名就能使用 jdbc 事务管理呢？
    • 原因就是这里， 因为我们在 sqlMapConfig.xml 中，指定了用哪个工厂来赋值，其中的 type 字段就是
<configuration>
	...
    <environment id="development">
      <!-- 使用jdbc事务管理 -->
      <transactionManager type="JDBC" />
      <!-- 数据库连接池 -->
      <dataSource type="POOLED">
		...
      </dataSource>
    </environment>
	...
</configuration>
  1. 回到 build() 得到 XMLConfigBuilder 后，才真正开始执行分析
public class SqlSessionFactoryBuilder {
  ...
  public SqlSessionFactory build(InputStream inputStream, String environment, Properties properties) {
   
      XMLConfigBuilder parser = new XMLConfigBuilder(inputStream, environment, properties);

      // parser.parse()：使用 XPATH 解析 XML 配置文件，将配置文件封装到 Configuration 对象
      // 返回 DefaultSqlSessionFactory 对象，该对象拥有 Configuration 对象（封装配置文件信息）
      // parse()：配置文件就解析完成了
      return build(parser.parse());
  }
}

XMLConfigBuilder 解析 Document 获取配置存入 configuration

  1. 继续从 parser.parse() 里面进入会看到 parse() 只会解析一次
public class XMLConfigBuilder extends BaseBuilder {
  ...
  public Configuration parse() {
    // 一开始是 false，只会计息一次
    if (parsed) {
      throw new BuilderException("Each XMLConfigBuilder can only be used once.");
    }
    parsed = true;

    // parser.evalNode("/configuration")：通过 XPATH 解析器，解析 configuration 根节点
    // 从 configuration 根节点开始解析，最终将解析出的内容封装到 Configuration 对象中
    parseConfiguration(parser.evalNode("/configuration"));

    return configuration;
  }
}
  1. 然后通过 evalNode() 将解析 /configuration 下的所有内容成 Xnode
public class XPathParser {
  ...
  public XNode evalNode(String expression) {
    // 根据XPATH语法，获取指定节点
    return evalNode(document, expression);
  }

  public XNode evalNode(Object root, String expression) { // 获取需选中的内容，转换成 xnode
    Node node = (Node) evaluate(expression, root, XPathConstants.NODE);
    if (node == null) {
      return null;
    }
    return new XNode(this, node, variables);
  }
  ...
}
  • 其中 Xnode 包含的内容就是 sqlMapConfig.xml 标签 <configuration> 下的所有内容
  1. 进入到 parseConfiguration() 之后会发现很多 **Element() 的函数，很关键，这些都是把 /configuration 节点下的内容解析出来，存到 configuration 对象中
public class XMLConfigBuilder extends BaseBuilder {
	...
	  private void parseConfiguration(XNode root) {
    try {
      // 解析 </properties> 标签
      propertiesElement(root.evalNode("properties"));
      // 解析 </settings> 标签
      Properties settings = settingsAsProperties(root.evalNode("settings"));
      loadCustomVfs(settings);
      loadCustomLogImpl(settings);
      // 解析 </typeAliases> 标签
      typeAliasesElement(root.evalNode("typeAliases"));
      // 解析 </plugins> 标签
      pluginElement(root.evalNode("plugins"));
      // 解析 </objectFactory> 标签
      objectFactoryElement(root.evalNode("objectFactory"));
      // 解析 </objectWrapperFactory> 标签
      objectWrapperFactoryElement(root.evalNode("objectWrapperFactory"));
      // 解析 </reflectorFactory> 标签
      reflectorFactoryElement(root.evalNode("reflectorFactory"));
      settingsElement(settings);
      // 解析 </environments> 标签
      environmentsElement(root.evalNode("environments"));
      // 解析 </databaseIdProvider> 标签
      databaseIdProviderElement(root.evalNode("databaseIdProvider"));
      // 解析 </typeHandlers> 标签
      typeHandlerElement(root.evalNode("typeHandlers"))
      // 解析 </mappers> 标签 加载映射文件流程主入口
      mapperElement(root.evalNode("mappers"));
    } catch (Exception e) {
      throw new BuilderException("Error parsing SQL Mapper Configuration. Cause: " + e, e);
    }
  }
}
  1. 跳到 environmentsElement() 看看
  • 首先它会从 Xnode 节点中提取 /environments 元素，然后判断存不存在内容
  • 然后判断是否传入过 environment 参数，如果没有，就从 /environments 拿到 default 属性 要激活的环境
  • 拿到环境后，开始根据每个标签下定义的 type 属性 创建各个工厂类，最后封装到 configuration 中
public class XMLConfigBuilder extends BaseBuilder {
  ...
  private void environmentsElement(XNode context) throws Exception {
    // 如果定义了environments
    if (context != null) {
      // 方法参数如何没有传递 environment，则解析 sqlMapConfig.xml 中的
      if (environment == null) {
        // <environments default="development" >
        environment = context.getStringAttribute("default");
      }

      //遍历解析 environment 节点，找到生效的 environment
      for (XNode child : context.getChildren()) {
        // 获得 id 属性值
        String id = child.getStringAttribute("id");
        // 判断 id 和 environment 值是否相等
        if (isSpecifiedEnvironment(id)) {

          // <transactionManager type="JDBC" /> 创建事务工厂对象
          TransactionFactory txFactory = transactionManagerElement(child.evalNode("transactionManager"));

          // <dataSource type="POOLED"> 创建数据源对象
          DataSourceFactory dsFactory = dataSourceElement(child.evalNode("dataSource"));
          DataSource dataSource = dsFactory.getDataSource();
          Environment.Builder environmentBuilder = new Environment.Builder(id)
              .transactionFactory(txFactory)
              .dataSource(dataSource);

          // 将 Environment 存到 configuraion 中
          configuration.setEnvironment(environmentBuilder.build());
          break;
        }
      }
    }
  }
}
  • 像 transactionManagerElement()，type 属性 作用就是起的别名里面已经有对应工厂类了，直接初始化即可
public class XMLConfigBuilder extends BaseBuilder {
  ...
  private TransactionFactory transactionManagerElement(XNode context) throws Exception {
    if (context != null) {
      String type = context.getStringAttribute("type");
      Properties props = context.getChildrenAsProperties();
      TransactionFactory factory = (TransactionFactory) resolveClass(type).getDeclaredConstructor().newInstance();
      factory.setProperties(props);
      return factory;
    }
    throw new BuilderException("Environment declaration requires a TransactionFactory.");
  }
}
  1. 再来看看 mapperElement() 解析 /mappers 的情况
  • 它会根据子标签 /package 还是 /mapper 进行处理，先简单看看 /mapper 的解析
  • 它会从 /mapper 中解析出 resource 属性、 url 属性、class 属性，这 3 者是互斥的，只能用其中一个
  • 像 resource 属性 的解析，还需要使用 XMLMapperBuilder 来专门解析
public class XMLConfigBuilder extends BaseBuilder {
  ...
  private void mapperElement(XNode parent) throws Exception {
    if (parent != null) {
      // 获取 <mappers> 标签的子标签
      for (XNode child : parent.getChildren()) {
        // <package> 子标签
        if ("package".equals(child.getName())) {
			...
        } else {// <mapper>子标签
          // 获取<mapper>子标签的 resource 属性
          String resource = child.getStringAttribute("resource");
          // 获取 <mapper> 子标签的 url 属性
          String url = child.getStringAttribute("url");
          // 获取 <mapper> 子标签的 class 属性
          String mapperClass = child.getStringAttribute("class");
          // 它们是互斥的
          if (resource != null && url == null && mapperClass == null) {
            ErrorContext.instance().resource(resource);
            try(InputStream inputStream = Resources.getResourceAsStream(resource)) {
              // 专门用来解析 mapper 映射文件
              XMLMapperBuilder mapperParser = new XMLMapperBuilder(inputStream, configuration, resource, configuration.getSqlFragments());
              // 通过 XMLMapperBuilder 解析 mapper 映射文件
              mapperParser.parse();
            }
          } else if (resource == null && url != null && mapperClass == null) {
            ErrorContext.instance().resource(url);
            try(InputStream inputStream = Resources.getUrlAsStream(url)){
              XMLMapperBuilder mapperParser = new XMLMapperBuilder(inputStream, configuration, url, configuration.getSqlFragments());
              // 通过 XMLMapperBuilder 解析 mapper 映射文件
              mapperParser.parse();
            }
          } else if (resource == null && url == null && mapperClass != null) {
            Class<?> mapperInterface = Resources.classForName(mapperClass);
            // 将指定 mapper 接口以及它的代理对象存储到一个 Map 集合中，key 为 mapper 接口类型，value 为代理对象工厂
            configuration.addMapper(mapperInterface);
          } else {
            throw new BuilderException("A mapper element may only specify a url, resource or class, but not more than one.");
          }
        }
      }
    }
  }
  ...
}
  1. 总结
  • 解析配置文件
    在这里插入图片描述
  • 获取 SqlSessionFactory
    在这里插入图片描述
Gavinjou大笨象
关注
专栏目录
Spring Boot - 手撕SpringBoot - 七、启动配置原理（debugger走一遍SpringBoot启动） ： 创建SpringApplication对象、run方法、事件监听机制
LawssssCat的博客
01-12 364
七、启动配置原理 几个重要的事件回调机制 配置在META-INF/spring.factories ApplicationContextInitializer SpringApplicationRunListener 只需要放在ioc容器中 ApplicationRunner CommandLineRunner 启动流程： 1、创建SpringApplication对象 initialize(so...
『手撕 Mybatis 源码』03 - 解析映射配置文件
Gavinjou大笨象的博客
05-21 352
/</</</</
【手撕MyBatis源码】MyBatis启动流程、Configuration配置体系
十八岁讨厌编程的博客
06-13 1260
本文涉及Configuration概述、Configuration的核心作用与配置来源、配置元素、元素承载、配置文件解析等内容。
手撕MyBatis源码
helloworld工程师的博客
07-20 314
简介 什么是 MyBatis？ MyBatis 是一款优秀的持久层框架，它支持自定义 SQL、存储过程以及高级映射。MyBatis 免除了几乎所有的 JDBC 代码以及设置参数和获取结果集的工作。MyBatis 可以通过简单的 XML 或注解来配置和映射原始类型、接口和 Java POJO（Plain Old Java Objects，普通老式 Java 对象）为数据库中的记录。 摘自mybatis官网 官网地址https://mybatis.org/mybatis-3/zh/index.html.
思维导图手撕MyBatis源码
十八岁讨厌编程的博客
04-11 1349
使用思维导图理解MyBatis源码
『手撕 Mybatis 源码』05 - SqlSession 执行主流程
Gavinjou大笨象的博客
06-10 670
SqlSession 执行主流程 获取 BoundSql 经过加载完所有配置之后，继续梳理执行 sql 的过程 public class MybatisTest { @Test public void test1() throws IOException { ... // 4. 委派给 Executor 来执行，Executor 执行时又会调用很多其他组件（参数设置、解析 sql 的获取，sql 的执行、结果集的封装） User user = sqlSession.selectOne("u
Mybatis手撕源码（全网最细）
qq_72239654的博客
12-22 1015
随着行业的趋势发展越来越好，想要高薪资不是学习这个框架怎么使用，而是吃透你以后要上班经常用到的技术。比如说Mybatis这个框架，现在java开发工程师使用的最多的就是mybatis框架做为我们的访问层框架，我们应该去熟悉它的一个运行流程，和代理的机制。
一行行手撕mybatis源码
weixin_44162368的博客
01-30 247
一、 首先介绍几个类。 1、SqlSessionFactoryBuilder 用来构建SqlSessionFactory (默认为DefaultSqlSessionFactory) 2、SqlSessionFactory sqlsession的创建工厂接口。 3、XMLConfigBuilder 用来构建生成Configuration类（全局配置类，也就是mybatis的配置文件对用的java类）。 4、XPathParser 位于XMLConfigBuilder ，用来读取xml文件流，解析的各个标签，
『手撕 Mybatis 源码』09 - MyBatis 插件
Gavinjou大笨象的博客
06-30 195
用于定义插件的类指定要拦截哪个对象里面哪个方法// 详细的配置要拦截那些对象里面的那些方法 }由于一个拦截器可以同时拦截多个对象的多个方法，，所以就使用了Signture数组，该注解定义了拦截的完整信息// 拦截的类 Class <?> type();// 举例：type = StatementHandler.class // 拦截的方法 String method();// 举例：method = "prepare" // 拦截方法的参数 Class <?
『手撕 Mybatis 源码』04 - 创建 sqlSession
Gavinjou大笨象的博客
05-22 350
【代码】『手撕 Mybatis 源码』04 - 创建 sqlSession。
Mybatis动态代理的原理详解，mybatis的分页原理
m0_64384350的博客
12-09 166
package com.xiongxin.mybatis; import com.alibaba.fastjson.JSON; import com.xiongxin.mybatis.entity.User; import com.xiongxin.mybatis.mapper.UserMapper; import org.apache.ibatis.io.Resources; import org.apache.ibatis.session.SqlSession; import org.apache.ib
做了5年Java，目前最全的Java架构师成长路线，手撕面试官
m0_56662269的博客
05-04 351
前言 SQL 语句执行慢的原因是面试中经常会被问到的，对于服务端开发来说也是必须要关注的问题。 在生产环境中，SQL 执行慢是很严重的事件。那么如何定位慢 SQL、慢的原因及如何防患于未然。接下来带着这些问题让我们开启本期之旅！ 正文 如果你参加过一些大厂面试，肯定会遇到一些开放性的问题： 1、 写一段程序，让其运行时的表现为触发了5次Young GC、3次Full GC、然后3次Young GC； 2、 如果一个Java进程突然消失了，你会怎么去排查这种问题？ 3、 给了一段Spring加载Bean的
2024-JAVA-大数据-面试汇总_大数据java部门面试(1)
2401_84141419的博客
04-27 729
1,sex 改为age,非空，默认值为02 统计035号课程分数大于036号课程分数的学生ID3 统计所有003班学生各门功课的课程名称和平均分以上是所有的面试题，在写sql的时候，卡了好久，因为好久没写过三表联查，子查询的sql，差不多忘了，后来下线时，一度以为自己挂了，但是过了一个多小时之后，看了一下状态，面试一轮通过，可能是面试官看我前面的问题答得还可以让我过吧。只是这问题量着实有点多。希望尽快约下轮面试。
应届生校招Java研发岗需要学习哪些知识点？--凌晨写作
Java学习
12-23 4643
可能 2019 年马上就要结束了，21 届秋招的同学已经感觉到紧张感了。最近很多同学问我关于校招 Java研发工程师 岗位的要求，因为只有先知道了要求，再结合自身的情况，做好学习计划。 最近都在忙着写毕业论文，所以公众号干货文章更新的比较慢。上面截图这位同学一直等着我的这篇文章，我觉得不能再拖了，那就加班干吧！写到这里的时间是：2019.12.21 : 01.51。不知道这篇文章最后能对多...
MybatisPlus的LambdaQueryWrapper用法
2301_79693537的博客
08-21 5452
【代码】MybatisPlus的LambdaQueryWrapper用法。
HashMap为什么线程不安全？
最新发布
rnnf_yyds的博客
11-03 130
HashMap底层是基于数组 + 链表（在 Java 8 以后，当链表长度超过一定阈值时会转换为红黑树）的数据结构。在多线程环境下，当多个线程同时对HashMap进行put操作时，可下面这种情况：假设两个线程 A 和 B 同时执行put操作，它们计算出的插入位置相同（假设为index线程 A 先获取到了当前index位置的节点，在它还没来得及将新节点插入链表（或树）时，线程 B 也获取到了这个位置的节点。
[自用，更新自day5]瑞吉外卖代码及笔记
lapiii的博客
11-01 809
当使用ThreadLocal维护变量时，ThreadLocal为每个使用该变量的线程提供独立的变量副本，所以每一个线程都可以独立地改变自己的副本，而不会影响其它线程所对应的副本。Mybatis Plus公共字段自动填充，也就是在插入或者更新的时候为指定字段赋予指定的值，使用它的好处就是可以统一对这些字段进行处理，避免了重复代码。因为在分页查询的Dish的records(菜品记录中)，只有这个菜品所属的categoryId，但是我们需要分页的时候展示的是菜品名字。
JAVA 插入 JSON 对象到 PostgreSQL
qq_52143611的博客
10-30 864
在现代软件开发中，由于 JSON 数据的轻量和通用性，处理 JSON 数据已经变得无处不在。PostgreSQL凭借其对 JSON 的强大支持，为存储和查询 JSON 数据提供了出色的平台。为了将JSON数据保存到PostgreSQL数据库中，我们可以将JSON数据转换为PostgreSQL的JSONB类型数据，然后将其存储在数据库中。在Java中，我们可以使用JDBC或者基于ORM框架的方式来实现这一功能。
SpringSession源码分析
lkr_lkr的博客
11-01 249
默认对常规Session的理解和使用，如何使用Set-Cookie。
mybatis.mapper-locations配置
06-06
### 回答1： mybatis.mapper-locations配置是MyBatis框架中的一个配置项，用于指定Mapper映射文件的位置。Mapper映射文件是MyBatis框架中用于描述SQL语句与Java方法之间映射关系的XML文件，通过mybatis.mapper-locations配置可以告诉MyBatis框架Mapper映射文件所在的路径。该配置项可以在MyBatis的配置文件中进行配置，例如： <configuration> <mappers> <mapper resource="com/example/mapper/UserMapper.xml"/> </mappers> </configuration> 上述配置中，mybatis.mapper-locations配置项指定了UserMapper.xml文件所在的路径。在实际应用中，我们可以将Mapper映射文件放置在classpath下的任意位置，然后通过mybatis.mapper-locations配置项进行指定。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值