The basis and application of Java Persistence object relational mapping

introduction

Java Persistence API (JPA) is an object relational mapping (ORM) standard provided by the Java platform, aiming to simplify the persistence of relational databases. It is available in both Java EE and Java SE environments, providing developers with a unified way to access data. JPA eliminates a lot of boilerplate code in traditional JDBC programming, allowing developers to focus on business logic rather than underlying database operations. As a specification, JPA itself does not provide specific implementations, but relies on third-party frameworks such as Hibernate, EclipseLink and OpenJPA to implement its functions.

1. Basic concepts of JPA

1.1 Overview of JPA specifications

The JPA specification defines a set of standard APIs, mainly located in the package. It implements the mapping of Java objects to database tables through simple annotations or XML configurations, allowing developers to operate databases in an object-oriented manner. JPA automatically handles tedious tasks such as SQL generation, result set mapping and transaction management, greatly improving development efficiency. From a historical perspective, JPA is the evolution of EJB entity bean technology, which has absorbed the advantages of various ORM frameworks and formed a more flexible and easy-to-use persistent solution.

1.2 Core Components

The architecture of JPA is composed of several key components that work together to complete data persistence. The EntityManagerFactory is responsible for creating an EntityManager instance, which is usually created once at the start of the application, corresponding to a persistence unit. EntityManager is the core interface of JPA, responsible for managing the life cycle of an entity and providing query functions. Entity is a persisted object that corresponds to records in the database. EntityTransaction manages local transactions of resources, while Persistence class is the boot class of JPA, responsible for the initialization process. The Query interface provides the ability to execute JPQL and native SQL queries.

// Example of JPA core component usageEntityManagerFactory emf = ("myPersistenceUnit");
EntityManager em = ();
EntityTransaction tx = ();
try {
    ();
    // Create and persist entities    Employee employee = new Employee();
    ("Zhang San");
    (8000.0);
    (employee);
    // Query the entity    Employee foundEmployee = (, ());
    ();
} catch (Exception e) {
    ();
    ();
} finally {
    ();
}
();

2. Entity Mapping

2.1 Entity definition

JPA entities are ordinary Java objects (POJOs) tagged with @Entity annotation. Entity classes must meet some basic requirements: they have a parameterless constructor, cannot be a final type, persistent fields cannot be final modification, and primary keys must be defined. Each entity class corresponds to a table in the database. The table name and other table-level characteristics can be specified through the @Table annotation. The fields or properties of an entity are mapped to the columns of the table through the @Column annotation, and the column name, length, constraints and other characteristics can be configured. The primary key is identified by the @Id annotation, and the primary key generation strategy can be defined in combination with the @GeneratedValue annotation.

