Many-to-Many Mapping

Many-to-many mappings represent the relationships between a collection of source objects and a collection of target objects. They require the creation of an intermediate table for managing the associations between the source and target records.

This figure illustrates a many-to-many mapping in Java and in relational database tables.

Many-to-many Relationships

Note: For the projects attribute shown in the Many-to-many Relationships you can use a Collection interface (or any class that implements the Collection interface) for declaring the collection attribute.

JPA Mapping

By default, JPA automatically defines a ManyToMany mapping for a many-valued association with many-to-many multiplicity.

configure the associated target entity because the Collection used is not defined using generics;

configure the operations that must be cascaded to the target of the association (for example, if the owning entity is removed, ensure that the target of the association is also removed).

@ManyToMany Annotation Attributes

Attribute

Description

Default

Required?

cascade

– By default, JPA does not cascade any persistence operations to the target of the association.If you want some or all persistence operations cascaded to the target of the association, set the value of this attribute to one or more CascadeType instances, including the following:

ALL – Any persistence operation performed on the owning entity is cascaded to the target of the association.

MERGE – If the owning entity is merged, the merge is cascaded to the target of the association.

PERSIST – If the owning entity is persisted, the persist is cascaded target of the association.

REFRESH – If the owning entity is refreshed, the refresh is cascaded target of the association.

REMOVE – If the owning entity is removed, the target of the association is also removed.

An empty javax.persitence.CascadeType array

No

fetch

– By default, EclipseLink persistence provider uses a fetch type of javax.persitence.FetchType.LAZY: this is a hint to the persistence provider that data should be fetched lazily when it is first accessed (if possible).If the default is inappropriate for your application or a particular persistent field, set fetch to FetchType.EAGER: this is a requirement on the persistence provider runtime that data must be eagerly fetched..

javax.persitence.FetchType.LAZY

No

mappedBy

By default, if the relationship is unidirectional, EclipseLink persistence provider determines the field that owns the relationship.If the relationship is bidirectional, then set the mappedBy element on the inverse (non-owning) side of the association to the name of the field or property that owns the relationship, as the @ManyToMany Annotation - Project Class with Generics example shows.

No

targetEntity

By default, if you are using a Collection defined using generics, then the persistence provider infers the associated target entity from the type of the object being referenced. Thus, the default is the parameterized type of the Collection when defined using generics.If your Collection does not use generics, then you must specify the entity class that is the target of the association: set the targetEntity element on owning side of the association to the Class of the entity that is the target of the relationship.

Note: Use a @JoinTable annotation to define a many-to-many join table; if you do not specify this annotation, EclipseLink will default to @JoinTable with the join table name format of <source-table-name>_<target-table-name> in uppercase characters, and with columns format of <source-entity-alias>_<source-primary-key-column>, <source-field-name>_ <target-primary-key-column> (or <source-property-name>_ <target-primary-key-column>) in uppercase characters.

For more information, see Section 11.1.23 "JoinTable Annotation" in the JPA Specification.