跳到主要内容

7 篇博文 含有标签「架构」

架构 tag description

查看所有标签

MyBatisGX 批量操作:比 MyBatis-Plus 和 MyBatis-Flex 更好用、更快

· 阅读需 6 分钟

一、批量操作本该很简单​

项目里批量操作场景太常见了:

  • 导入 Excel 数据
  • 同步第三方接口数据
  • 定时任务批量落库
  • 状态批量更新

但翻开不同框架的文档,你会发现:这么基础的能力,复杂度差了好几档。


二、各框架是怎么写批量的​

先看代码,直接感受差距。

原生 MyBatis​

原生 MyBatis 要用真正的 JDBC batch,需要手动打开 ExecutorType.BATCH 的 Session,自己管理生命周期:

// Mapper 接口(单条插入)
void insert(User user);
// 调用方:手动管理 BatchSession
SqlSession sqlSession = sqlSessionFactory.openSession(ExecutorType.BATCH, false);
try {
UserMapper mapper = sqlSession.getMapper(UserMapper.class);
for (int i = 0; i < users.size(); i++) {
mapper.insert(users.get(i));
if ((i + 1) % 1000 == 0 || (i + 1) == users.size()) {
sqlSession.flushStatements(); // 手动 flush
}
}
sqlSession.commit();
} catch (Exception e) {
sqlSession.rollback();
throw e;
} finally {
sqlSession.close();
}

每次批量操作都要写这一套模板代码,容易遗漏 flush,也容易忘关 Session。

MyBatis-Plus​

批量操作在 IService 里,不在 Mapper 里。必须让 ServiceImpl 继承 ServiceImpl<Mapper, Entity>:

@Service
public class UserServiceImpl extends ServiceImpl<UserMapper, User> implements UserService {

public void importUsers(List<User> users) {
this.saveBatch(users, 500); // 只能通过 IService 的方法调
}
}

必须先有 Service 层、必须继承 ServiceImpl,DAO 层没有批量能力。

MyBatis-Flex​

BaseMapper 有个 insertBatch 方法,但它是 MyBatis for 循环,不是真正的 JDBC batch 协议。

真正的批量写法要用 Db.executeBatch:

Db.executeBatch(users, 1000, UserMapper.class, (mapper, user) -> mapper.insert(user));

能用,但 lambda + 类型 + 回调,写法比较重。

MyBatisGX​

userDao.insertBatch(list);
userDao.updateBatchById(list);
userDao.deleteBatchById(ids);

直接调 DAO,不需要继承任何东西,不需要任何工具类。


对比一下:

框架调用方式额外负担SQL 生成时机真 JDBC batch
原生 MyBatis手动 BatchSession手动管理 Session 生命周期手写是
MyBatis-PlusIService.saveBatch必须继承 ServiceImpl运行时是
MyBatis-FlexDb.executeBatchlambda + 类型 + 回调运行时是
MyBatisGXdao.insertBatch无启动期预生成是

三、为什么坚持这种设计​

DAO 是唯一入口​

批量操作本质上是数据访问层的能力。它不应该扩散到:

  • Service 层(MyBatis-Plus 的路子)
  • 全局静态 Db 工具(MyBatis-Flex 的路子)
  • 手动管理的 BatchSession(原生 MyBatis)

让它待在它该在的位置。

语义要直白​

insertBatch     = 批量插入
updateBatchById = 按主键批量更新
deleteBatchById = 按主键批量删除

方法名就是含义,不需要查文档。

分批大小可控​

默认 batchSize=1000,可以自己传:

userDao.insertBatch(list, 500);   // 每 500 条提交一次

不用担心数据量大了撑爆内存。


四、性能不打折​

先说结论:

批量插入:MyBatisGX ≈ 原生 MyBatis,比 Flex 快约 14%,比 Plus 快约 25%。 批量更新:MyBatisGX 与 Flex 差距约 5%,均优于 Plus。

测试环境:JVM -Xms1g -Xmx4g,单条记录约 10 个字段,每框架跑 15 次,去掉第 1 次冷启动取稳定区间。

批量插入 100 条​

框架稳定区间均值
MyBatisGX7ms ~ 17ms~10ms
原生 MyBatis6ms ~ 19ms~10ms
MyBatis-Flex10ms ~ 32ms~19ms
MyBatis-Plus10ms ~ 30ms~18ms

批量插入 1W 条​

框架稳定区间均值
MyBatisGX264ms ~ 409ms~320ms
原生 MyBatis239ms ~ 459ms~290ms
MyBatis-Flex293ms ~ 580ms~370ms
MyBatis-Plus350ms ~ 686ms~430ms

1W 条批量插入,MyBatisGX 比 MyBatis-Plus 快约 25%,比 MyBatis-Flex 快约 14%。

批量更新 100 条​

框架稳定区间均值
原生 MyBatis12ms ~ 25ms~16ms
MyBatisGX16ms ~ 28ms~20ms
MyBatis-Flex18ms ~ 29ms~23ms
MyBatis-Plus19ms ~ 31ms~25ms

批量更新 1W 条​

框架稳定区间均值
原生 MyBatis1294ms ~ 1618ms~1450ms
MyBatis-Flex1397ms ~ 1674ms~1560ms
MyBatisGX1423ms ~ 1855ms~1640ms
MyBatis-Plus1497ms ~ 1965ms~1720ms

批量更新 1W 条,MyBatisGX 与 Flex 差距约 80ms(约 5%),原生 MyBatis 最快。

为什么批量插入能做到这个性能?​

MyBatisGX 的批量操作本质上仍然是:

  • JDBC batch 协议(addBatch + executeBatch)
  • MyBatis BatchExecutor 执行
  • SQL 在启动期预生成,运行时不再拼接
  • 无 persistence context 干预
  • 无反射取字段,无 Lambda 包装

运行时只剩"传参 + 执行"两步,这是批量插入性能贴近原生的根本原因。


五、执行流程​

@startuml
skinparam backgroundColor #FEFEFE
skinparam sequenceArrowThickness 2
title MyBatisGX 批量操作执行流程

actor "Service" as service
participant "DAO\n(insertBatch)" as dao
participant "MybatisgxRoutingExecutor\n(路由执行器)" as routing
participant "MybatisgxBatchExecutor\n(批量执行器)" as batchExec
participant "MyBatis BatchExecutor\n(底层 JDBC Batch)" as mybatis
database "MySQL" as db

note over dao, routing
启动期:SQL 已预生成
运行时:仅传参 + 执行
end note

service -> dao : insertBatch(list, 1000)
dao -> routing : update(MappedStatement, params)
note right of routing
resolveExecutor()
@BatchOperation → getBatch() == true
→ 路由至 batchExecutor
end note
routing -> batchExec : update(ms, params)

loop 遍历 list(共 N 条)
batchExec -> mybatis : delegate.update(ms, item[i])
mybatis -> db : addBatch()
alt 每满 batchSize 条,或到达末尾
batchExec -> mybatis : flushStatements()
mybatis -> db : executeBatch()
batchExec -> mybatis : clearLocalCache()
end
end

batchExec --> service : return N
@enduml

六、写在最后​

批量操作本来就不应该复杂。

它只是数据库最基础的写入方式,却被各框架包装成了"必须先学一套约定"才能调的能力。

MyBatisGX 想做的事情很朴素:

把一个本来应该简单的能力,还原成简单的样子。

调用最短,语义最直,性能不打折。

从命名到约束,从定义到归属,这些追求背后有一个更简单的信念:

Coding 是一种艺术。

好的代码有结构、有表达、有边界。持久层尤其如此——它离数据最近,也最容易成为系统混乱的根源。MyBatisGX 的每一个设计决策,都是在试图让这层代码更像一门手艺,而不是临时凑合。

如果你也在追求代码的清晰与可控

欢迎来试试 MyBatisGX。

也欢迎来挑战我的设计理念。

因为:

技术的进步,来自于不断的质疑和对话。


社区交流​

欢迎交流 MyBatisGX 使用问题、ORM 设计与 SQL 架构实践。

微信:xcc137396549 备注:进 MyBatisGX 群

相关链接​

为什么我把 MyBatisGX 设计成现在这样

· 阅读需 28 分钟

一、开场:持久层的"熵增"现象​

MyBatisGX 不是为了解决 ORM 问题​

在开始之前,我想先澄清一个重要的认知:

MyBatisGX 不是为了解决"如何操作数据库"的问题。

ORM(对象关系映射)早就不是什么难题了。无论是 JPA、MyBatis、MyBatis Plus,还是其他任何 ORM 框架,都可以很好地操作数据库。

MyBatisGX 是为了解决工程化问题。

具体来说,是解决:

  • 查询逻辑如何组织?(不是如何实现查询)
  • 查询代码如何管理?(不是如何写查询)
  • 系统如何长期演进?(不是如何快速开发)

这是一个架构问题,不是一个技术能力问题。


一个真实的故事​

让我讲一个你可能经历过的故事。

第一周,你接到一个需求:实现用户列表查询,支持按名称和状态筛选。

你打开 IDE,快速写下:

// Service 层
public List<User> queryUsers(String name, Integer status) {
return userMapper.selectList(
new LambdaQueryWrapper<User>()
.like(StringUtils.isNotBlank(name), User::getName, name)
.eq(status != null, User::getStatus, status)
);
}

10 分钟搞定,测试通过,提交代码。很爽。


第三个月,需求迭代了 5 次:

  • 增加按创建时间范围筛选
  • 增加按角色筛选
  • 增加按部门筛选
  • 增加按标签筛选
  • 增加模糊搜索手机号

你的 Service 方法变成了这样:

public List<User> queryUsers(UserQueryParam param) {
LambdaQueryWrapper<User> wrapper = new LambdaQueryWrapper<>();

if (StringUtils.isNotBlank(param.getName())) {
wrapper.like(User::getName, param.getName());
}
if (param.getStatus() != null) {
wrapper.eq(User::getStatus, param.getStatus());
}
if (param.getStartTime() != null && param.getEndTime() != null) {
wrapper.between(User::getCreateTime, param.getStartTime(), param.getEndTime());
}
if (param.getRoleId() != null) {
wrapper.eq(User::getRoleId, param.getRoleId());
}
if (param.getDeptId() != null) {
wrapper.eq(User::getDeptId, param.getDeptId());
}
if (CollectionUtils.isNotEmpty(param.getTagIds())) {
wrapper.in(User::getTagId, param.getTagIds());
}
if (StringUtils.isNotBlank(param.getPhone())) {
wrapper.like(User::getPhone, param.getPhone());
}

return userMapper.selectList(wrapper);
}

方法变长了,但还能接受。


第六个月,你发现了一些问题:

  1. 订单服务也需要查询用户,但条件略有不同(不需要标签,但需要按等级筛选)
  2. 统计服务也需要查询用户,条件又不一样(只需要按时间和状态)
  3. 导出服务需要查询所有用户,但要排除某些状态

于是你发现:

  • UserService 里有 3 个相似的查询方法
  • OrderService 里又拼了一遍用户查询
  • StatisticsService 里又拼了一遍
  • 每个方法里都在操作 user 表的字段名

一年后,产品经理说:

"我们要把 status 字段拆成 account_status 和 verify_status 两个字段。"

遵循开闭原则,增加字段没问题。但问题是:谁来感知新字段、谁来决定在哪里用?

你打开项目全局搜索,发现:

  • 15 个 Service 文件
  • 47 处分散的查询拼装点

每一处都需要逐一评估:这里的查询逻辑需不需要引入新字段?用哪个?条件怎么写?没有人能快速判断影响范围,改完之后也没人敢说"我确认都处理到了"。

这就是持久层的"熵增"现象:

查询逻辑从集中走向分散,
从清晰走向混乱,
从可控走向失控。


为什么会这样?​

不是因为技术不行,也不是因为开发者不努力。

而是因为:

大部分 ORM 框架在帮你"实现查询",但没人管"查询应该在哪里定义"。

这是一个工程化问题,不是技术能力问题。

  • Wrapper 可以在任何地方拼装
  • Specification 可以在任何地方构造
  • Criteria 可以在任何地方组合

这种"自由"在早期确实方便,但随着时间推移:

自由 → 分散 → 混乱 → 失控

MyBatisGX 要解决的,就是这个工程化问题。


二、核心观点:查询是业务能力,不是实现细节​

一个思维转变​

传统 ORM 框架告诉你:

"你需要什么数据,就去拼装一个查询。"

这听起来没问题,但隐含了一个假设:

查询是一次性的实现细节。

但在真实的企业级系统中,查询不是一次性的,它是稳定的业务能力。

这是一个工程化视角的转变。

我们不是在讨论"如何写查询"(这是技术问题),而是在讨论"查询应该如何组织和管理"(这是工程问题)。


什么是"业务能力"?​

举个例子:

