mybatis-config.xml是 MyBatis 的核心配置文件，用于配置整个 MyBatis 框架的全局行为，比如环境（数据源）、事务、类型别名、插件、Mapper 映射等。

示例：

<?xml version="1.0" encoding="UTF-8" ?> <!DOCTYPE configuration PUBLIC "-//mybatis.org//DTD Config 3.0//EN" "http://mybatis.org/dtd/mybatis-3-config.dtd"> <configuration> <!-- 映入外部的properties文件 --> <properties resource="db.properties"/> <!-- 开启Mybatis对标准日志的视线 --> <settings> <setting name="logImpl" value="SLF4J"/> </settings> <environments default="development"> <!-- 每一个environment对应一个SqlSessionFactory --> <environment id="development"> <!-- 事务管理器 --> <transactionManager type="JDBC"/> <dataSource type="POOLED"> <property name="driver" value="${jdbc.driver}"/> <property name="url" value="${jdbc.url}"/> <property name="username" value="${jdbc.username}"/> <property name="password" value="${jdbc.password}"/> </dataSource> </environment> </environments> <!-- 执行XxxMapper.xml文件的路径 --> <!-- resource路径自动会从根路径下开始查找资源 --> <mappers> <mapper resource="CarMapper.xml"/> </mappers> </configuration>

一、xml配置文件的开头：

1、任意的xml文件的首行，都是如下的配置：

<?xml version="1.0" encoding="UTF-8" ?>

2、xml文件中根标签的名字

3、dtd是对xml文件的约束：能有什么标签，标签的顺序，标签的属性，有哪些子标签......

二、<environments>：环境标签

可以配置多个环境，一个环境对应一个sqlsessionFactory对象。

在java中创建sqlSessionFactory的时候，可以指定环境的id，表明，用哪一个数据库创建的sqlSessionFactory：

SqlSessionFactoryBuilder sqlSessionFactoryBuilder = new SqlSessionFactoryBuilder(); // 两种方式创建sqlSessionFactory // 1、没有指明具体的environment中的id，则用默认的environment SqlSessionFactory sqlSessionFactory1 = sqlSessionFactoryBuilder.build(Resources.getResourceAsStream("mybatis-config.xml")); // 2、指明具体的environment中的id SqlSessionFactory sqlSessionFactory2 = sqlSessionFactoryBuilder.build(Resources.getResourceAsStream("mybatis-config.xml"), "mybatisDB");

2-1、什么叫一个数据库对应一个sqlsessionfactory对象

1、SqlSessionFactory 是什么？

先拆解这个名字：

SqlSessionFactory = 生产 "数据库会话" 的工厂

// 1. 先建工厂（全局只需要一个，很"重"） SqlSessionFactory factory = new SqlSessionFactoryBuilder() .build(inputStream); // 读取 mybatis-config.xml // 2. 工厂生产会话（每次操作数据库都要新开一个） SqlSession session = factory.openSession(); // 3. 用会话执行 SQL UserMapper mapper = session.getMapper(UserMapper.class); User user = mapper.selectById(1); // 4. 用完关闭会话（轻量，用完即弃） session.close();

2、为什么说"一个数据库对应一个"？

核心原因：SqlSessionFactory 太"重"了

它"重"在哪里？

┌─────────────────────────────────────────┐ │ SqlSessionFactory 里面装着什么 │ ├─────────────────────────────────────────┤ │ 1. 数据库连接池配置（连接池初始化） │ │ 2. 所有 Mapper XML 的解析结果（缓存） │ │ 3. 数据源 DataSource（连接信息） │ │ 4. 全局配置（缓存、插件、类型别名等） │ │ 5. 事务管理器配置 │ └─────────────────────────────────────────┘

这些资源创建一次开销很大，所以要全局复用！

类比理解

想象 SqlSessionFactory 是一家银行的总行：

