JPA cơ bản

Java Persistence API cơ bản

1. JPA là gì?

Java Persistence API (JPA) là đặc tả (specification) chuẩn của Java để ánh xạ đối tượng Java với các bảng trong cơ sở dữ liệu quan hệ (ORM) và để lưu trữ dữ liệu một cách bền vững (persistence). JPA ban đầu thuộc Java EE (Oracle) và hiện được phát triển bởi Eclipse Foundation với tên Jakarta Persistence.

JPA có Java Persistence Query Language (JPQL), một ngôn ngữ truy vấn hướng đối tượng, độc lập với từng loại database. Nhờ vậy, ứng dụng có thể đổi database (MySQL, PostgreSQL, Oracle...) mà không cần sửa code.

Lưu ý: JPA chỉ là đặc tả. Để chạy được cần một implementation (JPA provider).

Các JPA provider phổ biến

• Hibernate (phổ biến nhất)
• EclipseLink (reference implementation)
• OpenJPA
• DataNucleus (hỗ trợ cả JPA và JDO)

Ý tưởng chính: nếu chỉ dùng API chuẩn của JPA, bạn có thể thay đổi provider mà không sửa code. Tuy nhiên Hibernate còn cung cấp native API (HQL, Criteria của Hibernate, Session...) với nhiều tính năng vượt ngoài JPA, đổi lại bạn bị phụ thuộc vào Hibernate.

2. JPA và JDO

JDO (Java Data Objects) và JPA đều là đặc tả, không phải implementation, và đều là chuẩn persistence của Java.

	JPA	JDO
Datastore hỗ trợ	Chỉ RDBMS	Mọi loại datastore (RDBMS, NoSQL, object DB...)
Mức độ phổ biến	Rất cao	Thấp hơn
Implementation	Hibernate, EclipseLink, OpenJPA...	DataNucleus...

Hibernate không implement JDO. Nếu cần JDO, hãy tham khảo DataNucleus.

3. Lịch sử phát triển

Quá trình tiến hoá của các công nghệ persistence trong Java:

1. JDBC: thao tác SQL trực tiếp
2. Data Mapper (MyBatis...)
3. EJB (Entity Bean)
4. JDO
5. JPA
   • JPA 1.0 (cùng EJB 3.0, 2006)
   • JPA 2.0 (2009)
   • JPA 2.1 (2013)
   • JPA 2.2 (2017)
   • Jakarta Persistence 3.0 (2020, đổi package sang jakarta.persistence)
   • Jakarta Persistence 3.1 (2022) và 3.2 (2024)

4. Cấu trúc của JPA

JPA gồm 4 phần:

• The Java Persistence API: EntityManager, EntityManagerFactory, annotation...
• The Criteria API: xây dựng truy vấn bằng code, an toàn kiểu (type-safe)
• Query language (JPQL)
• Object-relational mapping metadata: annotation hoặc XML (@Entity, @Table, @Column...)

5. Ví dụ nhanh

Entity

java

@Entity
@Table(name = "customers")
public class Customer {

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

    @Column(nullable = false, length = 100)
    private String name;

    // constructor mặc định (bắt buộc), getter/setter
}

persistence.xml (đặt trong META-INF/)

xml

<persistence-unit name="demoPU" transaction-type="RESOURCE_LOCAL">
    <class>com.example.Customer</class>
    <properties>
        <property name="jakarta.persistence.jdbc.url" value="jdbc:mysql://localhost:3306/demo"/>
        <property name="jakarta.persistence.jdbc.user" value="root"/>
        <property name="jakarta.persistence.jdbc.password" value="secret"/>
        <!-- Hibernate dialect, thường tự nhận diện ở bản mới -->
        <property name="hibernate.dialect" value="org.hibernate.dialect.MySQLDialect"/>
    </properties>
</persistence-unit>

Danh sách dialect: Hibernate Configuration (TutorialsPoint)

Dùng EntityManager (CRUD)

java