// Entity class definition example@Entity
@Table(name = "employees")
public class Employee {
    @Id
    @GeneratedValue(strategy = )
    private Long id;
    @Column(name = "full_name", nullable = false, length = 100)
    private String name;
    @Column(precision = 10, scale = 2)
    private Double salary;
    @Temporal()
    @Column(name = "hire_date")
    private Date hireDate;
    // No parameter constructor    public Employee() {}
    // Getters and setters
    public Long getId() { return id; }
    public void setId(Long id) {  = id; }
    public String getName() { return name; }
    public void setName(String name) {  = name; }
    // Other getters and setters are omitted}

2.2 Relationship Mapping

Relationships between entities are an important part of the domain model, and JPA provides complete relationship mapping support. One-to-many relationships usually use @OneToMany annotation on the "one" party, and @ManyToOne annotation on the "many" party, forming a two-way relationship. Many-to-many relationships are expressed through @ManyToMany annotation, and often need to use @JoinTable to define the association table. Relational mapping can configure cascading operations and crawling policies to affect the persistence behavior and loading of entities. Reasonable relationship design and mapping configuration have an important impact on application performance and data consistency.

// Example of entity relationship mapping@Entity
public class Department {
    @Id
    @GeneratedValue
    private Long id;
    private String name;
    @OneToMany(mappedBy = "department", cascade = , fetch = )
    private List&lt;Employee&gt; employees = new ArrayList&lt;&gt;();
    // Getters and setters
}
@Entity
public class Employee {
    // ... Other fields    @ManyToOne
    @JoinColumn(name = "department_id")
    private Department department;
    // Getters and setters
}

3. JPA query language

3.1 JPQL Basics

JPQL is an object-oriented query language provided by JPA. Its syntax is similar to SQL but operates on entity objects rather than database tables. As a database-independent query language, JPQL provides portability across databases, automatically converted to SQL statements for specific databases. JPQL supports selection, update and delete operations, as well as projection, connection, grouping and sorting functions. It uses named parameters or positional parameters to bind variables to provide type-safe query methods. JPQL's named query function allows separation of query definition and execution, improving code maintainability.

// JPQL query exampleString jpql = "SELECT e FROM Employee e WHERE  &gt; :minSalary ORDER BY ";
TypedQuery&lt;Employee&gt; query = (jpql, );
("minSalary", 5000.0);
List&lt;Employee&gt; results = ();
// Pagination query(0);  // Start position(10);  // Number of records per pageList&lt;Employee&gt; firstPage = ();
// Name query@Entity
@NamedQuery(name = "",
            query = "SELECT e FROM Employee e WHERE  &gt; :salary")
public class Employee {
    // Entity definition}
// Use named queryTypedQuery&lt;Employee&gt; query = ("", );
("salary", 5000.0);
List&lt;Employee&gt; results = ();

3.2 Criteria API

The Criteria API is a type-safe query construction method introduced by JPA 2.0, and queries are built through object-oriented APIs rather than strings. It avoids the problem of JPQL string splicing, allowing the compiler to catch syntax errors. The Criteria API is particularly suitable for building dynamic queries and flexibly assemble query statements according to runtime conditions. It provides the same expressive capabilities as JPQL, but uses a more structured way to improve code readability and maintainability. Although the syntax of the Criteria API is more verbose than JPQL, its advantages in building complex dynamic queries are significant.

// Criteria API exampleCriteriaBuilder cb = ();
CriteriaQuery&lt;Employee&gt; cq = ();
Root&lt;Employee&gt; employee = ();
// Build query conditionsPredicate salaryPredicate = (("salary"), 5000.0);
Predicate datePredicate = (("hireDate"), someDate);
Predicate finalPredicate = (salaryPredicate, datePredicate);
(employee).where(finalPredicate).orderBy((("name")));
TypedQuery&lt;Employee&gt; query = (cq);
List&lt;Employee&gt; results = ();

4. JPA life cycle and transactions

4.1 Entity Life Cycle

JPA entities experience different states throughout their life cycle, and understanding these states and their transitions is essential to properly manage entities. The entity in the newly created state has just been created and has not been associated with the EntityManager. An entity with a persistent state has been associated with the EntityManager through the persist method, and its modifications will be automatically synchronized to the database when the transaction is committed. An entity with a detached state was once in a persistent state, but is no longer managed by EntityManager, and modifications to it will not affect the database. The entity with the deleted status has been marked as deleted and will be removed from the database after the transaction is committed. EntityManager provides persist, merge, remove and other methods to change the entity state, while the flush method manually synchronizes the entity state to the database.

// Entity life cycle example// New statusEmployee employee = new Employee();
("Li Si");
// Persistence state(employee);
(9000.0);  // Automatic tracking of changes// Separation state();  // or()(10000.0);  // It will not affect the database// Reattachemployee = (employee);  // Return to persistent state// Delete status(employee);  // Mark as delete

4.2 JPA transaction management

Transactions are the basic unit of database operations. JPA provides a complete transaction management mechanism to ensure the atomicity, consistency, isolation and persistence of database operations (ACID). JPA supports two transaction models: resource-local transactions implemented through EntityTransaction, and distributed transactions implemented through JTA in Java EE environment. Transactions define the boundaries of operations, control when changes are applied to the database and roll back changes when errors occur. JPA's transaction management is closely related to the entity life cycle, transaction commits trigger synchronization of entity state, and transaction rollback cancels uncommitted changes.

// JPA transaction exampleEntityTransaction tx = ();
try {
    ();
    Department dept = new Department();
    ("R&D Department");
    (dept);
    Employee emp1 = new Employee();
    ("Wang Wu");
    (dept);
    (emp1);
    Employee emp2 = new Employee();
    ("Zhao Liu");
    (dept);
    (emp2);
    ();
} catch (Exception e) {
    if (()) {
        ();
    }
    ();
}

V. JPA implementation and practice

5.1 Mainstream JPA implementation

JPA as a specification, its functions are provided by specific implementations. There are several mainstream JPA implementations on the market, each with its own characteristics. Hibernate is the most popular JPA implementation, with rich features, excellent performance, active community, but relatively complex configuration. EclipseLink is a reference implementation of JPA. It comes from Oracle's TopLink, which has excellent performance and supports more JPA specification features, but has relatively few community resources. OpenJPA is Apache's JPA implementation, focusing on performance and standard compatibility, suitable for projects that pursue lightweight solutions. When choosing JPA implementation, factors such as functional requirements, performance requirements, community support and team familiarity should be comprehensively considered.

5.2 JPA Best Practices

In practical applications, the rational use of JPA can significantly improve development efficiency, but some best practices need to be paid attention to. Entity design should avoid too deep inheritance levels and too complex relationship networks to reduce the complexity of mapping and query. Relational cascades should be used with caution, as excessive cascades can lead to unexpected database operations, affecting performance and data consistency. The selection of crawl policy has a significant impact on performance, and appropriate policies should be set according to the actual access mode. For scenarios where more reads and less writes, configuring a secondary cache can effectively reduce database access and improve application response speed. Large-scale data operations should consider using batch processing technology to reduce the number of database interactions.

// Examples of best practices for batch operationsEntityTransaction tx = ();
();
for (int i = 0; i &lt; 1000; i++) {
    Employee emp = new Employee();
    ("staff" + i);
    (emp);
    if (i % 50 == 0) {
        // Refresh every 50 records and clear the persistence context        ();
        ();
    }
}
();

Summarize

The JPA specification provides Java applications with a powerful and flexible object-relational mapping solution, simplifying persistence layer development. Through standardized entity definition, relationship mapping, query language and lifecycle management, JPA allows developers to deal with data persistence in an object-oriented way, freeing from the complexity of traditional JDBC programming. From the original EJB entity bean to the current JPA 2.2 specification, Java persistence technology has been constantly evolving to provide developers with better tools and APIs.

The above is the basis and application of Java Persistence object relationship mapping. For more information about Java Persistence object relationship mapping, please pay attention to my other related articles!