Overview Of Hibernate - Ii

Overview of Hibernate II

Objectives In this session, you will learn to: Mapping value type objects Mapping collection Mapping database relationships Mapping class Inheritance

Mapping Value Type Objects While developing an application, you may find that a common property is shared among different classes of the application. Sometimes, shared property consists of multiple constituent elements. For example, your application consists of two classes, Employee and Student, and both these classes have a common property named address.

To accomplish reusability and modularity in your application, you can: Create a Java class to represent the shared property. Refer the Java class from any class in the application.

This Java class is referred to as the value type. The value types: Are mapped as a component of the entity class. Are mapped by using the element in the Hibernate mapping file.

Mapping Value Type Objects (Contd.) Consider a scenario where you are developing an application that stores information about the orders placed by different customers of an organization in a database. For this, you have created the ORDERS table by using the following query: ORDERS table CREATE TABLE ORDERS ( ORDER_ID INT PRIMARY KEY, ONLINE_RECIPIENT VARCHAR(40), ONLINE_ADDRESS VARCHAR(100), OFFLINE_RECIPIENT VARCHAR(40), OFFLINE_ADDRESS VARCHAR(100))

To map the ORDERS table, a Java class named OrderDetails is created by using the following code snippet: OrderDetails class public class OrderDetails{ private int orderID; private String onlineRecipient; private String onlineAddress; private String offlineRecipient; private String offlineAddress; //getter and setter methods to set the properties . . . . . }

Mapping Value Type Objects (Contd.) A solution to the preceding problem is to create a new class that encapsulates the contact details of the customers. A separate class, ContactDetails is created to encapsulate the address of the customers, as shown in the following code snippet: public class ContactDetails { private String recipient; private String address; // getter and setter methods . . . . . . }

Mapping Value Type Objects (Contd.) Two different instances of the ContactDetails class for the online and offline contact details can be created. The OrderDetails class can use these instances to specify the online and offline contact details, as shown in the following code snippet: public class OrderDetails { private int orderID; private ContactDetails onlineContact; private ContactDetails offlineContact; // getter and setter methods . . . . . . . }

The contact details are dependent on the OrdersDetails class. This implies that you cannot model the ContactDetails class as an independent persistent class. It needs to be associated as a component of an entity class that has a database identity.

Therefore, the OrderDetails class is an entity class and the ContactDetails class is modeled as its component.

Mapping Value Type Objects (Contd.) In Hibernate applications, the mapping of a component class is different from the mapping of an entity class. The mapping of an entity class is configured under the tag that is used to create a unique identifier for its object. However, the component class is configured under a tag. The following code snippet shows the mapping of the OrderDetails and ContactDetails classes in the Hibernate mapping file: <property name="recipient" type="string" column="ONLINE_RECIPIENT" /> <property name="address" type="string" column="ONLINE_ADDRESS"/> <property name="recipient" type="string" column="OFFLINE_RECIPIENT" /> <property name="address" type="string" column="OFFLINE_ADDRESS" /> . . . . . . . . . .

Activity: Mapping Value Type Object Consider a scenario where you need to create a Java application that implement mapping of the value type object. Application should be based on the following guideline. Student table contains column , such as ID, name, and address however member variable of an address column ,such as street, city, state, and pin code are object instead of a simple data type.

Application should list following tasks as an option:  1. for Insert  2. for List  3. for Update  4. for Delete

Identifying Mapping of Collection When a property of a class is declared as a collection, you need to perform collection mapping in the Hibernate mapping file. The commonly used collection mapping elements in the Hibernate mapping file are: <set> <list>

Identifying Mapping of Collection (Contd.) The <set> element: Is used when the duplicate elements are not required in the collection. Does not maintain the order of its elements in the collection. Is used to map an attribute of the java.util.Set collection type in the Hibernate mapping file.

Uses the following sub elements and attributes to achieve mapping between the application and the database tables:  cascade attribute: Specifies that the operations performed on an entity update the related entities also.  name attribute: Specifies the name of the database table that stores the collection objects  element: Specifies the properties that associate the entity and the collection objects  element: Specifies a one-to-many relationship between the entity and the collection objects. It contains the class attribute. This attribute contains the name of the collection object.

Identifying Mapping of Collection (Contd.) Consider a scenario, you are developing an application that stores the details of authors and the books written by them. For this, you have created the Authors class that contains the following code snippet: import java.util.Set; public class Authors { private String authorID; private String authorName; private Set books;

public void setAuthorName(String authorName) { this.authorName = authorName; }

public String getAuthorID() {

public Set getBooks() {

return authorID;

return books;

} } public void public void setAuthorID(String authorID) { setBooks(Set books) { this.books = books; this.authorID = } authorID; } } public String getAuthorName() { return authorName; }

Identifying Mapping of Collection (Contd.) In the preceding slide, the books property is a collection of instances of the Books class. The Authors class is called an entity which owns the collection of the Books class. package Test; public class Books { private String bookID; private String bookName; public String getBookID() { return bookID; } public void setBookID(String bookID) { this.bookID = bookID; } public String getBookName() { return bookName; } public void setBookName(String bookName) { this.bookName = bookName; } }

Identifying Mapping of Collection (Contd.) The collection objects are distinguished in the database by the foreign key of the entity that owns the collection. This foreign key is referred to as the collection key column. The collection key column is mapped by the element in the mapping file. The following figure shows how the author and book details are stored in the database. Books AUTHORS

AUTHORID AUTHORNAME

BOOKID AUTHORID BOOKNAME

Identifying Mapping of Collection (Contd.) You can map the Authors and Books class with the AUTHORS and BOOKS tables in the Hibernate mapping file, as shown in the following code snippet: <property name="authorName" type="string"> <set cascade="all" name="BOOKS"> <property name="bookName" type="string">

Identifying Mapping of Collection (Contd.) The <list> element: Is used to represent a collection in which duplicate elements are allowed and the elements are stored in ascending order. Requires an additional index column in the collection table, which maintains the position of each element in the collection. The column values that define the position of each element in the collection are referred to as the index values. Contains attributes and sub elements similar to the <set> element. Contains the <list-index> sub-element.

Identifying Mapping of Collection (Contd.) For example: package Test; import java.util.List; public { . .class . . .Authors . . private List books; . . . . . . . . . . public getBooks() { List return books; public void setBooks(List } books) { this.books = books; } }

The Authors class declares the books property as a collection of type, List.

Identifying Mapping of Collection (Contd.) Now, consider the following code snippet: . . . . . . . . <list cascade="all" name="BOOKS"> <list-index column="bookid"/> . . . . . . . . . . . . . .

Specifies that the Books class is mapped with the BOOKS table as a List type collection by using the <list> element. The bookid column of the BOOKS table is defined as the column that stores the index values.

Identifying Mapping of Collection (Contd.) The element: Represents a collection of objects that can have duplicates. Does not have any order and is similar to an ArrayList collection without an index. Is implemented by using either the java.util.List or java.util.Collection collection interfaces. Is used only when the collection used in the application may contain duplicate values and does not maintain the order of its elements. Is mapped using the element. Contains attributes and sub elements similar to the <set> element.

Identifying Mapping of Collection (Contd.) For example: package Test; import java.util.Collection; public class Authors { . . . . . . . private Collection books; . . . . . . . } public Collection getBooks() { return books; } public void setBooks(Collection books) { this.books = books; } }

The preceding code, declares the books property of the Authors class as a collection of type, Collection.

Identifying Mapping of Collection (Contd.) To map the Books class as a bag collection in the Hibernate mapping file, you need to use the element, as shown in the following code snippet: . . . . . . . . . . . .

The element is used to map the Books class with the BOOKS table as a collection. The element specifies the one-to-many relationship between the AUTHORS and BOOKS tables.

Activity: Saving a Collection in Hibernate Consider a scenario where the student have lots of address. So in this case you need to create more number of embedded object in the student class, which is so tedious at certain point. Therefore, to solve this problem you have decided to use Collection. This collection can be a list, set, map, collection, sorted set, sorted map. Application should be based on the following guideline. Student table contains column, such as ID, name, and address however member variable of an address column, such as street, city, state, and pin code are object instead of a simple data type.

Mapping Database Relationships Consider the following tables: Employee ID

Employee Name

Employee Address

Department ID

Department ID

Department Name

Department Manager

E1

Peter

London

D1

D1

Sales

Tom

E2

Tom

New York

D1

D2

HR

Sam

EMPLOYEE

DEPARTMENT

In this case, the EMPLOYEE table has a relationship with the DEPARTMENT table because the department ID entered in the EMPLOYEE table must exist in the DEPARTMENT table. To access and store the application data in these tables you need to create two classes, Employee and Department. You need to map these classes with the EMPLOYEE and DEPARTMENT tables, respectively. In addition, you need to map the relationship between these two tables by defining the relationship between the Employee and Department classes. This is referred to as mapping the database relationships in a Web application.

Mapping Database Relationships (Contd.) At times, you may need to manage the relationships between the persistent classes in the application. The persistent classes are also known as entity classes. For this, Hibernate allows you to map relationships among entity classes with the relationships among the tables in the mapping file.

Mapping Entity Association Hibernate allows you to map relationships among the database tables in the Hibernate mapping file. These relationships can be of the following types: One-to-one One-to-many

Many-to-many

Mapping Entity Association One-to-one association: Consider a scenario where to store the details of the persons, you have created two tables named PERSON and PERSONINFO in the database PERSONID

PERSONNAME

INFOID

INFOID

ADDRESS

JOB

INCOME

P1

Peter

E1

E1

New York

Teacher

5000

P2

Tom

E2

E2

Shanghai

Doctor

6000

PERSON

PERSONINFO

For each person in the PERSON table, a unique record should be available in the PERSONINFO table. For each person, a unique record should be inserted in both the PERSON and PERSONINFO tables. You can link these tables by using one-to-one association.

Mapping Entity Association (Contd.) To implement the required functionality you need to create the following class that represents the person entity of the application: package Test; public class Perso { privat n personID; e Strin personName privat g PersonInfo ; e Strin privatPerson() public g { } e public Person(String personDetail; personID) { this.personID = personID; } personName) public Person(String personID, String personName, PersonInfo personDetail) this.personID { = personID; this.personNam = e personName; this.personDetail = personDetail; } public String getPersonID() return { this.personID; }

public void setPersonID(String personID) { this.personID = personID; } public String getPersonName() { return this.personName; } setPersonName(String public void { this.personName = personName; } public PersonInfo getPersonDetail() { return this.personDetail; } public void setPersonDetail(PersonInf o personDetail) { this.personDetail = personDetail; } }

Mapping Entity Association (Contd.) The personDetail property refers to an instance of the PersonInfo class. You can create the PersonInfo class by using the following code snippet: package Test; public class PersonInfo { private String infoID; private String address; private String job; private Integer income; public PersonInfo() { }

public void setInfoID(String infoID) { this.infoID = infoID; } public String getAddress() { return this.address; }

public void setAddress(String public PersonInfo(String infoID) address) { this.address = address; { this.infoID = infoID; } } public String getJob() { public PersonInfo(String infoID, return this.job; String address, String job, Integer } income) { this.infoID = infoID; public void setJob(String job) { this.address = address; this.job = job; this.job = job; } this.income = income; public Integer getIncome() { } return this.income; } public String getInfoID() { return this.infoID; public void setIncome(Integer } income) { this.income = income; } }

Mapping Entity Association (Contd.) you need to map the one-to-one association between the classes in the Hibernate mapping file. For this, you can use the <many-to-one> element in the Hibernate mapping file. This element contains the following attributes:  name: Specifies the property name that is used to associate the classes.

 class: Specifies the fully qualified name of the associated class that provides value for the property specified by the name attribute.  column: Specifies the name of the foreign key column that stores the value of the property specified by the name attribute.  not-null: Specifies that the foreign key column cannot contain null values, if set to true.

 cascade: Specifies that the operations performed on one table will also affect the other table with similar updates.  unique: Specifies that the foreign key column contains unique values. This attribute makes the link between the tables as a one-to-one association.

Mapping Entity Association (Contd.) To map the PERSON table with the Person class, you can use the following code snippet in the Person.hbm.xml file:

<property name="personName" type="string"> <many-to-one name="personDetail" class="Test.PersonInfo" column="INFOID" notnull="true" cascade="all" unique="true" />

Mapping Entity Association (Contd.) One-to-many association: Consider the scenario where you have created the application that stores the details of authors and the books written by them in the database tables. In this application, when a record is inserted in the AUTHORS table, a corresponding record must be inserted in the BOOKS table that contains the details of the books written by that author. In addition, an author might have written multiple books. Therefore, for an author record, multiple books records may exist in the BOOKS table.

Mapping Entity Association (Contd.) You need to map the classes with the tables in the database that contains the one-to-many relationship. For this, you can use the element in the Authors.hbm.xml mapping file, as shown in the following code snippet: name="authorID" n length="20" /> r class="assigned" /> class="assigned"/> <propert name="authorName" <property y type="string"> name="bookName" name="AUTHORNAME" length="40" name="bookname" length="40"/> <set cascade="all" name="BOOKS"> column="authorid"/>

Mapping Entity Association (Contd.) Many-to-many association: Consider a scenario where an university offers multiple courses. In each course, several students can be registered. In addition, a student can register himself or herself in multiple courses simultaneously. Therefore, you decide to create three tables, STUDENT, COURSE, and REGISTRATION. The STUDENT table contains student information by using the various fields, such as StudentID, StudentName, and StudentAddress. The COURSE table contains course information by using the various fields, such as CourseID, CourseName, CourseDuration, and CourseFee. However, the REGISTRATION table contains registration information by using the various fields, such as StudentID and CourseID.

Mapping Entity Association (Contd.) You can use the following code snippet to map the Student class with the STUDENT table in the Student.hbm.xml file: <property name="studentName" type="string"> <property name="studentAddress" type="string"> <set cascade="all" name="courses" table="REGISTRATION"> <many-to-many class="Test.Course" column="COURSEID"/>

In the preceding code snippet, the <many-to-many> element is used to map the association between the Student and Course classes.

Activity: Implementing One-to-One Association in Hibernate Consider a scenario where you need to implement one to one associate in hibernate application. Your Application should be based on the following guide lines: Student table contains column, such as ID, name, and address however member variable of an address column, such as street, city, state, and zip code are object instead of a simple data type.

Mapping Class Inheritance Consider a scenario where you need to develop an application that stores the details of the books sold by a book store. Note that book store sells different types of books, such as special edition books and books that are published in multiple languages. Therefore, you decide to create three classes, Books, SEBooks, and INBooks in the application. The Books class defines the common properties of different types of books, such as bookID, bookTitle, author, and cost. However, the SEBooks and INBooks classes extend the Books class and define their specific properties, such as specialfeatures and booklanguage.

Mapping Class Inheritance (Contd.) The Java classes are associated with each other with an inheritance relationship. However, the inheritance relationship cannot be achieved between the tables of a database. Therefore, you need to explicitly map the inheritance relationship of classes in the Hibernate mapping file while mapping the classes with the database tables. Hibernate provides the following types of mapping to support the inheritance hierarchy: Table per concrete class

Table per subclass Table per class

Mapping Class Inheritance (Contd.) Table per concrete class: In the table per concrete class mapping, a table is created for each class in the inheritance hierarchy. Each table defines columns for all the properties of the class including the inherited properties. After creating the tables and the classes, you need to map them in the Hibernate mapping file. You can use the element to map the subclasses in the mapping file. This element contains the following commonly used attributes:  name: Specifies the name of the subclass.  table: Specifies the name of the table that is to be mapped with the subclass.

Mapping Class Inheritance (Contd.) For example: ...... <property name="specialFeatures" type="string"> <property name="bookLanguage" type="string">

The element provides mapping information of the super class, Book. The element is used to map each subclass with the corresponding tables in the database.

Mapping Class Inheritance (Contd.) Implementing the table per concrete class mapping strategy has the following drawbacks: For each property mapped in the super class, the column name must be the same in all the subclass tables. Each table defines columns for all properties of the class including inherited properties. This results in duplication of values.

A separate query is needed to retrieve data from each table that stores the data of the concrete class. A change in the super class property results in the change of the various columns of the subclass tables.

Mapping Class Inheritance (Contd.) Table per class: In the table per class hierarchy mapping strategy, a single table is created for all the classes in the inheritance hierarchy. It eliminates the repetitive column names in the tables created for each class in the class hierarchy. However, you need to create an additional column in the table that distinguishes the objects of the subclasses. This column is referred to as the discriminator. The values stored in this column are used to identify the rows represented by the subclasses.

Mapping Class Inheritance (Contd.) The following elements are used to achieve table per class hierarchy mapping: :  Specifies the settings about the discriminator column with the help of the following attributes:  column: Specifies the name of the discriminator column.  type: Specifies the data type of the values stored in the discriminator column.

<subclass>:  Specifies the settings about the subclasses with the help of the following attributes:  name: Specifies the name of the subclass.  discriminator-value: Specifies a discriminator value that is used for the current subclass.

Mapping Class Inheritance (Contd.) For example: ...... ...... <subclass name="Test.SEBooks" discriminatorvalue="SE"> ...... <subclass name="Test.INBooks" discriminatorvalue="IN"> ......

The BOOKTYPE column of the BOOKDETAILS table is specified as the discriminator column. IN and SE are specified as the discriminator values that distinguish the objects of the INBooks and SEBooks subclasses.

Mapping Class Inheritance (Contd.) Key points of Table per class are: The table per class hierarchy simplifies the mapping and you do not need to create multiple tables with repetitive column names. However, if the inheritance hierarchy increases and contains multiple classes, the size of the table increases. In addition, when a single table is created for all the classes in the inheritance hierarchy, the columns that are not common among classes contain null values. Therefore, if the class hierarchy increases, the number of null values stored in the table also increases. This affects the data integrity of the database.

Mapping Class Inheritance (Contd.) Table per subclass: In the table per subclass mapping strategy, a separate table is created for each class. However, columns are not repeated for the inherited properties in the table that stores the objects of the subclass. The table that stores the objects of the super class contains the primary key, which is used as a foreign key in the tables that stores the objects of the subclasses. To achieve the table per subclass mapping, you need to use the <joinedsubclass> element in the hibernate mapping file.

Mapping Class Inheritance (Contd.) For example: ...... <property name="bookTitle" type="string"> ...... <joined-subclass name="Test.SEBooks" table="SEBOOKS"> <property name="specialFeatures" type="string"> ......

Mapping Class Inheritance (Contd.) Key points of Table per subclass are: In the table per subclass, the inheritance relationship is mapped by using the foreign key associations in the tables. You do not require separate queries for the tables that store objects of the subclasses. If the properties of the super classes change, you do not need to make any change in the columns of the tables that store the objects of the subclasses.

Activity: Implementing Inheritance Mapping in Hibernate Consider a scenario where you have been asked to create a Java application that implement Table per Class inheritance mapping. The Application should be based on the following guideline: Employee is the super class for PermanentEmployee and ContractEmployee classes, as shown in the following figure. Employee int empID String EmpName

PermanentEmployee String companyName

ContractEmployee String ContractorName

Summary To accomplish reusability and modularity in your application, you can: Create a Java class to represent the shared property. Refer the Java class from any class in the application.

The value types: Are mapped as a component of the entity class.

Are mapped by using the element in the Hibernate mapping file.

The mapping of an entity class is configured under the tag that is used to create a unique identifier for its object. However, the component class is configured under a tag. The commonly used collection mapping elements in the Hibernate mapping file are: <set>

<list>

Summary (Contd.) Hibernate allows you to map relationships among entity classes with the relationships among the tables in the mapping file. Hibernate allows you to map relationships in the following form: One-to-one One-to-many

Many-to-many

Hibernate provides the following types of mapping to support the inheritance hierarchy: Table per concrete class

Table per subclass Table per class