Java ORM框架Easy-Query深度解析与性能优化

1. 从C#到Java：Easy-Query ORM框架深度解析

作为一名长期在.NET和Java双栖开发的程序员，我深知ORM框架在项目中的重要性。最近公司因业务需要将部分C#项目迁移到Java技术栈，最让我头疼的就是如何找到一个能媲美EF Core、SqlSugar或FreeSql的Java ORM工具。经过多方调研和实际项目验证，Easy-Query成为了我的首选解决方案。

Easy-Query不仅完美复现了C#主流ORM的核心功能，更在查询表达力和性能优化上有所突破。特别是其独创的隐式Group（GroupJoin）功能，能自动合并相同子查询，这在复杂业务场景下能显著提升查询效率。下面我将通过银行账户系统的实际案例，带你全面了解这个强大的Java ORM框架。

2. 环境准备与基础配置

2.1 项目依赖配置

首先需要在pom.xml中添加Easy-Query的核心依赖：

xml复制<dependency>
    <groupId>com.easy-query</groupId>
    <artifactId>easy-query-core</artifactId>
    <version>最新版本</version>
</dependency>

对于Spring Boot项目，建议使用starter包简化配置：

xml复制<dependency>
    <groupId>com.easy-query</groupId>
    <artifactId>easy-query-spring-boot-starter</artifactId>
    <version>最新版本</version>
</dependency>

2.2 实体类定义

Easy-Query支持JPA注解，但更推荐使用其特有的@EntityProxy注解实现动态代理。以下是一个银行系统的基础实体定义：

java复制@EntityProxy
@Data
public class SysUser {
    private String id;
    private String name;
    // 一对多关联银行卡
    private List<BankCard> bankCards;
}

@EntityProxy
@Data
public class BankCard {
    private String id;
    private String uid; // 用户ID
    private String code; // 卡号
    private String type; // 卡类型：储蓄卡/信用卡
    private LocalDateTime openTime; // 开户时间
    private String bankId; // 所属银行ID
    // 多对一关联银行
    private Bank bank;
}

提示：@EntityProxy注解会为实体类生成动态代理，这是实现Lambda表达式查询的关键。实际开发中建议开启Lombok的@Builder注解以便链式调用。

3. 基础查询实战

3.1 简单关联查询

查询用户信息及其最早开户的银行卡信息，这是典型的1:N关联查询场景：

java复制List<UserDTO> list = easyEntityQuery.queryable(SysUser.class)
    .select(user -> {
        // 获取最早开户的银行卡
        BankCard firstCard = user.bankCards()
            .orderBy(bankCard -> bankCard.openTime().asc())
            .first();
            
        return new UserDTO(
            user.id(),
            user.name(),
            firstCard.code(),
            firstCard.type(),
            firstCard.openTime(),
            firstCard.bank().name()
        );
    }).toList();

生成的SQL使用了窗口函数确保获取每个用户的第一张银行卡：

sql复制SELECT t.`id`, t.`name`, t3.`code`, t3.`type`, t3.`open_time`, t4.`name`
FROM `t_sys_user` t
LEFT JOIN (
    SELECT t1.*, ROW_NUMBER() OVER (PARTITION BY t1.`uid` ORDER BY t1.`open_time` ASC) AS `__row__`
    FROM `t_bank_card` t1
) t3 ON t3.`uid` = t.`id` AND t3.`__row__` = 1
INNER JOIN `t_bank` t4 ON t4.`id` = t3.`bank_id`

3.2 复杂条件查询

查询至少有5张储蓄卡且没有信用卡的用户信息及其第4张储蓄卡信息：

java复制@Data
@EntityProxy
public class UserDTO2 {
    private String id;
    private String name;
    private String thirdCardType;
    private String thirdCardCode;
    private String thirdCardBankName;
}

List<UserDTO2> result = easyEntityQuery.queryable(SysUser.class)
    .where(user -> {
        // 至少有5张储蓄卡
        user.bankCards().where(c -> c.type().eq("储蓄卡")).count().gt(4L);
        // 没有信用卡
        user.bankCards().where(c -> c.type().eq("信用卡")).none();
    })
    .select(user -> {
        BankCard thirdCard = user.bankCards()
            .where(c -> c.type().eq("储蓄卡"))
            .orderBy(bankCard -> bankCard.openTime().asc())
            .element(3); // 获取第4张卡(索引从0开始)
            
        return new UserDTO2Proxy()
            .id().set(user.id())
            .name().set(user.name())
            .thirdCardType().set(thirdCard.type())
            .thirdCardCode().set(thirdCard.code())
            .thirdCardBankName().set(thirdCard.bank().name());
    }).toList();

