第1章：Jimmer框架概述¶

public Order findOrderById(long id) {
    Connection conn = null;
    PreparedStatement stmt = null;
    ResultSet rs = null;
    try {
        conn = dataSource.getConnection();
        stmt = conn.prepareStatement(
            "SELECT o.*, c.* FROM orders o " +
            "LEFT JOIN customers c ON o.customer_id = c.id " +
            "WHERE o.id = ?"
        );
        stmt.setLong(1, id);
        rs = stmt.executeQuery();

        if (rs.next()) {
            Order order = new Order();
            order.setId(rs.getLong("id"));
            order.setOrderNo(rs.getString("order_no"));
            order.setCreateTime(rs.getTimestamp("create_time"));

            Customer customer = new Customer();
            customer.setId(rs.getLong("customer_id"));
            customer.setName(rs.getString("name"));
            order.setCustomer(customer);

            // 查询订单项需要额外的SQL
            order.setItems(findOrderItems(conn, id));

            return order;
        }
        return null;
    } catch (SQLException e) {
        throw new RuntimeException(e);
    } finally {
        // 这里还需要一大段关闭资源的代码
        try {
            if (rs != null) rs.close();
            if (stmt != null) stmt.close();
            if (conn != null) conn.close();
        } catch (SQLException e) {
            // 错误处理
        }
    }
}

private List<OrderItem> findOrderItems(Connection conn, long orderId) {
    List<OrderItem> items = new ArrayList<>();
    PreparedStatement stmt = null;
    ResultSet rs = null;
    try {
        stmt = conn.prepareStatement(
            "SELECT * FROM order_items WHERE order_id = ?"
        );
        stmt.setLong(1, orderId);
        rs = stmt.executeQuery();

        while (rs.next()) {
            OrderItem item = new OrderItem();
            item.setId(rs.getLong("id"));
            item.setProductId(rs.getLong("product_id"));
            item.setQuantity(rs.getInt("quantity"));
            item.setPrice(rs.getBigDecimal("price"));
            items.add(item);
        }
    } catch (SQLException e) {
        throw new RuntimeException(e);
    } finally {
        // 又是一段关闭资源的代码
    }
    return items;
}

public abstract class Order {
    private Long id;
    private String orderNo;
    // 共同属性
}

public class NormalOrder extends Order {
    private BigDecimal actualPrice;
    // 普通订单特有属性
}

public class PreOrder extends Order {
    private BigDecimal deposit;
    private Date preOrderTime;
    // 预售订单特有属性
}

public void createOrder(Order order) {
    Connection conn = null;
    try {
        conn = dataSource.getConnection();
        conn.setAutoCommit(false);  // 开启事务

        // 保存订单主表
        saveOrder(conn, order);

        // 保存订单项
        for (OrderItem item : order.getItems()) {
            saveOrderItem(conn, item);
        }

        // 更新库存
        for (OrderItem item : order.getItems()) {
            updateStock(conn, item);
        }

        conn.commit();  // 提交事务
    } catch (SQLException e) {
        try {
            if (conn != null) {
                conn.rollback();  // 回滚事务
            }
        } catch (SQLException ex) {
            // 错误处理
        }
        throw new RuntimeException(e);
    } finally {
        try {
            if (conn != null) {
                conn.close();
            }
        } catch (SQLException e) {
            // 错误处理
        }
    }
}

public abstract class OrderEJB implements EntityBean {
    // CMP字段声明 - 注意这些都是抽象方法
    public abstract Long getId();
    public abstract void setId(Long id);

    public abstract String getOrderNo();
    public abstract void setOrderNo(String orderNo);

    public abstract Customer getCustomer();
    public abstract void setCustomer(Customer customer);

    public abstract Collection getItems();
    public abstract void setItems(Collection items);

    // 业务方法
    public void addItem(OrderItem item) {
        Collection items = getItems();
        items.add(item);
    }

    // 查询方法
    public Collection findItemsByProduct(Long productId) {
        return ejbContext.getEJBHome()
            .createFinder("SELECT OBJECT(i) FROM OrderItems i " +
                         "WHERE i.product.id = ?1")
            .findByPrimaryKey(productId);
    }
}