总行（SqlSessionFactory） ├── 金库（连接池）← 初始化很费劲 ├── 所有客户档案（Mapper 配置）← 加载很费时 ├── 规章制度（全局配置） │ ├── 柜台1（SqlSession）← 轻量，客户来了就开 ├── 柜台2（SqlSession）← 用完就关 └── 柜台3（SqlSession）

一家银行（数据库）只需要一个总行（Factory），但有很多柜台（Session）服务客户。

3、代码层面的对应关系

单数据库（最常见）

// mybatis-config.xml 里配置了一个数据库 // <environment id="development">...</environment> // 全局只创建一个 Factory public class MyBatisUtil { private static SqlSessionFactory factory; static { InputStream is = Resources.getResourceAsStream("mybatis-config.xml"); factory = new SqlSessionFactoryBuilder().build(is); // ← 只执行一次！ } public static SqlSession getSession() { return factory.openSession(); // ← 每次需要就新开一个 } }

使用场景：

// 用户 A 来查询 SqlSession session1 = MyBatisUtil.getSession(); // 用户 B 来插入 SqlSession session2 = MyBatisUtil.getSession(); // 用户 C 来更新 SqlSession session3 = MyBatisUtil.getSession(); // 三个 Session，但共用一个 Factory！

4、如果有多个数据库呢？

那就需要多个 SqlSessionFactory！

// 数据库 1：用户库（user_db） InputStream is1 = Resources.getResourceAsStream("mybatis-user.xml"); SqlSessionFactory userFactory = new SqlSessionFactoryBuilder().build(is1); // 数据库 2：订单库（order_db） InputStream is2 = Resources.getResourceAsStream("mybatis-order.xml"); SqlSessionFactory orderFactory = new SqlSessionFactoryBuilder().build(is2); // 数据库 3：日志库（log_db） InputStream is3 = Resources.getResourceAsStream("mybatis-log.xml"); SqlSessionFactory logFactory = new SqlSessionFactoryBuilder().build(is3);

对应关系：

5、为什么不能多个数据库共用一个 Factory？

因为Factory 在创建时就绑定了数据源：

<!-- mybatis-config.xml --> <environments default="development"> <environment id="development"> <!-- 这里的数据源一旦确定，Factory 就绑死了这个数据库 --> <dataSource type="POOLED"> <property name="driver" value="com.mysql.cj.jdbc.Driver"/> <property name="url" value="jdbc:mysql://localhost:3306/user_db"/> <property name="username" value="root"/> <property name="password" value="123456"/> </dataSource> </environment> </environments>

一个 Factory 只能对应一个<dataSource>配置！

6、总结图

┌─────────────────────────────────────────────┐ │ 你的 Java 应用 │ ├─────────────────────────────────────────────┤ │ │ │ ┌─────────────────┐ ┌─────────────┐ │ │ │ SqlSessionFactory │ │ user_db │ │ │ │ (userFactory) │◄──►│ 用户数据库 │ │ │ └─────────────────┘ └─────────────┘ │ │ │ │ │ ┌────────┴────────┐ │ │ ▼ ▼ │ │ SqlSession1 SqlSession2 ← 线程1、线程2 │ │ (查用户) (改用户) ← 用完就关闭 │ │ │ │ ┌─────────────────┐ ┌─────────────┐ │ │ │ SqlSessionFactory │ │ order_db │ │ │ │ (orderFactory) │◄──►│ 订单数据库 │ │ │ └─────────────────┘ └─────────────┘ │ │ │ │ │ ┌────────┴────────┐ │ │ ▼ ▼ │ │ SqlSession3 SqlSession4 │ │ (查订单) (插订单) │ │ │ └─────────────────────────────────────────────┘

7、一句话总结

SqlSessionFactory 是"数据库专属工厂"，创建时绑定了特定的数据库连接信息，所以一个数据库对应一个 Factory；

而SqlSession 是工厂生产的"临时会话"，每次操作数据库都新建一个，用完即关。

