Can someone explain mappedBy in JPA and Hibernate?

I am new to hibernate and need to use one-to-many and many-to-one relations. It is a bi-directional relationship in my objects, so that I can traverse from either direction. mappedBy is the recommended way to go about it, however, I couldn't understand it. Can someone explain:

• what is the recommended way to use it?
• what purpose does it solve?

For the sake of my example, here are my classes with annotations:

• Airline OWNS many AirlineFlights
• Many AirlineFlights belong to ONE Airline

Airline:

@Entity 
@Table(name="Airline")
public class Airline {
	private Integer idAirline;
	private String name;

	private String code;
	
	private String aliasName;
	private Set<AirlineFlight> airlineFlights = new HashSet<AirlineFlight>(0);
	
	public Airline(){}
	
	public Airline(String name, String code, String aliasName, Set<AirlineFlight> flights) {
		setName(name);
		setCode(code);
		setAliasName(aliasName);
		setAirlineFlights(flights);
	}

	@Id
	@GeneratedValue(strategy=GenerationType.IDENTITY)
	@Column(name="IDAIRLINE", nullable=false)
	public Integer getIdAirline() {
		return idAirline;
	}
	
	private void setIdAirline(Integer idAirline) {
		this.idAirline = idAirline;
	}
	
	@Column(name="NAME", nullable=false)
	public String getName() {
		return name;
	}
	public void setName(String name) {
		this.name = DAOUtil.convertToDBString(name);
	}
	
	@Column(name="CODE", nullable=false, length=3)
	public String getCode() {
		return code;
	}
	public void setCode(String code) {
		this.code = DAOUtil.convertToDBString(code);
	}
	
	@Column(name="ALIAS", nullable=true)
	public String getAliasName() {
		return aliasName;
	}
	public void setAliasName(String aliasName) {
		if(aliasName != null)
			this.aliasName = DAOUtil.convertToDBString(aliasName);
	}

	@OneToMany(fetch=FetchType.LAZY, cascade = {CascadeType.ALL})
	@JoinColumn(name="IDAIRLINE")
	public Set<AirlineFlight> getAirlineFlights() {
		return airlineFlights;
	}

	public void setAirlineFlights(Set<AirlineFlight> flights) {
		this.airlineFlights = flights;
	}
}

AirlineFlights:

@Entity
@Table(name="AirlineFlight")
public class AirlineFlight {
	private Integer idAirlineFlight;
	private Airline airline;
	private String flightNumber;
	
	public AirlineFlight(){}
	
	public AirlineFlight(Airline airline, String flightNumber) {
		setAirline(airline);
		setFlightNumber(flightNumber);
	}

	@Id
	@GeneratedValue(generator="identity")
	@GenericGenerator(name="identity", strategy="identity")
	@Column(name="IDAIRLINEFLIGHT", nullable=false)
	public Integer getIdAirlineFlight() {
		return idAirlineFlight;
	}
	private void setIdAirlineFlight(Integer idAirlineFlight) {
		this.idAirlineFlight = idAirlineFlight;
	}
	
	@ManyToOne(fetch=FetchType.LAZY)
	@JoinColumn(name="IDAIRLINE", nullable=false)
	public Airline getAirline() {
		return airline;
	}
	public void setAirline(Airline airline) {
		this.airline = airline;
	}
	
	@Column(name="FLIGHTNUMBER", nullable=false)
	public String getFlightNumber() {
		return flightNumber;
	}
	public void setFlightNumber(String flightNumber) {
		this.flightNumber = DAOUtil.convertToDBString(flightNumber);
	}
}

EDIT:

Database schema:

AirlineFlights has the idAirline as ForeignKey and Airline has no idAirlineFlights. This makes, AirlineFlights as the owner/identifying entity ?

Theoretically, I would like airline to be the owner of airlineFlights.

MappedBy signals hibernate that the key for the relationship is on the other side.

This means that although you link 2 tables together, only 1 of those tables has a foreign key constraint to the other one. MappedBy allows you to still link from the table not containing the constraint to the other table.

