This article introduces four advanced mapping methods of JPA. 1. Bidirectional association specifies the relationship maintainer through mappedBy to enable user and Address to access each other; 2. Many-to-many association uses @ManyToMany and @JoinTable to manage intermediate tables, or manually create entity classes to expand intermediate table functions; 3. Embed object uses @Embeddable and @Embedded to embed Address into the Order table, supporting compound primary key design; 4. The inheritance structure uses SINGLE_TABLE, JOINED, and TABLE_PER_CLASS policies to map Employee subclasses, and select appropriate solutions according to query needs.

When using the Java Persistence API (JPA), in addition to basic entity mapping, mastering some advanced mapping techniques can help us more flexibly handle complex data models and business logic. This article will introduce several practical advanced JPA mapping methods, including advanced usage of one-to-one, one-to-many, and many-to-many relationships, as well as the processing of nested objects and inherited structures.

1. Two-way relationship: make the relationship more controllable

In actual development, in many cases we need two entities to be able to access each other. For example, user (User) and address (Address), a user can have an address, and an address may also belong to a certain user.

 @Entity
public class User {
    @Id
    private Long id;

    @OneToOne
    @JoinColumn(name = "address_id")
    private Address address;
}

@Entity
public class Address {
    @Id
    private Long id;

    @OneToOne(mappedBy = "address")
    private User user;
}

The key here lies in the use of mappedBy , which tells JPA which party to maintain the relationship. It is usually recommended that the "owner" manage foreign keys, and the other party references them through mappedBy .

Tips:

• Bidirectional relationships are prone to cause circular reference problems, especially when serializing into JSON.
• Using @JsonManagedReference and @JsonBackReference can avoid the infinite recursion problem of Jackson serialization.

2. Many-to-many association: how to process intermediate tables

When there is a many-to-many relationship between two entities, JPA provides concise annotation support, but an intermediate table will be automatically generated behind it. For example, the relationship between student and course:

 @Entity
public class Student {
    @Id
    private Long id;

    @ManyToMany
    @JoinTable(
        name = "student_course",
        joinColumns = @JoinColumn(name = "student_id"),
        inverseJoinColumns = @JoinColumn(name = "course_id")
    )
    private Set<Course> courses = new HashSet<>();
}

 @Entity
public class Course {
    @Id
    private Long id;

    @ManyToMany(mappedBy = "courses")
    private Set<Student> students = new HashSet<>();
}

If you want to do extra operations on the intermediate table (such as recording creation time or status), you need to manually create the intermediate entity class to replace the default JoinTable.

Note:

• When inserting data many to many, the referenced party (such as Course) needs to be saved first, otherwise an exception may be thrown.
• Be careful when modifying a collection to avoid inconsistency in data due to incorrect synchronization of the two-side relationship.

3. Embed objects and composite primary keys: data modeling that is closer to reality

Sometimes we encounter some fields of an entity that can be abstracted into another object, but do not need to exist as a table alone. At this time, you can use @Embeddable and @Embedded annotations.

For example, an order address information can be used as an embedded object:

 @Embeddable
public class Address {
    private String street;
    private String city;
    private String zipCode;
}

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

    @Embedded
    private Address shippingAddress;
}

In the database table generated in this way, the Order table will directly contain street , city , zipCode fields.

If multiple fields combine to form a primary key, you can also use @Embeddable to define a composite primary key class and reference it with @EmbeddedId in the entity.

4. Inheritance structure mapping: How to persist class inheritance relationships

JPA supports three common inheritance strategies, suitable for different scenarios:

1. SINGLE_TABLE : All subclasses share a table, and use a discriminator column to identify the type.
2. JOINED : Each subclass has its own table, and the parent class table is connected by foreign keys.
3. TABLE_PER_CLASS : Each subclass is a complete table without sharing structure.

 @Entity
@Inheritance(strategy = InheritanceType.SINGLE_TABLE)
@DiscriminatorColumn(name = "employee_type")
public abstract class Employee { ... }

@Entity
@DiscriminatorValue("fulltime")
public class FullTimeEmployee extends Employee { ... }

A common practice is to select a strategy based on the query frequency. Single tables are suitable for frequent cross-type queries, and JOINED is more in line with the paradigm but has slightly poor query performance.

Basically these common but easily overlooked advanced JPA mapping methods. Mastering them not only improves code flexibility, but also better deal with complex business models. Only by rationally using annotations and strategies can the greatest value of JPA be achieved.

The above is the detailed content of Java Persistence API (JPA) Advanced Mappings. For more information, please follow other related articles on the PHP Chinese website!