Hibernate example1

INTRODUCTION TO HIBERNATE
http://raj-hibernate.blogspot.in/

What is hibernate?
• Is one of the most efficient ORM
implementations in Java

What is ORM?
• 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?
• 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.

The definition of ORM, Diagrammatic Representation

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
Configuration:
• This object of Hibernate system is responsible for loading the configurations into the memory
(hibernate system)
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 2nd
level cache and creating the proxy classes
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
Transaction:
• This provides a standard abstraction for accessing the JDBC or JTA Transaction Service
• We know that Hibernate includes support to integrate with JTA

TOP LEVEL ARCHITECTURE HIBERNATE

With this information we now want to
move creating a start up example.
• Hibernate start up Examle:
• The following files are required for this example:
• Employee.java
• Is a persistence class
• Will demonstrate the rules in creating the hibernate persistence class
• Employee.hbm.xml
• Is a hibernate mapping XML document
• Demonstrates how define the mappings using XML style
• hibernate.cfg.xml
• is a hibernate configuration XML File
• 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
• Should be a public Non-abstract class
• Should have a no-arg constructor: This is because of the following two reasons:
• Hibernate is programmed to create an instance of the persistence class using no-arg constructor.
• 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
• 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:
• 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)
• 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:
• Creating Hibernate Mapping XML
• 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
<!DOCTYPE-->

<?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>
erator 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-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
• 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
• //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:
• 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.jarorghibernate-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)

To compile and run this program:
• 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

Hibernate example1

More Related Content

What's hot (20)

Viewers also liked (20)

Similar to Hibernate example1 (20)

More from myrajendra (18)

Recently uploaded (20)

Hibernate example1

Editor's Notes