{"id":635,"date":"2022-12-03T04:13:41","date_gmt":"2022-12-03T04:13:41","guid":{"rendered":"https:\/\/www.canosielabs.com\/blog\/?p=635"},"modified":"2022-12-03T04:17:29","modified_gmt":"2022-12-03T04:17:29","slug":"jpa-with-hibernate-relationship-mapping-using-annotations","status":"publish","type":"post","link":"https:\/\/www.canosielabs.com\/blog\/jpa-with-hibernate-relationship-mapping-using-annotations\/","title":{"rendered":"JPA with Hibernate – Relationship Mapping using Annotations"},"content":{"rendered":"
\n
\n
\n
\n
\n

In this guide, I’ll show you how to create all of the common relationship mappings available using the JPA specification<\/strong>.  In my examples, Hibernate<\/strong> is used as the underlying implementation<\/strong>.  This isn’t a full tutorial, but instead, this guide can be used as a quick cheat sheet when required to setup future implementations so I keep it updated or add to it as required.  In this guide, we’ll be using only annotation based configurations. <\/p>\n

This is not a exhaustive list of all possible configurations of the four basic relationships possible but rather a explanation of the common setups.  In particular, within each type of relationship, the exact configuration used often depends on the specifics of the use case – in particular, who should be the relationship owner<\/strong>.  Concepts we will be covering(in summary) are relationship owner, unidirectional and bidirectional relationships and the 4 basic mapping types.<\/p>\n

We’ll also present some use cases that, while possible, are not recommended due to various inconsistencies that may crop up.  These are discussed for completeness.<\/p>\n

Note:<\/h3>\n
    \n
  • Getters and setters have been omitted for verbosity.<\/li>\n
  • As primary key column names are used in JPA configurations, to prevent confusing stemming from the proliferation of “ID”<\/strong> or <TABLE_NAME>_ID<\/strong> column names being used everywhere, foreign key column names have been named “<TABLE NAME>_ID_FK”<\/strong> (instead of just <TABLE_NAME_ID> <\/strong>or “ID”<\/strong>) to distinguish themselves from the actual table primary key column.<\/li>\n
  • Casecase<\/strong> configurations have been omitted to simplify the code.<\/li>\n<\/ul>\n

    Introduction<\/h1>\n

    There are four basic<\/strong> relationships outlined in the JPA specification.<\/p>\n

      \n
    1. One to one<\/li>\n
    2. One to many<\/li>\n
    3. Many to one<\/li>\n
    4. Many to many<\/li>\n<\/ol>\n

      One to One<\/h1>\n

      The one to one relationship is used when one entity is at most associated with one other entity.  Since it is one to one, the foreign key can linking the two entities can be on:<\/p>\n

        \n
      • On either side of the relationship.<\/li>\n
      • Using a third join table.<\/li>\n<\/ul>\n

        Thus, lets use an example Car<\/strong> and Engine<\/strong>.  A CAR<\/strong> has one ENGINE<\/strong> and a ENGINE<\/strong> is part of one CAR.<\/strong><\/p>\n

        1. Foreign key car_id is on the Engine table.<\/h3>\n
        \n

        <\/p>\n

        @Entity\r\n@Table(name = \"car\")\r\npublic class Car {\r\n\r\n    @Id\r\n    @GeneratedValue(strategy=GenerationType.IDENTITY)\r\n    private long car_id;\r\n\r\n    @OneToOne(mappedBy = \"car\")\r\n    private Engine engine;\r\n}\r\n\r\n\r\n@Entity\r\n@Table(name=\"engine\")\r\npublic class Engine {\r\n\r\n    @Id\r\n    @GeneratedValue(strategy=GenerationType.IDENTITY)\r\n\tprivate long engine_id;\r\n\r\n    @OneToOne\r\n    @JoinColumn(name=\"car_id_fk\")\r\n\tprivate Car car;\r\n}\r\n<\/code><\/pre>\n<\/div>\n<\/div>\n<\/div>\n<\/div>\n<\/div>\n<\/div>\n
        \n
        \n
        \n
        \n
        This is a bidirectional<\/strong> relationship with the Engine<\/strong> being the owner<\/strong> of the relationship.  <\/p>\n
        In the Car entity:<\/p>\n
          \n
        • We are using the mappedBy<\/strong> attribute in the @OneToOne<\/strong> annotation.   We are telling Hibernate that the mapping between Car<\/strong> and Engine<\/strong> is found on the Engine<\/strong>(owner<\/strong>) side.<\/li>\n<\/ul>\n
          In the Engine (owner) entity:<\/p>\n
            \n
          • In addition to using the @OneToOne<\/strong> annotation to denote the relationship, since the ENGINE<\/strong> table contains the foreign key, it must use the @JoinColumn<\/strong> to denote the mapping to the Car<\/strong> entity.   <\/li>\n<\/ul>\n
            In this example, it is possible to create a unidirectional<\/strong> relationship from Engine<\/strong> to Car<\/strong>, by omitting the Engine<\/strong> member in Car<\/strong> (and associated JPA annotations).  It is not possible to create a unidirectional<\/strong> relationship from Car<\/strong> to Engine<\/strong> (in any standard form).   I.e. The mappedBy<\/strong> attribute requires a bidirectional reference  (Engine<\/strong> to Car<\/strong>), a member of type Car in Engine to complete the mapping  and the @JoinColumn<\/strong> annotation cannot be used since the foreign key is on the ENGINE<\/strong> table – not CAR<\/strong>.<\/p>\n
            2. Foreign key engine_id is on the Car table.<\/h3>\n
            <\/p>\n
            @Entity\r\n@Table(name = \"car\")\r\npublic class Car {\r\n\r\n    @Id\r\n    @GeneratedValue(strategy=GenerationType.IDENTITY)\r\n    private long car_id;\r\n\r\n    @OneToOne\r\n    @JoinColumn(name=\"engine_id_fk\")\r\n    private Engine engine;\r\n}\r\n\r\n\r\n@Entity\r\n@Table(name=\"engine\")\r\npublic class Engine {\r\n\r\n    @Id\r\n    @GeneratedValue(strategy=GenerationType.IDENTITY)\r\n\tprivate long engine_id;\r\n\r\n    \/\/ to create a bidirectional mapping\r\n    @OneToOne(mappedBy = \"engine\")\r\n    private Car car;\t\r\n}\r\n<\/code><\/pre>\n
            The Car entity:<\/p>\n
              \n
            1. Denotes the one-to-one relation via the @OneToOne<\/strong> annotation.<\/li>\n
            2. Is the owner<\/strong> of the relationship<\/li>\n
            3. Uses the @JoinColumn<\/strong> to denote the existence of the foreign column in the CAR table which will be used to perform the join. <\/li>\n<\/ol>\n
              In the Engine entity, the mappedBy<\/strong> attribute is used to let Hibernate know the owner of the mapping is controlled by the engine<\/strong> property in Car<\/strong>.<\/p>\n
              3. A mapping table car_engine is used<\/h3>\n
              <\/p>\n
              First, we’ll decide on a owning side, Car<\/strong> in this case.<\/p>\n
              @Entity\r\n@Table(name = \"car\")\r\npublic class Car {\r\n\r\n    @Id\r\n    @GeneratedValue(strategy=GenerationType.IDENTITY)\r\n    private long car_id;\r\n\r\n\t@OneToOne\r\n    @JoinTable(\r\n            name = \"car_engine\", \r\n            joinColumns = { @JoinColumn(name = \"car_id_fk\") }, \r\n            inverseJoinColumns = { @JoinColumn(name = \"engine_id_fk\") }\r\n        )    \r\n\tprivate Engine engine;\r\n}\r\n\r\n\r\n@Entity\r\n@Table(name=\"engine\")\r\npublic class Engine {\r\n\r\n    @Id\r\n    @GeneratedValue(strategy=GenerationType.IDENTITY)\r\n\tprivate long engine_id;\r\n\r\n    @OneToOne(mappedBy=\"engine\")\r\n    private Car car;\t\r\n}\r\n<\/code><\/pre>\n
              The Car entity:<\/p>\n
                \n
              1. Denotes the one-to-one relation via the @OneToOne<\/strong> annotation.<\/li>\n
              2. Is the owner<\/strong> of the relationship<\/li>\n
              3. Uses the @JoinTable <\/strong>with a name attribute to specify the join table name in the database.\n
                  \n
                1. The joinColumns<\/strong> attribute is used to identify the foreign key for this entity (Car<\/strong>)<\/li>\n
                2. The inverseJoinColumn<\/strong> is used to identify the foreign key for the other entity (Engine<\/strong>).<\/li>\n<\/ol>\n<\/li>\n<\/ol>\n
                  In the Engine entity, the mappedBy<\/strong> attribute is used to let Hibernate know the owner of the mapping is controlled by the engine<\/strong> property in Car<\/strong>.  When creating a new Engine instance, it can be assigned to the Car via the setter method on the Car’s side. See example below:<\/p>\n
                  Car honda = carDao.findById((long) 1).get(); ID=1\r\nEngine e1 = engineDao.findById(1l).get();  \/\/ ID=1\r\n\r\nhonda.setEngine(e1)\r\ncarDao.save(honda);  \t\t\r\n<\/code><\/pre>\n
                  It is possible to define both sides as owners.<\/p>\n
                  @Entity\r\n@Table(name = \"car\")\r\npublic class Car {\r\n\r\n    @Id\r\n    @GeneratedValue(strategy=GenerationType.IDENTITY)\r\n    private long car_id;\r\n\r\n\t@OneToOne\r\n    @JoinTable(\r\n            name = \"car_engine\", \r\n            joinColumns = { @JoinColumn(name = \"car_id_fk\") }, \r\n            inverseJoinColumns = { @JoinColumn(name = \"engine_id_fk\") }\r\n        )    \r\n\tprivate Engine engine;\r\n}\r\n\r\n\r\n@Entity\r\n@Table(name=\"engine\")\r\npublic class Engine {\r\n\r\n    @Id\r\n    @GeneratedValue(strategy=GenerationType.IDENTITY)\r\n\tprivate long engine_id;\r\n\r\n    \/\/ to create a bidirectional mapping\r\n\t@OneToOne\r\n    @JoinTable(\r\n            name = \"car_engine\", \r\n            joinColumns = { @JoinColumn(name = \"engine_id_fk\") }, \r\n            inverseJoinColumns = { @JoinColumn(name = \"car_id_fk\") }\r\n    )   \r\n    private Car car;\t\r\n}\r\n<\/code><\/pre>\n
                   <\/p>\n
                  One to Many and Many to One<\/h1>\n
                  Many one-to-many relationships often form a parent-child relationship.  Unlike the one-to-one mapping (above), a one-to-many mapping cannot be mapped via a foreign key on the parent side.  It can only be mapped via:<\/p>\n
                    \n
                  1. The foreign key on the child side (usually the case)<\/li>\n
                  2. The use of a mapping table. <\/li>\n<\/ol>\n
                    In this relationship, the owning<\/strong> side is usually the “many” side.   In this example, we’ll use two entities Car<\/strong> (as above) but introduce another entity called Wheel<\/strong>.  A car has 0 or more wheels and each wheel is associated to only one wheel. <\/p>\n
                    1. Foreign key CAR_ID is on the WHEEL table.<\/h3>\n
                    <\/p>\n
                    For a unidirectional<\/strong> Car to Wheel mapping, we need to specify the foreign key column on the WHEEL<\/strong> table using the @JoinColumn<\/strong> annotation.<\/p>\n
                    @Entity\r\n@Table(name = \"car\")\r\npublic class Car {\r\n\r\n    @Id\r\n    @GeneratedValue(strategy=GenerationType.IDENTITY)\r\n    private long car_id;\r\n\r\n\t@OneToMany\r\n\t@JoinColumn(name = \"car_id_fk\")\r\n\tprivate Set wheels;\r\n}\r\n\r\n\r\n@Entity\r\n@Table(name=\"wheel\")\r\npublic class Wheel {\r\n\r\n    @Id\r\n    @GeneratedValue(strategy=GenerationType.IDENTITY)\r\n\tprivate long engine_id;\r\n}\r\n<\/code><\/pre>\n
                    On the Car entity:<\/p>\n
                      \n
                    1. The @OneToMany<\/strong> annotation indicates the relationship type.<\/li>\n
                    2. The @JoinColumn<\/strong> annotation is interesting.  When used with a @OneToMany<\/strong>, it indicates to Hibernate that this entity is the owner of the relationship and will set the foreign key on the other side.<\/li>\n<\/ol>\n
                      For a bidirectional<\/strong> mapping, we need to choose the owning side.  In the standard use case, the many side, Wheel<\/strong>, is the owner.  See below:<\/p>\n
                      @Entity\r\n@Table(name = \"car\")\r\npublic class Car {\r\n\r\n    @Id\r\n    @GeneratedValue(strategy=GenerationType.IDENTITY)\r\n    private long car_id;\r\n\r\n\t@OneToMany( mappedBy = \"car\")\r\n\tprivate Set wheels;\r\n}\r\n\r\n\r\n@Entity\r\n@Table(name=\"wheel\")\r\npublic class Wheel {\r\n\r\n    @Id\r\n    @GeneratedValue(strategy=GenerationType.IDENTITY)\r\n    private long engine_id;\r\n\r\n    @ManyToOne\r\n    @JoinColumn(name=\"car_id_fk\")\r\n    private Car car;\r\n}\r\n<\/code><\/pre>\n
                      On the Car entity:<\/p>\n
                        \n
                      1. we can replace the annotations used in Car<\/strong> with the mappedBy<\/strong> attribute, to tell Hibernate that the relationship is tracked on the Wheel <\/strong>side (no need to create a third mapping table).  In this situation, we can remove the @JoinColumn<\/strong> annotation used above as the @ManyToOne<\/strong> and @JoinColumn<\/strong> provides Hibernate the necessary information to perform the mapping. <\/li>\n
                      2. This can be omitted if you only want a unidirectional Wheel<\/strong> to Car<\/strong> mapping.<\/li>\n<\/ol>\n
                        On the Wheel Entity:<\/p>\n
                          \n
                        1. Using the @ManyToOne<\/strong> annotation on Wheel<\/strong> indicates that Wheel is the owner.  <\/li>\n<\/ol>\n
                          For completeness, it is possible to have a bidirectional relationship where the Car<\/strong> is the owner.<\/p>\n
                          @Entity\r\n@Table(name = \"car\")\r\npublic class Car {\r\n\r\n    @Id\r\n    @GeneratedValue(strategy=GenerationType.IDENTITY)\r\n    private long car_id;\r\n\r\n\t@OneToMany(cascade = {CascadeType.ALL})\r\n\t@JoinColumn(name = \"cart_id_fk\")\r\n\tprivate Set wheels;\r\n}\r\n\r\n\r\n@Entity\r\n@Table(name=\"wheel\")\r\npublic class Wheel {\r\n\r\n    @Id\r\n    @GeneratedValue(strategy=GenerationType.IDENTITY)\r\n    private long engine_id;\r\n\r\n    @ManyToOne\r\n    @JoinColumn(name=\"car_id_fk\")\r\n    private Car car;\r\n}\r\n<\/code><\/pre>\n
                          In the Car entity:<\/p>\n
                            \n
                          1. The mapped by attribute in the @OneToMany<\/strong> annotation has been replaced by the @JoinColumn<\/strong> annotation.<\/li>\n<\/ol>\n
                            In the Wheel entity:<\/p>\n
                              \n
                            1. Nothing has changed from before.<\/li>\n<\/ol>\n
                              While this setup does allow for the setting of the foreign key on Item from both sides of the relationship, unwanted inconsistencies can arise.  Consider the case where a new Wheel is added to a Honda’s collection but the Wheel’s own reference to Car is set to a Toyota.  What happens?<\/p>\n
                              Car honda = carDao.findById(1l).get();\r\nCar toyota = carDao.findById(2l).get();\r\n\r\nWheel wheel = new Wheel();\r\n\/\/ set other properties of a wheel \r\n    \r\nhonda.getWheels().add(wheel);\r\nwheel.setCar(toyota);\r\n\t\t\r\nwheelDao.save(wheel);\r\ncarDao.save(honda);  \t\t\r\n<\/code><\/pre>\n
                               Well, unlike the example above where the Wheel<\/strong> was defined as the owner<\/strong>, in this new example, the Car<\/strong> side takes precedence.<\/p>\n
                              2. A mapping table car_engine is used<\/h3>\n
                              <\/p>\n
                              This is the same table structure used in number 3 of the one-to-one mapping.  It can also be used for a one-to-many or even a many-to-many mapping.   As expected, we have to use the @JoinTable<\/strong> annotation specifying the join table and join columns.  These can be avoid if the table and column names are default names expected by Hibernate.<\/p>\n
                              For the bidirectional setup, we first choose a owning side.  In our example, Wheel<\/strong> will be the owning side.<\/p>\n
                              @Entity\r\n@Table(name = \"car\")\r\npublic class Car {\r\n\r\n   @Id\r\n   @GeneratedValue(strategy=GenerationType.IDENTITY)\r\n   private long car_id;\r\n\r\n   @OneToMany (mappedBy=\"car\")\r\n   private Set wheels;\r\n}\r\n\r\n\r\n@Entity\r\n@Table(name=\"wheel\")\r\npublic class Wheel {\r\n\r\n    @Id\r\n    @GeneratedValue(strategy=GenerationType.IDENTITY)\r\n    private long engine_id;\r\n\r\n    @ManyToOne\r\n    @JoinTable(\r\n            name = \"car_wheel\", \r\n            joinColumns = { @JoinColumn(name = \"wheel_id_fk\") }, \r\n            inverseJoinColumns = { @JoinColumn(name = \"car_id_fk\") }\r\n   )  \r\n   private Car car;\r\n}\r\n<\/code><\/pre>\n
                              In this example, the Car<\/strong> entity uses the mappedBy<\/strong> attribute to tell Hibernate that the owning side(Wheel<\/strong>) is tracked on the car<\/strong> member of the Wheel<\/strong> entity.<\/p>\n
                              The Wheel entity:<\/p>\n
                                \n
                              1. Denotes the many-to-one relation via the @ManyToOne<\/strong> annotation.  Remember, this is the inverse of a One-to-Many relationship.<\/li>\n
                              2. Is the owner<\/strong> of the relationship<\/li>\n
                              3. Uses the @JoinTable <\/strong>with a name attribute to specify the join table name in the database.\n
                                  \n
                                1. The joinColumns<\/strong> attribute is used to identify the foreign key for this entity (Wheel<\/strong>)<\/li>\n
                                2. The inverseJoinColumn<\/strong> is used to identify the foreign key for the other entity (Car<\/strong>).<\/li>\n<\/ol>\n<\/li>\n<\/ol>\n
                                  This is a bidirectional<\/strong> setup, but we can make it one unidirectional<\/strong> from Wheel<\/strong> to Car<\/strong> by removing the Wheel<\/strong> member in Car<\/strong>.  In this setup, because we are using the mappedBy<\/strong> attribute, we cannot make it unidirectional<\/strong> Car<\/strong> to Wheel<\/strong> by deleting the annotations in Wheel<\/strong>.  To see how to create a unidirectional<\/strong> Car<\/strong> to Wheel<\/strong> setup, see below:<\/p>\n
                                  A bidirectional<\/strong> setup with both sides being a owning is shown below but a unidirectional Car<\/strong> to Wheel<\/strong> or vice versa simply be removing their corresponding member in the entity and mapping annotations.  <\/p>\n
                                  @Entity\r\n@Table(name = \"car\")\r\npublic class Car {\r\n\r\n    @Id\r\n    @GeneratedValue(strategy=GenerationType.IDENTITY)\r\n    private long car_id;\r\n\r\n\t@OneToMany\r\n    @JoinTable(\r\n            name = \"cart_box\", \r\n            joinColumns = { @JoinColumn(name = \"cart_id_fk\") }, \r\n            inverseJoinColumns = { @JoinColumn(name = \"box_id_fk\") }\r\n        )    \r\n     \r\n   private Set wheels;\r\n}\r\n\r\n\r\n@Entity\r\n@Table(name=\"wheel\")\r\npublic class Wheel {\r\n\r\n    @Id\r\n    @GeneratedValue(strategy=GenerationType.IDENTITY)\r\n    private long engine_id;\r\n\r\n    @ManyToOne\r\n    @JoinTable(\r\n            name = \"car_wheel\", \r\n            joinColumns = { @JoinColumn(name = \"wheel_id_fk\") }, \r\n            inverseJoinColumns = { @JoinColumn(name = \"car_id_fk\") }\r\n   )  \r\n   private Car car;\r\n}\r\n<\/code><\/pre>\n
                                  This is a bidirectional<\/strong> relationship with two owners defined.  It’s important to understand the inconsistency that may happen if a Wheel<\/strong> is both added to one Car<\/strong> collection of wheels but it’s own Car<\/strong> member is set to another Car<\/strong>.<\/p>\n
                                  Car honda = carDao.findById(1l).get();  \/\/ ID=1\r\nCar toyota = carDao.findById(2l).get();  \/\/ ID=2\r\n\r\nWheel wheel1= wheelDao.findById((long) 1).get(); ID=1\r\n    \r\nhonda.getWheels().add(wheel1);\r\nwheel1.setCar(toyota);\r\n\t\t\r\nwheelDao.save(wheel1);\r\ncarDao.save(honda);  \t\t\r\n<\/code><\/pre>\n
                                  The Honda is assigned a Wheel via it’s Wheel collection but the Wheel’s Car is set to a Toyota.  After saving both Car and Wheel, we get both<\/strong> mappings appearing in the database, which is wrong.<\/p>\n
                                  <\/p>\n
                                  Many to Many<\/h1>\n
                                  Many-to-many relationships are “almost” always implemented with a third join table.  In addition, when defining a many-to-many relationship, we need to define a owning<\/strong> side<\/strong> of the relationship.  Either entity can be a owning side, but not at the same time.<\/p>\n
                                  For this example, we’ll introduce a Person entity. A person(or car owner) can own many cars and a car can have many owners.  This defines our many-to-many relationship.<\/p>\n
                                  <\/p>\n
                                  @Entity\r\n@Table(name = \"person\")\r\npublic class Person{\r\n\r\n    @Id\r\n    @GeneratedValue(strategy=GenerationType.IDENTITY)\r\n    private long person_id;\r\n\r\n    @ManyToMany\r\n    @JoinTable(\r\n            name = \"person\", \r\n            joinColumns = { @JoinColumn(name = \"person_id_fk\") }, \r\n            inverseJoinColumns = { @JoinColumn(name = \"car_id_fk\") }\r\n   )   \r\n   private Set<Car> cars;\r\n}\r\n\r\n\r\n@Entity\r\n@Table(name=\"car\")\r\npublic class Car {\r\n\r\n    @Id\r\n    @GeneratedValue(strategy=GenerationType.IDENTITY)\r\n    private long car_id;\r\n\r\n    @ManyToMany(mappedBy = \"cars\")\r\n    private Set<Person> people;\r\n}\r\n<\/code><\/pre>\n
                                  In the Person (owner) entity:<\/p>\n
                                    \n
                                  1. The @ManyToMany<\/strong> annotation denotes the type of relationship.<\/li>\n
                                  2. The @JoinTable<\/strong> denotes the use of a join table and specifies the name<\/strong>.  \n
                                      \n
                                    1. The joinColumns<\/strong> attribute specifies the foreign key column to this entity (Person).<\/li>\n
                                    2. The inverseJoinColumn<\/strong> attribute specifies the foreign key column to the inverse side of the relationship (I.e. the primary key on CAR<\/strong>).<\/li>\n<\/ol>\n<\/li>\n
                                    3. Even though we’re setting up a bidirectional mapping, we can create a unidirectional mapping from only Person to Car by omitting the collection of owners (Person) that a car has had. <\/li>\n
                                    4. We cannot create a unidirectional<\/strong> mapping from Car to Person simply by removing Car’s car member since Person is the owner of the relationship and Hibernate depends on it when figuring out the “mappedBy<\/strong>” instruction.  Instead, if we want a unidirectional Car to Person mapping, we need to make Person the relationship owner and “reverse” the annotations used above.  <\/li>\n<\/ol>\n
                                      In the Car entity, we used the @ManyToMany<\/strong> annotation to denote the relationship type.   The mappedBy<\/strong> attribute denotes that the people collection is mapped by the owner<\/strong> entity (Person<\/strong>).   In other words, adding a Car instance to a Person’s cars will create the mapping regardless of instances may be present in the Car’s person collection.  Consider the code snippet below:<\/p>\n
                                      Person joe = personDao.findById(1l).get();\r\nPerson peter = personDao.findById(2l).get();\r\n\r\nCar honda = carDao.findById((long) 1).get();\r\n    \r\njoe.getCars().add(honda);\r\nhonda.getPeople().add(peter);\r\n\t\t\r\npersonDao.save(joe);\r\npersonDao.save(peter);\r\ncarDao.save(honda);  \t\t\r\n<\/code><\/pre>\n
                                      This code is attempting to assign a the Honda(a Car instance) to a person.  The code has a inconsistency in mapping as the Honda is being added to Joe’s list of cars but Peter is being added to his collection of Cars.  Because Hibernate will use the owner’s mapping to save the relationship and Joe will own a Honda and not Peter.<\/p>\n
                                      As mentioned above, this reverse mapping is to support the bidirectional<\/strong> mapping.  We can also perform a unidirectional<\/strong> mapping from Person<\/strong> to Car<\/strong> by removing the people member in the Car<\/strong> entity but we cannot remove the cars member in People<\/strong> as it is the owner of the relationship.<\/p>\n
                                      Because of the use of the join table, we can reverse the owner side.<\/p>\n
                                      Just to reiterate the mapping behavior, we can also have mapping a way which has two owners.  This method is not recommended:<\/p>\n
                                      @Entity\r\n@Table(name = \"person\")\r\npublic class Person{\r\n\r\n    @Id\r\n    @GeneratedValue(strategy=GenerationType.IDENTITY)\r\n    private long person_id;\r\n\r\n    @OneToMany\r\n    @JoinTable(\r\n            name = \"person\", \r\n            joinColumns = { @JoinColumn(name = \"person_id_fk\") }, \r\n            inverseJoinColumns = { @JoinColumn(name = \"car_id_fk\") }\r\n   )   \r\n   private Set<Car> cars;\r\n}\r\n\r\n\r\n@Entity\r\n@Table(name=\"car\")\r\npublic class Car {\r\n\r\n    @Id\r\n    @GeneratedValue(strategy=GenerationType.IDENTITY)\r\n    private long car_id;\r\n\r\n    @ManyToMany\r\n    @JoinTable(\r\n            name = \"person\", \r\n            joinColumns = { @JoinColumn(name = \"car_id_fk\") }, \r\n            inverseJoinColumns = { @JoinColumn(name = \"person_id_fk\") }\r\n   )   \r\n   private Set<Person> people;\r\n}\r\n<\/code><\/pre>\n
                                      It is important to know in this situation, since both relationships are ‘owners’, the following code:<\/p>\n
                                      Person joe = personDao.findById(1l).get();  \/\/ ID=1\r\nPerson peter = personDao.findById(2l).get();  \/\/ ID=2\r\n\r\nCar honda = carDao.findById((long) 1).get(); ID=1\r\n    \r\njoe.getCars().add(honda);\r\nhonda.getPeople().add(peter);\r\n\t\t\r\npersonDao.save(joe);\r\npersonDao.save(peter);\r\ncarDao.save(honda);  \t\t\r\n<\/code><\/pre>\n
                                      The result in the PERSON_CAR table will be:<\/p>\n
                                      <\/p>\n
                                      Both people will be associated to the Honda, which is probably not what we want. <\/p>\n
                                      Conclusion<\/h1>\n
                                      This is only a rough outline how the basic relationship types and their configurations.  It is important to know configurations will be dependent on the exact use case and other specifics.  For example, the addition of nullable=false<\/strong><\/em> on a mapping annotation may cause a particular configuration to no longer persist.  <\/p>\n
                                       <\/p>\n
                                       <\/p>\n<\/div>\n<\/div>\n<\/div>\n<\/div>\n","protected":false},"excerpt":{"rendered":"
                                      In this guide, I’ll show you how to create all of the common relationship mappings available using the JPA specification.  In my examples, Hibernate is…<\/p>\n","protected":false},"author":3,"featured_media":667,"comment_status":"open","ping_status":"open","sticky":false,"template":"","format":"standard","meta":{"bgseo_title":"","bgseo_description":"","bgseo_robots_index":"index","bgseo_robots_follow":"follow","footnotes":""},"categories":[11],"tags":[16,7,12,3,17,6],"class_list":["post-635","post","type-post","status-publish","format-standard","has-post-thumbnail","hentry","category-interview-coding-questions","tag-hibernate","tag-interview-prep","tag-interview-questions","tag-java","tag-jpa","tag-software-development"],"_links":{"self":[{"href":"https:\/\/www.canosielabs.com\/blog\/wp-json\/wp\/v2\/posts\/635","targetHints":{"allow":["GET"]}}],"collection":[{"href":"https:\/\/www.canosielabs.com\/blog\/wp-json\/wp\/v2\/posts"}],"about":[{"href":"https:\/\/www.canosielabs.com\/blog\/wp-json\/wp\/v2\/types\/post"}],"author":[{"embeddable":true,"href":"https:\/\/www.canosielabs.com\/blog\/wp-json\/wp\/v2\/users\/3"}],"replies":[{"embeddable":true,"href":"https:\/\/www.canosielabs.com\/blog\/wp-json\/wp\/v2\/comments?post=635"}],"version-history":[{"count":10,"href":"https:\/\/www.canosielabs.com\/blog\/wp-json\/wp\/v2\/posts\/635\/revisions"}],"predecessor-version":[{"id":690,"href":"https:\/\/www.canosielabs.com\/blog\/wp-json\/wp\/v2\/posts\/635\/revisions\/690"}],"wp:featuredmedia":[{"embeddable":true,"href":"https:\/\/www.canosielabs.com\/blog\/wp-json\/wp\/v2\/media\/667"}],"wp:attachment":[{"href":"https:\/\/www.canosielabs.com\/blog\/wp-json\/wp\/v2\/media?parent=635"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/www.canosielabs.com\/blog\/wp-json\/wp\/v2\/categories?post=635"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/www.canosielabs.com\/blog\/wp-json\/wp\/v2\/tags?post=635"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}