8、多个数据库config文件 VS 多个<environment>标签

一个mybatis-config.xml里确实可以有多个<environment>，但SqlSessionFactory创建时只能选一个！

<!-- mybatis-config.xml --> <environments default="development"> <!-- 默认用哪个 --> <environment id="development"> <!-- 环境1：开发库 --> <dataSource type="POOLED"> <property name="url" value="jdbc:mysql://localhost:3306/db1"/> </dataSource> </environment> <environment id="production"> <!-- 环境2：生产库 --> <dataSource type="POOLED"> <property name="url" value="jdbc:mysql://localhost:3306/db2"/> </dataSource> </environment> </environments>

关键点：SqlSessionFactoryBuilder.build()时只能指定一个 environment！

// 方式1：不指定，用 default（即 development） SqlSessionFactory factory1 = new SqlSessionFactoryBuilder().build(inputStream); // 方式2：指定 environment SqlSessionFactory factory2 = new SqlSessionFactoryBuilder() .build(inputStream, "production"); // ← 只能选一个！

默认是id="development"。

（1）、为什么我说"多个数据库要多个 Factory"？

场景1：多环境切换（开发/测试/生产）

这是MyBatis 设计<environments>的真正目的——同一套代码，不同环境切换：

开发时：build(inputStream, "development") → 连 db1 测试时：build(inputStream, "test") → 连 db2 上线时：build(inputStream, "production") → 连 db3

特点：同一时间只连一个数据库！

场景2：同时连多个数据库（这才是我说的）

比如你的系统要同时操作：

• user_db（用户库）

• order_db（订单库）

• log_db（日志库）

这时候你需要同时存在 3 个活跃的 Factory：

// 配置文件1：用户库 InputStream is1 = Resources.getResourceAsStream("mybatis-user.xml"); SqlSessionFactory userFactory = new SqlSessionFactoryBuilder().build(is1); // 配置文件2：订单库 InputStream is2 = Resources.getResourceAsStream("mybatis-order.xml"); SqlSessionFactory orderFactory = new SqlSessionFactoryBuilder().build(is2); // 配置文件3：日志库 InputStream is3 = Resources.getResourceAsStream("mybatis-log.xml"); SqlSessionFactory logFactory = new SqlSessionFactoryBuilder().build(is3);

（2）、对比：两种方式的本质区别

（3）、能不能一个 XML 配多个数据库同时用？

可以，但有点别扭，需要你自己管理：

<!-- mybatis-config.xml --> <environments default="user_db"> <environment id="user_db">...</environment> <environment id="order_db">...</environment> </environments>

// 自己建两个 Factory InputStream is = Resources.getResourceAsStream("mybatis-config.xml"); SqlSessionFactory userFactory = new SqlSessionFactoryBuilder() .build(is, "user_db"); // ⚠️ 问题：inputStream 只能读一次！上面读完了，这里要重新读 InputStream is2 = Resources.getResourceAsStream("mybatis-config.xml"); SqlSessionFactory orderFactory = new SqlSessionFactoryBuilder() .build(is2, "order_db");

这样写很别扭，所以通常直接拆成多个 XML 文件，更清晰。

（4）、Spring 中的优雅做法（实际开发常用）

在 Spring 项目里，根本不用 XML，直接配多个数据源：

@Configuration public class DataSourceConfig { @Bean public SqlSessionFactory userSqlSessionFactory() { DataSource ds = createDataSource("jdbc:mysql://localhost:3306/user_db"); return new SqlSessionFactoryBean() {{ setDataSource(ds); }}.getObject(); } @Bean public SqlSessionFactory orderSqlSessionFactory() { DataSource ds = createDataSource("jdbc:mysql://localhost:3306/order_db"); return new SqlSessionFactoryBean() {{ setDataSource(ds); }}.getObject(); } }

（5）、总结

核心记住：

<environment>是"选项"，不是"多开"。