public class OrderServiceBean implements SessionBean {
    public Collection findRecentOrders(Long customerId) {
        try {
            // 需要通过Home接口创建查询
            OrderHome home = (OrderHome)
                new InitialContext().lookup("java:comp/env/ejb/OrderHome");

            // 使用EJB QL查询
            return home.findByCustomerAndDate(
                customerId,
                DateUtils.oneMonthAgo(),
                new Date()
            );
        } catch (Exception e) {
            throw new EJBException(e);
        }
    }
}

public void createOrder(OrderDTO orderDTO) {
    try {
        // 创建订单实体
        OrderHome orderHome = (OrderHome)
            new InitialContext().lookup("java:comp/env/ejb/OrderHome");
        Order order = orderHome.create(orderDTO.getId());

        // 设置订单属性
        order.setOrderNo(orderDTO.getOrderNo());

        // 关联客户
        CustomerHome customerHome = (CustomerHome)
            new InitialContext().lookup("java:comp/env/ejb/CustomerHome");
        Customer customer = customerHome.findByPrimaryKey(orderDTO.getCustomerId());
        order.setCustomer(customer);

        // 创建订单项
        OrderItemHome itemHome = (OrderItemHome)
            new InitialContext().lookup("java:comp/env/ejb/OrderItemHome");
        for (OrderItemDTO itemDTO : orderDTO.getItems()) {
            OrderItem item = itemHome.create(itemDTO.getId());
            item.setQuantity(itemDTO.getQuantity());
            item.setPrice(itemDTO.getPrice());
            order.addItem(item);
        }
    } catch (Exception e) {
        throw new EJBException("Failed to create order", e);
    }
}

@Entity
@Table(name = "orders")
public class Order {
    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;

    @Column(name = "order_no")
    private String orderNo;

    @ManyToOne(fetch = FetchType.LAZY)
    @JoinColumn(name = "customer_id")
    private Customer customer;

    @OneToMany(mappedBy = "order", cascade = CascadeType.ALL)
    private List<OrderItem> items = new ArrayList<>();

    // 业务方法
    public void addItem(OrderItem item) {
        items.add(item);
        item.setOrder(this);
    }

    public BigDecimal getTotalAmount() {
        return items.stream()
            .map(item -> item.getPrice().multiply(
                new BigDecimal(item.getQuantity())))
            .reduce(BigDecimal.ZERO, BigDecimal::add);
    }

    // Getters and setters
}

public class OrderService {
    private final SessionFactory sessionFactory;

    public List<Order> findRecentOrders(Long customerId) {
        Session session = sessionFactory.getCurrentSession();

        return session.createQuery(
            "from Order o " +
            "where o.customer.id = :customerId " +
            "and o.createTime >= :startDate " +
            "order by o.createTime desc",
            Order.class
        )
        .setParameter("customerId", customerId)
        .setParameter("startDate", DateUtils.oneMonthAgo())
        .list();
    }

    // 使用Criteria API的替代方案
    public List<Order> findRecentOrdersCriteria(Long customerId) {
        Session session = sessionFactory.getCurrentSession();

        return session.createCriteria(Order.class)
            .createAlias("customer", "c")
            .add(Restrictions.eq("c.id", customerId))
            .add(Restrictions.ge("createTime", DateUtils.oneMonthAgo()))
            .addOrder(Order.desc("createTime"))
            .list();
    }
}

@Service
@Transactional
public class OrderService {
    public Order createOrder(OrderDTO orderDTO) {
        Session session = sessionFactory.getCurrentSession();

        // 创建订单
        Order order = new Order();
        order.setOrderNo(orderDTO.getOrderNo());

        // 关联客户 - 延迟加载
        Customer customer = session.load(Customer.class, orderDTO.getCustomerId());
        order.setCustomer(customer);

        // 创建订单项 - 级联保存
        for (OrderItemDTO itemDTO : orderDTO.getItems()) {
            OrderItem item = new OrderItem();
            item.setQuantity(itemDTO.getQuantity());

            // 商品引用 - 延迟加载
            Product product = session.load(Product.class, itemDTO.getProductId());
            item.setProduct(product);

            order.addItem(item);  // 自动处理双向关系
        }

        // 保存订单 - 级联保存所有订单项
        session.save(order);

        return order;
    }
}

@Entity
@Table(name = "orders")
@EntityListeners(AuditingEntityListener.class)
public class Order {
    // ... 其他属性

