当前位置： 首页 > news >正文

MyBatis 进阶：连接池、动态 SQL 与多表关联查询

news 2025/7/12 12:06:10

MyBatis 作为一款灵活的持久层框架，除了基础的 CRUD 操作，还提供了连接池管理、动态 SQL 以及多表关联查询等高级特性。本文将从连接池原理出发，深入讲解动态 SQL 的常用标签，并通过实例演示一对多、多对多等复杂关联查询的实现，帮助你掌握 MyBatis 的进阶用法。

一、MyBatis 连接池：提升数据库交互性能

连接池是存储数据库连接的容器，它的核心作用是避免频繁创建和关闭连接，从而减少资源消耗、提高程序响应速度。在 MyBatis 中，连接池的配置通过dataSource标签的type属性实现，支持三种类型的连接池：

1. 连接池类型详解

  • POOLED：使用 MyBatis 内置的连接池
    MyBatis 会维护一个连接池，当需要连接时从池中获取，使用完毕后归还给池，避免频繁创建连接。适用于高并发场景，是开发中最常用的类型。

    配置示例：

    <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>

  • UNPOOLED：不使用连接池
    每次执行 SQL 时都会创建新的连接，使用后直接关闭。适用于低并发场景，性能较差，一般仅用于简单测试。

    配置示例：

    <dataSource type="UNPOOLED"><!-- 同POOLED的属性配置 -->
</dataSource>

  • JNDI：依赖容器的连接池
    由 Web 容器（如 Tomcat）提供连接池管理，MyBatis 仅负责从容器中获取连接。适用于Java EE 环境，需在容器中提前配置连接池。

    配置示例：

    <dataSource type="JNDI"><property name="data_source" value="java:comp/env/jdbc/mybatis_db"/>
</dataSource>

2. 连接池的优势

  • 资源复用：连接池中的连接可重复使用，减少创建连接的开销；
  • 响应速度：提前创建连接，避免 SQL 执行时的连接创建延迟；
  • 并发控制：通过最大连接数限制，防止数据库因连接过多而崩溃。

二、动态 SQL：灵活拼接 SQL 语句

在实际开发中，查询条件往往是动态变化的（如多条件筛选、批量操作等）。MyBatis 的动态 SQL 标签可以优雅地解决 SQL 语句拼接问题，避免手动拼接导致的语法错误和 SQL 注入风险。

1. <if>标签：条件判断

<if>标签用于根据参数值动态生成 SQL 片段，常用来处理多条件查询。

示例场景：根据用户名和性别查询用户（参数非空时才添加条件）。

  • UserMapper 接口：

    public interface UserMapper {// 条件查询用户List<User> findByWhere(User user);
}

  • UserMapper.xml 配置：

    <select id="findByWhere" parameterType="user" resultType="user">select * from user<where><!-- 当username非空且非空字符串时，添加条件 --><if test="username != null and username != ''">and username like #{username}</if><!-- 当sex非空且非空字符串时，添加条件 --><if test="sex != null and sex != ''">and sex = #{sex}</if></where>
</select>

  • 测试代码：

    @Test
public void testFindByWhere() {User user = new User();user.setUsername("%zz%"); // 模糊查询包含"zz"的用户名user.setSex("m");List<User> list = userMapper.findByWhere(user);// 遍历结果...
}

说明：test属性中的表达式用于判断参数是否有效，where标签会自动处理多余的and或or，避免 SQL 语法错误。

 

2. <foreach>标签：遍历集合

<foreach>标签用于遍历集合或数组，常用来处理in查询或批量操作。

场景 1：查询 ID 在指定集合中的用户（in查询）

  • User 实体类：添加存储 ID 集合的属性

    public class User {private List<Integer> ids; // 存储多个ID// 省略getter、setter
}

  • UserMapper 接口：

    List<User> findByIds(User user);

  • UserMapper.xml 配置：

    <select id="findByIds" parameterType="user" resultType="user">select * from user<where><!-- collection：集合属性名（此处为ids）open：SQL片段开头close：SQL片段结尾separator：元素分隔符item：遍历的元素别名--><foreach collection="ids" open="id in (" separator="," close=")" item="id">#{id}</foreach></where>