SqlSessionFactory是"单选后的结果"，不是"多选"。

三、Mybatis的事务管理器

<transactionManager>标签：

1、作用：配置事务管理器。指定mybatis具体使用什么方式去管理事务。

2、type属性有两个值：

• 第一个：JDBC：使用原生的JDBC代码来管理事务。
• 第二个：MANAGED：mybatis不再负责事务的管理，将事务管理交给其它的JEE(JavaEE)容器来管理。例如：spring

3、大小写无所谓。不区分大小写。但是不能写其他值。只能是二选一： jdbc、managed

4、在mybatis中提供了一个事务管理器接口：Transaction 该接口下有两个实现类：

• JdbcTransaction
• ManagedTransaction

如果type="JDBC"，那么底层会实例化JdbcTransaction对象。

如果type="MANAGED"，那么底层会实例化ManagedTransaction。

四、dataSource配置

3-1、基本配置介绍

1、dataSource被称为数据源。

2、dataSource作用是什么？

为程序提供Connection对象。

【注意】：

但凡是给程序提供Connection对象的，都叫做数据源。

3、数据源实际上是一套规范（接口）。

JDK中有这套规范：javax.sql.DataSource（这个数据源的规范，这套接口实际上是JDK规定的。）

4、我们自己也可以编写数据源组件，只要实现javax.sql.DataSource接口就行了。实现接口当中所有的方法。这样就有了自己的数据源。

比如你可以写一个属于自己的数据库连接池（数据库连接池是提供连接对象的，所以数据库连接池就是一个数据源）。

5、常见的数据源组件有哪些呢【常见的数据库连接池有哪些呢】？

• 阿里巴巴的德鲁伊连接池：druid
• c3p0
• dbcp
• ....

6、type属性用来指定数据源的类型，就是指定具体使用什么方式来获取Connection对象：

type属性有三个值：必须是三选一。

type="[UNPOOLED|POOLED|JNDI]"

• UNPOOLED：不使用数据库连接池技术。每一次请求过来之后，都是创建新的Connection对象。
• POOLED：使用mybatis自己实现的数据库连接池。
• JNDI：集成其它第三方的数据库连接池。

3-2、JNDI

JNDI是一套规范，大部分web容器都实现了这个规范：例如Tomcat、Jetty、WebLogic、WebSphere。这些服务器（容器）都实现了JNDI规范。

所以，可以把对应的连接池，配置到服务器（容器）中，如：druid配置到Tomcat中，然后Tomcat会给druid提供一个上下文的名称，将上下文的名称配到对应的<datasource>位置即可。

使用<dataSource type="JNDI">就是告诉 MyBatis：别自己创建数据库连接了，去应用服务器（Tomcat/GlassFish/WebLogic）拿现成的连接池资源。

MyBatis 的<dataSource>标签本身并不直接指定连接池类型，而是通过type 属性来选择使用哪种连接池实现。

不同数据库连接池的配置：

• 纯mybatis项目
  • 自定义数据库连接池：DataSourceFactory
  • JNDI方式（Tomcat容器）
• mybatis + spring项目
• mybatis + springboot项目

查看：Mybatis11-不同的数据库连接池的配置-CSDN博客

3-3、type = "POOLED"和UNPOOLED对比

测试代码：

