What is the inverse side of the association in a bidirectional JPA OneToMany ManyToOne association

Question

In the example section of the  OneToMany JPA annotation reference   Example 1-59  OneToMany - Customer Class With Generics   Entity public class Customer implements Serializable                OneToMany cascade ALL  mappedBy  customer       public Set lt Order gt  getOrders              return orders                     Example 1-60  ManyToOne - Order Class With Generics   Entity public class Order implements Serializable                ManyToOne      JoinColumn name  CUST ID   nullable false      public Customer getCustomer              return customer                     It seems to me that the Customer entity is the owner of the association  However  in the explanation for the mappedBy attribute in the same document  it is written that      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 Example 1-60 shows    However  if I am not wrong  it looks like in the example  the mappedBy is actually specified on the owning side of the association  rather than the non-owning side   So my question is basically    In a bidirectional  one-to-many many-to-one  association  which of the entities is the owner  How can we designate the One side as the owner  How can we designate the Many side as the owner  What is meant by  the inverse side of the association   How can we designate the One side as the inverse  How can we designate the Many side as the inverse

User · Answer

Table relationships vs  entity relationships In a relational database system  there can be only three types of table relationships   one-to-many  via a Foreign Key column  one-to-one  via a shared Primary Key  many-to-many  via a link table with two Foreign Keys referencing two separate parent tables   So  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    quot post quot       cascade   CascadeType ALL      orphanRemoval   true   private List lt PostComment gt  comments   new ArrayList lt  gt      And  in the PostComment  the post association is mapped as follows   ManyToOne      fetch   FetchType LAZY    JoinColumn name    quot post id quot   private Post post   So  you have two sides that can change the entity association   By adding an entry in the comments child collection  a new post comment row should be associated with the parent post entity via its post id column  By setting the post property of the PostComment entity  the post id column should be updated as well   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  a k a the inverse side  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    It s called the inverse side because it references the child entity property that manages this table relationship   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

User · Answer

Simple rules of bidirectional relationships   1 For many-to-one bidirectional relationships  the many side is always the owning side of the relationship  Example  1 Room has many Person  a Person belongs one Room only  -  owning side is Person  2 For one-to-one bidirectional relationships  the owning side corresponds to the side that contains the corresponding foreign key   3 For many-to-many bidirectional relationships  either side may be the owning side   Hope can help you

User · Answer

The entity which has the table with foreign key in the database is the owning entity and the other table  being pointed at  is the inverse entity

User · Answer

Unbelievably  in 3 years nobody has answered your excellent question with examples of both ways to map the relationship   As mentioned by others  the  owner  side contains the pointer  foreign key  in the database  You can designate either side as the owner  however  if you designate the One side as the owner  the relationship will not be bidirectional  the inverse aka  many  side will have no knowledge of its  owner    This can be desirable for encapsulation loose coupling       One  Customer owns the associated orders by storing them in a customer orders join table public class Customer        OneToMany cascade   CascadeType ALL      private List lt Order gt  orders        if the Customer owns the orders using the customer orders table     Order has no knowledge of its Customer public class Order           ManyToOne annotation has no  mappedBy  attribute to link bidirectionally     The only bidirectional mapping solution is to have the  many  side own its pointer to the  one   and use the  OneToMany  mappedBy  attribute  Without the  mappedBy  attribute Hibernate will expect a double mapping  the database would have both the join column and the join table  which is redundant  usually undesirable         One  Customer as the inverse side of the relationship public class Customer        OneToMany cascade   CascadeType ALL  mappedBy    customer       private List lt Order gt  orders         many  orders each own their pointer to a Customer public class Order        ManyToOne     private Customer customer

User · Answer