</select>

  • 测试代码：

    @Test
public void testFindByIds() {User user = new User();List<Integer> ids = new ArrayList<>();ids.add(1);ids.add(2);ids.add(3);user.setIds(ids);List<User> list = userMapper.findByIds(user); // 查询ID为1、2、3的用户
}

 

场景 2：批量查询（or条件）

如需生成id = 1 or id = 2 or id = 3形式的 SQL，只需调整<foreach>的open和separator：

<foreach collection="ids" open="id = " separator="or id = " item="id">#{id}
</foreach>

3. <sql>与<include>标签：SQL 片段复用

对于频繁使用的 SQL 片段（如查询字段、表名等），可以用<sql>标签定义，再通过<include>标签引用，减少代码冗余。

示例：复用查询用户的 SQL 片段。

  • UserMapper.xml 配置：
    <!-- 定义SQL片段 -->
<sql id="userColumns">id, username, birthday, sex, address
</sql><!-- 引用SQL片段 -->
<select id="findAll" resultType="user">select <include refid="userColumns"/> from user
</select>

说明：id为片段唯一标识，refid指定要引用的片段 ID，适用于多表查询中重复的字段列表。

三、一对多查询：用户与账户的关联

在实际业务中，表之间往往存在关联关系（如用户与账户：一个用户可以有多个账户）。MyBatis 通过<collection>标签处理一对多关联查询。

1. 表结构与实体类设计

  • 用户表（user）：存储用户基本信息（id、username 等）；
  • 账户表（account）：存储账户信息，通过uid关联用户表（多对一关系）。

实体类设计：

  • Account 类（多对一：一个账户属于一个用户）：

    public class Account implements Serializable {private Integer id;private Integer uid; // 关联用户IDprivate Double money;// 关联的用户对象private User user; // 省略getter、setter
}

  • User 类（一对多：一个用户有多个账户）：

    public class User implements Serializable {private Integer id;private String username;// 关联的账户列表private List<Account> accounts; // 省略getter、setter
}

2. 多对一查询（账户关联用户）

查询所有账户，并关联查询所属用户的信息。

  • AccountMapper 接口：

    public interface AccountMapper {List<Account> findAll();
}

  • AccountMapper.xml 配置：

    <select id="findAll" resultMap="accountMap"><!-- 关联查询账户和用户 -->select a.*, u.username, u.address from account aleft join user u on a.uid = u.id
</select><!-- 定义结果映射 -->
<resultMap id="accountMap" type="account"><id property="id" column="id"/><result property="uid" column="uid"/><result property="money" column="money"/><!-- 关联用户对象（多对一） --><association property="user" javaType="user"><result property="username" column="username"/><result property="address" column="address"/></association>
</resultMap>

说明：<association>标签用于映射关联的单个对象，javaType指定对象类型。

 

3. 一对多查询（用户关联账户）

查询所有用户，并关联查询其名下的所有账户。

  • UserMapper 接口：

    public interface UserMapper {// 查询用户及关联的账户List<User> findOneToMany();
}

  • UserMapper.xml 配置：

    <select id="findOneToMany" resultMap="userAccountMap">select u.*, a.id as aid, a.money from user uleft join account a on u.id = a.uid
</select><resultMap id="userAccountMap" type="user"><id property="id" column="id"/><result property="username" column="username"/><result property="birthday" column="birthday"/><result property="sex" column="sex"/><result property="address" column="address"/><!-- 关联账户列表（一对多） --><collection property="accounts" ofType="account"><id property="id" column="aid"/> <!-- 注意别名避免与用户ID冲突 --><result property="money" column="money"/></collection>
</resultMap>

说明：<collection>标签用于映射关联的集合对象，ofType指定集合中元素的类型。

 

四、多对多查询：用户与角色的关联

多对多关系需要通过中间表实现（如用户与角色：一个用户可拥有多个角色，一个角色可分配给多个用户，通过user_role表关联）。