By specifying the @JoinColumn on both models you don't have a two way relationship. You have two one way relationships, and a very confusing mapping of it at that. You're telling both models that they "own" the IDAIRLINE column. Really only one of them actually should! The 'normal' thing is to take the @JoinColumn off of the @OneToMany side entirely, and instead add mappedBy to the @OneToMany.

@OneToMany(cascade = CascadeType.ALL, mappedBy="airline")
public Set<AirlineFlight> getAirlineFlights() {
    return airlineFlights;
}

That tells Hibernate "Go look over on the bean property named 'airline' on the thing I have a collection of to find the configuration."

Table relationship vs. entity relationship

In a relational database system, a one-to-many table relationship looks as follows:

Note that the relationship is based on the Foreign Key column (e.g., post_id) in the child table.

So, there is a single source of truth when it comes to managing a one-to-many table relationship.

Now, if you take a bidirectional entity relationship that maps on the one-to-many table relationship we saw previously:

If you take a look at the diagram above, you can see that there are two ways to manage this relationship.

In the Post entity, you have the comments collection:

@OneToMany(
    mappedBy = "post",
    cascade = CascadeType.ALL,
    orphanRemoval = true
)
private List<PostComment> comments = new ArrayList<>();

And, in the PostComment, the post association is mapped as follows:

@ManyToOne(
    fetch = FetchType.LAZY
)
@JoinColumn(name = "post_id")
private Post post;

Because there are two ways to represent the Foreign Key column, you must define which is the source of truth when it comes to translating the association state change into its equivalent Foreign Key column value modification.

MappedBy

The mappedBy attribute tells that the @ManyToOne side is in charge of managing the Foreign Key column, and the collection is used only to fetch the child entities and to cascade parent entity state changes to children (e.g., removing the parent should also remove the child entities).

Synchronize both sides of a bidirectional association

Now, even if you defined the mappedBy attribute and the child-side @ManyToOne association manages the Foreign Key column, you still need to synchronize both sides of the bidirectional association.

The best way to do that is to add these two utility methods:

public void addComment(PostComment comment) {
    comments.add(comment);
    comment.setPost(this);
}

public void removeComment(PostComment comment) {
    comments.remove(comment);
    comment.setPost(null);
}

The addComment and removeComment methods ensure that both sides are synchronized. So, if we add a child entity, the child entity needs to point to the parent and the parent entity should have the child contained in the child collection.

mappedby speaks for itself, it tells hibernate not to map this field. it's already mapped by this field [name="field"].
field is in the other entity (name of the variable in the class not the table in the database)..

> If you don't do that, hibernate will map this two relation as it's not > the same relation

so we need to tell hibernate to do the mapping in one side only and co-ordinate between them.

mappedby="object of entity of same class created in another class”

Note:-Mapped by can be used only in one class because one table must contain foreign key constraint. if mapped by can be applied on both side then it remove foreign key from both table and without foreign key there is no relation b/w two tables.

Note:- it can be use for following annotations:- 1.@OneTone 2.@OneToMany 3.@ManyToMany

Note---It cannot be use for following annotation :- 1.@ManyToOne

In one to one :- Perform at any side of mapping but perform at only one side . It will remove the extra column of foreign key constraint on the table on which class it is applied.

For eg . If we apply mapped by in Employee class on employee object then foreign key from Employee table will be removed.

The mappedBy attribute characterizes a bidirectional association and must be set on the parent-side. In other words, for a bidirectional @OneToMany association, set mappedBy to @OneToMany on the parent-side and add @ManyToOne on the child-side referenced by mappedBy . Via mappedBy, the bidirectional @OneToMany association signals that it mirrors the @ManyToOne child-side mapping.

You started with ManyToOne mapping , then you put OneToMany mapping as well for BiDirectional way. Then at OneToMany side (usually your parent table/class), you have to mention "mappedBy" (mapping is done by and in child table/class), so hibernate will not create EXTRA mapping table in DB (like TableName = parent_child).