"根据名称和状态查询用户",这是一个查询吗?

不,这是一个业务能力。

它应该:

  1. 有明确的名字:findByNameAndStatus
  2. 有明确的参数:(String name, Integer status)
  3. 有明确的归属:UserDao
  4. 可以被多个 Service 复用
  5. 可以被单独测试
  6. 可以被独立优化

但如果你用 Wrapper 在 Service 里拼装:

// MyBatis Plus 做法
LambdaQueryWrapper<User> wrapper = new LambdaQueryWrapper<>();
wrapper.like(User::getName, name).eq(User::getStatus, status)

// 在 OrderService 里又拼一遍
wrapper.like(User::getName, name).eq(User::getStatus, status)

// 在 StatisticsService 里又拼一遍
wrapper.like(User::getName, name).eq(User::getStatus, status)

这时:

  • 它没有名字(只是一段代码)
  • 它没有归属(散落在各处)
  • 它无法复用(只能复制粘贴)
  • 它难以测试(嵌在业务流程里)
  • 它难以优化(不知道有多少地方在用)

两种范式的本质区别​

传统 ORM(实现查询)MyBatisGX(定义查询)
思维方式"我需要什么数据,就去拼一个查询""这个查询是稳定的业务能力,应该被定义"
解决的问题如何操作数据库(技术问题)如何组织查询代码(工程问题)
代码位置Service 层自由拼装DAO 层明确定义
复用方式复制粘贴方法调用
演进方式到处修改修改一处,影响范围可控
维护难度时间越长,越混乱时间越长,越清晰

MyBatisGX 的核心设计哲学​

查询应该被"定义",而不是被"实现"。

这不是技术能力的差异,而是工程化理念的差异。

具体来说:

  1. 查询必须在 DAO 层定义(四种方式渐进升级,按场景选择)

    方式解决的问题适用场景
    方法名快速开发,框架自动解析为 SQL条件 ≤ 3 个的简单查询
    QueryEntity方法名太长的问题多条件动态组合,不带分组的查询
    @Statement方法名无法表达 OR 条件的问题(如 name AND (age OR sex))含 OR 逻辑的中等复杂查询
    XML报表、复杂查询的兜底复杂 SQL、性能敏感、多表 JOIN
  2. Service 层不允许拼装查询

    • 不提供 Wrapper
    • 不提供 Specification
    • 不提供 Criteria
  3. 强制查询有明确归属

    • 每个查询都是一个方法
    • 每个方法都在 DAO 接口里
    • 所有查询都可枚举、可追踪

这是为了解决工程化问题,不是为了解决技术问题。


这就是 MyBatisGX 与其他 ORM 框架最本质的区别。

不是功能上的差异,而是架构哲学上的差异。


三、设计推导:从哲学到实现​

有了"查询是业务能力"这个核心观点,MyBatisGX 的所有设计决策都是自然推导出来的。


3.1 为什么坚持 DAO 收敛​

问题:查询逻辑可以在哪里实现?

选择 A:Service 层自由拼装(JPA/MyBatis Plus/MyBatis Flex 的做法)​

// UserService.java
public List<User> queryUsers(String name, Integer status) {
return userMapper.selectList(
new LambdaQueryWrapper<User>()
.like(User::getName, name)
.eq(User::getStatus, status)
);
}

// OrderService.java(又拼了一遍)
public List<User> queryUsers(String name) {
return userMapper.selectList(
new LambdaQueryWrapper<User>()
.like(User::getName, name)
);
}

// StatisticsService.java(又拼了一遍)
public List<User> queryActiveUsers(Integer status) {
return userMapper.selectList(
new LambdaQueryWrapper<User>()
.eq(User::getStatus, status)
);
}

优势:

  • 灵活、快速
  • 想怎么查就怎么查

问题:

  • 查询逻辑分散在多个 Service
  • 相似查询重复拼装
  • 字段名散落各处
  • 不知道改一个字段会影响哪些地方

选择 B:强制 DAO 层预定义(MyBatisGX 的做法)​

// UserDao.java(查询集中定义)
public interface UserDao extends SimpleDao<User, UserQuery, Long> {

// 方法名定义查询
List<User> findByNameLikeAndStatus(String name, Integer status);

// 或者用 QueryEntity
@Dynamic
List<User> findList(UserQuery query);
}

// UserService.java(只调用,不拼装)
public List<User> queryUsers(String name, Integer status) {
return userDao.findByNameLikeAndStatus(name, status);
}

// OrderService.java(复用同一个查询)
public List<User> queryUsers(String name) {
return userDao.findByNameLikeAndStatus(name, null);
}

优势:

  • 查询有明确归属(UserDao)
  • 查询可以复用(多个 Service 调用同一个方法)
  • 字段名集中管理(只在 DAO 层出现)
  • 易于追踪(全局搜索方法名)

代价:

  • 需要提前定义查询
  • 不能即兴拼装

MyBatisGX 的立场​

查询是稳定的业务能力,不是一次性实现细节。

因此:

宁愿早期多一步(定义查询),也要保证长期可维护。


真实场景:订单查询的演变​

**第一版需求:**按订单号和状态查询

// MyBatis Plus 做法
orderMapper.selectList(
new LambdaQueryWrapper<Order>()
.eq(Order::getOrderNo, orderNo)
.eq(Order::getStatus, status)
)

// MyBatisGX 做法
orderDao.findByOrderNoAndStatus(orderNo, status)

此时两者差不多。


**第五版需求:**增加了 10 个查询条件

// MyBatis Plus 做法(在 Service 里)
LambdaQueryWrapper<Order> wrapper = new LambdaQueryWrapper<>();
if (StringUtils.isNotBlank(orderNo)) wrapper.eq(Order::getOrderNo, orderNo);
if (status != null) wrapper.eq(Order::getStatus, status);
if (startTime != null && endTime != null) wrapper.between(Order::getCreateTime, startTime, endTime);
if (userId != null) wrapper.eq(Order::getUserId, userId);
if (payType != null) wrapper.eq(Order::getPayType, payType);
// ... 还有 5 个条件
orderMapper.selectList(wrapper);

// MyBatisGX 做法(在 DAO 定义 QueryEntity)
@QueryEntity(Order.class)
public class OrderQuery extends Order {
private String orderNoLike;
private List<Integer> statusIn;
private List<LocalDateTime> createTimeBetween;
private Long userId;
private Integer payType;
// ... 还有 5 个条件
}

// Service 只需要:
orderDao.findList(orderQuery);

**第十版需求:**需要在多个 Service 里查询订单

// MyBatis Plus 做法
// → UserService 里拼一遍
// → StatisticsService 里拼一遍
// → ReportService 里拼一遍
// 每个地方都要维护一套查询逻辑

// MyBatisGX 做法
// → 所有 Service 都调用 orderDao.findList(query)
// 只需要在 DAO 层维护一处

**第 N 版需求:**要优化这个查询的性能

// MyBatis Plus 做法
// → 找到所有拼装的地方(可能有 10+ 处)
// → 不确定能不能改(不知道会影响什么)

// MyBatisGX 做法
// → 在 DAO 的 XML 里接管这个查询
// → 只改一处,影响所有调用方
// → 影响范围明确(看谁调用了这个方法)

3.2 为什么不走全自动 ORM 路线​

全自动 ORM 的承诺:

"你不需要了解 SQL,专注对象建模。"

听起来很美好。但在复杂业务系统中:


问题 1:性能问题难以排查​

JPA 的例子:

// 你写的代码
List<Order> orders = orderRepository.findByUserId(userId);

// 实际执行的 SQL(你看不到)
SELECT * FROM t_order WHERE user_id = ?
SELECT * FROM t_order_item WHERE order_id = ? -- N+1 问题!
SELECT * FROM t_order_item WHERE order_id = ?
SELECT * FROM t_order_item WHERE order_id = ?
...

问题:

  • 你不知道发了多少条 SQL
  • 你不知道为什么慢
  • 你要去学 @EntityGraph、JOIN FETCH 这些"魔法"

问题 2:复杂查询最终还是要写 SQL​

真实场景:订单统计报表

需求:按日期统计每个用户的订单数量、总金额、平均金额,按金额倒序。

// JPA 的 Specification?几十行代码,难以阅读
// Criteria API?更复杂

// 最后还是:
@Query(value = "SELECT user_id, COUNT(*), SUM(amount), AVG(amount) " +
"FROM t_order " +
"WHERE create_time BETWEEN ?1 AND ?2 " +
"GROUP BY user_id " +
"ORDER BY SUM(amount) DESC", nativeQuery = true)
List<Object[]> statisticsOrderByUser(LocalDateTime start, LocalDateTime end);

结论:复杂查询绕不开 SQL。


问题 3:数据库特性无法使用​

场景:MySQL 的 INSERT ... ON DUPLICATE KEY UPDATE

-- 高效的批量 upsert
INSERT INTO user (id, name, status)
VALUES (1, 'Alice', 1), (2, 'Bob', 1)
ON DUPLICATE KEY UPDATE
name = VALUES(name),
status = VALUES(status);

JPA:无法表达,只能循环 saveOrUpdate,性能差。


MyBatisGX 的立场​

SQL 不是负担,而是资产。

不试图隐藏 SQL,而是让 SQL 有稳定归属:

简单查询 → 自动生成(方法名、QueryEntity)
复杂查询 → 显式定义(XML)
性能优化 → 直接接管(XML 覆盖)

对比:什么样的查询适合对象化?​

查询类型适合对象化适合 SQL
单表 CRUD✓-
简单条件查询✓-
多表 JOIN(2-3 张表)△✓
聚合统计✗✓
复杂报表✗✓
批量操作✗✓
数据库特定优化✗✓

MyBatisGX 的做法:

  • 对象化能解决的 → 自动生成
  • 对象化不适合的 → 直接写 SQL

不强求"完全对象化",也不放弃"自动化"。


3.3 为什么保留 XML​

很多现代 ORM 的方向是:彻底消灭 XML 和 SQL。

但 MyBatisGX 反其道而行之:拥抱 XML,让 SQL 有稳定归属。


哪些场景必须写 SQL?​

场景 1:复杂报表

SELECT 
u.dept_id,
d.dept_name,
COUNT(DISTINCT u.id) as user_count,
COUNT(o.id) as order_count,
SUM(o.amount) as total_amount,
AVG(o.amount) as avg_amount
FROM t_user u
LEFT JOIN t_dept d ON u.dept_id = d.id
LEFT JOIN t_order o ON u.id = o.user_id
WHERE o.create_time BETWEEN ? AND ?
GROUP BY u.dept_id, d.dept_name
HAVING SUM(o.amount) > 10000
ORDER BY total_amount DESC
LIMIT 100

你能用对象化表达这个查询吗?能,但为什么要这么折磨自己?


场景 2:性能优化

-- MySQL 的 Index Hint
SELECT * FROM t_order USE INDEX (idx_user_time)
WHERE user_id = ? AND create_time > ?

-- PostgreSQL 的 CTE
WITH recent_orders AS (
SELECT * FROM t_order WHERE create_time > NOW() - INTERVAL '7 days'
)
SELECT u.*, o.* FROM t_user u
JOIN recent_orders o ON u.id = o.user_id

这些数据库特定的优化,对象化无法表达。


场景 3:批量操作

-- 批量更新(一条 SQL 搞定)
UPDATE t_order
SET status = CASE
WHEN amount > 1000 THEN 2
WHEN amount > 500 THEN 1
ELSE 0
END
WHERE create_time < ?

-- 如果用 ORM:要么循环更新(性能差),要么写 Native SQL

MyBatisGX 的 XML 优先级策略​

如果 mapper.xml 存在对应方法 → 优先使用 XML
否则 → 使用自动生成的 SQL

这意味着:

  1. 简单查询不用写 XML:自动生成足够了
  2. 需要优化时,可以接管:写 XML 覆盖自动生成的 SQL
  3. 复杂查询直接写 XML:不强求对象化

举例:查询的演变过程​

阶段 1:简单查询

// DAO 定义
List<Order> findByUserIdAndStatus(Long userId, Integer status);

// 不用写 XML,MyBatisGX 自动生成 SQL

阶段 2:需要优化

<!-- 在 OrderMapper.xml 里接管 -->
<select id="findByUserIdAndStatus" resultType="Order">
SELECT * FROM t_order USE INDEX (idx_user_status)
WHERE user_id = #{userId} AND status = #{status}
ORDER BY create_time DESC
LIMIT 1000
</select>

DAO 接口不变,只是 SQL 实现被接管了。


阶段 3:变成复杂查询

<select id="findByUserIdAndStatus" resultType="Order">
SELECT o.*, u.name as user_name, u.phone as user_phone
FROM t_order o
JOIN t_user u ON o.user_id = u.id
WHERE o.user_id = #{userId}
AND o.status = #{status}
AND o.create_time > DATE_SUB(NOW(), INTERVAL 30 DAY)
ORDER BY o.create_time DESC
</select>

