{"id":3887,"date":"2020-07-01T18:06:52","date_gmt":"2020-07-01T12:36:52","guid":{"rendered":"https:\/\/www.h2kinfosys.com\/blog\/?p=3887"},"modified":"2020-07-01T18:06:54","modified_gmt":"2020-07-01T12:36:54","slug":"hibernate-associations","status":"publish","type":"post","link":"https:\/\/www.h2kinfosys.com\/blog\/hibernate-associations\/","title":{"rendered":"Hibernate Associations"},"content":{"rendered":"\n

Hibernate Associations technology handles how to persist java objects. But, it is possible only when the object has the XML-file that describes how to map it, or the object is annotated with hibernate annotations. In another case, the objects will be just simple plain java objects without relation to the database tables. Very often several entities can be related. In this situation, they must have references from each other. Such objects can have unidirectional or bidirectional references. We are going to understand in details how to deal with such situations.<\/p>\n\n\n\n

Java objects can contain references to one or several other Java objects. They can have direct references as an embedded property or field. In the case of indirect references,  it is usually implemented via arrays, sets, lists, etc. These associations are represented in the database with foreign key relationships. <\/p>\n\n\n\n

If only one of the pair of Java classes<\/a> contains a reference to the other, the association is called unidirectional. In the cases of the mutual association, we get the bidirectional relation.<\/p>\n\n\n\n

The widespread beginner’s mistake in designing entity models is to try to make all associations bidirectional.  It is important to remember that associations that do not look like a natural part of the model of your object should not be forced into it.<\/p>\n\n\n\n

\"\"<\/p>\n\n\n\n

Before starting with code we need to create User and Address tables and relationships in our MySql database<\/a> exampledb by running queries:<\/p>\n\n\n

[box type=”shadow” align=”” class=”” width=””]<\/p>\n

create table exampledb.USER (<\/span>
<\/span>   user_id INT NOT NULL auto_increment,<\/span>
<\/span>   first_name VARCHAR(100) default NULL,<\/span>
<\/span>   last_name  VARCHAR(100) default NULL,<\/span>
<\/span>   PRIMARY KEY (user_id)<\/span>
<\/span>);<\/span>
<\/span>create table exampledb.address (<\/span>
<\/span>   address_id INT NOT NULL auto_increment,<\/span>
<\/span>   city VARCHAR(20) default NULL,<\/span>
<\/span>   address  VARCHAR(20) default NULL,<\/span>
<\/span>   PRIMARY KEY (address_id),<\/span>
<\/span>   CONSTRAINT user_address FOREIGN KEY (address_id) REFERENCES user(user_id) ON DELETE CASCADE <\/span>
<\/span>);<\/span><\/p>\n

[\/box]<\/p>\n\n\n

Here are our entities in code:<\/em><\/strong><\/p>\n\n\n\n

package<\/strong> edu.hibernate.example;\n\nimport<\/strong> java.io.Serializable;\nimport<\/strong> javax.persistence.*;\n\n@Entity\n@Table(name = \"User\")\npublic<\/strong> class<\/strong> UserEntity implements<\/strong> Serializable {\n@Id\n@Column(name = \"user_id\", unique = true<\/strong>, nullable = false<\/strong>)\n@GeneratedValue(strategy = GenerationType.IDENTITY<\/em><\/strong>)\nprivate<\/strong> Integer id;\n@Column(name = \"first_name\", unique = false<\/strong>, nullable = false<\/strong>, length = 100)\nprivate<\/strong> String firstName;\n@Column(name = \"last_name\", unique = false<\/strong>, nullable = false<\/strong>, length = 100)\nprivate<\/strong> String lastName;\n\n@OneToOne(mappedBy=\"user\", cascade = CascadeType.ALL<\/em><\/strong>)\nAddressEntity address;\n\npublic<\/strong> String getFirstName() {\nreturn<\/strong> firstName;\n}\n\npublic<\/strong> void<\/strong> setFirstName(String firstName) {\nthis<\/strong>.firstName = firstName;\n}\n\npublic<\/strong> String getLastName() {\nreturn<\/strong> lastName;\n}\n\npublic<\/strong> void<\/strong> setLastName(String lastName) {\nthis<\/strong>.lastName = lastName;\n}\n\npublic<\/strong> AddressEntity getAddress() {\nreturn<\/strong> address;\n}\n\npublic<\/strong> void<\/strong> setAddress(AddressEntity address) {\nthis<\/strong>.address = address;\n}\n\npublic<\/strong> Integer getId() {\nreturn<\/strong> id;\n}\n}\n<\/pre>\n\n\n\n
package<\/strong> edu.hibernate.example;\n\nimport<\/strong> java.io.Serializable;\n\nimport<\/strong> javax.persistence.*;\n\n@Entity\n@Table(name = \"Address\")\npublic<\/strong> class<\/strong> AddressEntity  implements<\/strong> Serializable{\n@Id\n@Column(name = \"address_id\", unique = true<\/strong>, nullable = false<\/strong>)\n@GeneratedValue(strategy = GenerationType.IDENTITY<\/em><\/strong>)\nprivate<\/strong> Integer id;\n \n@Column(name = \"city\", unique = false<\/strong>, nullable = false<\/strong>, length = 20)\nprivate<\/strong> String city;\n   \n@Column(name = \"address\", unique = false<\/strong>, nullable = false<\/strong>, length = 20)\nprivate<\/strong> String address;\n \n@OneToOne\n@PrimaryKeyJoinColumn\nUserEntity user;\n\n\/\/getters and setters\n}\nAnd, the second entity:\npackage<\/strong> edu.hibernate.example;\n\nimport<\/strong> java.io.Serializable;\n\nimport<\/strong> javax.persistence.*;\n\n@Entity\n@Table(name = \"Address\")\npublic<\/strong> class<\/strong> AddressEntity implements<\/strong> Serializable {\n@Id\n@Column(name = \"address_id\", unique = true<\/strong>, nullable = false<\/strong>)\n@GeneratedValue(strategy = GenerationType.IDENTITY<\/em><\/strong>)\nprivate<\/strong> Integer id;\n\n@Column(name = \"city\", unique = false<\/strong>, nullable = false<\/strong>, length = 20)\nprivate<\/strong> String city;\n\n@Column(name = \"address\", unique = false<\/strong>, nullable = false<\/strong>, length = 20)\nprivate<\/strong> String address;\n\n@OneToOne\n@PrimaryKeyJoinColumn\nUserEntity user;\n\n\/\/getters and setters\n}\n<\/pre>\n\n\n\n
In our case, with cascade operations and one-to-one relationships, it is enough to same just one entity into the database. Let’s create User and Address objects, save one of them into the database. After, we will create a new session and get our entities from the database to make sure that both User and Address objects were persisted.<\/p>\n\n\n\n
package edu.hibernate.example;<\/em><\/strong><\/p>\n\n\n\n
import java.util.Iterator;\nimport java.util.List;\n\nimport org.hibernate.Session;\nimport org.hibernate.cfg.Configuration;\n\npublic class HibernateExample {\n\npublic static void main(String[] args) {\nConfiguration configuration = new Configuration();\nconfiguration.addAnnotatedClass(edu.hibernate.example.UserEntity.class);\nconfiguration.addAnnotatedClass(edu.hibernate.example.AddressEntity.class);\nSession session1 = configuration.configure().buildSessionFactory().openSession();\n \nsession1.beginTransaction();\n\n\/\/ Create new User object\nUserEntity user = new UserEntity();\nuser.setFirstName(\"Jozeph\");\nuser.setLastName(\"Jonson\");\n\n\/\/ Create new Address object\nAddressEntity address = new AddressEntity();\naddress.setCity(\"Berlin\");\naddress.setAddress(\"High str., 111\");\n\nuser.setAddress(address);\naddress.setUser(user);\nsession1.save(user);\n\/\/ session1.save(address);\n\nsession1.getTransaction().commit();\nInteger userId = user.getId();\nInteger addressId = address.getId();\n\nSession session2 = configuration.configure().buildSessionFactory().openSession();\nsession2.beginTransaction();\nUserEntity userDB = (UserEntity) session2.get(UserEntity.class, userId);\nAddressEntity addressDB = (AddressEntity) session2.get(AddressEntity.class, addressId);\n\nSystem.out.println(userDB.getId());\nSystem.out.println(userDB.getAddress().getId());\nSystem.out.println(addressDB.getId());\nSystem.out.println(addressDB.getUser().getId());\n\n}\n}\n<\/pre>\n\n\n\n
There are two more ways to create one-to-one relationships that are less popular. For example, we can create one more table to store keys of User and Address tables, one record is responsible for one relationship between User and Address objects. The table is called a common join table.<\/p>\n\n\n\n
One more way is to create a one-to-one mapping with a shared primary key<\/p>\n\n\n\n
In this technique, we have to use a common primary key value in both the tables. <\/p>\n\n\n\n
One-to-many association<\/strong><\/h2>\n\n\n\n
\"\"<\/p>\n\n\n\n
In a one-to-many approach, both entities are responsible for creating the relationship and maintaining it. The UserEntity needs to declare one-to-many relationships, the CarEntity declares is many-to-one from its end. Let’s look at the code of User and Car entities.<\/p>\n\n\n\n
package<\/strong> edu.hibernate.example;\n\nimport<\/strong> java.io.Serializable;\nimport<\/strong> java.util.Set;\n\nimport<\/strong> javax.persistence.*;\n\n@Entity\n@Table(name = \"User\")\npublic<\/strong> class<\/strong> UserEntity implements<\/strong> Serializable {\n@Id\n@Column(name = \"user_id\", unique = true<\/strong>, nullable = false<\/strong>)\n@GeneratedValue(strategy = GenerationType.IDENTITY<\/em><\/strong>)\nprivate<\/strong> Integer id;\n@Column(name = \"first_name\", unique = false<\/strong>, nullable = false<\/strong>, length = 100)\nprivate<\/strong> String firstName;\n@Column(name = \"last_name\", unique = false<\/strong>, nullable = false<\/strong>, length = 100)\nprivate<\/strong> String lastName;\n\n@OneToMany(cascade = CascadeType.ALL<\/em><\/strong>)\n@JoinColumn(name = \"USERE_ID\")\nprivate<\/strong> Set<CarEntity> cars;\n\n\/\/ Getters and setters\n}\npackage<\/strong> edu.hibernate.example;\n\nimport<\/strong> java.io.Serializable;\n\nimport<\/strong> javax.persistence.Column;\nimport<\/strong> javax.persistence.Entity;\nimport<\/strong> javax.persistence.GeneratedValue;\nimport<\/strong> javax.persistence.GenerationType;\nimport<\/strong> javax.persistence.Id;\nimport<\/strong> javax.persistence.ManyToOne;\nimport<\/strong> javax.persistence.Table;\n\n@Entity\n@Table(name = \"Car\")\npublic<\/strong> class<\/strong> CarEntity implements<\/strong> Serializable {\n@Id\n@Column(name = \"car_id\", unique = true<\/strong>, nullable = false<\/strong>)\n@GeneratedValue(strategy = GenerationType.IDENTITY<\/em><\/strong>)\nprivate<\/strong> Integer id;\n\n@Column(name = \"model\", unique = false<\/strong>, nullable = false<\/strong>, length = 20)\nprivate<\/strong> String model;\n\n@ManyToOne\nprivate<\/strong> UserEntity user;\n\n\/\/ Getters and setters\n}\n<\/pre>\n\n\n\n
Besides one-to-many mapping with a foreign key association, Hibernate also allows doing one-to-many mapping with a join table.<\/p>\n\n\n\n
Many-to-many association<\/strong><\/h2>\n\n\n\n
Hibernate many-to-many mapping is between two entities where one can have a relation with multiple another entity and vise versa. For example,  a user can be subscribed to several sites with the news. Every site with the news has a lot of users. Here is the schema:
\"\"<\/p>\n\n\n\n
Let’s look at the code of out entities:<\/p>\n\n\n\n
package<\/strong> edu.hibernate.example;\n\nimport<\/strong> java.io.Serializable;\nimport<\/strong> java.util.Set;\n\nimport<\/strong> javax.persistence.*;\n\n@Entity\n@Table(name = \"User\")\npublic<\/strong> class<\/strong> UserEntity implements<\/strong> Serializable {\n@Id\n@Column(name = \"id\", unique = true<\/strong>, nullable = false<\/strong>)\n@GeneratedValue(strategy = GenerationType.IDENTITY<\/em><\/strong>)\nprivate<\/strong> Integer id;\n@Column(name = \"first_name\", unique = false<\/strong>, nullable = false<\/strong>, length = 100)\nprivate<\/strong> String firstName;\n@Column(name = \"last_name\", unique = false<\/strong>, nullable = false<\/strong>, length = 100)\nprivate<\/strong> String lastName;\n\n    @ManyToMany(cascade=CascadeType.ALL<\/em><\/strong>)\n    @JoinTable(name=\"USER_SUBSCRIPTIONS\", joinColumns={@JoinColumn(referencedColumnName=\"ID\")}, inverseJoinColumns={@JoinColumn(referencedColumnName=\"ID\")})  \n    private<\/strong> Set<SubscriptionEntity> subscriptions;\n\/\/Getters and setters \n}\n\npackage<\/strong> edu.hibernate.example;\n\nimport<\/strong> java.io.Serializable;\nimport<\/strong> java.util.Set;\n\nimport<\/strong> javax.persistence.*;\n\n@Entity\n@Table(name = \"Subscription\")\npublic<\/strong> class<\/strong> SubscriptionEntity implements<\/strong> Serializable {\n@Id\n@Column(name = \"id\", unique = true<\/strong>, nullable = false<\/strong>)\n@GeneratedValue(strategy = GenerationType.IDENTITY<\/em><\/strong>)\nprivate<\/strong> Integer id;\n@Column(name = \"name\", unique = false<\/strong>, nullable = false<\/strong>, length = 20)\nprivate<\/strong> String name;\n@Column(name = \"link\", unique = false<\/strong>, nullable = false<\/strong>, length = 100)\nprivate<\/strong> String link;\n\n@ManyToMany(mappedBy=\"subscriptions\")\nprivate<\/strong> Set<UserEntity> subscriptions;\n \n\/\/Getters and setters \n\n}\n<\/pre>\n\n\n\n
UserEntity class is the owner entity, that is responsible for making the association and maintaining it. For this entity, we have used @JoinTable annotation. SubcriptionEntity is our mapped entity, which is mapped to UserEntity using the \u201cmappedBy\u201d attribute. Also, we user annotation @ManyToMany in both entities. Here is the way to work on such kinds of relationships.<\/p>\n\n\n\n
package<\/strong> edu.hibernate.example;\n\nimport<\/strong> java.util.HashSet;\nimport<\/strong> java.util.Set;\n\nimport<\/strong> org.hibernate.Session;\nimport<\/strong> org.hibernate.cfg.Configuration;\n\npublic<\/strong> class<\/strong> HibernateExample {\n\npublic<\/strong> static<\/strong> void<\/strong> main(String[] args) \n    {\nConfiguration configuration = new<\/strong> Configuration();\nconfiguration.addAnnotatedClass(edu.hibernate.example.UserEntity.class<\/strong>);\nconfiguration.addAnnotatedClass(edu.hibernate.example.SubscriptionEntity.class<\/strong>);\nSession session = configuration.configure().buildSessionFactory().openSession();\n\n        SubscriptionEntity site1 = new<\/strong> SubscriptionEntity();\n        SubscriptionEntity site2 = new<\/strong> SubscriptionEntity();\n        Set<SubscriptionEntity> subscriptions = new<\/strong> HashSet<SubscriptionEntity>();\n        subscriptions.add(site1);\n        subscriptions.add(site2);\n        \n        UserEntity user1 = new<\/strong> UserEntity();\n        UserEntity user2 = new<\/strong> UserEntity();     \n        Set<UserEntity> users = new<\/strong> HashSet<UserEntity>();\n        users.add(user1);\n        users.add(user2);\n        user1.setSubscriptions(subscriptions);\n        user2.setSubscriptions(subscriptions);\n \n        session.save(user1);\n        session.save(user2);\n         \n        session.getTransaction().commit();\n    }\n}\n<\/pre>\n\n\n\n
We have created two instances of users and two instances of subscriptions. It is enough to save just user entities, all data about subscriptions and relationships will be persisted too.<\/p>\n","protected":false},"excerpt":{"rendered":"
Hibernate Associations technology handles how to persist java objects. But, it is possible only when the object has the XML-file that describes how to map it, or the object is annotated with hibernate annotations. In another case, the objects will be just simple plain java objects without relation to the database tables. Very often several […]<\/p>\n","protected":false},"author":1,"featured_media":3915,"comment_status":"open","ping_status":"open","sticky":false,"template":"","format":"standard","meta":{"footnotes":""},"categories":[42],"tags":[1046,1049,1048,1047],"class_list":["post-3887","post","type-post","status-publish","format-standard","has-post-thumbnail","hentry","category-java-tutorials","tag-hibernate-associations","tag-many-to-many-association","tag-one-to-many-association","tag-one-to-one-relationships"],"_links":{"self":[{"href":"https:\/\/www.h2kinfosys.com\/blog\/wp-json\/wp\/v2\/posts\/3887","targetHints":{"allow":["GET"]}}],"collection":[{"href":"https:\/\/www.h2kinfosys.com\/blog\/wp-json\/wp\/v2\/posts"}],"about":[{"href":"https:\/\/www.h2kinfosys.com\/blog\/wp-json\/wp\/v2\/types\/post"}],"author":[{"embeddable":true,"href":"https:\/\/www.h2kinfosys.com\/blog\/wp-json\/wp\/v2\/users\/1"}],"replies":[{"embeddable":true,"href":"https:\/\/www.h2kinfosys.com\/blog\/wp-json\/wp\/v2\/comments?post=3887"}],"version-history":[{"count":0,"href":"https:\/\/www.h2kinfosys.com\/blog\/wp-json\/wp\/v2\/posts\/3887\/revisions"}],"wp:featuredmedia":[{"embeddable":true,"href":"https:\/\/www.h2kinfosys.com\/blog\/wp-json\/wp\/v2\/media\/3915"}],"wp:attachment":[{"href":"https:\/\/www.h2kinfosys.com\/blog\/wp-json\/wp\/v2\/media?parent=3887"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/www.h2kinfosys.com\/blog\/wp-json\/wp\/v2\/categories?post=3887"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/www.h2kinfosys.com\/blog\/wp-json\/wp\/v2\/tags?post=3887"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}