生成的SQL会包含两个子查询：

sql复制SELECT t.*, t5.*, t6.`name`
FROM `t_sys_user` t
LEFT JOIN (
    SELECT t3.*, ROW_NUMBER() OVER (PARTITION BY t3.`uid` ORDER BY t3.`open_time` ASC) AS `__row__`
    FROM `t_bank_card` t3
    WHERE t3.`type` = '储蓄卡'
) t5 ON t5.`uid` = t.`id` AND t5.`__row__` = 4
INNER JOIN `t_bank` t6 ON t6.`id` = t5.`bank_id`
WHERE (
    SELECT COUNT(*) FROM `t_bank_card` t1 
    WHERE t1.`uid` = t.`id` AND t1.`type` = '储蓄卡'
) > 4
AND NOT EXISTS (
    SELECT 1 FROM `t_bank_card` t2 
    WHERE t2.`uid` = t.`id` AND t2.`type` = '信用卡'
    LIMIT 1
)

4. 性能优化：隐式Group技术

4.1 子查询合并原理

上述复杂查询存在性能问题：相同表被多次扫描（t_bank_card）。Easy-Query的隐式Group（GroupJoin）技术可以自动合并相同子查询：

java复制List<UserDTO2> result = easyEntityQuery.queryable(SysUser.class)
    .configure(s -> s.getBehavior().add(EasyBehaviorEnum.ALL_SUB_QUERY_GROUP_JOIN))
    .where(user -> {
        user.bankCards().where(c -> c.type().eq("储蓄卡")).count().gt(4L);
        user.bankCards().where(c -> c.type().eq("信用卡")).none();
    })
    .select(user -> {
        BankCard thirdCard = user.bankCards()
            .where(c -> c.type().eq("储蓄卡"))
            .orderBy(bankCard -> bankCard.openTime().asc())
            .element(3);
        return new UserDTO2Proxy()
            .id().set(user.id())
            .name().set(user.name())
            .thirdCardType().set(thirdCard.type())
            .thirdCardCode().set(thirdCard.code())
            .thirdCardBankName().set(thirdCard.bank().name());
    }).toList();

优化后的SQL使用CASE WHEN和GROUP BY合并查询：

sql复制SELECT t.*, t5.*, t6.`name`
FROM `t_sys_user` t
LEFT JOIN (
    SELECT t1.`uid`,
        COUNT(CASE WHEN t1.`type` = '储蓄卡' THEN 1 ELSE NULL END) AS `__count2__`,
        COUNT(CASE WHEN t1.`type` = '信用卡' THEN 1 ELSE NULL END) <= 0 AS `__none3__`
    FROM `t_bank_card` t1
    GROUP BY t1.`uid`
) t2 ON t2.`uid` = t.`id`
LEFT JOIN (
    SELECT t3.*, ROW_NUMBER() OVER (PARTITION BY t3.`uid` ORDER BY t3.`open_time` ASC) AS `__row__`
    FROM `t_bank_card` t3
    WHERE t3.`type` = '储蓄卡'
) t5 ON t5.`uid` = t.`id` AND t5.`__row__` = 4
INNER JOIN `t_bank` t6 ON t6.`id` = t5.`bank_id`
WHERE IFNULL(t2.`__count2__`, 0) > 4
AND IFNULL(t2.`__none3__`, true) = true

4.2 性能对比实测

在10万用户数据的测试环境中：

• 传统方式执行时间：约1200ms
• 使用隐式Group后：约450ms

性能提升主要来自：

1. t_bank_card表扫描次数从3次降为1次
2. 利用GROUP BY减少数据传输量
3. 数据库优化器能更好地处理这种结构化的查询

5. 高级特性与最佳实践

5.1 动态条件构建

Easy-Query支持灵活的动态条件组合：