对比其他框架​

框架简单查询复杂查询优化策略
JPA自动@Query + Native SQL跳出 JPA 体系
MyBatis Plus自动自定义 XML需要手动写
MyBatisGX自动XML 接管平滑过渡

3.4 为什么支持方法名但不鼓励无限动态化​

MyBatisGX 支持方法名查询:

List<User> findByNameLikeAndStatusAndCreateTimeBetween(
String name,
Integer status,
LocalDateTime start,
LocalDateTime end
);

但不提供 Wrapper/Specification/Criteria。

为什么?


方法名查询的定位:快速开发,不是稳定业务​

重要说明:

方法名查询是为了条件在 3 个左右的快速开发场景,不是为了稳定的业务查询。

  • ✓ 适合:简单的、临时的、条件少的查询
  • ✗ 不适合:复杂的、稳定的、长期维护的业务查询

对于稳定的业务查询,应该用:

  1. QueryEntity:条件较多且需要动态组合
  2. XML:复杂 SQL、性能敏感的查询

@Dynamic 注解的定位:让条件自动动态化​

@Dynamic 的作用是让方法名、QueryEntity、@Statement 中的所有查询条件具备动态化能力——参数为 null 时自动跳过,不生成对应的 SQL 条件。

// 不加 @Dynamic:name 和 status 都会拼入 WHERE,传 null 可能产生预期外的结果
List<User> findByNameAndStatus(String name, Integer status);

// 加了 @Dynamic:name 为 null 时跳过,status 为 null 时跳过,自动变成动态查询
@Dynamic
List<User> findByNameAndStatus(String name, Integer status);

@Dynamic 与 XML 是两套独立的机制:XML 里的动态化(<if>、<choose> 等)完全由你精确控制,不需要 @Dynamic;@Dynamic 也不依赖 XML,它只作用在自动生成的查询条件上。

但要注意:@Dynamic 不能滥用。 如果方法上加了 @Dynamic,而调用方把所有条件都传了 null,会生成没有任何 WHERE 条件的 SQL——查询时是全表扫描,更新和删除时则是全表操作,后果极其严重。这正是为什么 MyBatisGX 支持动态化但不鼓励无节制地动态化。


方法名查询 vs Wrapper 的本质区别​

方法名查询的本质:把查询"定义"为方法签名

// 这是一个"查询定义"
List<User> findByNameAndStatus(String name, Integer status);
  • 它有明确的名字:findByNameAndStatus
  • 它有明确的参数:(String name, Integer status)
  • 它是稳定的、可枚举的
  • 它可以被 XML 接管

Wrapper 的本质:在运行时"实现"查询

// 这是一个"查询实现"
LambdaQueryWrapper<User> wrapper = new LambdaQueryWrapper<>();
wrapper.like(User::getName, name);
wrapper.eq(User::getStatus, status);
userMapper.selectList(wrapper);
  • 它没有名字(只是一段代码)
  • 它是动态的、临时的
  • 它无法被 XML 接管
  • 它散落在各处

更深层的问题:Wrapper 在 DAO 的 default 方法中​

有些讲究的开发者会把 Wrapper 写在 DAO 接口的 default 方法中:

public interface UserDao extends BaseMapper<User> {

default List<User> queryByConditions(String name, Integer status,
LocalDateTime startTime, LocalDateTime endTime,
Long roleId, Long deptId) {
LambdaQueryWrapper<User> wrapper = new LambdaQueryWrapper<>();
if (StringUtils.isNotBlank(name)) wrapper.like(User::getName, name);
if (status != null) wrapper.eq(User::getStatus, status);
if (startTime != null && endTime != null) wrapper.between(User::getCreateTime, startTime, endTime);
if (roleId != null) wrapper.eq(User::getRoleId, roleId);
if (deptId != null) wrapper.eq(User::getDeptId, deptId);
return this.selectList(wrapper);
}
}

这看起来解决了"查询分散"的问题,但引入了两个新问题:


问题 1:通用查询方法缺失业务表达

为了让方法通用,你会枚举出所有可能的字段作为参数:

default List<User> queryByConditions(
String name, Integer status, LocalDateTime startTime, LocalDateTime endTime,
Long roleId, Long deptId, List<Long> tagIds, String phone, Integer level
) {
// 动态拼装所有条件
}

问题是:

  • 方法名 queryByConditions 天生缺失业务表达
  • 谁都可以调用,但到底表达什么业务含义?
  • 是"查询活跃用户"?还是"查询待审核用户"?还是"导出用户列表"?
  • 方法签名无法传达业务意图

问题 2:隐性的架构膨胀

把 Wrapper 写在 DAO 的 default 方法里,从层次上说仍然是三层架构——DAO 只是一层里多了一种写法,并没有多出一层。

但真正的问题出在 Service 层。当 Service 里充满了各种 Wrapper 拼装逻辑,业务代码和数据库代码混在一起,有些团队为了维持 Service 的"业务纯净度",会在上层再加一层:

Controller → Compose → Service → DAO

这个 Compose 层专门负责编排业务流程,Service 层专注于调用 DAO 做数据操作。

问题是:这一层为什么会存在?

因为 Service 里被数据库代码占据,业务逻辑和查询逻辑的边界模糊了,不得不加一层来分离关注点。

这一层是为了解决持久层无序而衍生出来的,不是业务真的需要一个编排层。你为了解决一个工程化问题,膨胀了整个系统的架构复杂度。性价比高吗?


更根本的问题:Wrapper 是"无名查询",无论放在哪里​

有一点需要说清楚:把 Wrapper 移到 DAO 的 default 方法里,解决的只是"物理位置",没有解决"查询本质"。

Wrapper 在任何地方都有一个根本缺陷——它是无名的:

  • 无法被 XML 接管:你无法在 XML 里优化一段 Wrapper 拼装逻辑,因为它没有固定的方法签名
  • 无法追踪调用方:grep 方法名可以找到所有调用者,但 Wrapper 逻辑散落在代码里,无从追踪
  • 无法表达业务意图:queryByConditions(name, status, startTime, ...) 这样的通用方法,谁调用它都不知道这次调用代表什么业务含义

结论:这是 Wrapper 机制本身的问题,不是"在哪里写"的问题。


MyBatisGX 的做法:不增加层次,而是改变表达方式​

MyBatisGX 不需要 default 方法这一层,而是通过 QueryEntity 和 XML 来表达:

// 方式 1:QueryEntity(类型安全、业务清晰)
@QueryEntity(User.class)
public class UserQuery extends User {
private String nameLike;
private List<Integer> statusIn;
private List<LocalDateTime> createTimeBetween;
}

@Dynamic
List<User> findList(UserQuery query);

// 方式 2:业务明确的方法(语义清晰)
List<User> findActiveUsers(UserQuery query);
List<User> findPendingUsers(UserQuery query);

优势:

  • 不增加层次,仍然是三层架构
  • 方法名可以表达业务含义
  • QueryEntity 提供类型安全
  • XML 可以接管和优化

为什么方法名更像"业务能力"?​

对比:

// 方法名(定义)
userDao.findByNameAndStatus(name, status);

// Wrapper(实现)
userMapper.selectList(
new LambdaQueryWrapper<User>()
.like(User::getName, name)
.eq(User::getStatus, status)
);

问题:

  • 半年后,哪个更容易理解?
  • 如果要优化,改哪个更安全?
  • 如果要复用,哪个更方便?

对象表达 SQL 真的好吗?​

MyBatis Plus、MyBatis Flex 都在用 Java 对象去表达 SQL。但我们需要先问一个更根本的问题:

SQL 是声明式语言,Wrapper 是命令式拼装

SQL 说的是"我要什么":

SELECT * FROM user WHERE name LIKE ? AND status = ?

Wrapper 说的是"我怎么构建一个查询对象":

wrapper.like(User::getName, name).eq(User::getStatus, status)

用对象拼装 SQL,本质上是把一个声明式问题变成了命令式问题。SQL 本来就能清晰地表达意图,对象化之后反而多了一层翻译。简单查询时感觉不出区别,一旦查询复杂,你就要在脑子里把对象链式调用"翻译"回 SQL 才能理解逻辑,调试更是如此。


问题 1:对象化后,SQL 无法调试

// 用对象表达
LambdaQueryWrapper<User> wrapper = new LambdaQueryWrapper<>();
wrapper.like(User::getName, name)
.eq(User::getStatus, status)
.between(User::getCreateTime, startTime, endTime)
.in(User::getRoleId, roleIds);

问题是:

  • 你看不到最终生成的 SQL 是什么
  • 你无法在 SQL 客户端里调试这个查询
  • 你无法直接复制 SQL 去优化
  • 出了性能问题,你要先"翻译"成 SQL 才能分析

对比 MyBatisGX 的 XML:

<select id="findList" resultType="User">
SELECT * FROM t_user
<where>
<if test="name != null">AND name LIKE #{name}</if>
<if test="status != null">AND status = #{status}</if>
<if test="createTimeBetween != null">
AND create_time BETWEEN #{createTimeBetween[0]} AND #{createTimeBetween[1]}
</if>
<if test="roleIds != null">AND role_id IN
<foreach collection="roleIds" item="id" open="(" close=")" separator=",">
#{id}
</foreach>
</if>
</where>
</select>
  • SQL 清晰可见
  • 可以直接复制到 SQL 客户端调试
  • 可以直接看到执行计划
  • 可以直接优化

问题 2:对象真的比 SQL 更适合表达数据操作吗?

SQL 是专门为数据操作设计的语言,它有:

  • 声明式语义(说"要什么",不说"怎么做")
  • 集合操作(JOIN、GROUP BY、HAVING)
  • 丰富的函数(聚合、窗口、字符串、日期)
  • 数据库特定优化(索引提示、执行计划)

用对象表达 SQL,本质上是在用一种不适合的工具去做一件事。

简单的 CRUD 可以对象化,但复杂的数据操作,SQL 才是最自然的表达方式。


MyBatisGX 的立场:不强求对象化​

简单查询 → 对象化(方法名、QueryEntity)
复杂查询 → SQL 化(XML)

不试图用对象表达一切,而是让每种工具做它最擅长的事。


QueryEntity:参数化查询,但查询本身仍然稳定​

MyBatisGX 的 QueryEntity:

@QueryEntity(User.class)
public class UserQuery extends User {
private String nameLike;
private List<Integer> statusIn;
private List<LocalDateTime> createTimeBetween;
}

// 使用
UserQuery query = new UserQuery();
query.setNameLike("Alice");
query.setStatusIn(Arrays.asList(1, 2));
userDao.findList(query);

对比 Wrapper:

LambdaQueryWrapper<User> wrapper = new LambdaQueryWrapper<>();
wrapper.like(User::getName, "Alice");
wrapper.in(User::getStatus, Arrays.asList(1, 2));
userMapper.selectList(wrapper);

区别:

QueryEntityWrapper
查询定义findList(UserQuery) 方法没有,只是一段代码
参数类型安全✓(Java 类)✓(Lambda 表达式)
可复用✓(传递 QueryEntity 对象)△(需要封装成方法)
可接管✓(XML 可以接管 findList)✗(无法接管)
可调试✓(XML 中 SQL 可见)✗(SQL 隐藏在对象中)

需要动态条件怎么办?​

两种路径,取决于查询的复杂程度:

路径 1:@Dynamic 自动动态化

适合方法名、QueryEntity、@Statement 场景——加一个注解,所有参数为 null 时自动跳过:

@Dynamic
List<User> findByNameAndStatus(String name, Integer status);

@Dynamic
List<User> findList(UserQuery query);

路径 2:XML 精确控制

适合复杂动态逻辑,由你完全掌控每个条件的生成规则:

<select id="findList" resultType="User">
SELECT * FROM t_user
<where>
<if test="name != null">AND name LIKE #{name}</if>
<if test="status != null">AND status = #{status}</if>
<if test="createTimeBetween != null">
AND create_time BETWEEN #{createTimeBetween[0]} AND #{createTimeBetween[1]}
</if>
</where>
</select>

关键点:

  • @Dynamic 和 XML 是两套独立机制,各自解决不同场景
  • 无论哪种方式,动态 SQL 都在 DAO 层显式定义,而不是在 Service 里临时拼装

小结:设计决策的一致性​

核心哲学:查询是业务能力,应该被定义和管理
↓
决策 1:强制 DAO 收敛(查询有明确归属)
↓
决策 2:不走全自动 ORM(SQL 是资产)
↓
决策 3:保留 XML(复杂查询有稳定归属)
↓
决策 4:方法名但不动态化(定义 > 实现)

所有设计决策都在强化同一个理念:

