Can someone explain mappedBy in JPA and Hibernate?

java

jpa

hibernate

best-practices

byNikita Barsukov·Nov 1, 2024

The mappedBy attribute in JPA/Hibernate signifies the non-owning side of a bi-directional relationship between entities. It points to the field in the owning entity, thus preventing duplication and consolidating the association definition at one place.

Here's a One-To-Many example in action:

@Entity
public class Team {
    // And you thought handling a team is easy 😉
    @OneToMany(mappedBy = "team")
    private Set<Player> players;
}

@Entity
public class Player {
    // Life as a Player is hypnotically diverse!
    @ManyToOne
    private Team team;
}

In this case, mappedBy = "team" indicates that the Player is mapped via its team field. The players set in Team mirrors the database accurately, providing a lean and mean object-relation mapping.

Ownership & Utility Methods

In JPA/Hibernate, the relationship owner is where the foreign key constraint lives, and mappedBy isn't present. In a Many-To-One setup, the many side bears the @JoinColumn defining the corresponding database column.

Utility methods can help keep both sides of a bi-directional association in sync:

public void addPlayer(Player player) {
    // New player: Welcome aboard, mate!
    players.add(player);
    player.setTeam(this);
}

public void removePlayer(Player player) {
    // Player leaving: Farewell, warrior!
    players.remove(player);
    player.setTeam(null);
}

Utilize cascade types, e.g., CascadeType.ALL, to propagate operations to related entities.

Bidirectional Associations Management

Bi-directional associations need careful handling to satisfy data consistency and integrity conditions. Here's how to wield mappedBy like a pro:

Unequivocal Ownership: Clearly define the relationship owner for consistent updates.
Synchronize with Utility Methods: Use add/remove style utility methods for state synchronization.
Right Use of Cascading: Define the cascade types keeping in mind entity operations.
Annotation Placement: Deploy @JoinColumn on owning side and mappedBy on the other.

Neglecting these might lead Hibernate to treat relationships as separate, causing data anomalies.

Handling Complex Relationships

In more complex setups, the significance of mappedBy is amplified:

In @ManyToMany situations, ensure only one side owns the relationship while the other uses mappedBy. Ignore this and you'll have two mapping tables!
For derived entities, mappedBy should reference a valid parent class property for a single, non-conflicting relationship definition.
When relationships are immutable, restrict mappedBy to read-only mappings. This barricade avoids accidental entity state modifications.