JPA Relationships: What's the Difference Between `@JoinColumn` and `mappedBy`?

Understanding the Difference Between JPA JoinColumn and mappedBy

In JPA, the @JoinColumn and mappedBy annotations are used to define relationships between entities. However, they play different roles in establishing these relationships.

JoinColumn Annotation

The @JoinColumn annotation is used on the owning side of a relationship. This means that the entity annotated with @JoinColumn has a foreign key column pointing to the referenced entity. Here's an example:

@Entity
public class Company {

    @OneToMany(cascade = CascadeType.ALL, fetch = FetchType.LAZY)
    @JoinColumn(name = "companyIdRef", referencedColumnName = "companyId")
    private List<branch> branches;
    ...
}</branch>

In this example, the Company entity is the owning side of the relationship. It has a foreign key column named 'companyIdRef' that references the 'companyId' column in the Branch entity. This indicates that a Branch entity is associated with a specific Company.

mappedBy Annotation

The mappedBy annotation is used on the non-owning side of a relationship. This means that the entity annotated with mappedBy has a field that stores the foreign key of the referenced entity. Here's an example:

@Entity
public class Company {

    @OneToMany(cascade = CascadeType.ALL, fetch = FetchType.LAZY, mappedBy = "companyIdRef")
    private List<branch> branches;
    ...
}</branch>

In this example, the Company entity is still the owning side of the relationship. However, the Branch entity is now the inverse side. It has a field named 'companyIdRef' that stores the foreign key of the owning entity (Company).

Key Differences

The key difference between @JoinColumn and mappedBy is that:

• @JoinColumn: Specifies the foreign key column in the owning entity.
• mappedBy: Specifies the field in the inverse entity that holds the foreign key of the owning entity.

Bidirectional Relationships

Both @JoinColumn and mappedBy allow for bidirectional relationships between entities. This means that you can navigate from one entity to the other using the annotated fields. However, it's important to note that the entity annotated with mappedBy does not have its own cascade operations. This means that changes made to the inverse entity will not automatically cascade to the owning entity.

To enable full cascade operations in bidirectional relationships, it's recommended to place the @JoinColumn on the owning side and the mappedBy on the inverse side. This ensures that changes to either entity will cascade properly to the other.

The above is the detailed content of JPA Relationships: What's the Difference Between `@JoinColumn` and `mappedBy`?. For more information, please follow other related articles on the PHP Chinese website!