// ═══════════════════════════════════════════
// MyBatis Plus 方式（Service 层 50 行）
// ═══════════════════════════════════════════
@Service
public class OrderService {

    public List<Order> searchOrders(OrderQueryDTO query) {
        LambdaQueryWrapper<Order> wrapper = new LambdaQueryWrapper<>();

        // 状态筛选
        if (query.getStatus() != null) {
            wrapper.eq(Order::getStatus, query.getStatus());
        }

        // 时间范围
        if (query.getStartTime() != null) {
            wrapper.ge(Order::getCreateTime, query.getStartTime());
        }
        if (query.getEndTime() != null) {
            wrapper.le(Order::getCreateTime, query.getEndTime());
        }

        // 金额范围
        if (query.getMinAmount() != null) {
            wrapper.ge(Order::getTotalAmount, query.getMinAmount());
        }
        if (query.getMaxAmount() != null) {
            wrapper.le(Order::getTotalAmount, query.getMaxAmount());
        }

        // 支付方式
        if (query.getPayType() != null) {
            wrapper.eq(Order::getPayType, query.getPayType());
        }

        // 配送方式
        if (query.getDeliveryType() != null) {
            wrapper.eq(Order::getDeliveryType, query.getDeliveryType());
        }

        // 关键词搜索（多字段）
        if (StringUtils.isNotBlank(query.getKeyword())) {
            wrapper.and(w -> w
                .like(Order::getOrderNo, query.getKeyword())
                .or()
                .like(Order::getUserName, query.getKeyword())
                .or()
                .like(Order::getUserPhone, query.getKeyword())
            );
        }

        // ...（省略类似的 20 行条件判断）

        wrapper.orderByDesc(Order::getCreateTime);
        return orderMapper.selectList(wrapper);
    }
}

public Specification<User> buildSpec(UserQueryDTO query) {
    return (root, criteriaQuery, cb) -> {
        List<Predicate> predicates = new ArrayList<>();

        if (query.getName() != null) {
            predicates.add(cb.like(root.get("name"), "%" + query.getName() + "%"));
        }

        if (query.getMinAge() != null) {
            predicates.add(cb.gt(root.get("age"), query.getMinAge()));
        }

        if (query.getStatus() != null) {
            predicates.add(cb.equal(root.get("status"), query.getStatus()));
        }

        // 字段名是字符串，没有类型安全
        // 写起来很啰嗦

        return cb.and(predicates.toArray(new Predicate[0]));
    };
}

// 使用
List<User> users = userRepository.findAll(buildSpec(query));

@Transactional
public void updateUser(Long userId, String newName) {
    User user = userRepository.findById(userId).get();
    user.setName(newName);
    // 没有显式 save()，但数据库已经更新了？！
    // 什么时候执行的 SQL？
    // 执行了哪些 SQL？
    // 你完全不知道...
}

List<User> users = userRepository.findAll();

for (User user : users) {
    // 看起来只是取个属性，实际上...
    List<Order> orders = user.getOrders(); // ← 触发 SQL！
    // 如果有 100 个用户，这里会执行 100 次 SQL！
}

// Step 1: 写 Native SQL
@Query(value = "SELECT u.*, o.* FROM user u " +
               "LEFT JOIN orders o ON u.id = o.user_id " +
               "WHERE u.status = ?1",
       nativeQuery = true)
List<Object[]> findUsersWithOrders(Integer status);

// Step 2: 结果映射变复杂
// 返回的是 Object[]，需要手动映射...
// 或者配置 @SqlResultSetMapping...
// 总之，很麻烦！

接管成本：极高 ❌

// ═══════════════════════════════════════════
// MyBatis Plus 方式（Service 层 50 行）
// ═══════════════════════════════════════════
@Service
public class OrderService {
    public List<Order> searchOrders(OrderQueryDTO query) {
        // 50 行 Wrapper 构建代码...
        LambdaQueryWrapper<Order> wrapper = new LambdaQueryWrapper<>();

        if (query.getStatus() != null) {
            wrapper.eq(Order::getStatus, query.getStatus());
        }
        // ...（省略 40 行）

        return orderMapper.selectList(wrapper);
    }
}

// ═══════════════════════════════════════════
// MyBatisGX 方式（Service 层 5 行）
// ═══════════════════════════════════════════
@Service
public class OrderService {
    public List<Order> searchOrders(OrderQuery query) {
        return orderDao.findList(query);
    }
}

// 查询逻辑在 DAO 层
public interface OrderDao extends SimpleDao<Order, OrderQuery, Long> {
    @Dynamic
    List<Order> findList(OrderQuery query);
}

// QueryEntity 定义（类型安全）
@QueryEntity
public class OrderQuery extends Order {
    private Integer statusEq;
    private Date createTimeGe;
    private Date createTimeLe;
    private BigDecimal totalAmountGe;
    private BigDecimal totalAmountLe;
    private String orderNoLike;
    private String userNameLike;
    // ...null 字段自动忽略
}

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

    // 简单查询（不需要写 XML）
    List<User> findByNameLike(String name);

    // 复杂条件组合
    List<User> findByNameLikeAndAgeGtAndStatusIn(
        String name,
        Integer age,
        List<Integer> statusList
    );

    // 排序
    List<User> findByStatusOrderByCreateTimeDesc(Integer status);

    // 分页
    Page<User> findByAgeGt(Integer age, Pageable pageable);
}

// 框架自动生成 SQL，无需写 XML ✅
// 但如果需要优化，XML 随时可以接管 ✅

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

    // 声明式关联 + 批量抓取避免 N+1
    @ManyToOne(fetch = FetchType.LAZY)
    @JoinColumn(name = "org_id")
    @Fetch(FetchMode.BATCH)  // 批量查询避免 N+1
    private Org org;
}

// 四种抓取模式：SIMPLE / BATCH / JOIN / NONE
// 精确控制性能，不会有 JPA 的 N+1 问题

// NONE 模式：完全不查询，手动控制
@ManyToOne
@Fetch(FetchMode.NONE)
private Avatar avatar;  // 从缓存/CDN 加载，不走数据库

@Entity
public class User {
    @LogicDelete
    private Integer deleted;  // 0: 正常，1: 已删除

    @Version
    private Integer version;  // 乐观锁
}

// 删除时自动转换为 UPDATE
userDao.deleteById(userId);
// UPDATE user SET deleted = 1 WHERE id = ? AND deleted = 0

@Entity
public class User {
    @GeneratedValue(CreateTimeProcessor.class)
    private Date createTime;

    @GeneratedValue(UpdateTimeProcessor.class)
    private Date updateTime;
}

// 插入/更新时自动填充