For two Entity Classes Customer and Order   hibernate will create two tables   Possible Cases    mappedBy is not used in Customer java and Order java Class then-   At customer side a new table will be created name   CUSTOMER ORDER  which will keep mapping of CUSTOMER ID and ORDER ID  These are primary keys of Customer and Order Tables  At Order side an additional column is required to save the corresponding Customer ID record mapping   mappedBy is used in Customer java  As given in problem statement   Now additional table CUSTOMER ORDER  is not created  Only one column in Order Table mappedby is used in Order java Now additional table will be created by hibernate  name   CUSTOMER ORDER  Order Table will not have additional column  Customer ID   for mapping    Any Side can be made Owner of the relationship  But its better to choose xxxToOne side   Coding effect -   Only Owning side of entity can change relationship status  In below example BoyFriend class is owner of the relationship  even if Girlfriend wants to break-up   she can t   import javax persistence    import java util ArrayList  import java util List    Entity  Table name    BoyFriend21   public class BoyFriend21         Id      GeneratedValue strategy   GenerationType SEQUENCE  generator    Boy ID        SequenceGenerator name    Boy ID   sequenceName    Boy ID SEQUENCER   initialValue   10 allocationSize   1      private Integer id        Column name    BOY NAME       private String name        OneToOne cascade     CascadeType ALL        private GirlFriend21 girlFriend       public BoyFriend21 String name            this name   name             public BoyFriend21                public Integer getId             return id             public void setId Integer id            this id   id             public String getName             return name             public void setName String name            this name   name             public BoyFriend21 String name  GirlFriend21 girlFriend            this name   name          this girlFriend   girlFriend             public GirlFriend21 getGirlFriend             return girlFriend             public void setGirlFriend GirlFriend21 girlFriend            this girlFriend   girlFriend           import org hibernate annotations    import javax persistence    import javax persistence CascadeType  import javax persistence Entity  import javax persistence Table  import java util ArrayList  import java util List    Entity   Table name    GirlFriend21   public class GirlFriend21         Id      GeneratedValue strategy   GenerationType SEQUENCE  generator    Girl ID        SequenceGenerator name    Girl ID   sequenceName    Girl ID SEQUENCER   initialValue   10 allocationSize   1      private Integer id        Column name    GIRL NAME       private String name        OneToOne cascade    CascadeType ALL  mappedBy    girlFriend       private BoyFriend21 boyFriends   new BoyFriend21         public GirlFriend21                public GirlFriend21 String name            this name   name              public Integer getId             return id             public void setId Integer id            this id   id             public String getName             return name             public void setName String name            this name   name             public GirlFriend21 String name  BoyFriend21 boyFriends            this name   name          this boyFriends   boyFriends             public BoyFriend21 getBoyFriends             return boyFriends             public void setBoyFriends BoyFriend21 boyFriends            this boyFriends   boyFriends            import org hibernate HibernateException  import org hibernate Session  import org hibernate SessionFactory  import org hibernate cfg Configuration  import java util Arrays   public class Main578 DS        public static void main String   args            final Configuration configuration   new Configuration             try                configuration configure  hibernate cfg xml               catch  HibernateException e                 throw new RuntimeException e                      final SessionFactory sessionFactory   configuration buildSessionFactory            final Session session   sessionFactory openSession            session beginTransaction             final BoyFriend21 clinton   new BoyFriend21  Bill Clinton            final GirlFriend21 monica   new GirlFriend21  monica lewinsky             clinton setGirlFriend monica           session save clinton            session getTransaction   commit            session close             import org hibernate HibernateException  import org hibernate Session  import org hibernate SessionFactory  import org hibernate cfg Configuration  import java util List   public class Main578 Modify        public static void main String   args            final Configuration configuration   new Configuration            try               configuration configure  hibernate cfg xml              catch  HibernateException e                throw new RuntimeException e                     final SessionFactory sessionFactory   configuration buildSessionFactory            final Session session1   sessionFactory openSession            session1 beginTransaction             GirlFriend21 monica    GirlFriend21 session1 load GirlFriend21 class 10       Monica lewinsky record has id  10          BoyFriend21 boyfriend   monica getBoyFriends            System out println boyfriend getName        It will print  Clinton Name         monica setBoyFriends null      It will not impact relationship          session1 getTransaction   commit            session1 close             final Session session2   sessionFactory openSession            session2 beginTransaction             BoyFriend21 clinton    BoyFriend21 session2 load BoyFriend21 class 10       Bill clinton record          GirlFriend21 girlfriend   clinton getGirlFriend            System out println girlfriend getName        It will print Monica name            But if Clinton Who owns the relationship as per  mappedby  rule can break this          clinton setGirlFriend null              Now if Monica tries to check BoyFriend Details  she will find Clinton is no more her boyFriend         session2 getTransaction   commit            session2 close             final Session session3   sessionFactory openSession            session1 beginTransaction             monica    GirlFriend21 session3 load GirlFriend21 class 10       Monica lewinsky record has id  10          boyfriend   monica getBoyFriends             System out println boyfriend getName        Does not print Clinton Name          session3 getTransaction   commit            session3 close

User · Answer

To understand this  you must take a step back  In OO  the customer owns the orders  orders are a list in the customer object   There can t be an order without a customer  So the customer seems to be the owner of the orders   But in the SQL world  one item will actually contain a pointer to the other  Since there is 1 customer for N orders  each order contains a foreign key to the customer it belongs to  This is the  connection  and this means the order  owns   or literally contains  the connection  information   This is exactly the opposite from the OO model world   This may help to understand   public class Customer           This field doesn t exist in the database         It is simulated with a SQL query          OO speak   Customer owns the orders      private List lt Order gt  orders     public class Order           This field actually exists in the DB         In a purely OO model  we could omit it          DB speak   Order contains a foreign key to customer      private Customer customer      The inverse side is the OO  owner  of the object  in this case the customer  The customer has no columns in the table to store the orders  so you must tell it where in the order table it can save this data  which happens via mappedBy    Another common example are trees with nodes which can be both parents and children  In this case  the two fields are used in one class   public class Node          Again  this is managed by Hibernate         There is no matching column in the database       OneToMany cascade   CascadeType ALL     mappedBy is only necessary when there are two fields with the type  Node      private List lt Node gt  children          This field exists in the database         For the OO model  it s not really necessary and in fact        some XML implementations omit it to save memory         Of course  that limits your options to navigate the tree       ManyToOne     private Node parent      This explains for the  foreign key  many-to-one design works  There is a second approach which uses another table to maintain the relations  That means  for our first example  you have three tables  The one with customers  the one with orders and a two-column table with pairs of primary keys  customerPK  orderPK    This approach is more flexible than the one above  it can easily handle one-to-one  many-to-one  one-to-many and even many-to-many   The price is that    it s a bit slower  having to maintain another table and joins uses three tables instead of just two    the join syntax is more complex  which can be tedious if you have to manually write many queries  for example when you try to debug something  it s more error prone because you can suddenly get too many or too few results when something goes wrong in the code which manages the connection table    That s why I rarely recommend this approach

[java] What is “the inverse side of the association” in a bidirectional JPA OneToMany/ManyToOne association?

Table relationships vs. entity relationships

MappedBy (a.k.a the inverse side)

Synchronize both sides of a bidirectional association

Examples related to java

Examples related to hibernate

Examples related to jpa

Examples related to one-to-many

Examples related to mappedby