让查询成为稳定的、可管理的业务能力。


四、MyBatisGX 与 JPA/MyBatis Plus/MyBatis Flex 的本质区别​

不是能力的差异,而是约束的差异​

这几个框架在基础技术能力上都能操作数据库:

  • 都支持基础 CRUD
  • 都支持自定义 SQL

真正的区别在于:设计约束。


对比:在不同场景下的表现​

场景 1:单表 CRUD​

// JPA
userRepository.save(user);
userRepository.findById(id);

// MyBatis Plus / MyBatis Flex
userMapper.insert(user);
userMapper.selectById(id);

// MyBatisGX
userDao.insert(user);
userDao.findById(id);

结论:基础 CRUD 上,几个框架没有区别。


场景 2:简单条件查询​

// JPA(Spring Data 方法名自动解析为 SQL)
List<User> findByNameLikeAndStatus(String name, Integer status);

// MyBatis Plus / MyBatis Flex(不支持方法名解析,必须手动实现)
// 方式 1:Wrapper 在调用方拼装
userMapper.selectList(
new LambdaQueryWrapper<User>()
.like(User::getName, name)
.eq(User::getStatus, status)
);
// 方式 2:写 XML

// MyBatisGX(方法名自动解析为 SQL,与 JPA 一样)
List<User> findByNameLikeAndStatus(String name, Integer status);

结论: 方法名解析只有 JPA 和 MyBatisGX 支持。MyBatis Plus 和 MyBatis Flex 不具备这个能力,简单查询也需要手动写 Wrapper 或 XML。


场景 3:复杂动态查询​

需求:根据不同条件组合查询用户

// JPA(Specification,可以在 Service 拼装)
Specification<User> spec = (root, query, cb) -> {
List<Predicate> predicates = new ArrayList<>();
if (name != null) {
predicates.add(cb.like(root.get("name"), "%" + name + "%"));
}
if (status != null) {
predicates.add(cb.equal(root.get("status"), status));
}
return cb.and(predicates.toArray(new Predicate[0]));
};
userRepository.findAll(spec);

// MyBatis Plus / MyBatis Flex(LambdaQueryWrapper,可以在 Service 拼装)
LambdaQueryWrapper<User> wrapper = new LambdaQueryWrapper<>();
if (name != null) wrapper.like(User::getName, name);
if (status != null) wrapper.eq(User::getStatus, status);
userMapper.selectList(wrapper);

// MyBatisGX(必须在 DAO 定义)
// 方式 1:QueryEntity
@QueryEntity(User.class)
class UserQuery {
private String nameLike;
private Integer status;
}
@Dynamic
userDao.findList(query);

// 方式 2:自定义方法 + XML
List<User> findByConditions(UserQuery query);

区别:

JPA / MyBatis Plus / MyBatis FlexMyBatisGX
灵活性✓ 可以在任何地方拼装△ 必须在 DAO 定义
查询收敛✗ 容易分散到 Service✓ 框架强制

场景 4:需求变更,查询条件增加​

需求:从 2 个条件增加到 10 个条件

// JPA / MyBatis Plus / MyBatis Flex
// → Service 里的拼装代码越来越长
// → 多个 Service 各自拼装,逻辑分散

// MyBatisGX
// → 扩展 QueryEntity,添加新字段
// → 或者在 XML 里添加新条件
// → 所有 Service 自动享受新条件(调用同一个 DAO 方法)

场景 5:关联查询​

需求:查询用户及其订单列表

// JPA
@Entity
class User {
@OneToMany(mappedBy = "user")
private List<Order> orders;
}
// JPA 也可以批量抓取(@BatchSize、@Fetch(FetchMode.SUBSELECT))
// 在抓取策略上,JPA 和 MyBatisGX 都能解决 N+1 问题

// MyBatis Plus
// 完全手动写 ResultMap + JOIN SQL

// MyBatis Flex
// 支持关联查询(@RelationOneToMany 等注解)

// MyBatisGX
@Entity
class User {
@OneToMany(mappedBy = "user", fetch = FetchType.EAGER)
@Fetch(FetchMode.BATCH) // 自动解决 N+1
private List<Order> orders;
}

结论:关联查询上,JPA 和 MyBatisGX 都能自动处理,MyBatis Flex 也提供了注解支持,MyBatis Plus 则需要完全手动。这不是各框架的核心差异点,JPA 真正的软肋在动态 SQL,见场景 6。


场景 6:动态 SQL​

需求:根据不同条件组合构建复杂查询

// JPA
// Specification 可以动态组合,但这只是"条件过滤"的动态化
// 一旦涉及多表 JOIN + 动态条件、子查询、CASE WHEN、GROUP BY + HAVING
// Criteria API 写出来极其冗长,几乎没有可读性
// 最终的解决方案几乎都是退回到 @Query 写原生 SQL——彻底跳出 JPA 体系

// MyBatis Plus / MyBatis Flex
// LambdaQueryWrapper 可以动态拼装,但本质上只支持单表 WHERE 条件的动态化
// 涉及窗口函数、递归查询、复杂子查询时,仍然要回到 XML

// MyBatisGX
// 简单动态条件:QueryEntity/@Statement + @Dynamic,参数为 null 自动跳过
// 复杂动态 SQL:XML 的 <if>、<choose>、<foreach>,用户精确控制
// 两种机制独立,按场景选择,SQL 始终可见、可调试、可接管

结论:动态 SQL 是 JPA 最大的软肋。 你可以忍受 JPA 的 N+1(配置一下 @BatchSize 就解决了),但你无法优雅地解决 JPA 的动态 SQL 问题——要么接受冗长的 Criteria API,要么放弃 JPA 直接写原生 SQL,两者都是妥协。


完整对比表​

对比维度JPAMyBatis Plus / FlexMyBatisGX
基础 CRUD✓✓✓
方法名查询✓ Spring Data 解析✗ 不支持,需手写 Wrapper 或 XML✓ 自动解析
动态查询✓ Specification
可在 Service 拼装
✓ Wrapper
可在 Service 拼装
△ 必须在 DAO 方法定义@Dynamic
用 方法名/QueryEntity/@Statement
查询逻辑收敛✗ 依赖开发者自觉✗ 依赖开发者自觉✓ 框架强制
SQL 透明度✗ 完全黑盒△ 可以看到但不直观✓ 可预生成/可接管
复杂动态 SQL✗ Criteria API 极其冗长
最终退回原生 SQL
✓ XML✓ XML
关联查询✓ 自动且可控MP ✗ 完全手动
Flex △ 注解支持
✓ 自动且可控

MyBatisGX 适合谁?​

如果你认同下面这些:

  • 查询应该被定义,而不是随手实现
  • 代码要见名知意,数据库代码也不例外
  • 架构约束比无限自由更利于长期演进

那 MyBatisGX 就是为你设计的——无论项目大小。

写得干净不是企业级系统的专利,是每个有点追求的工程师都可以做到的选择。


五、收尾:我的技术价值观​

为什么我对"长期维护"有执念​

我做了十年企业级项目开发,见过太多系统从清晰走向混乱。

我发现一个规律:

早期"方便"的设计,往往会在后期变成技术债。


一个真实的案例​

某系统,第一年:

  • 用 MyBatis Plus 的 Wrapper
  • 开发很快,大家都很爽
  • 代码很灵活,想怎么查就怎么查

第三年:

  • 查询逻辑散落在 30+ 个 Service
  • 要优化一个慢查询,不知道影响范围
  • 要重构数据库表结构,不敢动

最后:

  • 技术负责人说:我们重构吧
  • 评估后发现:改不动了
  • 只能加新表,旧表标记为 @Deprecated
  • 系统越来越重

我的思考​

为什么会这样?

不是因为 MyBatis Plus 不好,也不是因为开发者不努力。

而是因为:

框架给了太多自由,但没有给足够的约束。

当每个开发者都可以在 Service 里拼装查询时:

  • 没有人会去复用已有的查询(因为不知道在哪)
  • 没有人会去思考查询的归属(因为到处都能查)
  • 没有人会去管理查询的生命周期(因为只是一段临时代码)

MyBatisGX 的设计立场​

我不追求"最快的框架",而是追求"最适合做长久的框架"。

MyBatisGX 的设计约束:

  1. 强制 DAO 收敛 → 查询有明确归属
  2. 不提供 Wrapper → 查询不能随意拼装
  3. 保留 XML 优先级 → 查询可被接管和优化
  4. 支持但不鼓励动态化 → 查询应该是稳定的

这些约束在早期可能不太方便,但在长期会让系统:

  • 更清晰(查询在哪里一目了然)
  • 更可控(影响范围可预测)
  • 更可维护(修改一处,到处生效)

我的技术价值观​

我相信:

好的架构不是给你无限的自由,而是给你恰当的约束。

  • 自由让你快速开始
  • 约束让你持续演进

MyBatisGX 选择了后者。


写在最后​

从命名到约束,从定义到归属,这些追求背后有一个更简单的信念:

Coding 是一种艺术。

好的代码有结构、有表达、有边界。持久层尤其如此——它离数据最近,也最容易成为系统混乱的根源。MyBatisGX 的每一个设计决策,都是在试图让这层代码更像一门手艺,而不是临时凑合。

如果你认同"查询应该被定义,而不是被随手实现",如果你也在追求代码的清晰与可控——

欢迎来试试 MyBatisGX。

也欢迎来挑战我的设计理念。

因为:

技术的进步,来自于不断的质疑和对话。


社区交流​

欢迎交流 MyBatisGX 使用问题、ORM 设计与 SQL 架构实践。

微信:xcc137396549 备注:进 MyBatisGX 群

相关链接​

自动生成 SQL 会拖慢性能吗?实测 MyBatisGX、MyBatis、MyBatis-Plus、MyBatis-Flex

· 阅读需 15 分钟

一、引言​

选持久化框架时,很多开发者会担心:

  • "自动生成的 SQL 肯定不如手写的快"
  • "ORM 框架抽象层越高,性能损耗越大"
  • "为了开发效率牺牲性能,划算吗?"

这些担忧合理,但事实如此吗?

我对主流的 MyBatis 系列框架做了一次性能测试:

  • MyBatis:原生手写 SQL,性能基准
  • MyBatisGX:方法名生成 SQL + 预生成机制
  • MyBatis-Plus:运行时动态生成 SQL
  • MyBatis-Flex:轻量级动态生成

用真实的测试数据回答:自动生成 SQL 的性能代价到底有多大?


二、测试环境​

硬件配置​

  • CPU:4核8线程
  • 内存:16GB

软件配置​

  • JDK 版本:21
  • MySQL 版本:5.7
  • Spring Boot 版本:3.x

JVM 参数​

-Xms1g
-Xmx4g

测试表结构​

CREATE TABLE `user` (
`id` BIGINT PRIMARY KEY AUTO_INCREMENT,
`username` VARCHAR(50),
`age` INT,
`status` TINYINT,
`email` VARCHAR(100),
`phone` VARCHAR(20),
`create_time` DATETIME,
`update_time` DATETIME
) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4;

8个字段,贴近真实业务。只有主键索引,避免索引优化干扰。


三、测试方法​

3.1 测试项目​

插入操作:

  • 单条插入
  • 批量插入 100 条
  • 批量插入 10,000 条

更新操作:

  • 单条更新
  • 动态更新(仅更新非空字段)
  • 批量更新 100 条
  • 批量更新 10,000 条

查询操作:

  • 主键查询
  • 简单条件查询(3个条件)
  • 复杂条件查询(Like、In、Gt 等)
  • 动态条件查询

3.2 测试策略​

JVM 在首次执行时会进行类加载、JIT 编译等初始化工作。每个测试项连续执行 15 轮,第 1 轮单独记录,第 2-15 轮用于统计。

统计指标:

  • 首次执行耗时
  • 热身后平均值
  • 热身后最快值
  • 热身后最慢值

3.3 四个框架的实现方式​

四个框架执行完全相同的业务逻辑。

MyBatis(手写 XML)​

