Mapping and Relationships

The owning side is the entity whose table holds the foreign key; only changes on the owning side are written to the database. The other side uses mappedBy to say "this is just a mirror of the field over there". In @OneToMany/@ManyToOne, the @ManyToOne side always owns.

@Entity
public class Order {
    @OneToMany(mappedBy = "order", cascade = CascadeType.ALL, orphanRemoval = true)
    private List<OrderItem> items = new ArrayList<>();

    public void addItem(OrderItem item) {   // keep both sides in sync
        items.add(item);
        item.setOrder(this);
    }
}

@Entity
public class OrderItem {
    @ManyToOne(fetch = FetchType.LAZY)
    @JoinColumn(name = "order_id")          // owning side: holds the FK
    private Order order;
}

A unidirectional @OneToMany without @JoinColumn creates an extra join table (orders_items) and produces extra INSERT/DELETE statements. With @JoinColumn it uses a FK but may still issue extra UPDATEs to set it.

The most efficient mapping is @ManyToOne on the child (often enough on its own) plus, if you need navigation from the parent, @OneToMany(mappedBy = ...).

@JoinColumn names the foreign-key column in the owning table (order_items.order_id). @JoinTable describes a link table with two FKs; it is required for @ManyToMany and optional for others.

@ManyToMany
@JoinTable(name = "product_tags",
           joinColumns = @JoinColumn(name = "product_id"),
           inverseJoinColumns = @JoinColumn(name = "tag_id"))
private Set<Tag> tags = new HashSet<>();

• Use a Set, not a List: with a List (a "bag") Hibernate deletes all link rows and re-inserts them when one element is removed.
• Never use CascadeType.REMOVE/ALL on it: deleting a product would delete shared tags.
• If the link needs extra columns (quantity, added_at), replace it with a join entity and two @ManyToOnes, e.g. CartItem(user, product, quantity).

Cascade passes an operation from parent to child: PERSIST, MERGE, REMOVE, REFRESH, DETACH, or ALL. Use it on parent → child compositions (Order → OrderItem), not on @ManyToOne (an item must not delete its product).

Use @Enumerated(EnumType.STRING). The default ORDINAL stores 0, 1, 2..., so inserting a new constant in the middle silently corrupts existing data.

@Embeddable is a value object without its own identity or table; its fields are stored as columns of the owning entity (@Embedded Address address → street, city, pincode columns).

@Enumerated(EnumType.STRING)
private OrderStatus status;     // stored as 'PLACED', 'SHIPPED'

@Embedded
private Address shippingAddress;