Spring Data JPA

JPA、Hibernate 与 Spring Data JPA 的关系

这三者常被混淆，实际上是不同层次的东西：

简言之：JPA 是规范，Hibernate 是实现，Spring Data JPA 是在 JPA 之上的便利层。日常开发中我们主要使用 Spring Data JPA 的接口，Hibernate 的细节由框架处理。

核心概念名词解释

实体类设计

@Entity
@Table(name = "users")     // 对应表名，不指定则用类名小写
@Data
@NoArgsConstructor
@AllArgsConstructor
@Builder
public class User {

    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;

    @Column(nullable = false, unique = true, length = 50)
    private String username;

    @Column(nullable = false, unique = true)
    private String email;

    @Column(nullable = false)
    private String passwordHash;

    // 一个用户可以有多个订单（一对多关系）
    @OneToMany(mappedBy = "user", cascade = CascadeType.ALL, fetch = FetchType.LAZY)
    private List<Order> orders = new ArrayList<>();

    @CreationTimestamp
    @Column(updatable = false)
    private LocalDateTime createdAt;

    @UpdateTimestamp
    private LocalDateTime updatedAt;
}

@Entity
@Table(name = "orders")
@Data
@Builder
public class Order {

    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;

    // 多个订单属于一个用户（多对一关系）
    @ManyToOne(fetch = FetchType.LAZY)
    @JoinColumn(name = "user_id", nullable = false)
    private User user;

    @Column(nullable = false)
    private BigDecimal totalAmount;

    @Enumerated(EnumType.STRING)
    private OrderStatus status;
}

Repository 接口

// 继承 JpaRepository，泛型参数：实体类型, 主键类型
public interface UserRepository extends JpaRepository<User, Long> {

    // 方法名查询推导：Spring Data JPA 自动生成 SQL
    Optional<User> findByEmail(String email);

    List<User> findByUsernameContainingIgnoreCase(String keyword);

    boolean existsByEmail(String email);

    // JPQL 查询（当方法名推导不够用时）
    @Query("SELECT u FROM User u WHERE u.createdAt >= :since ORDER BY u.createdAt DESC")
    List<User> findRecentUsers(@Param("since") LocalDateTime since);

    // 原生 SQL 查询（nativeQuery = true）
    @Query(value = "SELECT * FROM users WHERE email ILIKE %:keyword%",
           nativeQuery = true)
    List<User> searchByEmailNative(@Param("keyword") String keyword);

    // 解决 N+1：用 JOIN FETCH 预加载关联数据
    @Query("SELECT DISTINCT u FROM User u LEFT JOIN FETCH u.orders WHERE u.id = :id")
    Optional<User> findByIdWithOrders(@Param("id") Long id);
}

N+1 查询问题详解

N+1 问题是 ORM 使用中最高频的性能陷阱，必须深刻理解其成因和解决方案。

事务管理

Spring 的事务管理基于 AOP 代理实现。当调用 @Transactional 方法时，Spring 创建一个代理对象，在方法执行前后注入事务逻辑。

@Service
@RequiredArgsConstructor
public class UserServiceImpl implements UserService {

    private final UserRepository userRepository;
    private final PasswordEncoder passwordEncoder;

    // 只读事务：Spring 优化只读操作（关闭脏检查，数据库可使用只读副本）
    @Transactional(readOnly = true)
    public UserResponseDTO findById(Long id) {
        User user = userRepository.findById(id)
            .orElseThrow(() -> new EntityNotFoundException("用户不存在: " + id));
        return toDTO(user);
    }

    // 写事务：默认 REQUIRED，RuntimeException 自动回滚
    @Transactional
    public UserResponseDTO create(UserCreateDTO dto) {
        if (userRepository.existsByEmail(dto.getEmail())) {
            throw new BusinessException(409, "邮箱已被注册");
        }
        User user = User.builder()
            .username(dto.getUsername())
            .email(dto.getEmail())
            .passwordHash(passwordEncoder.encode(dto.getPassword()))
            .build();
        return toDTO(userRepository.save(user));
    }
}