INTRODUCTION TO HIBERNATE

INTRODUCTION TO HIBERNATE

What is hibernate?

Is one of the most efficient ORM implementations in Java

What is ORM?

Ans:

·         is Object Relation Mapping (ORM)

·         IS A system that maps the object to Relational model.

·         ORM is not only relation to java only, it also there in cpp, c#

Understanding why ORM?

Ans:

·         We understand most of the enterprise applications these days are created using oop LANGUAGES

·         That is , OOP Systems(OOP’s)

·         In this condition we know that the activities are distributed into multiple components.

·         This introduces a requirement to describe the business data between these components (with in the OOP System)

·         To meet this requirement we create a DOM (Domain Object Model)

What is Domain Object Model(DOM)?

·         DOM is a object Model designed to describe the business domain data between the components in OOP System.

·         Now we also understand most of this business data is need to be persisted.

What is Persistence data?

·         Persistence Data is the data that can be outlive the process in which it is created.

·         One of the most common way of persisting the data is using RDBMS (i.e: Relational Data stores)

·         In a relational Data Store we find to create the relational model describing the business data.

·         In this situation(context), that is we have a complex Object model (DOM) in the OOP System (Enterprise Applications) and relational Model in the backend datastore to describe the business data in the respective environments.

·         Both of them are best in there environments.

·         In this case we find some problems because of mismatch between these models as they are created using different concepts that is, OOP and relational.

·         It is also identified that these problems are common in enterprise applications.

·         Thus we got some vendors finding interest to provide a readymade solution implementing the logic to bridge between the object and relational model.

·         Such systems are referred as ORM’s and Hibernate is one among them.

Fig: Hibernate1.JPG

The definition of ORM, Diagrammatic Representation

Fig: Hibernate2.JPG

The following are the mismatch problems found in mapping the object and relational models:

1.       Problem of identity

2.       Problem of Relationships

3.       Problem of subtypes

4.       Problem of  Granularity

5.       Problem of  Object Tree Navigation

Features of Hibernate

·         Hibernate supports Plain Java objects as persistence objects

·         Supports simple XML and annotation style of configuring the system

·         Hibernate supports the two level cache (one at session and other between the sessions) .This  can reduce the interactions with the database server and thus improve the performance.

·         Hibernate supports object oriented Query Language (HQL) for querying the objects

·         Hibernate supports integrating with the JDBC and JTA Transactions

·         Hibernate includes a Criterion API which facilitates creating the dynamic queries

Understanding the top level elements of Hibernate Architecture

1.       Configuration:

·         This object of Hibernate system is responsible for loading the configurations into the memory (hibernate system)

2.       SessionFactory:

·         This is responsible to initialize the Hibernate System to service the client (i.e: our java Application)

·         This performs all the time taken costlier on-time initializations includes understanding the configurations and setting up the environment like creating the connection pool, starting the 2^nd level cache and creating the proxy classes

3.       Session:

·         This is the core (central part) object of the Hibernate system which is used to access the CRUD operations

·         That means we use the methods of session object to create or read or update or delete the objects

·         Session object is created by SessionFactory, it also works with JDBC. 

·         SESSION is just like a front office execute in the office

4.       Transaction:

·         This provides a standard abstraction for accessing the JDBC or JTA Transaction Service

·         We know that Hibernate includes support to integrate with JTA

Fig: TOPLEVELARCHI.JPG

·         With this information we now want to move creating a start up example.

Hibernate start up Example:

·         The following files are required for this example:

(1.)  Employee.java

·         Is a persistence class

·         Will demonstrate the rules in creating the hibernate persistence class

(2.)  Employee.hbm.xml

·         Is a hibernate mapping XML document

·         Demonstrates how define the mappings using XML style

(3.)  hibernate.cfg.xml

·         is a hibernate configuration XML File

(4.)  HibernateTestCase.java

·         Demonstrates implementing the steps involved in accessing the persistence objects using Hibernate API

What is Hibernate Persistence class?

Ans:

·         It is a java class that is understood by the Hibernate system to manage its instances.

·         A java class should satisfy the following rules to become a Hibernate Persistence class:

1.       Should be a public Non-abstract class

2.       Should have a no-arg constructor: This is because of the following two reasons:

(a.)  Hibernate is programmed to create an instance of the persistence class using no-arg constructor.

(b.) For implementing the lazy loading Hibernate may need to create a dynamic proxy class sub type of the persistence class, for which no-argument constructor is mandatory

3.       Should have a java Bean style setter and getter methods for every persistence property.

<access_specifier> <non_void>

get<property_name_with_first_char_upper_case>()

<access_specifier>void

set<property_name_with_first_char_upper_case>(<one_argument>)

In addition to these rules; it is recommended to follow the below rules also:

(a.)  Make the class and the persistence property getter-setter methods to non-final.

·         If not followed may need to compromise with lazy loading (as hibernate could not implement it)

(b.) Implement the hashCode() and equals() methods.

Note:

·                     We can use the term entity to refer the persistence class

·                     Lets create the Employee.java following there rules:

package com.st.dom;

public class Employee {

      private int empno, deptno;

      private String name;

      private double sal;

      //we should have no arg constructor

      public Employee(){}

      public Employee(int empno, String name, double sal, int deptno)

      {

            this.empno=empno;

            this.name=name;

            this.sal=sal;

            this.deptno=deptno;

      }

      public int getEmpno()

      {

            return empno;

           

      }

      private void setEmpno(int eno)

      {

            empno=eno;

      }

      public String getName()

      {

            return name;

      }

      public void setName(String s)

