Background

Suppose we have bidirectional OneToOne relationship.
There are User and Address entity. User has many Addresses.

CREATE SEQUENCE IF NOT EXISTS hibernate_sequence;
CREATE TABLE users (
 id BIGINT PRIMARY KEY
);

CREATE TABLE addresses (
 id BIGINT PRIMARY KEY,
 user_id BIGINT NOT NULL UNIQUE CONSTRAINT fk_addresses_user_id REFERENCES users(id) ON DELETE CASCADE,
);

and

@Table(name = "users")
public class User 

 @Id
 @GeneratedValue(strategy = GenerationType.SEQUENCE)
 private Long id;

 //mappings
 private Address address;


@Table(name = "addresses")
public class Address 

 @Id
 @GeneratedValue(strategy = GenerationType.SEQUENCE)
 private Long id;

 //mapings
 private User user;

Disclaimer:

I'm using OneToOne as an example but the question is about relations in general so the right approach is valid for ManyToMany as well.

TL;DR - the question is about using mappedBy<->relation owner<->cascades<->managing other side in setters in general

Questions:

1. In database there should be user_id in address table table, right? Who is the owner of the relation then?


2. In entities: which one should have mappedBy - (User or Address) / (Owner or Inverse)?
   
   
   • This link: https://coderanch.com/t/595728/databases/Newbie-Hibernate-OneToMany-owning-side states: "Note that the mappedBy automatically makes the relationship the inverse or non-owning side." so Address should have mappedBy
   
   
   • While in this link: https://vladmihalcea.com/the-best-way-to-map-a-onetoone-relationship-with-jpa-and-hibernate/ Post (User in my example) have mappedBy to PostDetails (Address in my example)
   
   
   • Javadoc: https://docs.oracle.com/javaee/7/api/javax/persistence/OneToOne.html#mappedBy() says "The field that owns the relationship" so User owns the relation, and therefore Address should have mappedBy (CustomerRecord in JavaDoc)
   
   
   • But hibernate documentation: http://docs.jboss.org/hibernate/orm/5.4/userguide/html_single/Hibernate_User_Guide.html#associations-one-to-one-bidirectional the parent Phone (Person in my example) has mappedBy to PhoneDetails (Address)
   
   


3. On which side (User or Address) / (mappedBy or inverse-side) the @OneToOne(cascade = CascadeType.MERGE, CascadeType.DETACH, CascadeType.REFRESH) should be placed?


4. And last question: which of the entities should manage the relation like this:

public void addAddress(Address address) 
 if (address != null) 
 address.addUser(this);
 
 this.addresses.add(address);


public void removeAddress(Address address) 
 if (address != null) 
 address.removeUser(this);
 
 this.addresses.remove(address);


public Set<Address> getAddresses() 
 return Collections.unmodifiableSet(this.addresses);

the (User or Address) / (mappedBy or inverse-side)?

• This link: https://vladmihalcea.com/the-best-way-to-map-a-onetomany-association-with-jpa-and-hibernate/ shows the approach listed above (where the parent, User in my example, manages the relation)


• But here: https://www.quora.com/What-is-the-purpose-of-mapped-by-element-in-OneToMany-annotation-in-Hibernate Vlad says: "it’s always good practice if the child side, where the Foreign Key is located, controls the association", so the Address should "controll the relation" (exactly the opposite)?

Moreover - look at theese two links:

• 
  https://docs.oracle.com/javaee/7/api/javax/persistence/OneToOne.html - here CustomerRecord has mappedBy


• 
  https://docs.oracle.com/javaee/7/api/javax/persistence/OneToMany.html - but here Customer has mappedBy!

Thank you in advance

PS. Previous version of my question was using OneToMany as an example, but because inverse - ManyToOne does not have mapped by I changed it to OneToOne which better shows the problem

The mappedBy attribute marks the side of a bidirectional association which does not own the association. Usually, that's the side which does not have the Foreign Key.

On the other hand, cascading entity state transitions only makes sense from parents to child entities. Doing the cascade from the child entity where the FK is stored is a code smell.

It's as simple as that.

1. In database there should be user_id in address table table, right? Who is the owner of the relation then?

1. Exactly. Basically, the owner is address, as it's the owner who holds the reference.

2. In entities: which one should have mappedBy - User or Address?

@ManyToOne doesn't even have the attribute mappedBy. It's present only on xToMany annotations.

Your mapping should be:

@Table(name = "users")
public class User 

 @Id
 @GeneratedValue(strategy = GenerationType.SEQUENCE)
 private Long id;

 @OneToMany(mappedBy="user", cascade = ...) // atenttion, this refer the attribute name as opposed to the column name
 private Set<Address> addresses = new HashSet<>();


@Table(name = "addresses")
public class Address 

 @Id
 @GeneratedValue(strategy = GenerationType.SEQUENCE)
 private Long id;

 @ManyToOne
 @JoinColumn(name="user_id") // the name is optional if you refer to the PK
 private User user;

On which side (User or Address?) the @ManyToMany(cascade = CascadeType.MERGE, CascadeType.DETACH, CascadeType.REFRESH) should be placed?

And last question: which of the entities should manage the relation like this:

In this case, you want to handle User, and then JPA handles Address automatically.
Therefore, the cascade would be on User.

On this side (OneToMany), you probably also want to add orphanRemoval = true.

Trying to adjust after clarification...

About the support, JPA supports cascading from both sides, ok?!
From where you should use it depends on your domain.

