从入门到实战详解Spring Data JPA应用的完整指南

// ❌ 传统 JDBC：要写这么多代码
String sql = "SELECT * FROM t_order WHERE order_no = ?";
PreparedStatement ps = connection.prepareStatement(sql);
ps.setString(1, orderNo);
ResultSet rs = ps.executeQuery();
while (rs.next()) {
    Order order = new Order();
    order.setId(rs.getLong("id"));
    order.setOrderNo(rs.getString("order_no"));
    // ... 还要一个个字段赋值
}

// ✅ Spring Data JPA：就这一行！
Optional<Order> order = orderRepository.findByOrderNo("ORD123");

Order order = new Order();
order.setOrderNo("ORD123");
order.setAmount(new BigDecimal("99.50"));

orderRepository.save(order);

// ORM 自动执行：
// INSERT INTO t_order (order_no, amount) VALUES ('ORD123', 99.50)

Order order = orderRepository.findByOrderNo("ORD123").get();

// ORM 自动执行：
// SELECT * FROM t_order WHERE order_no = 'ORD123'
// 并将结果转换为 Order 对象

String no = order.getOrderNo();   // 直接拿到 "ORD123"

@Entity                          // ← 告诉 JPA：这个类对应一张表
@Table(name = "t_order")         // ← 指定表名（不写则默认是 order）
public class Order {

    @Id                         // ← 主键
    @GeneratedValue(strategy = GenerationType.IDENTITY)  // ← 自增策略
    private Long id;            // → id BIGINT AUTO_INCREMENT PRIMARY KEY

    @Column(name = "order_no", unique = true, nullable = false, length = 32)
    private String orderNo;     // → order_no VARCHAR(32) UNIQUE NOT NULL

    @Column(nullable = false, precision = 10, scale = 2)
    private BigDecimal amount;  // → amount DECIMAL(10,2) NOT NULL

    @Enumerated(EnumType.STRING) // ← 枚举存为字符串（推荐）
    @Column(nullable = false, length = 20)
    private OrderStatus status; // → status VARCHAR(20) NOT NULL

    @Column(name = "user_id")
    private Long userId;        // → user_id BIGINT

    @Column(name = "create_time", updatable = false)
    private LocalDateTime createTime; // → create_time DATETIME

    @Column(name = "update_time")
    private LocalDateTime updateTime; // → update_time DATETIME
}

CREATE TABLE t_order (
    id          BIGINT AUTO_INCREMENT PRIMARY KEY,
    order_no    VARCHAR(32) UNIQUE NOT NULL,
    amount      DECIMAL(10,2) NOT NULL,
    status      VARCHAR(20) NOT NULL,
    user_id     BIGINT,
    create_time DATETIME,
    update_time DATETIME
);

@Repository
public interface OrderRepository extends JpaRepository<Order, Long> {

    // ========== 自定义查询方法 ==========

    /**
     * 根据订单号查询订单
     * 自动生成：SELECT * FROM t_order WHERE order_no = ?
     */
    Optional<Order> findByOrderNo(String orderNo);

    /**
     * 查询指定状态且创建时间早于某时间的订单
     * 用于查询超时未支付的订单
     * 自动生成：SELECT * FROM t_order WHERE status = ? AND create_time < ?
     */
    List<Order> findByStatusAndCreateTimeBefore(OrderStatus status, LocalDateTime createTime);

    /**
     * 查询指定状态且发货时间早于某时间的订单
     * 用于查询需要自动确认收货的订单
     * 自动生成：SELECT * FROM t_order WHERE status = ? AND delivery_time < ?
     */
    List<Order> findByStatusAndDeliveryTimeBefore(OrderStatus status, LocalDateTime deliveryTime);

    /**
     * 查询所有订单，按创建时间倒序
     * 自动生成：SELECT * FROM t_order ORDER BY create_time DESC
     */
    List<Order> findAllByOrderByCreateTimeDesc();
}

// ========== 保存/更新 ==========
orderRepository.save(order);           // INSERT 或 UPDATE
orderRepository.saveAll(orders);       // 批量保存

// ========== 查询单个 ==========
orderRepository.findById(1L);          // 根据 ID 查询，返回 Optional
orderRepository.getById(1L);           // 根据 ID 查询，不存在则抛异常

// ========== 查询列表 ==========
orderRepository.findAll();             // 查询所有
orderRepository.findAllById(ids);      // 根据 ID 列表查询

// ========== 删除 ==========
orderRepository.delete(order);         // 删除对象
orderRepository.deleteById(1L);        // 根据 ID 删除
orderRepository.deleteAll();           // 删除所有

// ========== 统计 ==========
orderRepository.count();               // 总数
orderRepository.existsById(1L);        // 是否存在

@Service
public class OrderService {

    @Autowired
    private OrderRepository orderRepository;

    // ========== 创建订单 ==========

    @Transactional
    public Order createOrder(Long userId, BigDecimal amount, String remark) {
        // 1. 构建订单对象
        Order order = new Order();
        order.setOrderNo(generateOrderNo());
        order.setUserId(userId);
        order.setAmount(amount);
        order.setStatus(OrderStatus.CREATED);
        order.setCreateTime(LocalDateTime.now());

        // 2. 调用 Repository 保存到数据库
        // 执行：INSERT INTO t_order (...) VALUES (...)
        return orderRepository.save(order);
    }

    // ========== 查询订单 ==========