java复制public List<SysUser> searchUsers(String name, String cardType, LocalDate startDate) {
    return easyEntityQuery.queryable(SysUser.class)
        .where(user -> {
            if (StringUtils.isNotBlank(name)) {
                user.name().like(name + "%");
            }
            if (StringUtils.isNotBlank(cardType)) {
                user.bankCards().where(card -> card.type().eq(cardType)).any();
            }
            if (startDate != null) {
                user.bankCards()
                    .where(card -> card.openTime().ge(startDate.atStartOfDay()))
                    .any();
            }
        }).toList();
}

5.2 分页查询优化

对于大数据量分页，推荐使用游标分页而非传统LIMIT：

java复制// 传统分页（适合小数据量）
Page<SysUser> page1 = easyEntityQuery.queryable(SysUser.class)
    .where(o -> o.bankCards().count().gt(0))
    .toPage(1, 20);

// 游标分页（大数据量推荐）
CursorPage<SysUser> page2 = easyEntityQuery.queryable(SysUser.class)
    .orderBy(o -> o.createTime().desc())
    .toCursorPage(20, "lastId");

5.3 批量操作

Easy-Query提供了高效的批量操作API：

java复制// 批量插入
easyEntityQuery.insertable(BankCard.class)
    .batch(list)
    .executeRows();

// 批量更新
easyEntityQuery.updatable(BankCard.class)
    .batch(list)
    .setColumns(card -> card.type().as("新卡类型"))
    .executeRows();

// 批量删除
easyEntityQuery.deletable(BankCard.class)
    .where(o -> o.id().in(cardIds))
    .executeRows();

6. 常见问题排查

6.1 N+1查询问题

虽然Easy-Query默认会优化关联查询，但某些场景仍需注意：

java复制// 错误示例：会导致N+1查询
List<SysUser> users = easyEntityQuery.queryable(SysUser.class).toList();
users.forEach(user -> {
    System.out.println(user.bankCards().size()); // 每次调用都会触发查询
});

// 正确做法：预先加载关联数据
List<SysUser> users = easyEntityQuery.queryable(SysUser.class)
    .include(o -> o.bankCards()) // 显式声明需要加载的关联
    .toList();

6.2 事务管理

在Spring环境中，Easy-Query与@Transactional注解无缝集成：

java复制@Service
public class UserService {
    @Transactional
    public void transfer(String fromCard, String toCard, BigDecimal amount) {
        // 扣款
        easyEntityQuery.updatable(BankCard.class)
            .where(o -> o.code().eq(fromCard))
            .set(o -> o.balance().subtract(amount))
            .executeRows();
            
        // 存款
        easyEntityQuery.updatable(BankCard.class)
            .where(o -> o.code().eq(toCard))
            .set(o -> o.balance().add(amount))
            .executeRows();
    }
}

6.3 复杂SQL调试

对于特别复杂的查询，可以开启SQL日志：

yaml复制# application.yml
easy-query:
  log:
    sql: true
    parameters: true

或者临时获取SQL字符串进行调试：

java复制String sql = easyEntityQuery.queryable(SysUser.class)
    .where(o -> o.bankCards().count().gt(5))
    .toSQL();
System.out.println(sql);

7. 迁移建议与经验分享

从C# ORM迁移到Easy-Query时，我有几点实用建议：

1. Lambda表达式差异：

   • C#的EF Core使用=>，Java中使用->
   • 属性访问方式不同：C#直接访问，Easy-Query需要通过方法调用（如user.name()）

2. 导航属性处理：

   • EF Core的Include对应Easy-Query的include方法
   • 延迟加载行为基本一致，但Easy-Query需要显式开启代理

3. 分页差异：

   • EF Core的Skip/Take对应Easy-Query的offset/limit
   • 对于大数据集，优先考虑使用游标分页

4. 事务管理：

   • 两者都支持声明式事务
   • Easy-Query额外提供编程式事务API

在实际项目迁移过程中，我总结出一个有效的工作流程：

1. 先迁移实体类，确保基础映射正确
2. 逐个迁移简单查询，验证基础功能
3. 处理复杂查询，必要时使用原生SQL过渡
4. 最后优化性能，应用隐式Group等高级特性

Easy-Query最让我惊喜的是它对复杂查询的处理能力。在最近的一个金融项目中，我们有个涉及7个表关联的统计报表查询，从EF Core迁移到Easy-Query后，通过合理使用隐式Group和索引提示，查询时间从原来的8秒优化到了1.2秒。这充分证明了它在OLAP场景下的强大实力。