@Test public void testType() throws Exception{ SqlSessionFactoryBuilder sqlSessionFactoryBuilder = new SqlSessionFactoryBuilder(); SqlSessionFactory sqlSessionFactory = sqlSessionFactoryBuilder.build(Resources.getResourceAsStream("mybatis-config.xml")); // SqlSessionFactory可以创建多个SqlSession! SqlSession sqlSession = sqlSessionFactory.openSession(); Object selectById = sqlSession.selectOne("selectById", 12); System.out.println(selectById); sqlSession.commit(); sqlSession.close(); // 第二次创建 SqlSession sqlSession2 = sqlSessionFactory.openSession(); Object selectById2 = sqlSession2.selectOne("selectById", 12); System.out.println(selectById2); sqlSession2.commit(); sqlSession2.close(); }

情况一：type = "UNPOOLED"

两个connection对象不一样！

情况二：type = "POOLED"

同一个connection对象！

五、property标签

在 MyBatis 的mybatis-config.xml配置文件中，<properties>标签用于引入外部属性文件或者在XML 中内联配置参数，这些参数可以被用于整个配置文件中的占位符（${}）替换，例如数据库连接、分页插件参数等。

一句话理解：

<properties>就是给 MyBatis 提供参数值的地方，支持从外部.properties文件读取，也可以直接在 XML 中写死键值对，用于${xxx}占位符替换。

4-1、用法示例 1：引入外部属性文件

文件结构

src/ ├── mybatis-config.xml └── db.properties

db.properties 内容：

jdbc.driver=com.mysql.cj.jdbc.Driver jdbc.url=jdbc:mysql://localhost:3306/mydb jdbc.username=root jdbc.password=123456

mybatis-config.xml 内容：

<configuration> <!-- 映入外部的properties文件 --> <properties resource="db.properties"/> <environments default="development"> <environment id="development"> <transactionManager type="JDBC"/> <dataSource type="POOLED"> <property name="driver" value="${jdbc.driver}"/> <property name="url" value="${jdbc.url}"/> <property name="username" value="${jdbc.username}"/> <property name="password" value="${jdbc.password}"/> </dataSource> </environment> </environments> </configuration>

resource 路径是 classpath 相对路径
示例：resource="db.properties"表示类路径下的db.properties

【备注】：

不建议！

【注意】：

<properties resource="db.properties"/>

这行代码的作用是：

加载db.properties文件到 MyBatis 的配置上下文中。

MyBatis 会把文件里的所有key-value 对都加载进来，然后${xxx}就可以引用这些值了。

4-2、用法示例 2：在 XML 中内联写属性

<configuration> <properties> <property name="jdbc.driver" value="com.mysql.cj.jdbc.Driver"/> <property name="jdbc.url" value="jdbc:mysql://localhost:3306/mydb"/> <property name="jdbc.username" value="root"/> <property name="jdbc.password" value="123456"/> </properties> <environments default="development"> <environment id="development"> <transactionManager type="JDBC"/> <dataSource type="POOLED"> <property name="driver" value="${jdbc.driver}"/> <property name="url" value="${jdbc.url}"/> <property name="username" value="${jdbc.username}"/> <property name="password" value="${jdbc.password}"/> </dataSource> </environment> </environments> </configuration>

4-3、属性优先级（默认行为）：

如果你同时指定了外部文件（resource或url）和内联属性（<property>子标签），那么：

• 内联属性优先，会覆盖外部文件中相同的属性值。

MyBatis 的${}取值有优先级，如果多处定义了同名 key：

1. Java 方法传入的参数

这是指在代码中通过编程方式传入配置，而不是通过 XML 文件。

示例代码：

// 创建 Properties 对象 Properties props = new Properties(); props.setProperty("jdbc.username", "admin"); props.setProperty("jdbc.password", "secret"); // 构建 SqlSessionFactory 时，把 props 作为参数传入 InputStream inputStream = Resources.getResourceAsStream("mybatis-config.xml"); SqlSessionFactory factory = new SqlSessionFactoryBuilder().build(inputStream, props);

作用：你可以在运行时动态传入配置，覆盖 XML 中或 properties 文件中的值。

典型场景：

• 密码需要加密，解密后在代码中传入

• 不同环境（开发/测试/生产）用不同的配置

• 配置需要从外部配置中心（如 Apollo、Nacos）获取

2. 系统环境变量

这是指操作系统级别的环境变量，比如 Linux/Windows 中通过export或系统设置定义的环境变量。

示例：

在 Linux 终端执行：

export jdbc_url=jdbc:mysql://prod-server:3306/mydb

或者在 Windows 系统环境变量中设置jdbc_url=xxx

然后 MyBatis 的 XML 中可以直接用：

<property name="url" value="${jdbc_url}"/>

作用：把敏感配置或环境相关配置放到操作系统层面，不写入代码仓库。

典型场景：

• 生产环境的数据库密码不放在代码里

• Docker/K8s 容器通过环境变量注入配置

• CI/CD 流水线动态设置环境变量

什么是windows系统环境变量

Windows 设置环境变量的位置

方法：系统属性 → 环境变量

1. 右键"此电脑"→ 选择"属性"

2. 点击"高级系统设置"

3. 点击"环境变量"按钮

4. 在弹出的窗口中，你可以看到两个区域：

   • 用户变量（仅当前用户有效）

   • 系统变量（所有用户有效）

然后新建变量：

点击"新建"按钮，不是编辑Path：

就像这样：

变量名: jdbc_url 变量值: jdbc:mysql://localhost:3306/mydb

验证是否设置成功

打开CMD 命令提示符，输入：

echo %jdbc_url%

如果输出你设置的值，说明成功了。

为什么实际很少这样用？

这种方式在 Windows 开发中不太常见，原因：

实际更常见的做法：

// 从配置文件读取（开发环境） // 或从环境变量读取（Docker/K8s 部署） String url = System.getenv("jdbc_url"); // 读取系统环境变量

在 Linux/Docker 中更自然：

export jdbc_url=jdbc:mysql://prod:3306/mydb java -jar myapp.jar

3、优先级总结（从高到低）

1. XML 中 <properties> 标签内直接定义的 <property> ↓ 2. resource/url 引入的外部 .properties 文件 ↓ 3. Java 代码 build() 方法传入的 Properties 参数 ↓ 4. 系统环境变量（如 export 设置的） ↓ 5. Java 系统属性（如 -Djdbc.url=xxx 启动参数）

核心规则：后加载的会覆盖先加载的同名 key，所以优先级高的会"赢"。

4、实际工作中的常见用法

// 常见做法：先加载配置文件，再用代码覆盖敏感信息 Properties props = new Properties(); // 从安全的地方获取真实密码（如配置中心、密钥管理服务） String realPassword = getPasswordFromVault(); props.setProperty("jdbc.password", realPassword); SqlSessionFactory factory = new SqlSessionFactoryBuilder() .build(inputStream, props);

这样db.properties里可以放个占位密码，真实密码在运行时注入，兼顾开发便利和生产安全。

4-4、常见属性用途

4-5、SqlSessionFactory对象

不是"所有信息都在 SqlSessionFactory 中"，而是：

MyBatis 配置文件的解析结果 + 加载的 properties → 生成一个 SqlSessionFactory 实例

SqlSessionFactory是解析后的产物，不是容器本身。

具体流程

db.properties ──┐ ├──→ MyBatis 解析配置 ──→ SqlSessionFactory 实例 mybatis-config.xml ┘ ↑ │ 解析时：${jdbc.xxx} 被替换为实际值

关键点：

验证：SqlSessionFactory 里存的是什么？

// 构建完成后，SqlSessionFactory 内部大概是这样的结构： SqlSessionFactory factory = new SqlSessionFactoryBuilder().build(inputStream); // factory 内部已经存好了： // - DataSource 对象（包含真实的 url、username、password） // - Mapper 接口的代理工厂 // - 缓存配置、插件等 // 没有 properties 文件，也没有 ${jdbc.xxx} 这种占位符

SqlSessionFactory是"编译后"的结果，不是"源代码"。

SqlSessionFactory是工厂对象，它的职责是：

• 根据配置创建数据库连接

• 管理 Mapper 接口的代理

• 提供SqlSession实例

它内部存储的是解析后的、可直接使用的对象，而不是原始的 XML 文本或 properties 文件内容。