1. 表结构与实体类设计

  • 角色表（role）：存储角色信息（id、role_name 等）；
  • 中间表（user_role）：通过uid和rid关联用户表和角色表。

实体类设计：

  • Role 类（多对多：一个角色包含多个用户）：
    public class Role implements Serializable {private Integer id;private String role_name;private String role_desc;// 关联的用户列表private List<User> users;// 省略getter、setter
}

2. 多对多查询实现

查询所有角色，并关联查询拥有该角色的用户信息。

  • RoleDao 接口：

    public interface RoleDao {List<Role> findAll();
}

  • RoleDao.xml 配置：

    <select id="findAll" resultMap="roleMap">SELECT r.*, u.id as user_id, u.username FROM role rJOIN user_role ur ON r.id = ur.RIDJOIN user u ON u.id = ur.UID
</select><resultMap type="role" id="roleMap"><id property="id" column="id"/><result property="role_name" column="role_name"/><result property="role_desc" column="role_desc"/><!-- 关联用户列表（多对多） --><collection property="users" ofType="user"><id property="id" column="user_id"/> <!-- 别名避免与角色ID冲突 --><result property="username" column="username"/></collection>
</resultMap>

  • 测试代码：

    @Test
public void testFindAllRoles() {List<Role> roles = roleDao.findAll();for (Role role : roles) {System.out.println("角色：" + role.getRole_name());System.out.println("关联用户：" + role.getUsers());}
}

说明：多对多查询本质是双向的一对多查询，通过中间表建立关联，同样使用<collection>标签映射集合对象。

 

 

五、MyBatis 延迟加载策略

1. 延迟加载的概念

延迟加载（Lazy Loading）是一种数据库查询优化策略，其核心思想是：仅在需要使用关联数据时才进行实际查询。与立即加载（Eager Loading）相比，延迟加载避免了不必要的数据库访问，提高了系统性能。

对比示例（一对多关系）：

  • 立即加载：查询用户时，同时加载该用户的所有账户信息（即使后续可能不使用账户数据）。
  • 延迟加载：查询用户时，仅加载用户基本信息；当程序调用user.getAccounts()时，才会触发账户数据的查询。

2. 应用场景选择

场景加载策略示例
多对一关系立即加载查询账户时，同时加载所属用户
一对多 / 多对多延迟加载查询用户时，暂不加载账户信息

3. 多对一延迟加载实现

（1）配置文件示例
<!-- AccountMapper.xml -->
<resultMap type="Account" id="accountMap"><id column="id" property="id"/><result column="uid" property="uid"/><result column="money" property="money"/><!-- 配置延迟加载：通过select属性指定关联查询方法 --><association property="user" javaType="User" select="com.qcbyjy.mapper.UserMapper.findById" column="uid"><id column="id" property="id"/><result column="username" property="username"/></association>
</resultMap>
（2）核心配置参数
<!-- SqlMapConfig.xml -->
<settings><!-- 开启延迟加载功能 --><setting name="lazyLoadingEnabled" value="true"/><!-- 禁用积极加载（默认false，按需加载） --><setting name="aggressiveLazyLoading" value="false"/>
</settings>

 测试方法

