Code Insane: Hibernate Overview for Beginners

Hibernate Overview:

Hibernate is an Object-Relational Mapping(ORM) solution for JAVA. It is an open source framework created by Gavin King in 2001. It is a powerful, high performance Object-Relational Persistence and Query service for any Java Application.

Hibernate maps Java classes to database tables and from Java data types to SQL data types and relieves the developer lots of programming tasks. Hibernate acts between traditional Java objects and database server to handle all the works in persisting those objects based on the appropriate O/R mechanisms and patterns.

Hibernate Advantages:

Hibernate takes care of mapping Java classes to database tables using XML files and without writing any line of code.
Provides simple APIs for storing and retrieving the Java objects directly to and from database.
If there is change in the database or in any table, then you only need to change the XML file properties.
Abstracts away the unfamiliar SQL types and provides a way to work around familiar Java Objects.
Hibernate does not require an application server to operate on.
Manipulates Complex associations of objects of your database.
Minimizes database access with smart fetching strategies.
Provides simple querying of data.
No need to self create tables.
It creates tables in database according to needs.

Supported Databases:

Hibernate supports almost all the major RDBMS. Following is a list of few of the database engines supported by Hibernate:

HSQL Database Engine
Oracle
Microsoft SQL Server Database
Sybase SQL Server
Informix Dynamic Server
DB2/NT
MySQL
PostgreSQL
FrontBase

Supported Technologies:

Hibernate supports a variety of other technologies, including:

Eclipse plug-ins
Maven
XDoclet Spring
J2EE

Types of objects involved in Hibernate Application Architecture:

Configuration Object:

The Configuration object is the first Hibernate object you create in any Hibernate application. It is usually created only once during application initialization. It basically represents a configuration or properties file required by the Hibernate.

The Configuration object provides two components:

1. Database Connection: This is handled through one or more configuration files supported by Hibernate. These files are hibernate.properties and hibernate.cfg.xml.

2. Class Mapping Setup: This component creates the connection between the Java classes and database tables.

SessionFactory Object:

Configuration object is used to create a SessionFactory object which in turn configures Hibernate for the application using the supplied configuration file and allows for a Session object to be instantiated. The SessionFactory is a thread safe object and used by all the threads of an application.

The SessionFactory is a heavyweight object; it is usually created during application start up and kept for later use. You would need one SessionFactory object per database using a separate configuration file. So, if want to use multiple databases, then you would have to create multiple SessionFactory objects.

Session Object:

A Session is used to get a physical connection with a database. The Session object is lightweight and designed to be instantiated each time an interaction is needed with the database. Persistent objects are saved and retrieved through a Session object.

The session objects should not be kept open for a long time because they are not usually thread safe and they should be created and destroyed them as needed.

Transaction Object:

A Transaction represents a unit of work with the database and most of the RDBMS supports transaction functionality. Transactions in Hibernate are handled by an underlying transaction manager and transaction (from JDBC or JTA).

This is an optional object and Hibernate applications may choose not to use this interface, instead managing transactions in their own application code.

Query Object:

Query objects use SQL or Hibernate Query Language (HQL) string to retrieve data from the database and create objects. A Query instance is used to bind query parameters, limit the number of results returned by the query, and finally to execute the query.

Criteria Object:

Criteria objects are used to create and execute object oriented criteria queries to retrieve objects.

You can download the latest version of hibernate from link given below:

http://hibernate.org/orm/downloads/

Or If You are using Netbeans 8 IDE you don't need to download it.You can easilt add it while creating your web application.

A ScreenShot of Adding Hibernate to your Application:

Hibernate Example Using Hibernate One to One Mapping:

You have to first create Configuration file,it looks like:

<hibernate-configuration>

<session-factory>

<property name="hibernate.connection.driver_class">com.mysql.jdbc.Driver</property>

<property name="hibernate.connection.url">jdbc:mysql://localhost:3306/database2</property>

<property name="hibernate.hbm2ddl.auto">update</property>

<property name="hibernate.dialect">org.hibernate.dialect.MySQLDialect</property>

</session-factory>

</hibernate-configuration>

Don't forget to include this code on top of configuration file:

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

<!DOCTYPE hibernate-configuration PUBLIC "-//Hibernate/Hibernate Configuration DTD 3.0//EN" "http://hibernate.sourceforge.net/hibernate-configuration-3.0.dtd">

Then create Hibernate Mapping file:

Vote.hbm.xml-

<hibernate-mapping>

<param name="property">voter</param>

</generator>

</id>

<one-to-one name="voter" class="bean.Vote"/>

</class>

</hibernate-mapping>

Voter.hbm.xml-

<hibernate-mapping>

</class>

</hibernate-mapping>

Also inlcude this code in both mapping file:

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

<!DOCTYPE hibernate-mapping PUBLIC "-//Hibernate/Hibernate Mapping DTD 3.0//EN" "http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd">

Then create bean class for Vote:

package bean;

import java.util.Date;

public class Vote