    @Version
    private Integer version;

    @CreatedDate
    private LocalDateTime createTime;

    @LastModifiedDate
    private LocalDateTime updateTime;

    @Enumerated(EnumType.STRING)
    private OrderStatus status;

    @PreUpdate
    public void preUpdate() {
        if (status == OrderStatus.COMPLETED) {
            // 自动记录订单完成时间
            this.updateTime = LocalDateTime.now();
        }
    }
}

@Transactional
public OrderDTO findOrderDetail(Long orderId) {
    Order order = session.get(Order.class, orderId);
    Customer customer = order.getCustomer();
    List<OrderItem> items = order.getItems();

    return new OrderDTO(
        order.getId(),
        order.getOrderNo(),
        customer.getName(),
        items.stream()
            .map(item -> item.getProduct().getName())
            .collect(Collectors.toList())
    );
}

@Transactional
public List<OrderVO> findRecentOrders(Long customerId) {
    List<Order> orders = session.createQuery(
        "from Order o where o.customer.id = :customerId",
        Order.class
    )
    .setParameter("customerId", customerId)
    .setMaxResults(10)
    .list();

    return orders.stream().map(order -> {
        OrderVO vo = new OrderVO();
        vo.setId(order.getId());
        vo.setOrderNo(order.getOrderNo());
        vo.setItemCount(order.getItems().size());
        vo.setTotalAmount(order.getItems().stream()
            .map(item -> item.getPrice()
                .multiply(new BigDecimal(item.getQuantity())))
            .reduce(BigDecimal.ZERO, BigDecimal::add));
        return vo;
    }).collect(Collectors.toList());
}

@Transactional
public List<OrderVO> findRecentOrdersOptimized(Long customerId) {
    return session.createQuery(
        "select new com.example.OrderVO(" +
            "o.id, o.orderNo, " +
            "size(o.items), " +
            "sum(i.price * i.quantity)) " +
        "from Order o " +
        "left join o.items i " +
        "where o.customer.id = :customerId " +
        "group by o.id, o.orderNo",
        OrderVO.class
    )
    .setParameter("customerId", customerId)
    .setMaxResults(10)
    .list();
}

@Transactional
public void updateOrderStatus(Long orderId, OrderStatus status) {
    Order order = session.get(Order.class, orderId);
    order.setStatus(status);
}

@Transactional
public void updateOrderStatusWithDebug(Long orderId, OrderStatus status) {
    log.debug("开始更新订单状态: orderId={}, status={}", orderId, status);
    Session session = sessionFactory.getCurrentSession();
    log.debug("当前Session: {}", session.getStatistics());

    Order order = session.get(Order.class, orderId);
    log.debug("查询到订单: {}", order);
    log.debug("一级缓存状态: {}", session.contains(order));

    order.setStatus(status);
    session.flush();
    log.debug("状态更新完成");
}

@Entity
@Cache(usage = CacheConcurrencyStrategy.READ_WRITE)
public class Product {
    @Id
    private Long id;

    private String name;

    @Version
    private int version;

    @Cache(usage = CacheConcurrencyStrategy.NONE)
    private int stock;

    @Cache(usage = CacheConcurrencyStrategy.NONSTRICT_READ_WRITE)
    @Formula("(select avg(r.score) from reviews r where r.product_id = id)")
    private BigDecimal avgScore;
}

@Service
public class ProductService {
    @Transactional
    public void updateStock(Long productId, int delta) {
        Session session = sessionFactory.getCurrentSession();

        Product product = session.get(
            Product.class, 
            productId,
            LockMode.PESSIMISTIC_WRITE
        );

        int newStock = product.getStock() + delta;
        if (newStock < 0) {
            throw new IllegalStateException("库存不足");
        }
        product.setStock(newStock);

        session.getSessionFactory()
            .getCache()
            .evictEntity(Product.class, productId);
    }
}

// TopLink特有的注解和API
@Entity
@Table(name = "orders")
@DescriptorCustomizer(OrderCustomizer.class)
public class Order {
    @Id
    @GeneratedValue(strategy = GenerationType.SEQUENCE, 
        sequenceName = "ORDER_SEQ")
    private Long id;

    @OneToMany(mappedBy = "order", cascade = CascadeType.ALL)
    @PrivateOwned
    private List<OrderItem> items;