      {

            name=s;

      }

      public double getSal()

      {

            return sal;

      }

      private void setSal(double s)

      {

            sal=s;

      }

      public int getDeptNo()

      {

            return deptno;

      }

      private void setDeptNo(int d)

      {

            deptno=d;

      }

}

·         Now we have implemented the persistence class, we need to describe the mapping for this object to the Hibernate.

To do this we have two approaches:

1.       Creating Hibernate Mapping XML

2.       Using Annotations

For this example we prefer with Hibernate Mapping XML (hbm XML)

<?xml version="1.0" encoding="UTF-8"?>

<hibernate-mapping>

 <class name="com.st.dom.Employee" table="st_emp">

  <id name="empno">

   <gen<!-- Employee.hbm.xml

Note: the file name need not match with the persistence class name.

However it is recomended to do such for easy maintanance. Also the extension need not be .hbm.xml but

is recommended to be recognized by many tools (includes IDE)

WHICH CAN INCREASE THE CONVINIENCE OF DEVELOPMENT AND MAINTANANCE -->

<!DOCTYPE-->

<!-- Copy this DOCTYPE from any existing hibernate mapping XML or DTD file -->

<?xml version="1.0" encoding="UTF-8"?>

<hibernate-mapping>

 <class name="com.st.dom.Employee" table="st_emp">

  <id name="empno">

   <generator class="assigned"/>

   </id>

   <property name="name" column="ename"/>

   <property name="sal"/>

   <property name="deptno"/>

  

 </class>

</hibernate-mapping>

<generator class="assigned"/>

   </id>

   <property name="name" column="ename"/>

   <property name="sal"/>

   <property name="deptno"/>

  

 </class>

</hibernate-mapping>

Fig: HIBERNATE_MAPPING.JPG

The hibernate.cfg.xml:

·         Now we are telling explained the hibernate mapping between the entity class and table, we want to describe the hibernate about the database it needs to access (i.e we are informing the address of DB Server)

·         To do this we create hibernate.cfg.xml

<!-- hibernate.cfg.xml -->

<!-- DOCTYPE -->

<!-- COPY THE DOCTYPE FROM any existing hibernate cfg xml or dtd -->

<hibernate-configuration>

 <session-factory>

  <property>

   name="connection.driver_class">

   oracle.jdbc.driver.OracleDriver

  </property>

  <property name="connection.url">

   jdbc:oracle:thin:@localhost:1521:XE

  </property>

  <property>

  <property name="connection.username">

  system</property>

  <property name="connection.password">

  manager</property>

  <property name="dialect">

  org.hibernate.dialect.Oracle9Dialect</property>

  <mapping resource="Employee.hbm.xml"/>

    </property>

 </session-factory>

</hibernate-configuration>

The Hibernate Test Case:

·         Because of the first example, lets only use Hibernate for reading the object

The following steps are involved in working with Hibernate API

Steps:

Step 1.  Create the configuration

Step2:  Build the sessionFactory

Step3: Get the Session

Step 4: Access the CRUD operations

Step 5: close the session

//HibernateTestCase.java

import com.st.dom.Employee;

import org.hibernate.cfg.*;

import org.hibernate.*;

public class HibernateTestCase

{

      public static void main(String args[])

      {

            //          Step 1.  Create the configuration

            Configuration cfg=new Configuration();

            cfg.configure();

            //Step2:  Build the sessionFactory

            SessionFactory sf=cfg.buildSessionFactory();

            //Step3: Get the Session

            Session session=sf.openSession();

            //Step 4: Access the CRUD operations

            //to read the object

            Employee emp=(Employee)session.load(Employee.class,101);

        /* 101 is the empno(i.e id) this will query the Employee object with the identifier (empno) value 101*/

            //to test

            System.out.println("Name :"+emp.getName());

            System.out.println("Salary :"+emp.getSal());

            System.out.println("Deptno "+emp.getDeptNo());

        //  Step 5: close the session

            session.close();

      }//main()

}//class

/*

 * To compile and run this program:

 * we want to have the following installations /jars

 * (1) JDK

 * (2) Oracle DB (otherwise any other DB Server)

 * (3) Hibernate ORM downloads

 *     we can download this from following site:

 *     www.hibernate.org

 *  We get a simple zip file to download, Extract it you will find all the necessary jar files.

 * 

 Do the following to successfully Run this example:

 1. copy the DOCTYPE into the XML documents (hibertate3.jar\org\hibernate-zip archieve)

    we can find DTD files in the hibernate3.jar file

      ->open the jar file with winzip or winrar

      ->coy the doctype from hibernate-configuration-3.0.dtd file into the hibernate.cfg.xml

      ->copy the doctype from hibernate-mapping-3.0.dtd file into the Employee.hbm.xml

 2. set the following jar files into classpath:

    -hibernate3.jar

    -antlr-2.7.6.jar

    -commons-collections-3.1.jar

    -dom4j-1.6.1.jar

    -javassist-3.12.0.GA.jar

    -jta-1.1.jar

    -hibernate-jpa-2.0-api-1.0.1.Final.jar

    -ojdbc14.jar

    (to set the class path better to do batch file and you can execute when u want)

 3. create the following table and record in the database server:

    create table st_emp(

     empno number primary-key,

     ename varchar2(20),

     sal number(10,2),

     deptno number);

    

    insert into st_emp values(101,'e101',10000,10);

    commit;

 4. compile java files and Run

    >javac -d . *.java

    >classpath.bat //this executes the set the class path

    >java HibernateTestCase                         

 */

Understanding the Hibernate API

Step 1: Creating the configuration object