{

private int vtid;

private String pname;

private Date cdate;

private Voter voter;

public Vote() {

}

public int getVtid() {

return vtid;

}

public void setVtid(int vtid) {

this.vtid = vtid;

}

public String getPname() {

return pname;

}

public void setPname(String pname) {

this.pname = pname;

}

public Date getCdate() {

return cdate;

}

public void setCdate(Date cdate) {

this.cdate = cdate;

}

public Voter getVoter() {

return voter;

}

public void setVoter(Voter voter) {

this.voter = voter;

}

Create bean class for Voter:

package bean;

public class Voter {

private int vid;

private String name;

private int vage;

public Voter() {

}

public int getVid() {

return vid;

}

public void setVid(int vid) {

this.vid = vid;

}

public String getName() {

return name;

}

public void setName(String name) {

this.name = name;

}

public int getVage() {

return vage;

}

public void setVage(int vage) {

this.vage = vage;

}

LAST CREATE TEST CLASS:

package Test;

import bean.Vote;

import bean.Voter;

import java.util.Date;

import org.hibernate.Session;

import org.hibernate.SessionFactory;

import org.hibernate.cfg.Configuration;

public class Test

{

public static void main(String[] args) {

Configuration cfg=new Configuration();

cfg.configure("cfg/hibernate.cfg.xml");

SessionFactory sf=cfg.buildSessionFactory();

Session session=sf.openSession();

Voter v=new Voter();

v.setName("balwant");

v.setVage(24);

v.setVid(12);

Vote v1=new Vote();

v1.setPname("AKP");

v1.setCdate(new Date());

v1.setVoter(v);

Vote v2=new Vote();

v2.setPname("PPL");

v2.setCdate(new Date());

v2.setVoter(v);

session.save(v);

session.save(v1);

// session.save(v2);

session.beginTransaction().commit();

sf.close();

}

Hibernate Session Method:
1. save:hibernate save() can be used to save entity to database. We can invoke this method outside a transaction. If we use this without transaction and we have cascading between entities, then only the primary entity gets saved unless we flush the session.
e.g. session.save(s1);

2.persist: Hibernate persist is similar to save (with transaction) and it adds the entity object to the persistent context, so any further changes are tracked. If the object properties are changed before the transaction is committed or session is flushed, it will also be saved into database.

Second difference is that we can use persist() method only within the boundary of a transaction, so it’s safe and takes care of any cascaded objects.
e.g. session2.persist(emp2);

3.saveOrUpdate: Hibernate saveOrUpdate help in inserting and updating queries based on the provided data. If the data is present in the database, update query is executed.

We can use saveOrUpdate() without transaction also, but you will face the issues with mapped objects not getting saved if session is not flushed.
Hibernate saveOrUpdate adds the entity object to persistent context and track any further changes. Any further changes are saved at the time of committing transaction, like the persist method.
e.g. session.saveOrUpdate(emp);

4.update: Hibernate update must be used there where we know that we are only updating the entity information. This operation adds the entity object to persistent context and further changes are tracked and saved when transaction is committed.
e.g. session.update(emp);

5.merge: Hibernate merge can be used to update existing values, however this method create a copy from the passed entity object and return it. The returned object is part of persistent context and tracked for any changes. This is the major difference with merge() from all the other methods.

e.g. Employee emp4 = (Employee) session.merge(emp);

Hibernate Lifecycle Of pojo Class Objects:

POJO class object have 3 states which are given below;

Transient state
Persistent state
Detached state

1. Transient State: A New instance of a persistent class which is not associated with a Session, has no representation in the database and no identifier value is considered transient by Hibernate:UserDetail user = new UserDetail(); user.setUserName("BALWANT");

2. Persistent State:
A persistent instance has a representation in the database , an identifier value and is associated with a Session. You can make a transient instance persistent by associating it with a Session:Long id = (Long) session.save(user);

3. Detached State:
Now, if we close the Hibernate Session, the persistent instance will become a detached instance: it isn't attached to a Session anymore (but can still be modified and reattached to a new Session later though).session.close();

Example:

import org.hibernate.*;

import org.hibernate.cfg.*;

public class ClientProgram {

public static void main(String[] args)

{

Configuration cfg = new Configuration();

cfg.configure("hibernate.cfg.xml");

SessionFactory factory = cfg.buildSessionFactory();

Session session = factory.openSession();

// Transient state

Product p=new Product();

p.setProductId(101);

p.setProName("MACINTOSH");

p.setPrice(250000);

// Persistent state

Transaction tx = session.beginTransaction();

session.save(p);

System.out.println("Object saved..!!!!!!");

tx.commit();

// Persistent state

session.close();

factory.close();

}

Hibernate libraries:

dom4j

Xalan

Xerces

cglib

log4j

Commons

SLF4J

Hibernate Query language:Hibernate Query Language (HQL) is an object-oriented query language, it is similar to SQL, but instead of operating on tables and columns, HQL works with persistent objects and their properties. HQL queries are translated by Hibernate into conventional SQL queries which in turns perform action on database.Although you can use SQL statements directly with Hibernate using Native SQL but I would suggest you to use HQL whenever there is need of database portability or you can take the advantage of Hibernate's SQL generation and caching strategies.
Keywords like SELECT , FROM and WHERE etc. are not case sensitive but properties like table and column names are case sensitive in HQL.

FROM Clause
You can use FROM clause if you want to load a complete persistent objects into memory. Following is the simple syntax of using FROM clause:

String hql = "FROM Employee";