    // TopLink特有的缓存配置
    @Cache(
        type = CacheType.SOFT_WEAK, 
        size = 500,
        expiry = 36000000
    )
    private Customer customer;
}

// TopLink特有的查询API
public Order findOrder(EntityManager em, Long orderId) {
    ReadAllQuery query = new ReadAllQuery(Order.class);
    query.setSelectionCriteria(
        query.getExpressionBuilder().get("id").equal(orderId)
    );
    return (Order) em.createQuery(query).getSingleResult();
}

// Hibernate特有的注解和API
@Entity
@Table(name = "orders")
@Cache(usage = CacheConcurrencyStrategy.READ_WRITE)
public class Order {
    @Id
    @GeneratedValue(generator = "order_seq")
    @SequenceGenerator(
        name = "order_seq",
        sequenceName = "ORDER_SEQ"
    )
    private Long id;

    @OneToMany(mappedBy = "order", cascade = CascadeType.ALL)
    @Cascade(org.hibernate.annotations.CascadeType.DELETE_ORPHAN)
    private List<OrderItem> items;

    @ManyToOne(fetch = FetchType.LAZY)
    @Cache(usage = CacheConcurrencyStrategy.READ_WRITE)
    private Customer customer;
}

// Hibernate特有的查询API
public Order findOrder(Session session, Long orderId) {
    return session.createCriteria(Order.class)
        .add(Restrictions.eq("id", orderId))
        .uniqueResult();
}

@Entity
@Table(name = "orders")
public class Order {
    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;

    @Column(name = "order_no", length = 32, unique = true)
    private String orderNo;

    @ManyToOne(fetch = FetchType.LAZY)
    @JoinColumn(name = "customer_id")
    private Customer customer;

    @OneToMany(mappedBy = "order", cascade = CascadeType.ALL, orphanRemoval = true)
    private List<OrderItem> items = new ArrayList<>();

    @Version
    private Long version;

    @Temporal(TemporalType.TIMESTAMP)
    @Column(name = "create_time")
    private Date createTime;

    @Enumerated(EnumType.STRING)
    private OrderStatus status;

    // 业务方法
    public void addItem(OrderItem item) {
        items.add(item);
        item.setOrder(this);
    }

    public void removeItem(OrderItem item) {
        items.remove(item);
        item.setOrder(null);
    }

    public BigDecimal getTotalAmount() {
        return items.stream()
            .map(OrderItem::getSubTotal)
            .reduce(BigDecimal.ZERO, BigDecimal::add);
    }
}

@Stateless
public class OrderService {
    @PersistenceContext
    private EntityManager em;

    public Order findOrder(Long id) {
        return em.createQuery(
            "SELECT o FROM Order o " +
            "LEFT JOIN FETCH o.customer " +
            "LEFT JOIN FETCH o.items " +
            "WHERE o.id = :id",
            Order.class
        )
        .setParameter("id", id)
        .getSingleResult();
    }

    public List<Order> findRecentOrders(Long customerId) {
        // 使用Criteria API构建查询
        CriteriaBuilder cb = em.getCriteriaBuilder();
        CriteriaQuery<Order> cq = cb.createQuery(Order.class);
        Root<Order> order = cq.from(Order.class);

        // 构建查询条件
        cq.select(order)
            .where(cb.equal(order.get("customer").get("id"), customerId))
            .orderBy(cb.desc(order.get("createTime")));

        return em.createQuery(cq)
            .setMaxResults(10)
            .getResultList();
    }

    // 使用命名查询
    @NamedQuery(
        name = "Order.findByStatus",
        query = "SELECT o FROM Order o WHERE o.status = :status"
    )
    public List<Order> findOrdersByStatus(OrderStatus status) {
        return em.createNamedQuery("Order.findByStatus", Order.class)
            .setParameter("status", status)
            .getResultList();
    }
}

@Stateless
public class OrderService {
    @PersistenceContext
    private EntityManager em;

