Java: What is the difference between @OneToMany and @ManyToOne?

@OneToMany — one entity has many related. @ManyToOne — many entities reference one.

@OneToMany:

• One parent, many children.
• Collections (List, Set).
• mappedBy — inverse side.
• Can cause N+1 queries if not careful.

1@Entity
2public class User {
3    @Id
4    private Long id;
5
6    @OneToMany(mappedBy = "user", cascade = CascadeType.ALL)
7    private List<Order> orders;
8}

@ManyToOne:

• Many children, one parent.
• Single reference.
• Owns the foreign key.
• Default fetch type is EAGER.

1@Entity
2public class Order {
3    @Id
4    private Long id;
5
6    @ManyToOne
7    @JoinColumn(name = "user_id")
8    private User user;
9}

How it works:

1. @OneToMany defines the inverse side of the relationship.
2. @ManyToOne defines the owning side with the foreign key.
3. mappedBy points to the field in the other entity.
4. The owning side controls the relationship.

Bidirectional:

• @OneToMany(mappedBy = "user") on User.
• @ManyToOne on Order.
• Order owns the relationship.

N+1 problem:

• Loading a User and then accessing orders triggers N queries.
• Solution: Use JOIN FETCH or @EntityGraph.

Best practice:

• Always define both sides for bidirectional relationships.
• Use LAZY fetching for collections.
• Consider using DTOs to avoid N+1 issues.