    public Order getByOrderNo(String orderNo) {
        // 调用 Repository 的 findByOrderNo 方法
        // 执行：SELECT * FROM t_order WHERE order_no = ?
        return orderRepository.findByOrderNo(orderNo)
            .orElseThrow(() -> new RuntimeException("订单不存在：" + orderNo));
    }

    // ========== 支付订单 ==========

    @Transactional
    public Order payOrder(String orderNo) {
        // 1. 查询订单（调用 Repository）
        Order order = getByOrderNo(orderNo);

        // 2. 业务逻辑：校验状态
        if (order.getStatus() != OrderStatus.CREATED) {
            throw new RuntimeException("订单状态不正确，无法支付");
        }

        // 3. 业务逻辑：校验是否超时
        if (order.getCreateTime().plusMinutes(30).isBefore(LocalDateTime.now())) {
            order.setStatus(OrderStatus.CANCELLED);
            orderRepository.save(order); // 更新状态
            throw new RuntimeException("订单已超时，已自动取消");
        }

        // 4. 调用支付网关（业务逻辑）
        boolean paySuccess = mockPayGateway(order);

        // 5. 更新订单状态（调用 Repository）
        // 执行：UPDATE t_order SET status = 'PAID', pay_time = ? WHERE id = ?
        order.setStatus(OrderStatus.PAID);
        order.setPayTime(LocalDateTime.now());
        return orderRepository.save(order);
    }

    // ========== 定时任务：取消超时订单 ==========

    @Transactional
    public int cancelTimeoutOrders(int minutes) {
        LocalDateTime deadline = LocalDateTime.now().minusMinutes(minutes);

        // 调用 Repository 的自定义查询方法
        // 执行：SELECT * FROM t_order WHERE status = 'CREATED' AND create_time < ?
        List<Order> timeoutOrders = orderRepository.findByStatusAndCreateTimeBefore(
            OrderStatus.CREATED, deadline
        );

        // 业务逻辑：批量更新状态
        for (Order order : timeoutOrders) {
            order.setStatus(OrderStatus.CANCELLED);
            orderRepository.save(order);
        }

        return timeoutOrders.size();
    }
}

// ========== Controller 层 ==========
@RestController
@RequestMapping("/api/orders")
public class OrderController {

    @Autowired
    private OrderService orderService;

    @PostMapping("/create")
    public ResponseEntity<Order> createOrder(@RequestParam Long userId,
                                             @RequestParam BigDecimal amount) {
        Order order = orderService.createOrder(userId, amount, "");
        return ResponseEntity.ok(order);
    }

    @GetMapping("/{orderNo}")
    public ResponseEntity<Order> getOrder(@PathVariable String orderNo) {
        Order order = orderService.getByOrderNo(orderNo);
        return ResponseEntity.ok(order);
    }
}

// ========== Service 层 ==========
@Service
public class OrderService {

    @Autowired
    private OrderRepository orderRepository;

    @Transactional
    public Order createOrder(Long userId, BigDecimal amount, String remark) {
        Order order = new Order();
        order.setOrderNo(generateOrderNo());
        order.setUserId(userId);
        order.setAmount(amount);
        order.setStatus(OrderStatus.CREATED);
        return orderRepository.save(order);
    }

    public Order getByOrderNo(String orderNo) {
        return orderRepository.findByOrderNo(orderNo)
            .orElseThrow(() -> new RuntimeException("订单不存在"));
    }
}

// ========== Repository 层 ==========
@Repository
public interface OrderRepository extends JpaRepository<Order, Long> {
    Optional<Order> findByOrderNo(String orderNo);
}

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

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

    private BigDecimal amount;
    private OrderStatus status;
    private Long userId;
    private LocalDateTime createTime;
}

// 第一步：确定条件
// - userId = ?
// - status = PAID
// - amount > 100

// 第二步：按规则拼接
List<Order> findByUserIdAndStatusAndAmountGreaterThan(
    Long userId,
    OrderStatus status,
    BigDecimal amount
);

// 第三步：使用
List<Order> orders = orderRepository.findByUserIdAndStatusAndAmountGreaterThan(
    1L,
    OrderStatus.PAID,
    new BigDecimal("100")
);
// 执行：SELECT * FROM t_order WHERE user_id = 1 AND status = 'PAID' AND amount > 100

spring:
  jpa:
    show-sql: true           # 打印 SQL
    properties:
      hibernate:
        format_sql: true     # 格式化 SQL
logging:
  level:
    org.hibernate.SQL: DEBUG
    org.hibernate.type.descriptor.sql.BasicBinder: TRACE  # 显示参数绑定

@Query("SELECT o FROM Order o WHERE o.userId = :userId AND o.amount BETWEEN :min AND :max")
List<Order> findByUserIdAndAmountRange(@Param("userId") Long userId,
                                        @Param("min") BigDecimal min,
                                        @Param("max") BigDecimal max);

@Query(value = "SELECT * FROM t_order WHERE status = ? AND amount > ?", nativeQuery = true)
List<Order> findCustomByNativeQuery(OrderStatus status, BigDecimal amount);

Optional<Order> findByOrderNo(String orderNo);

// 好处：强制处理"找不到"的情况
Order order = orderRepository.findByOrderNo(orderNo)
    .orElseThrow(() -> new RuntimeException("订单不存在"));

// 或者返回默认值
Order order = orderRepository.findByOrderNo(orderNo)
    .orElse(new Order());

// 或者直接判断是否存在
if (orderRepository.findByOrderNo(orderNo).isPresent()) {
    // 存在
}