EntityManagerFactory emf = Persistence.createEntityManagerFactory("demoPU");
EntityManager em = emf.createEntityManager();

em.getTransaction().begin();
Customer c = new Customer();
c.setName("An");
em.persist(c);                         // Create
em.getTransaction().commit();

Customer found = em.find(Customer.class, c.getId());   // Read

em.getTransaction().begin();
found.setName("Binh");                 // Update (tự động flush khi commit)
em.getTransaction().commit();

em.getTransaction().begin();
em.remove(found);                      // Delete
em.getTransaction().commit();

em.close();
emf.close();

find() vs getReference()

• find() truy vấn DB ngay và trả về entity (hoặc null nếu không có).
• getReference() trả về một proxy lazy, chỉ truy vấn khi truy cập dữ liệu. Nếu không tồn tại sẽ ném EntityNotFoundException. Hữu ích khi chỉ cần tham chiếu khoá ngoại mà không cần tải toàn bộ entity.

6. Vòng đời của Entity

Trạng thái	Mô tả
New / Transient	Vừa tạo bằng new, chưa gắn với persistence context
Managed	Được quản lý bởi EntityManager, thay đổi sẽ tự được đồng bộ xuống DB
Detached	Đã tách khỏi persistence context (sau close(), detach())
Removed	Đã đánh dấu xoá, sẽ bị xoá khi commit

7. Ánh xạ quan hệ (Relationship Mapping)

4 loại quan hệ

• @OneToOne
• @ManyToOne
• @OneToMany
• @ManyToMany

Mỗi quan hệ có thể là một chiều (unidirectional) hoặc hai chiều (bidirectional), và có thể tải ngay (EAGER) hoặc theo yêu cầu (LAZY).

Mặc định: @OneToOne và @ManyToOne là EAGER, @OneToMany và @ManyToMany là LAZY.

Owning side và Inverse side

Mỗi quan hệ có hai phía:

• Owning side: chịu trách nhiệm cập nhật quan hệ xuống database, thường là phía giữ khoá ngoại.
• Inverse side: phía còn lại, ánh xạ ngược về owning side bằng thuộc tính mappedBy.

Nếu bạn quen Hibernate, mappedBy của JPA tương đương thuộc tính inverse của Hibernate: phía inverse sẽ bị bỏ qua khi cập nhật quan hệ.

java

@Entity
public class Order {
    @Id @GeneratedValue
    private Long id;

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

@Entity
public class OrderItem {
    @Id @GeneratedValue
    private Long id;