    @TransactionAttribute(TransactionAttributeType.REQUIRED)
    public Order createOrder(OrderDTO orderDTO) {
        // 创建订单
        Order order = new Order();
        order.setOrderNo(generateOrderNo());
        order.setCreateTime(new Date());
        order.setStatus(OrderStatus.PENDING);

        // 关联客户
        Customer customer = em.getReference(Customer.class, orderDTO.getCustomerId());
        order.setCustomer(customer);

        // 添加订单项
        for (OrderItemDTO itemDTO : orderDTO.getItems()) {
            OrderItem item = new OrderItem();
            item.setQuantity(itemDTO.getQuantity());

            // 关联商品
            Product product = em.find(Product.class, itemDTO.getProductId());
            item.setProduct(product);
            item.setPrice(product.getCurrentPrice());

            order.addItem(item);
        }

        // 持久化订单
        em.persist(order);
        return order;
    }

    @TransactionAttribute(TransactionAttributeType.REQUIRED)
    public void updateOrderStatus(Long orderId, OrderStatus newStatus) {
        Order order = em.find(Order.class, orderId);
        if (order == null) {
            throw new EntityNotFoundException("Order not found: " + orderId);
        }

        // 乐观锁自动处理并发
        order.setStatus(newStatus);

        // 无需显式调用merge，事务提交时自动更新
    }
}

@Entity
@EntityListeners(AuditingEntityListener.class)
public class Order {
    @PrePersist
    void onPrePersist() {
        if (createTime == null) {
            createTime = new Date();
        }
        if (status == null) {
            status = OrderStatus.PENDING;
        }
    }

    @PreUpdate
    void onPreUpdate() {
        if (status == OrderStatus.COMPLETED && completedTime == null) {
            completedTime = new Date();
        }
    }
}

public class AuditingEntityListener {
    @PrePersist
    @PreUpdate
    void onSave(Object entity) {
        if (entity instanceof Auditable) {
            Auditable auditable = (Auditable) entity;
            String user = SecurityContext.getCurrentUser();
            Date now = new Date();

            if (auditable.getCreatedBy() == null) {
                auditable.setCreatedBy(user);
                auditable.setCreatedDate(now);
            }
            auditable.setLastModifiedBy(user);
            auditable.setLastModifiedDate(now);
        }
    }
}

// Hibernate 3.2之前的代码
Session session = sessionFactory.openSession();
Transaction tx = session.beginTransaction();
try {
    Customer customer = (Customer) session.get(Customer.class, id);
    tx.commit();
} catch (Exception e) {
    tx.rollback();
    throw e;
} finally {
    session.close();
}

// 转向JPA后的代码
@PersistenceContext
private EntityManager em;

@Transactional
public Customer findCustomer(Long id) {
    return em.find(Customer.class, id);
}

// 原TopLink代码
Session session = workspace.getSession();
ReadObjectQuery query = new ReadObjectQuery(Customer.class);
query.setSelectionCriteria(new ExpressionBuilder().get("id").equal(id));
Customer customer = (Customer) session.executeQuery(query);

// 基于JPA的EclipseLink代码
@PersistenceContext
private EntityManager em;

public Customer findCustomer(Long id) {
    return em.find(Customer.class, id);
}

// 期望的优化方案
@Query(value = "SELECT * FROM orders WHERE create_time > ?1 " +
    "ORDER BY id LIMIT ?2 OFFSET ?3", 
    nativeQuery = true)
List<Order> findOrders(Date startTime, int limit, int offset);

// 但不同数据库的分页语法不同：
// MySQL: LIMIT x OFFSET y
// Oracle: OFFSET x ROWS FETCH NEXT y ROWS ONLY
// SQL Server: OFFSET x ROWS FETCH NEXT y ROWS ONLY
// DB2: OFFSET x ROWS FETCH FIRST y ROWS ONLY

// JPA只能使用低效的方案
@Query("SELECT o FROM Order o WHERE o.createTime > ?1 " +
    "ORDER BY o.id")
List<Order> findOrders(Date startTime, Pageable pageable);

@Service
@Transactional
public class OrderService {
    @PersistenceContext
    private EntityManager em;

    // JPA标准方式：每条记录一个SQL
    public void updateOrderStatus(List<Long> orderIds, OrderStatus status) {
        for (Long id : orderIds) {
            Order order = em.find(Order.class, id);
            order.setStatus(status);
        }
    }

    // 期望的优化方式，但不是JPA标准
    public void updateOrderStatusBatch(List<Long> orderIds, OrderStatus status) {
        // 不同框架有不同的实现
        // Hibernate: session.createQuery("UPDATE Order...")
        // EclipseLink: em.createNativeQuery("UPDATE orders...")
        // OpenJPA: em.createQuery("UPDATE Order...").setBatchSize(100)
    }
}