You are supposed to use it on the Entity which you use on entityManager operations, for instance: em.persist(user) or em.merge(address).

Really, depends on how your code is.

In this specify case, it seems it makes more sense to leave on User. I suppose you have an User CRUD, which also includes address.

In this case, it makes sense when you create or remove an User, then its addresses are created/remove together.

On the other side, it wouldn't make sense to cascade from the Address. If you remove an Address, it does NOT mean that the user should be removed too.

Can you see?! You need to check your use case. The side to use it (whether oneToMany or manyToOne or ...) should be thought and decided based on your needs on that moment.

This is what I have learnt so far.

If I'm mistaken to any of the points - please let me know in comments, and I edit the answer.

Database

Owner of the relation

`According to this answer

Basically, the owner is address, as it's the owner who holds the reference.

So the "owner" of relation in database is entity with foreign key - Address in case of OneToOne/OneToMany.
Moreover - it seems that in the same time "owner" of the database relation is the Child in Hibernate relation - but I need confirmation for this

OneToOne

Parent/Child

According to this article

The Post entity is the parent, while the PostDetails is the child association because the Foreign Key is located in the post_details database table

So User is the Parent and Address is the Child here (because Address holds foreign key)

mappedBy

According to this answer

The mappedBy attribute marks the side of a bidirectional association which does not own the association. Usually, that's the side which does not have the Foreign Key.

So mappedBy should be placed in User, because foreign key is in Address.
In seems that in @OneToOne mappedBy should be always placed in Parent (entity not holding the foreign key)

JoinColumn

It seems that JoinColumn in OneToOne must be always placed in Child (since it holds foreign key)

Cascades

According to this answer

cascading entity state transitions only makes sense from parents to child entities.

So cascades in OneToOne should be always done in Parent, so - according to previous links - User in this example

set utility method

I'm not sure but it seems that utility setter should be placed in User.

Is it always placed in the Parent?

Outcome

CREATE SEQUENCE IF NOT EXISTS hibernate_sequence;
CREATE TABLE users (
 id BIGINT PRIMARY KEY
);

CREATE TABLE addresses (
 id BIGINT PRIMARY KEY,
 user_id BIGINT NOT NULL UNIQUE CONSTRAINT fk_addresses_user_id REFERENCES users(id) ON DELETE CASCADE,
);

@Table(name = "users")
public class User 

 @Id
 @GeneratedValue(strategy = GenerationType.SEQUENCE)
 private Long id;

 @OneToOne(mappedBy = "user", cascade = CascadeType.ALL, fetch = FetchType.LAZY, optional = false, orphanRemoval = true)
 private Address address;

 public void setAddress(Address address) 
 if (address != null) 
 address.setUser(this);
 
 this.address = address;
 


@Table(name = "addresses")
public class Address 

 @Id
 @GeneratedValue(strategy = GenerationType.SEQUENCE)
 private Long id;

 @OneToOne(fetch = FetchType.LAZY)
 @JoinColumn(name = "user_id")
 private User user;

OneToMany

Parent/Child

It seems to be the same as with OneToOne, so User is the Parent and Address is the Child (because it has foreign key), but I'm not 100% sure...

mappedBy

In this article mappedBy is placed in Parent (but I'm not sure if this is the rule of thumb though)

JoinColumn

It seems that JoinColumn in OneToMany must be always placed in Child (since it holds foreign key)

Cascades

In above article cascades are also placed in Parent (but I'm not sure if this is the rule of thumb as well)

add/remove utility methods

In above article utility methods are also placed in Parent (but I'm not sure if this is the rule of thumb as well)

Outcome

CREATE SEQUENCE IF NOT EXISTS hibernate_sequence;
CREATE TABLE users (
 id BIGINT PRIMARY KEY
);

CREATE TABLE addresses (
 id BIGINT PRIMARY KEY,
 user_id BIGINT NOT NULL CONSTRAINT fk_addresses_user_id REFERENCES users(id) ON DELETE CASCADE,
);

@Table(name = "users")
public class User 

 @Id
 @GeneratedValue(strategy = GenerationType.SEQUENCE)
 private Long id;

 @OneToMany(mappedBy = "user", cascade = CascadeType.ALL, fetch = FetchType.LAZY, orphanRemoval = true)
 private List<Address> addresses = new ArrayList<>();

 public void addAddress(Address address) 
 if (address != null) 
 address.setUser(this);
 
 this.addresses.add(address);
 

 public void removeAddress(Address address) 
 this.addresses.remove(address);
 if (address != null) 
 address.setUser(null);
 
 

 public Set<Address> getAddresses() 
 return Collections.unmodifiableSet(this.addresses);
 


@Table(name = "addresses")
public class Address 

 @Id
 @GeneratedValue(strategy = GenerationType.SEQUENCE)
 private Long id;

 @ManyToOne(fetch = FetchType.LAZY)
 @JoinColumn(name = "user_id")
 private User user;

ManyToMany

Parent/Child

According to this article

A typical many-to-many database association includes two parent tables

So both User and Address are Parents

mappedBy

In the same article Vlad wrote:

The mappedBy attribute of the posts association in the Tag entity marks that, in this bidirectional relationship, the Post entity own the association

Therefore here is the eception, because we don't have one Parent.
It is not clear to me what Vlad means exactly by "own", but if User "owns" the relation, mappedBy must be placed in Address,

JoinTable

It seems that JoinTable must be always placed in entity that "owns" the relation, so User in this case.