<insert id="insert">
INSERT INTO user (id, username, age, status, email, phone, create_time, update_time)
VALUES (#{id}, #{username}, #{age}, #{status}, #{email}, #{phone}, #{createTime}, #{updateTime})
</insert>

<select id="findByIdAndAgeAndStatus" resultType="User">
SELECT * FROM user
WHERE id = #{id} AND age = #{age} AND status = #{status}
</select>

<select id="findDynamicByConditions" resultType="User">
SELECT * FROM user
<where>
<if test="id != null">AND id = #{id}</if>
<if test="username != null and username != ''">
AND username LIKE CONCAT('%', #{username}, '%')
</if>
<if test="age != null">AND age &gt; #{age}</if>
<if test="statusList != null and statusList.size() > 0">
AND status IN
<foreach item="item" collection="statusList" open="(" separator="," close=")">
#{item}
</foreach>
</if>
</where>
</select>

MyBatisGX(方法名生成)​

public interface UserDao extends SimpleDao<User, UserQuery, Long> {
// 继承自 SimpleDao 的方法:
// int insert(User user);
// int insertBatch(List<User> users, int batchSize);
// int updateById(User user);
// int updateBatchById(List<User> users, int batchSize);
// User findById(Long id);

// 方法名生成查询 SQL
List<User> findByIdAndAgeAndStatus(Long id, Integer age, Integer status);

// 复杂条件查询
List<User> findByIdAndUsernameLikeAndAgeGtAndStatusIn(
Long id, String username, Integer age, List<Integer> statusList
);

// 动态查询(使用 QueryEntity)
@Dynamic
List<User> findDynamicByIdAndUsernameLikeAndAgeGtAndStatusIn(UserQuery query);
}

MyBatis-Plus(Wrapper)​

public interface UserMapper extends BaseMapper<User> {
}

// Service 层构建查询
List<User> findByIdAndAgeAndStatus(Long id, Integer age, Integer status) {
return userMapper.selectList(
new LambdaQueryWrapper<User>()
.eq(User::getId, id)
.eq(User::getAge, age)
.eq(User::getStatus, status)
);
}

// 动态查询
List<User> findDynamicByConditions(Long id, String username, Integer age, List<Integer> statusList) {
return userMapper.selectList(
new LambdaQueryWrapper<User>()
.eq(id != null, User::getId, id)
.like(StringUtils.isNotBlank(username), User::getUsername, username)
.gt(age != null, User::getAge, age)
.in(CollectionUtils.isNotEmpty(statusList), User::getStatus, statusList)
);
}

MyBatis-Flex(QueryWrapper)​

public interface UserMapper extends BaseMapper<User> {
}

// Service 层构建查询
List<User> findByIdAndAgeAndStatus(Long id, Integer age, Integer status) {
return userMapper.selectListByQuery(
QueryWrapper.create()
.eq(User::getId, id)
.eq(User::getAge, age)
.eq(User::getStatus, status)
);
}

// 动态查询
List<User> findDynamicByConditions(Long id, String username, Integer age, List<Integer> statusList) {
QueryWrapper query = QueryWrapper.create();
if (id != null) query.eq(User::getId, id);
if (StringUtils.isNotBlank(username)) query.like(User::getUsername, username);
if (age != null) query.gt(User::getAge, age);
if (CollectionUtils.isNotEmpty(statusList)) query.in(User::getStatus, statusList);
return userMapper.selectListByQuery(query);
}

四、测试结果​

4.1 单条插入​

框架首次执行热身后平均最快最慢
MyBatis57,594 μs1,830 μs1,544 μs2,262 μs
MyBatisGX79,329 μs1,922 μs1,586 μs2,632 μs
MyBatis-Flex314,609 μs2,587 μs2,217 μs3,145 μs
MyBatis-Plus118,034 μs2,234 μs1,876 μs2,848 μs

首次执行,MyBatis-Flex 耗时最长(314ms),MyBatis 最短(57ms)。热身后,四者都在 1.82.6ms 之间,最大差距 757μs。各框架波动范围在 400900μs。


4.2 批量插入 100 条​

框架首次执行热身后平均最快最慢
MyBatis41 ms11 ms6 ms25 ms
MyBatisGX36 ms12 ms7 ms56 ms
MyBatis-Flex53 ms21 ms10 ms40 ms
MyBatis-Plus80 ms20 ms10 ms117 ms

热身后,MyBatis 和 MyBatisGX 在 1012ms,MyBatis-Flex 和 MyBatis-Plus 在 2021ms。


4.3 批量插入 10,000 条​

框架首次执行热身后平均最快最慢
MyBatis459 ms307 ms239 ms653 ms
MyBatisGX742 ms323 ms264 ms569 ms
MyBatis-Flex1,025 ms381 ms293 ms581 ms
MyBatis-Plus690 ms446 ms350 ms686 ms

热身后:MyBatis 307ms < MyBatisGX 323ms < MyBatis-Flex 381ms < MyBatis-Plus 446ms。MyBatisGX 比 MyBatis 慢 16ms(约 5%),MyBatis-Plus 慢 139ms(约 45%)。所有框架都在同一数量级。


4.4 单条更新​

框架首次执行热身后平均最快最慢
MyBatis3,302 μs1,139 μs877 μs1,318 μs
MyBatisGX1,987 μs1,323 μs1,035 μs2,523 μs
MyBatis-Flex4,109 μs1,308 μs863 μs1,772 μs
MyBatis-Plus15,781 μs1,558 μs1,230 μs2,070 μs

热身后,四者都在 1.1~1.6ms 之间,最大差距 419μs。MyBatis-Plus 首次执行明显慢于其他框架。


4.5 动态更新(UpdateSelective)​

框架首次执行热身后平均最快最慢
MyBatis21,109 μs1,350 μs1,123 μs1,524 μs
MyBatisGX24,655 μs1,574 μs1,244 μs2,182 μs
MyBatis-Flex58,886 μs1,362 μs1,054 μs1,890 μs
MyBatis-Plus29,328 μs1,950 μs1,591 μs2,679 μs

热身后,四者都在 1.3~2.0ms 之间,最大差距 600μs。


4.6 批量更新 100 条​

框架首次执行热身后平均最快最慢
MyBatis46 ms17 ms12 ms45 ms
MyBatisGX112 ms21 ms16 ms30 ms
MyBatis-Flex105 ms25 ms18 ms65 ms
MyBatis-Plus107 ms26 ms19 ms46 ms

热身后,四者都在 17~26ms 之间。


4.7 批量更新 10,000 条​

框架首次执行热身后平均最快最慢
MyBatis1,427 ms1,458 ms1,294 ms1,618 ms
MyBatisGX1,588 ms1,635 ms1,423 ms1,855 ms
MyBatis-Flex1,872 ms1,568 ms1,397 ms1,872 ms
MyBatis-Plus1,948 ms1,725 ms1,497 ms1,965 ms

热身后,四者都在 1.4~1.7 秒,最大差距 267ms。MyBatisGX 比 MyBatis 慢 177ms(约 12%)。


4.8 主键查询(FindById)​

框架首次执行热身后平均最快最慢
MyBatis17,080 μs1,314 μs889 μs1,813 μs
MyBatisGX14,819 μs1,472 μs1,047 μs2,051 μs
MyBatis-Flex26,498 μs1,232 μs777 μs1,512 μs
MyBatis-Plus25,419 μs1,333 μs1,026 μs2,101 μs

热身后,四者都在 1.21.5ms 之间,最大差距 240μs。各框架波动范围在 7001000μs。


4.9 简单条件查询(FindByIdAndAgeAndStatus)​

框架首次执行热身后平均最快最慢
MyBatis2,645 μs1,198 μs952 μs1,789 μs
MyBatisGX2,467 μs1,451 μs952 μs1,879 μs
MyBatis-Flex4,449 μs1,499 μs1,163 μs1,955 μs
MyBatis-Plus9,865 μs2,059 μs1,673 μs3,098 μs

热身后,MyBatis-Plus 慢于其他三个框架。MyBatis、MyBatisGX、MyBatis-Flex 三者在 1.2~1.5ms 之间。


4.10 复杂条件查询(Like + In + Gt)​

框架首次执行热身后平均最快最慢
MyBatis4,177 μs1,536 μs1,148 μs2,134 μs
MyBatisGX11,444 μs1,512 μs1,098 μs1,886 μs
MyBatis-Flex2,474 μs1,116 μs919 μs1,227 μs
MyBatis-Plus6,863 μs1,687 μs1,352 μs2,187 μs

热身后,四者都在 1.1~1.7ms 之间,最大差距 571μs。MyBatis-Flex 表现较好(1,116μs)。


4.11 动态条件查询​

框架首次执行热身后平均最快最慢
MyBatis14,796 μs1,897 μs1,529 μs2,316 μs
MyBatisGX2,193 μs1,476 μs1,145 μs1,804 μs
MyBatis-Flex1,723 μs1,386 μs1,058 μs1,777 μs
MyBatis-Plus2,696 μs1,584 μs1,242 μs2,163 μs

这是最接近真实业务的测试。条件参数可能为空,需要动态构建 WHERE 子句。

首次执行,MyBatis 耗时 14,796μs,显著高于其他三个框架(1,723μs ~ 2,696μs)。热身后,四个框架都在 1.4~1.9ms 之间,最大差距 511μs。

波动范围:

  • MyBatis:787μs(1,529 ~ 2,316)
  • MyBatisGX:659μs(1,145 ~ 1,804)
  • MyBatis-Flex:719μs(1,058 ~ 1,777)
  • MyBatis-Plus:921μs(1,242 ~ 2,163)

多轮测试结果可重复。热身后四个框架的性能在同一数量级。


五、MyBatisGX 的价值定位​

既然性能都差不多,为什么选 MyBatisGX?

在不牺牲性能的前提下,提升开发效率和代码可维护性。

5.1 代码对比:不同框架的实现方式​

场景1:简单查询​

MyBatis(手写 XML):

<!-- UserMapper.xml -->
<select id="findByIdAndAgeAndStatus" resultType="User">
SELECT id, username, age, status, email, phone, create_time, update_time
FROM user
WHERE id = #{id} AND age = #{age} AND status = #{status}
</select>
// UserMapper.java
List<User> findByIdAndAgeAndStatus(
@Param("id") Long id,
@Param("age") Integer age,
@Param("status") Integer status
);

MyBatisGX(方法名生成):

// UserDao.java - 无需 XML
List<User> findByIdAndAgeAndStatus(Long id, Integer age, Integer status);

MyBatis-Plus(Wrapper):

// Service 层
List<User> findByIdAndAgeAndStatus(Long id, Integer age, Integer status) {
return userMapper.selectList(
new LambdaQueryWrapper<User>()
.eq(User::getId, id)
.eq(User::getAge, age)
.eq(User::getStatus, status)
);
}

MyBatis-Flex(QueryWrapper):

// Service 层
List<User> findByIdAndAgeAndStatus(Long id, Integer age, Integer status) {
return userMapper.selectListByQuery(
QueryWrapper.create()
.eq(User::getId, id)
.eq(User::getAge, age)
.eq(User::getStatus, status)
);
}

代码量对比:

  • MyBatis:XML + 接口定义,约 8 行
  • MyBatisGX:仅 1 行方法声明
  • MyBatis-Plus:5 行 Wrapper 构建
  • MyBatis-Flex:5 行 QueryWrapper 构建

场景2:动态查询​

MyBatis(XML + if 标签):

<select id="findByConditions" resultType="User">
SELECT * FROM user
<where>
<if test="id != null">AND id = #{id}</if>
<if test="username != null and username != ''">
AND username LIKE CONCAT('%', #{username}, '%')
</if>
<if test="age != null">AND age &gt; #{age}</if>
<if test="statusList != null and statusList.size() > 0">
AND status IN
<foreach item="item" collection="statusList" open="(" separator="," close=")">
#{item}
</foreach>
</if>
</where>
</select>

MyBatisGX(QueryEntity + 注解):

// 定义查询实体
@QueryEntity(User.class)
public class UserQuery extends User {
private String usernameLike; // 自动识别为 LIKE 条件
private Integer ageGt; // 自动识别为 > 条件
private List<Integer> statusIn; // 自动识别为 IN 条件
}

// DAO 层 - 一行搞定
@Dynamic
List<User> findByConditions(UserQuery query);

MyBatis-Plus(Wrapper):

// Service 层
public List<User> searchUsers(Long id, String username, Integer minAge, List<Integer> statusList) {
return userMapper.selectList(
new LambdaQueryWrapper<User>()
.eq(id != null, User::getId, id)
.like(StringUtils.isNotBlank(username), User::getUsername, username)
.gt(minAge != null, User::getAge, minAge)
.in(CollectionUtils.isNotEmpty(statusList), User::getStatus, statusList)
);
}

MyBatis-Flex(QueryWrapper):

// Service 层
public List<User> searchUsers(Long id, String username, Integer minAge, List<Integer> statusList) {
QueryWrapper query = QueryWrapper.create();
if (id != null) query.eq(User::getId, id);
if (StringUtils.isNotBlank(username)) query.like(User::getUsername, username);
if (minAge != null) query.gt(User::getAge, minAge);
if (CollectionUtils.isNotEmpty(statusList)) query.in(User::getStatus, statusList);
return userMapper.selectListByQuery(query);
}

代码量对比:

  • MyBatis:XML 约 15 行
  • MyBatisGX:QueryEntity 类 + 1 行方法声明
  • MyBatis-Plus:6 行 Wrapper 构建
  • MyBatis-Flex:6 行 QueryWrapper 构建

场景3:层次边界的差异​

MyBatis-Plus / MyBatis-Flex(持久化逻辑泄露到 Service 层):

// Service 层代码
public List<User> searchUsers(Long id, String username, Integer minAge, List<Integer> statusList) {
// 持久化逻辑直接写在 Service 层
return userMapper.selectList(
new LambdaQueryWrapper<User>()
.eq(id != null, User::getId, id)
.like(StringUtils.isNotBlank(username), User::getUsername, username)
.gt(minAge != null, User::getAge, minAge)
.in(CollectionUtils.isNotEmpty(statusList), User::getStatus, statusList)
);
}

问题:数据库查询逻辑泄露到 Service 层,字段名直接暴露在业务代码中,难以复用和测试。

MyBatisGX(DAO 层收敛):

// DAO 层
public interface UserDao extends SimpleDao<User, UserQuery, Long> {
@Dynamic
List<User> searchUsers(UserQuery query);
}

// Service 层
public List<User> searchUsers(Long id, String username, Integer minAge, List<Integer> statusList) {
UserQuery query = new UserQuery();
query.setId(id);
query.setUsernameLike(username);
query.setAgeGt(minAge);
query.setStatusIn(statusList);

return userDao.searchUsers(query);
}

持久化逻辑不泄露,Service 层只知道 DAO 接口。易于测试,可以 Mock UserDao。字段名变更只需修改 Entity,不影响 Service 层。


5.2 MyBatisGX 的独特优势总结​

维度MyBatisMyBatis-PlusMyBatis-FlexMyBatisGX
性能★★★★★ (基准)★★★★☆★★★★☆★★★★★
简单查询代码量XML + 接口Wrapper 构建QueryWrapper仅方法名
动态查询XML <if> 标签Wrapper 动态构建QueryWrapperQueryEntity + @Dynamic
层次边界清晰持久化逻辑泄露持久化逻辑泄露清晰(DAO层收敛)
学习成本需学 XML 语法需学 Wrapper API需学 QueryWrapper API遵循命名约定
SQL 可控性完全可控Wrapper 生成QueryWrapper 生成预生成可查看 + XML 可覆盖
适用场景复杂 SQL / 性能敏感快速开发 / 动态查询灵活查询企业级应用 / 长期维护

5.3 为什么 MyBatisGX 不提供 Wrapper?​

这是架构设计立场的问题。

MyBatisGX 的观点:查询本身是稳定的业务能力,而非一次性的实现细节。Service 层应该只表达业务流程,而不承担任何数据库查询语义。

MyBatisGX 通过方法语义 + QueryEntity 的方式,将所有查询能力收敛在 DAO 层,避免持久化逻辑对业务层的侵入。

对比:

Wrapper 方式(MyBatis-Plus / Flex):
Service 层 ──────┐
↓(构建 Wrapper)
Mapper 层 ──> 数据库

问题:持久化逻辑向上泄露

MyBatisGX 的方式:
Service 层 ──────┐
↓(调用明确的方法)
DAO 层 ──> 数据库

优势:层次边界清晰

六、一个有趣的现象:JVM 预热的重要性​

测试数据显示,第一次执行通常明显更慢。

MyBatisGX 的单条插入:

[Insert][1] 首次执行:79,329 μs  (79ms)
[Insert][1] 第2次:1,675 μs (1.6ms)
[Insert][1] 第3次:1,625 μs (1.6ms)

首次执行是后续的 47 倍。

MyBatis-Flex 的单条插入:

[Insert][1] 首次执行:314,609 μs  (314ms)
[Insert][1] 第2次:3,124 μs (3.1ms)

首次执行是后续的 100 倍。

所有框架都有这个现象。原因包括 JVM JIT 编译、类加载、Mapper 初始化、SQL 缓存建立、连接池预热。

启示:不要用首次执行结果评估性能。生产环境建议预热,应用启动后执行几轮空查询。性能测试必须热身,否则结果没有参考价值。


七、结论​

这轮性能测试的结论:

1. 原生 MyBatis 依然是性能基准​

大部分场景中,手写 SQL 的 MyBatis 性能都处于第一梯队。

2. MyBatisGX 在提供高抽象能力的同时,保持了接近原生的性能​

热身后的数据:

  • 单条插入:仅慢 5%(92μs)
  • 批量插入 1 万条:仅慢 5%(16ms)
  • 动态更新:仅慢 16%(224μs)
  • 复杂查询:持平或更快

高抽象不等于高损耗。

3. MyBatis-Plus 和 MyBatis-Flex 的性能同样优秀​

某些场景下比 MyBatis 慢 20%~50%,但绝对值依然很小(微秒级或毫秒级),绝大部分业务系统感知不到差异。

4. 真正决定性能的不是 ORM 框架​

性能瓶颈通常在:

  • SQL 设计:JOIN 策略、子查询 vs 多次查询
  • 索引设计:WHERE 条件是否命中索引
  • 数据模型:表结构是否合理
  • 批量策略:单条 vs 批量操作

框架层的开销在总耗时中占比极小(通常 < 10%)。

5. 选择 ORM 时,更应该关注​

可维护性、SQL 管理方式、团队开发体验、架构边界,而不是执着于几个百分点的框架开销。


八、写在最后​

性能优化是系统工程,不是简单的框架选型问题。

如果系统遇到性能瓶颈,优先检查:慢 SQL(通过慢查询日志)、索引、N+1 查询、批量操作。解决这些问题后,再考虑是否需要"换一个更快的 ORM 框架"。

MyBatisGX 的设计理念:让代码不被数据库腐蚀。

持久层逻辑归于 DAO,业务逻辑留在 Service。这不仅是编码规范,更是架构立场。

大型项目和长期维护中,这种清晰的边界会带来价值。重构数据库时,Service 层代码无需修改。新人接手时,不需要理解 Wrapper 的构建细节。测试时,可以轻松 Mock DAO 接口。

测试结果显示,这个设计理念并没有以牺牲性能为代价。


项目地址:

欢迎下载源码自行测试,或在 GitHub 上提出你的问题和建议。

我的项目是怎么一步步烂掉的,以及我为什么自研 ORM

· 阅读需 11 分钟

一、从一个说烂了的话题说起​

知乎上隔三差五就有人问:JPA 好,还是 MyBatis 好,还是 MyBatis Plus 好?

吵了这么多年,也没吵出个结论。

原因很简单——每个人的项目不一样,痛点也不一样。用 JPA 的人嫌 MyBatis 写 XML 太累,用 MyBatis 的人嫌 JPA 黑盒太多,用 MyBatis Plus 的人刚开始觉得挺爽,项目做了一两年就觉得哪里不对。

我也在这个问题里纠结了好几年。

后来我发现,其实很多时候大家争论的不是一个技术选型问题,而是一个更深的问题:

数据库访问代码,怎么才能在项目生命周期里一直保持可控?

这个问题比"JPA 还是 MyBatis"重要得多。但很少有人从这角度去想过。


二、我的项目是怎么"烂"掉的​

先讲讲我的经历。

我做过不少 Java 项目。有大有小,有单体有微服务。技术栈也从最早的纯 MyBatis,到后来尝试 JPA,再到 MyBatis Plus。

刚开始用 MyBatis Plus 的时候,确实舒服了很多。不用再为每个表写一堆 XML 了,简单的 CRUD 一行代码搞定。

但项目做了半年之后,我发现代码开始变了味。

Service 层里到处是这样的东西:

public List<User> searchUsers(String name, Integer age, String dept) {
LambdaQueryWrapper<User> wrapper = new LambdaQueryWrapper<>();
if (StringUtils.isNotBlank(name)) {
wrapper.like(User::getName, name);
}
if (age != null) {
wrapper.gt(User::getAge, age);
}
if (StringUtils.isNotBlank(dept)) {
wrapper.eq(User::getDept, dept);
}
return userMapper.selectList(wrapper);
}

看起来没问题对吧?

一个查询两个查询确实没问题。但十个二十个查询呢?

数据库字段名开始大面积出现在 Service 层。

后来新人来了,不知道之前的查询逻辑,又在自己的 Service 里写了一遍类似的 Wrapper。重复代码越来越多,但你想抽公共方法的时候发现——每个查询的条件组合都不太一样,很难复用。

我也试过在 Dao 里写 default 方法封装 Wrapper。Service 确实干净了,但 Dao 里全是模板代码。问题没有解决,只是搬了个地方。

用 JPA 的项目也有类似的问题。简单的用方法名,复杂的用 Specification 或 @Query,再复杂一点就原生 SQL。到最后你会发现,一个项目的数据访问代码散落在至少三个地方:方法名、Specification 类、@Query 注解、还有 xml 里。

分层还在,但边界没了。

这件事让我开始认真思考一个问题:ORM 框架到底应该帮我们解决什么问题?


三、大多数 ORM 解决的是"少写代码",但真正难的是另一个问题​

回头看看这些年主流 ORM 框架的演进方向:

  • Lambda Wrapper
  • Specification
  • Criteria API
  • QueryDSL
  • 链式条件构造器

它们的共同特点是什么?

都是让开发者用 Java 对象的方式来描述查询。

这个方向初期体验确实好。少写 SQL,IDE 有提示,类型安全。

但项目做久了,这些方案慢慢都会出同一个问题:查询逻辑开始扩散。

因为构造查询太方便了,开发者就会在 Service 里随手拼一个。今天拼一个,明天拼一个,用不了多久,数据库访问代码就漏到了 Service 层、Manager 层、甚至 Controller 层。

你去看很多做了两三年的项目,分层架构看起来还在——Controller、Service、Dao,整整齐齐。但仔细看代码:

  • Service 里在拼查询条件
  • Dao 里要么空的,要么全是 Wrapper 封装
  • 复杂报表直接绕过 Dao 写 SQL

形式上的分层还在,但数据访问层的边界已经烂了。

而 ORM 框架对此的态度基本是——不管。它只管帮你少写代码,不管你把代码写在哪儿。


四、所以我自己做了一个​

想明白这件事之后,我做了一个决定:自己写一个 ORM 框架。

不是为了造轮子,是因为我确实没找到一个框架能从设计层面解决这个问题。

这个框架叫 MyBatisGX。

它的核心目标不是"少写代码"——虽然实际上代码确实少了很多。它的核心目标是:让查询逻辑收敛到 Dao 层,别让它到处乱跑。

这听起来很虚,我具体讲讲。

1、查询必须收敛到 Dao​

MyBatisGX 不提供任何让 Service 层拼数据库查询逻辑的能力。没有 Wrapper,没有 Criteria,没有链式构造器。

想查数据?在 Dao 里定义方法。不管是用方法名:

List<User> findByNameLikeAndAgeGt(String name, Integer age);

还是用 QueryEntity:

@QueryEntity(User.class)
public class UserQuery extends User {
private String nameLike;
private Integer ageGt;
}

List<User> findList(UserQuery query);

都是 Dao 层的事。Service 只管调方法,传参数。

这样做的好处是——如果你想改一个查询的逻辑,你知道去哪里找。就在 Dao 里。不会散落在 Service 的各个角落。

2、定义查询,而不是实现查询​

简单查询,用方法名就行,一行定义完事:

User findByName(String name);
List<User> findByAgeBetween(Integer min, Integer max);
Long countByStatusEq(Integer status);

复杂一点的查询,用 QueryEntity,把条件结构化:

@QueryEntity(User.class)
public class UserQuery extends User {
private String nameLike;
private Integer ageGt;
private List<Long> idIn;
}

但更复杂的 SQL 呢?多表关联、统计报表、动态条件?

还是写 SQL。 用 XML、@Statement、@Dynamic 都行。

因为我越来越觉得:SQL 不应该被消灭。 在复杂查询场景下,SQL 反而是最清晰、最直接的表达方式。你用 Java 对象去描述一个五表关联的报表查询,代码量比 SQL 还多,可读性还不如 SQL。

简单的东西简单写,复杂的东西回归本质。

3、保留 MyBatis 的可预测性​

我不想让 ORM 变成一个黑盒。所以 MyBatisGX 有几个坚决不做的事情:

  • 不做 Persistence Context
  • 不做自动脏检查
  • 不做隐式级联更新
  • 不做延迟加载的暗箱操作

所有 SQL 在启动期就预生成好了,你能看到每一条 SQL 长什么样。如果你觉得哪条 SQL 不满意,直接在 mapper.xml 里覆盖它,XML 优先级最高。

很多大型 JPA 项目到最后都在"禁用这些特性"——关掉级联、关掉脏检查、关掉延迟加载。那为什么不一开始就不做呢?


五、最难的地方不在功能​

说实话,做一个 ORM 框架,功能实现反而不是最难的。最难的是取舍。

查询能力要不要开放给 Service 层?​

做框架的人都想让框架好用。提供个 Wrapper,Service 层随手一拼就能查,多方便啊。

但方便的代价就是失控。

我在这个问题上纠结了很久。最后决定:不提供。 宁可框架看起来"笨"一点,也不想给数据访问层的腐蚀留口子。

这个决定意味着框架不能用 Wrapper 这种灵活但容易扩散的方式。那怎么办?

方法名查询和 QueryEntity 就是为了解决这个问题——让开发者能用结构化、可复用的方式定义查询,但必须定义在 Dao 层。

方法名查询的解析有多复杂?​

方法名查询看起来简单:findByNameLikeAndAgeGt,拆一下就知道是 name LIKE ? AND age > ?。

但真正做的时候你会发现,情况远比想象的复杂:

  • 条件之间的 AND/OR 怎么分组?优先级怎么处理?
  • findByNameOrAgeAndDept 到底是 (name OR age) AND dept 还是 name OR (age AND dept)?
  • 嵌套的条件怎么表达?
  • 字段名和关键字怎么准确切分?findByAge 里的 Age 是字段名还是关键字?

光是方法名的解析器,我就重写了三次。

最后用了一种类似 AST 的方式:先把方法名转成 Token 流,再建语法树,最后遍历生成 SQL。支持括号分组,优先级不会出歧义。

QueryEntity 的设计比想象中难​

QueryEntity 的思路是:继承实体类,在子类里加带后缀的查询字段。nameLike 就是 name LIKE ?,ageGt 就是 age > ?。

这个设计看起来很直觉。但实现起来要处理的问题不少:

  • 字段继承关系怎么处理?父类的字段要参与解析
  • 后缀怎么和字段名准确切分?nameLike 切成 name + Like 还是 nameLike + 什么?
  • @Dynamic 动态查询时 null 字段该跳过还是该当 IS NULL 处理?
  • 类型怎么匹配?ageBetween 应该是 List 类型,但编译期怎么校验?

每一个看起来是小问题,组合在一起就是一堆边界情况。

SQL 预生成的时机​

MyBatisGX 的所有 SQL 都是在应用启动时生成的,运行时零开销。但这个决定也让实现变得很难——启动期就必须把所有 SQL 生成正确,运行时再发现问题就晚了。

这意味着框架要在启动阶段完成:扫描实体、解析字段依赖、扫描 Dao 接口、解析方法名、生成 MyBatis 的 XNode、注册到 MyBatis 的 Configuration 里。

整个链路很长,中间任何一个环节出错,应用就起不来。调试和排错的成本比运行时生成高得多。


六、几个工程上的决定​

做这个项目的过程中,我做了一些可能"不够潮流"的决定。但每个决定都有明确的理由。

复用了 JPA 的注解,但不引入 JPA 运行时。 @Entity、@Table、@Column、@Id 这些注解语义成熟,开发者也熟悉,没必要再发明一套。但 JPA 的运行时机制——EntityManager、持久化上下文、自动脏检查——一个都不引入。注解只是描述结构,不控制行为。

SQL 可见、可覆盖。 启动期生成的 SQL,可以通过调试模式看到完整的 XML。如果觉得哪条 SQL 不行,直接在 mapper.xml 里写一条同名的,框架生成的那条就失效了。XML 永远是最高优先级。

多数据库方言适配方案。 目前支持 MySQL、Oracle、PostgreSQL。后续会支持更多的数据库。


七、一些真实的感受​

MyBatisGX雏形是在18年,经历过4次大版本迭代,最近一年多终于把所有的常用功能都实现了,有些想法想说说。

关于 ORM 的方向。 很多 ORM 框架的优化方向都是"让开发者尽量不碰 SQL"。但我觉得这个方向本身可能就值得商榷。SQL 不是什么需要被消灭的东西。在复杂业务场景下,SQL 是最精确、最高效的表达方式。与其花大力气把 SQL 包装成 Java 对象,不如想想怎么让 SQL 的管理更有序。

关于项目的回退现象。 我见过不少项目,初期用 JPA,中期加 @Query,后期又开始写原生 SQL。也见过用 MyBatis Plus 的项目,绕了一圈又回到了 XML。不是这些框架不好,而是项目的复杂度到了一定程度后,开发者对数据访问的精确控制权变得至关重要。这时候不管用什么框架,最终都会往"能直接写 SQL"的方向回退。

关于"SQL 是一种需要集中管理的资源"。 这个观点是我做 MyBatisGX 过程中越来越坚定的。项目里的每一条 SQL 都应该有明确的归属——属于哪个 Dao、查的是什么、条件是什么。散落在 Service 里的 Wrapper、写在 @Query 注解里的大段 SQL、在代码里拼接的动态 SQL——这些都是 SQL 管理失控的表现。


八、项目现状​

MyBatisGX 现在还不算成熟。核心功能已经稳定——CRUD、方法名查询、QueryEntity、分页、关联查询、动态 SQL、逻辑删除、乐观锁这些都有。但文档、测试覆盖、生态都还有很长的路要走。

它不是什么银弹,也不是要取代谁。说白了就是我自己这些年踩了太多坑,想通了一些事情,然后试着用代码把这些想法落地。

有些人做 ORM,出发点是隐藏 SQL。

而我现在越来越觉得,SQL 本身就不应该被隐藏。它需要的是更好的管理方式,而不是更厚的封装层。


GitHub:https://github.com/cris-xue/mybatisgx

官网:http://www.mybatisgx.com

MyBatis、MyBatis-Plus、JPA、MyBatisGX 写法比较:同一个需求,四种解法

· 阅读需 10 分钟

用两个真实场景,看看四种框架在日常开发中的真实体感。


场景 1:一个"普通"的用户管理需求​

产品经理说,用户模块需要支持:

  • 新增用户
  • 查询用户详情(带出 1:1 的用户详情关联)
  • 列表查询(姓名模糊、年龄区间、状态、注册时间范围、分页)
  • 更新用户状态(按部门 ID 批量更新)
  • 删除用户

这几乎是每个后端都写过的需求,足够把各框架的体感完全暴露出来。


MyBatis 写法​

1. 查询​

UserMapper.xml 核心片段:

<select id="findUserList" resultMap="userResultMap">
select u.*, d.phone, d.address from user u
left join user_detail d on u.id = d.user_id
<where>
<if test="name != null">and u.name like concat('%', #{name}, '%')</if>
<if test="minAge != null">and u.age >= #{minAge}</if>
<if test="maxAge != null">and u.age <= #{maxAge}</if>
<if test="status != null">and u.status = #{status}</if>
<if test="startTime != null">and u.create_time >= #{startTime}</if>
<if test="endTime != null">and u.create_time <= #{endTime}</if>
</where>
</select>

再加上 <resultMap> 做关联映射、Param 对象、Service 分页拼接……查询 alone 就要写约 50 行 XML。

2. 增删改​

<insert id="insert">insert into user(...) values(...)</insert>
<update id="updateStatusByDeptId">update user set status=#{status} where dept_id=#{deptId}</update>
<delete id="deleteById">delete from user where id=#{id}</delete>

增删改本身不复杂,但每个方法都要在 XML 里写一遍,重复劳动不少。


MyBatis-Plus 写法​

1. 列表查询​

Service 层常见写法:

LambdaQueryWrapper<User> wrapper = Wrappers.lambdaQuery();
wrapper.like(StringUtils.isNotBlank(name), User::getName, name)
.ge(minAge != null, User::getAge, minAge)
.le(maxAge != null, User::getAge, maxAge)
.eq(status != null, User::getStatus, status)
.ge(startTime != null, User::getCreateTime, startTime)
.le(endTime != null, User::getCreateTime, endTime);

Page<User> page = userMapper.selectPage(new Page<>(current, size), wrapper);

关联查询?MP 基本要回退到手写 SQL 或自己组装数据。

2. 增删改​

// 增
userMapper.insert(user);

// 查单条
userMapper.selectById(id);

// 改
LambdaUpdateWrapper<User> updateWrapper = new LambdaUpdateWrapper<>();
updateWrapper.set(User::getStatus, newStatus).eq(User::getDeptId, deptId);
userMapper.update(null, updateWrapper);

// 删
userMapper.deleteById(id);

单表增删查很顺手,但更新照样要在 Service 层拼 Wrapper。


JPA 写法​

1. 列表查询​

方法名查询:

Page<User> findByNameContainingAndAgeBetweenAndStatusAndCreateTimeBetween(
String name, Integer minAge, Integer maxAge,
Integer status, Date startTime, Date endTime, Pageable pageable);

或者用 Specification:

Specification<User> spec = (root, query, cb) -> {
List<Predicate> predicates = new ArrayList<>();
if (name != null) predicates.add(cb.like(root.get("name"), "%" + name + "%"));
if (minAge != null && maxAge != null)
predicates.add(cb.between(root.get("age"), minAge, maxAge));
// ... 省略类似条件
return cb.and(predicates.toArray(new Predicate[0]));
};
Page<User> page = userRepository.findAll(spec, pageable);

2. 增删改​

// 增/改
userRepository.save(user);

// 查单条
userRepository.findById(id);

// 按条件更新(需要写 JPQL)
@Modifying
@Query("UPDATE User u SET u.status = :status WHERE u.deptId = :deptId")
int updateStatusByDeptId(@Param("deptId") Long deptId, @Param("status") Integer status);

// 删
userRepository.deleteById(id);

关联查询可以在实体上配 @OneToOne,但 LAZY 容易触发 N+1,EAGER 又可能拖出不需要的数据。


MyBatisGX 写法​

1. 只需要定义这些​

实体(带关联):

@Entity
@Table(name = "user")
public class User {
@Id
private Long id;
private String name;
private Integer age;
private Integer status;
private Long deptId;

@OneToOne(mappedBy = "user", fetch = FetchType.EAGER)
@Fetch(FetchMode.BATCH)
private UserDetail userDetail;
}

查询实体:

@QueryEntity(User.class)
public class UserQuery extends User {
private String nameLike;
private List<Integer> ageBetween;
private List<Date> createTimeBetween;
}

DAO 接口——注意:这里不需要写任何自定义方法:

@Mapper
public interface UserDao extends SimpleDao<User, UserQuery, Long> {
}

2. Service 层写法​

// 增
userDao.insert(user);

// 查单条(自动带出 userDetail,BATCH 模式解决 N+1)
userDao.findById(id);

// 列表查询 —— 这是内置方法,直接传 QueryEntity 就行
Pageable pageable = new Pageable(pageNum, pageSize);
userDao.findPage(userQuery, pageable);

// 按部门 ID 更新状态
User updateData = new User();
updateData.setStatus(newStatus);
userDao.updateByDeptId(deptId, updateData);

// 删
userDao.deleteById(id);

3. 为什么列表查询不需要写方法?​

因为 SimpleDao 已经内置了:

@Dynamic
Page<ENTITY> findPage(ENTITY entity, Pageable pageable);

UserQuery 中的字段命名会自动映射成查询条件:

  • nameLike → name LIKE '%value%'
  • ageBetween → age BETWEEN min AND max
  • createTimeBetween → create_time BETWEEN start AND end
  • status → status = value

@Dynamic 注解会让 null 字段自动不参与 WHERE 拼接。


场景 2:产品经理改需求了​

本来以为这个需求已经够"标准"了。

但上线两周后,产品经理改需求了:

  • 状态从等值变多值
  • 用户名称从等值变模糊
  • 用户需要带角色(多对多)
  • 角色页要反查用户

关系从 1:1 变成了 多对多。看看四个框架分别要改多少代码。


MyBatis 改写​

1. 状态等值改多值(IN 查询)​

XML 里找 findUserList:

<!-- 之前 -->
<if test="status != null">and u.status = #{status}</if>

<!-- 之后 -->
<if test="statusList != null and statusList.size() > 0">
and u.status in
<foreach collection="statusList" item="s" open="(" separator="," close=")">
#{s}
</foreach>
</if>

Param 对象里的 Integer status 也要改成 List<Integer> statusList。

2. 名称从等值改模糊​

如果之前用的是 =,现在改成 like concat('%', #{name}, '%')。

3. 加多对多关联​

需要在 UserMapper.xml 里写新的 resultMap,加入 roleList 的 collection 映射,再写一条带 JOIN user_role、JOIN role 的 SQL。role 查用户 反向也要再写一套 ResultMap 和 SQL。

约新增 40~60 行 XML。

痛点:改一个查询条件 + 加一层关联,Param → XML → ResultMap 全要动。


MyBatis-Plus 改写​

1. 状态等值改多值​

找到 Service 里的 Wrapper:

// 之前
.eq(status != null, User::getStatus, status)

// 之后
.in(statusList != null && !statusList.isEmpty(), User::getStatus, statusList)

2. 名称改模糊​

// 之前可能用了 .eq()
// 之后
.like(StringUtils.isNotBlank(name), User::getName, name)

3. 加多对多关联​

MP 不原生支持多对多自动关联。方案:

  • 手写 SQL 带多表 JOIN
  • 或者查完用户后,再循环查角色列表手动塞进去(又会触发 N+1)

痛点:查询条件一改,所有拼过这个 Wrapper 的 Service 方法都要检查;关联查询仍是短板。


JPA 改写​

1. 状态等值改多值 + 名称改模糊​

如果你用的是方法名查询:

// 之前
Page<User> findByNameContainingAndAgeBetweenAndStatusAndCreateTimeBetween(...)

// 之后
Page<User> findByNameContainingAndAgeBetweenAndStatusInAndCreateTimeBetween(...)

方法名又变长一截。如果用 Specification,改 cb.equal → cb.in 和 cb.like,但要找到所有复用了这个条件的地方。

2. 加多对多关联​

实体改造:

@Entity
public class User {
// ...
@ManyToMany(mappedBy = "userList", fetch = FetchType.LAZY)
private List<Role> roleList;
}

@Entity
public class Role {
// ...
@ManyToMany(fetch = FetchType.LAZY)
@JoinTable(name = "user_role",
joinColumns = @JoinColumn(name = "role_id"),
inverseJoinColumns = @JoinColumn(name = "user_id"))
private List<User> userList;
}

关联声明确实优雅,但一不留神就会触发 N+1:查 10 个用户,每个用户再去查角色,变成 11 条甚至更多 SQL。要加 @EntityGraph 或 JOIN FETCH 才能缓解,分页时又有新坑。

痛点:条件一变,方法名爆炸;关联加了,但 SQL 黑盒和 N+1 的焦虑也来了。


MyBatisGX 改写​

1. 状态等值改多值 + 名称改模糊​

打开 UserQuery,改两个字段后缀:

// 之前
private Integer status;

// 之后
private List<Integer> statusIn;

名称本来就是 nameLike,不需要改。

DAO 不需要改,Service 不需要改。 因为 findPage(userQuery, pageable) 是内置方法,框架会自动把 statusIn 解析成 status IN (...)。

2. 加多对多关联​

实体上直接加注解:

@Entity
@Table(name = "user")
public class User {
// ...
@ManyToMany(mappedBy = "userList", fetch = FetchType.LAZY)
@Fetch(FetchMode.BATCH)
private List<Role> roleList;
}

@Entity
@Table(name = "role")
public class Role {
@Id
private Long id;

@ManyToMany(fetch = FetchType.LAZY)
@JoinTable(name = "user_role",
joinColumns = @JoinColumn(name = "role_id"),
inverseJoinColumns = @JoinColumn(name = "user_id"))
@Fetch(FetchMode.BATCH)
private List<User> userList;
}

然后:

// 查用户详情(自动带出 userDetail + roleList)
userDao.findById(userId);

// 查角色详情(自动带出 userList)
roleDao.findById(roleId);

不需要写 ResultMap,不需要写 JOIN SQL。 FetchMode.BATCH 默认会自动解决 N+1:先查主表,再批量用 IN 查关联表,最后组装数据。

一句话总结:需求变了,MyBatisGX 的改动最小,而且关联查询的稳定性是可预期的。


框架优痛点分析​

MyBatis​

  • ✅ SQL 完全可控,复杂查询最稳
  • ❌ 改一个字段,Param → XML → ResultMap 全链路改
  • ❌ 动态 SQL 一多,XML 迅速膨胀

MyBatis-Plus​

  • ✅ 单表 CRUD 效率很高,不用写 XML
  • ❌ 业务层被查询/更新逻辑严重侵入
  • ❌ Wrapper 到处传,DAO 抽象边界逐渐失效
  • ❌ 关联查询是明显短板

JPA​

  • ✅ CRUD 极其舒服,面向对象体验好
  • ❌ SQL 黑盒,优化全靠猜
  • ❌ N+1 问题防不胜防
  • ❌ 复杂查询方法名长到离谱,最终往往还是写原生 SQL

MyBatisGX​

  • ✅ Service 层零查询逻辑,所有条件收敛到 QueryEntity
  • ✅ 关联查询不用写 SQL / ResultMap,声明式关联 + BATCH 抓取策略 N+1 开箱解决
  • ✅ 分页、批量都是内置能力
  • ⚠️ 超复杂的多表聚合统计,仍然可以用 mapper.xml 兜底(优先级最高)

升维对比:四种框架,本质在解决什么?​

框架核心解决的问题典型代价
MyBatisSQL 完全可控重复代码、维护成本高
MyBatis-Plus单表开发效率业务层侵入、复杂查询乏力
JPA对象建模与 CRUD 体验SQL 黑盒、复杂场景失控
MyBatisGX查询定义与业务解耦需要适应新的设计规范

更进一步看 CRUD + 关联的支持:

能力MyBatisMPJPAMyBatisGX
单表增删改需手写 XML内置,快捷内置,优雅内置,简洁
复杂条件查询XML 冗长Service 拼 WrapperSpecification/长方法名QueryEntity 直接传
1:1 关联查询手写 ResultMap需手写 SQL声明式,但 N+1 隐患声明式 + BATCH 自动解决
按条件更新手写 XMLService 拼 UpdateWrapper需写 JPQL方法名自动生成
分页手动处理内置内置内置,对关联友好
需求变更成本高中中低

三种框架都在做"取舍",而 MyBatisGX 试图回答的问题是:

能不能既保留 MyBatis 的 SQL 可控性,又拥有 JPA 的声明式关联体验,同时避免 Wrapper/Specification 对业务层的侵蚀?


总结​

如果你也遇到过这些困境:

  • 写 MyBatis 写到手麻,每个查询都要复制粘贴 XML
  • 用 MyBatis-Plus 用到业务层一团乱,Wrapper 满天飞
  • 用 JPA 被黑盒 SQL 和 N+1 折磨到半夜调优

那或许可以了解一下 MyBatisGX 的思路:把查询还给 DAO,把业务还给 Service。

有的框架在“改实现” 有的框架在“改代码结构”

而 MyBatisGX,只是在“改定义”。

为什么我又写了一个 ORM 框架(MyBatisGX)

· 阅读需 5 分钟

ORM 的"铁三角诅咒"​

写了十年 Java,持久层框架一直没找到理想的选择。

选 MyBatis?
灵活归灵活,但增删改查、分页、批量操作全得手写 XML。每个表都要写一遍,机械重复的工作量很大。

选 MyBatis Plus?
开始用的时候确实爽,慢慢就发现不对劲:

  • 在 Service 层拼 LambdaQueryWrapper,业务代码里到处都是数据库字段名
  • 后来我在 Dao 写 default 方法封装 Wrapper。service 是干净了,但 dao 里全是样板代码,问题只是挪了个地方
  • 简单的 1:1 关联查询也得手写 SQL 或者查两次
  • 批量插入/更新又要继承接口又要继承类,用起来很麻烦

选 JPA?
写代码的时候确实省心,出问题就头疼了。不知道哪里又偷偷执行了一条 SQL,Specification 写动态查询像在用 Java 翻译 SQL 语句。N+1 查询、分页数据爆炸这些坑踩过几次就不想再碰了。复杂点的报表查询?还是老老实实写原生 SQL。

这三个框架分别代表了持久层的三个方向:

  • 要灵活 → 写得累
  • 要省事 → 架构糊
  • 要自动 → 黑盒坑

MyBatisGX 的做法:定义查询,不实现查询​

MyBatisGX 的核心思路:查询是稳定的业务能力,不是临时拼出来的实现细节。

Service 层只写业务流程,查询逻辑全部收敛到 Dao 层,用方法定义清楚地表达出来。

方法名查询​

// 简单查询
List<User> findByNameLike(String name);

// 复杂条件
List<User> findByNameLikeAndAgeBetweenOrStatusEq(
String name, Integer minAge, Integer maxAge, Integer status
);

// 支持任意分组(用括号)
@Statement(value = "findByNameLikeAnd(AgeOrSex)", language = StatementLanguage.METHOD)
List<User> findByNameLikeAndAgeOrSex(String name, Integer age, Integer sex);

方法名就是查询语义,不用 Wrapper,Service 里也不用拼条件。

查询实体​

条件太多的时候方法名会很长,这时候用 QueryEntity:

@QueryEntity
public class UserQuery extends User {
private String nameLike; // 自动解析成模糊查询
private List<Long> idIn; // 自动解析成 IN 查询
private List<Long> ageBetween; // 自动解析成 BETWEEN
}

// Dao 层
List<User> findList(UserQuery query);

查询条件作为结构化对象传递,类型安全,IDE 有提示。Service 层不用关心字段名和查询逻辑。

动态查询​

加个 @Dynamic 注解,自动生成动态 SQL:

@Dynamic
List<User> findByNameLikeAndId(String name, Long id);

参数为 null 的时候,条件自动不加入 SQL。

关联查询​

@Entity
public class User {
@OneToOne(mappedBy = "user", fetch = FetchType.EAGER)
@Fetch(FetchMode.BATCH) // 批量抓取,解决 N+1
private UserDetail userDetail;

@ManyToMany(mappedBy = "userList", fetch = FetchType.LAZY)
@Fetch(FetchMode.JOIN) // JOIN 抓取,分页不爆炸
private List<Role> roleList;
}

不用写 ResultMap,不用手写 JOIN SQL。支持 4 种抓取策略:SIMPLE / BATCH / JOIN / NONE,按场景选。

批量操作​

业务开发里批量插入/更新/删除太常见了。导入功能、数据同步、批量审核,到处都要用。

MyBatisGX 直接内置了批量方法:

// 继承 SimpleDao 就有,不用继承额外的接口或类
int insertBatch(List<User> users); // 批量插入
int updateBatchById(List<User> users); // 批量更新
int deleteBatchById(List<Long> ids); // 批量删除

框架提供的不够?用 @BatchOperation 自己定义:

@BatchOperation
int insertBatchCustom(@BatchData List<User> users, @BatchSize int batchSize);

不用为了批量功能改架构,直接在 Dao 层调用。


是 JPA 的换皮吗?​

不是。

MyBatisGX 确实用了 JPA 的注解(@Entity、@OneToMany 等),但只用来描述结构,不参与行为控制。

JPA 有的东西,MyBatisGX 都没有:

  • EntityManager、Session 生命周期
  • 持久化上下文(Persistence Context)
  • 隐式 SQL 执行、脏检查、自动 Flush

MyBatisGX 的执行模型是 MyBatis:

  • SQL 预生成(启动时扫描 Dao,生成 MappedStatement)
  • SQL 可被 mapper.xml 完全接管
  • SQL 最终形态对开发者可见、可干预

厌恶 JPA 的黑盒运行时,但认可它对象建模的成熟设计?MyBatisGX 就是这个定位。


XML 兜底​

框架生成的 SQL 有问题?需要写复杂的报表查询?

直接按 MyBatis 原始方式写 XML,框架立即失效。

<select id="findByNameLike" resultType="User">
SELECT * FROM user WHERE name LIKE #{name}
</select>

只要 mapper.xml 里有同名方法,MyBatisGX 就不再自动生成。

优先级:mapper.xml > MyBatisGX 自动生成。

这是个渐进式框架:

  • 简单场景,零 XML
  • 复杂场景,随时接管
  • 无缝兼容现有 MyBatis 项目

还有几个真香的点​

无缝升级现有 MyBatis 项目
原来的 mapper.xml 完全不用动,换个依赖、继承个 SimpleDao 接口,就能开始用。

逻辑删除、乐观锁、审计字段
加个注解就行:

@LogicDelete
private Integer deleted;

@Version
private Integer version;

@GeneratedValue(InputTimeValueProcessor.class)
private LocalDateTime createTime;

复合主键、字段加密、投影 DTO
都支持,不需要复杂配置。


总结​

MyBatisGX 不是要替代谁,它回答的是这个问题:

在意代码边界、架构演进和长期维护成本的时候,有没有更好的选择?

只追求"写得快",现在的 ORM 够用。但如果已经被重复代码、架构腐烂、SQL 黑盒、Specification 折磨过,可能不是缺框架,是缺一套正确的抽象。


核心理念: 定义查询,不实现查询。让持久层回归持久层。

为什么我不喜欢用 MyBatis Plus、JPA 框架,更愿意使用 MyBatis

· 阅读需 11 分钟

快速开发 vs 架构清晰,这是持久层框架选择中最常见的两难。

大多数团队选择 MyBatis Plus:

  • 第 1 个月:开发速度快 ✅
  • 第 6 个月:代码难维护 ❌

少数团队选择 MyBatis:

  • 第 1 个月:写 XML 繁琐 ❌
  • 第 6 个月:架构清晰 ✅

这就是技术选型的困境:前期效率 vs 长期质量

但真的必须在两者之间做选择吗?