@Entity
public class Order {
    @OneToMany(mappedBy = "order", fetch = FetchType.LAZY)
    private List<OrderItem> items;

    @ManyToOne(fetch = FetchType.LAZY)
    private Customer customer;

    @ElementCollection
    private Set<String> tags;
}

@Service
public class OrderService {
    // 看似简单的查询可能产生多次数据库访问
    public OrderDTO findOrder(Long id) {
        Order order = em.find(Order.class, id);
        return new OrderDTO(
            order.getId(),
            order.getCustomer().getName(),  // 懒加载查询
            order.getItems().size(),        // 懒加载查询
            order.getTags()                 // 懒加载查询
        );
    }

    // 优化方案（但实现效果依赖具体JPA实现）
    public OrderDTO findOrderOptimized(Long id) {
        return em.createQuery(
            "SELECT NEW com.example.OrderDTO(o.id, c.name, SIZE(o.items), o.tags) " +
            "FROM Order o " +
            "LEFT JOIN o.customer c " +
            "WHERE o.id = :id",
            OrderDTO.class
        )
        .setParameter("id", id)
        .getSingleResult();
    }
}

// 使用Hibernate的方案
@Entity
@Table(name = "TRANSACTIONS")
public class Transaction {
    @Id
    private Long id;

    @ManyToOne
    @JoinColumn(name = "ACCOUNT_ID")
    private Account account;

    @Column(precision = 19, scale = 4)
    private BigDecimal amount;

    @Column(name = "TXN_TYPE")
    @Enumerated(EnumType.STRING)
    private TransactionType type;
}

// 查询近一个月的大额交易
public List<Transaction> findLargeTransactions(Long accountId) {
    return entityManager.createQuery(
        "from Transaction t " +
        "where t.account.id = :accountId " +
        "and t.amount > 100000 " +
        "and t.createTime > :startTime",
        Transaction.class
    )
    .setParameter("accountId", accountId)
    .setParameter("startTime", LocalDateTime.now().minusMonths(1))
    .getResultList();
}

// iBatis的映射文件
<mapper namespace="TransactionMapper">
    <select id="findLargeTransactions" resultMap="transactionMap">
        SELECT /*+ INDEX(t IDX_TXN_ACCOUNT_DATE) */ 
            t.* 
        FROM TRANSACTIONS PARTITION(P_CURRENT) t
        WHERE t.ACCOUNT_ID = #{accountId}
        AND t.AMOUNT > 100000
        AND t.CREATE_TIME > TRUNC(SYSDATE) - 30
    </select>
</mapper>

// Java接口
public interface TransactionMapper {
    List<Transaction> findLargeTransactions(@Param("accountId") Long accountId);
}

// ORM方案：领域模型驱动
@Entity
public class Order {
    @OneToMany(mappedBy = "order")
    private List<OrderItem> items;

    public BigDecimal getTotalAmount() {
        return items.stream()
            .map(OrderItem::getAmount)
            .reduce(BigDecimal.ZERO, BigDecimal::add);
    }
}

// MyBatis方案：SQL驱动
public interface OrderMapper {
    @Select("SELECT o.*, " +
        "(SELECT SUM(amount) FROM order_items WHERE order_id = o.id) as totalAmount " +
        "FROM orders o WHERE o.id = #{id}")
    OrderDTO findOrderWithTotal(@Param("id") Long id);
}

// JPA借鉴了MyBatis的原生SQL理念
@Query(value = 
    "SELECT /*+ INDEX(o IDX_ORDER_TIME) */ * FROM orders o " +
    "WHERE o.status = :status " +
    "ORDER BY o.create_time DESC",
    countQuery = 
    "SELECT COUNT(*) FROM orders o " +
    "WHERE o.status = :status",
    nativeQuery = true)
Page<Order> findOrders(@Param("status") String status, Pageable pageable);

// MyBatis借鉴了JPA的分页抽象
public interface OrderMapper {
    @Select("SELECT * FROM orders WHERE status = #{status} ORDER BY create_time DESC")
    Page<Order> findOrders(@Param("status") String status, PageRequest page);
}