    // Owning side (giữ khoá ngoại order_id)
    @ManyToOne(fetch = FetchType.LAZY)
    @JoinColumn(name = "order_id")
    private Order order;
}

Cascade

CascadeType gồm PERSIST, MERGE, REMOVE, REFRESH, DETACH, ALL. Dùng để lan truyền thao tác từ entity cha sang entity con.

Embedded object và ElementCollection

• @Embeddable / @Embedded / @EmbeddedId: nhúng một đối tượng giá trị (ví dụ Address) hoặc khoá chính tổ hợp. Xem JPA EmbeddedId example
• @ElementCollection: lưu tập hợp các giá trị cơ bản hoặc embeddable. Xem ElementCollection (Wikibooks)

8. Truy vấn trong JPA

Có 3 cách truy vấn:

1. Native query: SQL thuần
2. JPQL (Java Persistence Query Language, SQL hướng đối tượng): Query, TypedQuery, @NamedQuery / @NamedQueries
3. Criteria API: xây dựng truy vấn bằng code, động và type-safe

java

// JPQL với tham số (khuyến nghị, tránh SQL injection)
TypedQuery<Customer> q = em.createQuery(
    "SELECT c FROM Customer c WHERE c.name = :name", Customer.class);
q.setParameter("name", "An");
List<Customer> list = q.getResultList();

// Named Query
@Entity
@NamedQuery(name = "Customer.findByName",
            query = "SELECT c FROM Customer c WHERE c.name = :name")
public class Customer { ... }

em.createNamedQuery("Customer.findByName", Customer.class)
  .setParameter("name", "An")
  .getResultList();

// Criteria API
CriteriaBuilder cb = em.getCriteriaBuilder();
CriteriaQuery<Customer> cq = cb.createQuery(Customer.class);
Root<Customer> root = cq.from(Customer.class);
cq.select(root).where(cb.equal(root.get("name"), "An"));
List<Customer> result = em.createQuery(cq).getResultList();

• Named Query là truy vấn tĩnh, được parse và kiểm tra cú pháp khi khởi động ứng dụng, dễ tái sử dụng.
• Truy vấn động (dynamic) (JPQL hoặc native) được tạo lúc runtime.
• Criteria API linh hoạt hơn và an toàn kiểu hơn khi cần xây dựng điều kiện động.
• Luôn dùng parameter binding (:name, ?1) thay vì nối chuỗi để chống SQL injection.

9. Kế thừa (Inheritance)

JPA có 3 chiến lược ánh xạ kế thừa:

Chiến lược	Mô tả	Ưu điểm	Nhược điểm
SINGLE_TABLE (mặc định)	Cả hệ thống phân cấp lớp vào một bảng (kèm cột phân biệt DTYPE)	Không cần JOIN, truy vấn nhanh	Nhiều cột NULL, không đặt được NOT NULL cho cột lớp con
JOINED	Mỗi lớp một bảng, bảng con chỉ chứa cột riêng và join với bảng cha qua khoá chính	Dữ liệu chuẩn hoá, không trùng lặp	Phải JOIN nên truy vấn chậm hơn
TABLE_PER_CLASS	Mỗi lớp cụ thể một bảng chứa đầy đủ cột (kể cả cột kế thừa)	Truy vấn lớp cụ thể không cần JOIN	Dữ liệu chung bị lặp ở nhiều bảng, truy vấn đa hình dùng UNION; là tính năng tuỳ chọn trong spec

Ví dụ với JOINED, đặt annotation ở entity cha:

java

@Entity
@Inheritance(strategy = InheritanceType.JOINED)
public abstract class Vehicle { ... }

@Entity
public class Car extends Vehicle { ... }

Ngoài ra có @MappedSuperclass: lớp cha chỉ để dùng chung các trường (ví dụ id, createdAt), không phải entity và không có bảng riêng.

Ghi chú (legacy) về Google App Engine: với Datastore cũ dùng DataNucleus, JOINED và SINGLE_TABLE không được hỗ trợ; TABLE_PER_CLASS và MAPPED_SUPERCLASS hoạt động như mô tả trong tài liệu DataNucleus.

10. Một số lưu ý thực tế (Best practices)

• N+1 problem: duyệt quan hệ LAZY trong vòng lặp có thể sinh rất nhiều câu SQL. Khắc phục bằng JOIN FETCH, @EntityGraph hoặc batch fetching.
• Ưu tiên FetchType.LAZY cho mọi quan hệ, chỉ dùng EAGER khi thật sự cần.
• Luôn có constructor mặc định (không tham số) cho entity, và override equals() / hashCode() cẩn thận.
• Với quan hệ hai chiều, hãy đồng bộ cả hai phía bằng phương thức tiện ích (ví dụ order.addItem(item)).
• Đừng dùng hbm2ddl.auto=update trên production; hãy dùng công cụ migration như Flyway hoặc Liquibase.
• Trong Spring, dùng Spring Data JPA (JpaRepository) để giảm code lặp, nhưng vẫn cần hiểu JPA bên dưới.

Reference:

• ObjectDB: JPA Persistence Overview
• Hibernate ORM Documentation 5.1
• Java Persistence API JPA Exam Certification 1z0-898
• JPA find() vs. getReference()
• TutorialsPoint: JPA Introduction
• JavaWorld: Understanding JPA, Part 2: Relationships the JPA way
• Sách: Pro JPA 2 in Java EE 8