@Testpublic void testFindAll1() throws IOException {// 先加载主配置文件，加载到输入流中InputStream inputStream = Resources.getResourceAsStream("SqlMapConfig.xml");// 创建SqlSessionFactory对象，创建SqlSession对象SqlSessionFactory factory = new SqlSessionFactoryBuilder().build(inputStream);// 创建SqlSession对象SqlSession session = factory.openSession();// 获取代理对象AccountMapper mapper = session.getMapper(AccountMapper.class);// 1. 查询主对象（账户）List<Account> accounts = mapper.findAll();System.out.println("===== 主查询已执行 =====");// 2. 遍历账户，但不访问关联的用户for (Account account : accounts) {System.out.println("账户ID：" + account.getId() + "，金额：" + account.getMoney());}System.out.println("===== 未访问关联对象 =====");// 3. 首次访问关联的用户for (Account account : accounts) {System.out.println("===== 开始访问用户 =====");System.out.println("用户名：" + account.getUser().getUsername()); // 触发懒加载System.out.println("===== 访问用户结束 =====");}// 关闭资源session.close();inputStream.close();}

执行findAll()时，日志仅输出账户表的查询 SQL 。遍历账户但不访问用户时，无新的 SQL 输出：

 

首次访问account.getUser()时，日志输出用户表的查询 SQL（按需加载）

 

（3）工作原理

当执行account.getUser()时，MyBatis 会：

  1. 检查lazyLoadingEnabled是否为true；
  2. 通过select属性调用UserMapper.findById(uid)方法；
  3. 将结果封装到Account.user属性中。

4. 一对多延迟加载实现

（1）配置文件示例
<!-- UserMapper.xml -->
<resultMap type="User" id="userMap"><id column="id" property="id"/><result column="username" property="username"/><!-- 配置延迟加载：集合属性 --><collection property="accounts" ofType="Account" select="com.qcbyjy.mapper.AccountMapper.findByUid" column="id"><id column="id" property="id"/><result column="money" property="money"/></collection>
</resultMap>
（2）延迟加载触发时机
List<User> users = userMapper.findAll();
for (User user : users) {// 调用getAccounts()时触发延迟查询System.out.println(user.getAccounts()); 
}

测试代码：

    @Testpublic void testFindAllq() throws Exception {// 调用方法List<User> list = mapper.findAll();for (User user : list) {System.out.println(user.getUsername());System.out.println(user.getAccounts());System.out.println("==============");}}

 

5. 延迟加载注意事项

  1. N+1 查询问题：延迟加载可能导致 N+1 查询（主查询 1 次，关联查询 N 次），需结合二级缓存优化。
  2. Session 生命周期：延迟加载需确保关联查询时SqlSession未关闭（可通过openSession(true)保持会话）。
  3. 序列化问题：延迟加载的对象在序列化时可能丢失代理状态，需通过<setting name="serializationFactory" value="..."/>配置。

七、MyBatis 缓存机制

1. 缓存的基本概念

缓存是一种内存临时存储技术，用于减少数据库访问次数，提高系统响应速度。适合缓存的数据特点：

  • 频繁查询但很少修改；
  • 数据一致性要求不高；
  • 数据量适中且访问频率高。

2. 一级缓存（SqlSession 级缓存）

（1）缓存原理
  • 作用域：每个SqlSession独享一个缓存实例；
  • 存储结构：底层使用PerpetualCache（基于HashMap实现）；
  • 生命周期：与SqlSession一致，session.close()后缓存销毁。
（2）缓存验证示例
@Test
public void testFirstLevelCache() {try (SqlSession session = sqlSessionFactory.openSession()) {UserMapper mapper = session.getMapper(UserMapper.class);// 第一次查询：触发SQLUser user1 = mapper.findById(1);// 第二次查询：命中缓存User user2 = mapper.findById(1);System.out.println(user1 == user2); // 输出true（同一对象）}
}

 

（3）缓存失效场景

以下操作会导致一级缓存清空：

  • session.clearCache()：手动清空缓存；
  • session.commit()/session.rollback()：事务提交或回滚；
  • 执行insert/update/delete操作（任何数据变更）。

3. 一级缓存源码分析

核心源码位于BaseExecutor类：

// BaseExecutor.java
@Override
public <E> List<E> query(MappedStatement ms, Object parameter, RowBounds rowBounds, ResultHandler resultHandler) throws SQLException {BoundSql boundSql = ms.getBoundSql(parameter);// 1. 创建缓存KeyCacheKey key = createCacheKey(ms, parameter, rowBounds, boundSql);// 2. 查询一级缓存return query(ms, parameter, rowBounds, resultHandler, key, boundSql);
}@Override
public <E> List<E> query(MappedStatement ms, Object parameter, RowBounds rowBounds, ResultHandler resultHandler, CacheKey key, BoundSql boundSql) throws SQLException {// 从本地缓存中获取List<E> list = localCache.getObject(key);if (list != null) {// 缓存命中handleLocallyCachedOutputParameters(ms, key, parameter, boundSql);return list;} else {// 缓存未命中，查询数据库return queryFromDatabase(ms, parameter, rowBounds, resultHandler, key, boundSql);}
}

4. 一级缓存的应用建议

  • 优势：无需额外配置，自动生效，适用于单次会话内的重复查询；
  • 局限：无法跨SqlSession共享，对长事务可能导致数据不一致；
  • 最佳实践：
    • 避免在同一SqlSession内进行重复查询；
    • 及时提交事务或关闭SqlSession以释放缓存资源。

八、延迟加载与一级缓存的协同工作

当延迟加载与一级缓存结合时，需注意：

  1. 关联查询缓存：延迟加载的关联对象（如user.getAccounts()）会被存入一级缓存；
  2. 会话隔离：不同SqlSession的延迟加载结果相互独立；
  3. 数据一致性：若主对象已缓存，关联对象的变更可能无法实时反映。

mysql缓存存的是语句，稍有修改就会更新缓存。一级缓存，输出的对象是同一个，二级缓存输出不同是因为通过序列化组装了两

一、一级缓存（SqlSession 级缓存）—— 同一个对象实例

1. 缓存本质与作用范围

一级缓存是 SqlSession 私有 的本地缓存，MyBatis 默认开启。在同一个 SqlSession 内，只要查询条件、SQL 语句相同，MyBatis 会直接从缓存取结果，不会重复访问数据库。

2. “输出对象是同一个” 的原因
  • 当执行查询时，MyBatis 会先检查一级缓存：若命中缓存，直接返回 缓存中存储的对象引用 。
  • 也就是说，多次查询拿到的是同一个 Java 对象实例（JVM 中同一个内存地址的对象 ）。例如：
try (SqlSession session = sqlSessionFactory.openSession()) {UserMapper mapper = session.getMapper(UserMapper.class);// 第一次查询，从数据库加载，存入一级缓存User user1 = mapper.getUserById(1);  // 第二次查询，命中一级缓存，直接返回 user1 的引用User user2 = mapper.getUserById(1);  System.out.println(user1 == user2); // 输出 true，是同一个对象实例
}

 

3. 缓存失效场景

当执行 update、insert、delete、commit、close 等操作时，一级缓存会被清空 。后续查询会重新从数据库加载数据，存入新的对象实例到缓存。

二、二级缓存（Mapper 级缓存）—— 不同对象实例（因序列化 / 反序列化）

1. 缓存本质与作用范围

二级缓存是 Mapper 作用域 的缓存，需手动开启（在 Mapper XML 或注解中配置 ）。它可以在多个 SqlSession 间共享，底层通常依赖序列化 / 反序列化机制存储数据 。

2. “输出不同对象” 的原因
  • 二级缓存存储的是 对象的序列化数据 （如 Java 对象先序列化为字节流，再存入缓存 ）。
  • 当不同 SqlSession 查询命中二级缓存时，MyBatis 会 反序列化 缓存中的字节流，重新生成一个新的 Java 对象实例 。例如：
// 开启二级缓存后，不同 SqlSession 测试
try (SqlSession session1 = sqlSessionFactory.openSession()) {UserMapper mapper1 = session1.getMapper(UserMapper.class);User user1 = mapper1.getUserById(1); session1.commit(); // 提交后，数据可能同步到二级缓存（取决于配置）
}try (SqlSession session2 = sqlSessionFactory.openSession()) {UserMapper mapper2 = session2.getMapper(UserMapper.class);User user2 = mapper2.getUserById(1); // 命中二级缓存，反序列化生成新对象System.out.println(user1 == user2); // 输出 false，是不同对象实例
}

 

3. 二级缓存的核心特点
  • 跨 SqlSession 共享：多个 SqlSession 可共用 Mapper 级的缓存数据；
  • 序列化存储：缓存数据需实现 Serializable 接口，存储和读取时会经历序列化 / 反序列化，因此每次命中缓存会生成新对象；
  • 缓存策略灵活：可配置 eviction（回收策略，如 LRU、FIFO ）、flushInterval（刷新间隔 ）、readOnly（是否只读 ）等。

三、一、二级缓存的核心差异对比

对比项一级缓存二级缓存
作用范围SqlSession 私有Mapper 作用域（跨 SqlSession 共享）
对象实例同一对象引用反序列化生成新对象
开启方式默认开启需手动配置（<cache> 标签或注解）
存储机制直接存对象引用存序列化后的字节流
数据一致性依赖 SqlSession 内操作，易维护需注意多表关联、更新同步问题

四、实际开发中的注意事项

  1. 一级缓存的 “隐式风险”：
    若在同一个 SqlSession 内，先查询再更新数据，由于一级缓存未及时清理（需手动 commit/close 触发 ），可能拿到旧数据。建议在增删改后，及时 commit 或 close SqlSession，保证缓存与数据库一致。

  2. 二级缓存的 “使用前提”：
    启用二级缓存时，实体类必须实现 Serializable 接口（否则序列化报错 ）；同时，若涉及多表关联查询，需注意缓存的更新策略（比如某张表数据变化后，关联的 Mapper 缓存需及时刷新 ）。

  3. 缓存的合理选择：

    • 一级缓存适合短生命周期的 SqlSession（如单次请求内的多次查询 ）；
    • 二级缓存适合查询频率高、数据变化少的场景（如系统字典表 ），但需谨慎处理数据更新后的缓存同步。

简单来说，一级缓存是 “同一个对象复用”，二级缓存是 “序列化后重新组装对象”，这种差异由它们的作用范围和存储机制决定。开发中根据业务场景合理利用缓存，既能提升性能，又能避免数据一致性问题～ 若你在实际配置或调试缓存时遇到具体问题（比如二级缓存不生效、序列化报错 ），可以接着展开说场景帮你分析 。

 

http://www.xdnf.cn/news/1103023.html

相关文章：

  • SpringBoot 使用注解获取配置文件中的值
  • 机器学习-06（Optimization-自动调整学习率）
  • FS820R08A6P2LB——英飞凌高性能IGBT模块，驱动高效能源未来！
  • 线程通信与进程通信的区别笔记
  • Java教程：JavaWeb ---MySQL高级
  • 从语音识别到智能助手：Voice Agent 的技术进化与交互变革丨Voice Agent 学习笔记
  • Matlab裁剪降水数据：1km掩膜制作实战
  • 从Markdown到PPT：用Python打造专业演示文稿转换器
  • axios 与 fetch 的区别
  • Android 开发中插桩
  • 微服务引擎 MSE 及云原生 API 网关 2025 年 6 月产品动态
  • Java 方法重载与类的构造器（一）
  • PDXP、UDP与HDLC协议技术解析：架构、应用与对比研究
  • NodeJs后端常用三方库汇总
  • UDP服务器的优缺点都包含哪些？
  • 森马服饰从 Elasticsearch 到阿里云 SelectDB 的架构演进之路
  • 静态路由综合配置实验报告
  • 政安晨【零基础玩转开源AI项目】ACE-Step —— 迈向音乐生成基础模型的重要一步：AI自动谱曲与自动演唱的免费开源框架部署实践
  • 林吉特危机下的技术革命：马来西亚金融系统升维作战手册
  • 2025人形机器动作捕捉技术研讨会于7月31日在京开启
  • 进制转换小题
  • 编码技术: PRBS， 8B/10B
  • 无锁队列：从零构建生产者-消费者数据结构
  • 数据结构 之 【链式二叉树】(C语言实现二叉树的前序中序后序层序遍历，节点个数、树的高度、第K层的节点个数、查找、完全二叉树的判别、销毁创建二叉树)
  • Redis5.0.5 漏洞
  • uni-app获取手机当前连接的WIFI名称
  • GIC控制器 （三）
  • 飞算JavaAI进阶：重塑Java开发范式的AI革命
  • 语音对话秒译 + 视频悬浮字 + 相机即拍即译：ViiTor 如何破局跨语言场景？
  • 上位机知识篇---Docker