Free practice test , mock test, driving test, interview questions » Hibernate Tutorial

Hibernate Persistence Tutorial: Use Hibernate in your java applications to access database

smitha — Mon, 17 Aug 2009 19:39:22 +0000

This is third hibernate tutorial for advanced users .We will talk about hibernate persistence and how you will connect with hibernate to the database. The database we would be using is mysql.

Our last two posts had covered hibernate setup , hibernate configuration and how using annotation with hibernate.

First Hibernate Tutorial

Hibernate Using Annotations

Step 1: Create java project in eclipse

Step2: add the required libraries.

These steps are well explained with screenshots in :

The required jars used in my projects are:

mysql-connector.jar
ejb3-persistence.jar, antlr-2.7.6.jar
asm.jar
asm-attrs.jar
commons-collections-2.1.1.jar
commons-logging-1.0.4.jar
concurrent-1.3.2.jar
connector.jar
dom4j-1.6.1.jar
ehcache-1.2.3.jar
hibernate3.jar
hibernate-annotations.jar
hibernate-entitymanager.jar
hibernate-tools.jar
jaas.jar
jacc-1_0-fr.jar
javassist.jar
jaxen-1.1-beta-7.jar
jboss-cache.jar
jboss-common.jar
jboss-jmx.jar
jboss-system.jar
jdbc2_0-stdext.jar
jgroups-2.2.8.jar
jta.jar
log4j-1.2.11.jar
oscache-2.1.jar
proxool-0.8.3.jar
swarmcache-1.0rc2.jar
syndiag2.jar
xerces-2.6.2.jar
xml-apis.jar

Step 3:

The Directory structure of the application:

I created a following structure:

Com.myapp.eo this package will contain all the Entity Classes.

Com.myapp.vo this package will contain all the beans for Entity Classes.

Com.myapp.accessor this package contains interfaces common to both eo and vo packages

Com.myapp.hibernate for hibernate utility classes

Com.myapp.services for the beans which will query database

Com.myapp.client the client programs which will call service functions

Com.myapp.exception will contain all the possible exceptions thrown by our application.

Now create database Entity class.

DB Setup:

Create database myapp_db;

Connect myapp_db;

Create a table with following fields:

Create table users values(user_id int(11) auto_increment,

Username varchar(100),

Password varchar(20)),

Status tinyint(1) default 0,

Primary key user_id);

Now for every db table we’ll have 3 files for each:

One in accessor class which is a common interface to both com.myapp.eo and com.myapp.vo classes. The vo class is a simple java bean. We use this bean in eo class in setter and getter methods.

Interface: User.java. Add following interface to com.myapp.accessor package.

package com.myapp.accessor;

public interface User {

public Integer getUserId();

public void setUserId(Integer userId);

public String getUserName();

public void setUserName(String userName);

public String getPassword();

public void setPassword(String password);

public Byte getState();

public void setState(Byte state);

}

File:UserVO.java. Add this to com.myapp.vo package

package com.myapp.vo;

import com. myapp.accessor.User;

public class UserVO implements User{

Integer userId;

String userName;

String password;

Byte state;

public Integer getUserId() {

return userId;

}

public void setUserId(Integer userId) {

this.userId = userId;

}

public String getUserName() {

return userName;

}

public void setUserName(String userName) {

this.userName = userName;

}

public String getPassword() {

return password;

}

public void setPassword(String password) {

this.password = password;

}

public Byte getState() {

return state;

}

public void setState(Byte state) {

this.state = state;

}

}

The UserEO class: Add this to

package com.myapp.eo;

import javax.persistence.Column;

import javax.persistence.Entity;

import javax.persistence.GeneratedValue;

import javax.persistence.GenerationType;

import javax.persistence.Id;

import javax.persistence.Table;

import javax.persistence.Transient;

import com.jda.server.accessor.User;

import com.jda.server.vo.UserVO;

@Entity

@Table(name=”users”)

public class UserEO implements User{

User user;

@Transient

public User getUser() {

return user;

}

public void setUser(User user) {

this.user = user;

}

public UserEO(){

user = new UserVO();

}

public UserEO(User user){

this.user = user;

}

@Id

@GeneratedValue(strategy = GenerationType.IDENTITY)

@Column(name=”user_id”, unique=true, nullable=false, insertable=true, updatable=true)

public Integer getUserId() {

return user.getUserId();

}

public void setUserId(Integer userId) {

user.setUserId(userId);

}

@Column(name=”username”)

public String getUserName() {

return user.getUserName();

}

public void setUserName(String userName) {

user.setUserName(userName);

}

@Column(name=”password”)

public String getPassword() {

return user.getPassword();

}

public void setPassword(String password) {

user.setPassword(password);

}

@Column(name=”state”)

public Byte getState() {

return user.getState();

}

public void setState(Byte state) {

user.setState(state);

}

}

Step 4: Configuring Hibernate and creating a hibernate mapping file

I am using mysql DB. Create a file by name hibernate.cfg.xml in the src directory.

“-//Hibernate/Hibernate Configuration DTD 3.0//EN”

“http://hibernate.sourceforge.net/hibernate-configuration-3.0.dtd”>

jdbc:mysql://localhost/myapp_db

root

com.mysql.jdbc.Driver

org.hibernate.dialect.MySQLDialect

root

org.hibernate.transaction.JDBCTransactionFactory

thread

true

Now in Hibernate for every database operation you will need a hibernate session.

Usually you do this using some code like below:

Now we have entity mapping and we have also configured the db. Now we need hibernate session to

AnnotationConfiguration cfg = new AnnotationConfiguration();

cfg.addAnnotatedClass(Contact.class);

cfg.configure();

SessionFactory sessionFactory = cfg.buildSessionFactory();

session =sessionFactory.openSession();

But it is not practical for the entire bean to open multiple sessions to same db for multiple operations. In a complex application you might have number of tables for which you will have number of beans to update/execute query. So it’s important to make sure all your application share a single session object.

We can accomplish this using a Singleton design pattern. Create a static session object and initialize it in the static block. This ensures that the session will be open before anyone tries to access session object. The class can look something like this:

package com.myapp.hibernate;

import org.hibernate.Session;

import org.hibernate.SessionFactory;

import org.hibernate.cfg.AnnotationConfiguration;

public class HibernateSessionUtil {

private static org.hibernate.SessionFactory sessionFactory;

private HibernateSessionUtil() {

}

static{

sessionFactory = new AnnotationConfiguration().configure().buildSessionFactory();

}

public static SessionFactory getInstance() {

return sessionFactory;

}

public Session openSession() {

return sessionFactory.openSession();

}

public Session getCurrentSession() {

return sessionFactory.getCurrentSession();

}

public static void close(){

if (sessionFactory != null)

sessionFactory.close();

sessionFactory = null;

}
}

Now we have the utility function ready.

We will also define exceptions which our application might throw. This are the application exceptions, part of business logic. For example in our application if we want to verify a user’s username ans pwd, then if the user is not found , we can throw a UserNotFound exception. If user’s password is not matching we can thorw a UserException with message the password didn’t match. If there is any other (checked) exception the system will wrap it inside a MyAppException and throw it.

Add following classes to the com.myapp.exception package.

package com.myapp.exception;

public class MyAppException extends Exception implements java.io.Serializable{

public MyAppException(String msg) {

super(msg);

}

public MyAppException(String msg, Throwable cause) {

super(msg, cause);

}

}

package com.myapp.exception;

public class UserException extends Exception implements java.io.Serializable{

public UserException(String msg) {

super(msg);

}

public UserException(String msg, Throwable cause) {

super(msg, cause);

}

}

package com.myapp.exception;

public class UserNotFoundException extends Exception implements java.io.Serializable{

public UserNotFoundException(String msg) {

super(msg);

}

public UserNotFoundException(String msg, Throwable cause) {

super(msg, cause);

}

}

Now we need functions for db operations. We do it in the service classess. For each business requirement we can have a service function which will perform the required task and return the results back. An example for user table business actions is shown below. It shows simple select, create and update and delete functions.

Creating the service classes.

package com.myapp.service;

import java.util.Iterator;

import java.util.List;

import org.hibernate.HibernateException;

import org.hibernate.Session;

import org.hibernate.Query;

import org.hibernate.Transaction;

import org.apache.commons.logging.Log;

import org.apache.commons.logging.LogFactory;

import com.myapp.accessor.*;

import com.myapp.eo.*;

import com.myapp.vo.*;

import com.myapp.hibernate.*;

import com.myapp.exception.MyAppException;

import com.myapp.exception.UserException;

import com.myapp.exception.UserNotFoundException;

public class UserService {

public User authenticateUser(User user) throws UserException,UserNotFoundException,MyAppException{

Transaction tx = null;

Session session = HibernateSessionUtil.getInstance().getCurrentSession();

try {

tx = session.beginTransaction();

Query q = session.createQuery(“select users from UserEO as users where users.userName = :userName”);

q.setParameter(“userName”, user.getUserName());

List users = q.list();

if(users.size() < 1)

throw new UserNotFoundException(“User Not found”);

for (Iterator iter = users.iterator(); iter.hasNext();) {

UserEO element = (UserEO) iter.next();

User userVO = element.getUser();

if(!user.getPassword().equals(userVO.getPassword()))

throw new UserException(“Username and password didnot match”);

else

user = userVO;

}

tx.commit();

} catch (Exception e) {

if (tx != null && tx.isActive()) {

try {

// Second try catch as the rollback could fail as well

tx.rollback();

} catch (HibernateException e1) {

System.out.println(“Error rolling back transaction”);

}

// throw again the first exception

}

throw new MyAppException(“Exception while fetching user data”,e);

}

return user;

}

public User createUpdateUser(User user) throws MyAppException{

Transaction tx = null;

User userObj = null;

Session session = HibernateSessionUtil.getInstance().getCurrentSession();

try {

UserEO userEO = new UserEO(user);

tx = session.beginTransaction();

userEO = (UserEO)session.merge(userEO);

userObj = userEO.getUser();

tx.commit();

} catch (Exception e) {

if (tx != null && tx.isActive()) {

try {

// Second try catch as the rollback could fail as well

tx.rollback();

} catch (HibernateException e1) {

System.out.println(“Error rolling back transaction”);

}

// throw again the first exception

}

throw new MyAppException(“Exception while saving user data”,e);

}

return userObj;

}

public void deleteUser(User user) throws MyAppException{

Transaction tx = null;

Session session = HibernateSessionUtil.getInstance().getCurrentSession();

try {

UserEO userEO = new UserEO(user);

tx = session.beginTransaction();

session.delete(userEO);

tx.commit();

} catch (RuntimeException e) {

if (tx != null && tx.isActive()) {

try {

// Second try catch as the rollback could fail as well

tx.rollback();

} catch (Exception e1) {

System.out.println(“Error rolling back transaction”);

}

}

throw new MyAppException(“Exception while deleting user data”,e);

}

}

}

The client for this service would be :

package com.myapp.client;

import com.myapp.service.*;

import com.myapp.vo.*;

import com.myapp.accessor.*;

public class UserTest {

public static void main(String[] args) throws Exception{

UserService service = new UserService();

User user = new UserVO();

user.setUserName(“Alex”);

user.setPassword(“XXX”);

try{

User svd = service.authenticateUser(user);

}catch(Exception e){

e.printStackTrace();

}

//create new user

user = new UserVO();

user.setUserName(“Smitha2″);

user.setPassword(“XXX”);

user.setState((byte)1);

User svdUser = null;

try{

svdUser = service.createUpdateUser(user);

}catch(Exception e){

e.printStackTrace();

}

if(svdUser!=null && svdUser.getUserId()!=null){

System.out.println(“svdUser.getUserId() ==>”+svdUser.getUserId());

svdUser.setPassword(“YYY”);

try{

svdUser = service.createUpdateUser(svdUser);

}catch(Exception e){

e.printStackTrace();

}

}

try{

service.deleteUser(svdUser);

}catch(Exception e){

e.printStackTrace();

}

}

}

I hope that this hibernate tutorial would be helpful to you. Please let us know your comments and feedback

Hibernate Tutorial – Using Annotations with Hibernate

smitha — Thu, 06 Aug 2009 17:48:17 +0000

In case you missed the first post Hibernate Tutorial for beginners , please go through it if you are new to hibernate.

Annotations are powerful and easy way used to provide metadata about the class.They do not effect the operation of the code. They can be used to provide information about the class to the compiler. They can be used to replace the configuration files. Many applications scan files and detect annotated classes and get configured accordingly. I am using JPA API here to demonstrate you the usage of annotations. Please download ejb3-persistence.jar and include in your referenced libraries.

We do not need jboss to run JPA hibernate examples but we can copy these jar files in our webserver and we are good to go.

I hope you have gone through my previous post explaining how to configure and run the first hibernate example because this hibernate tutorial would cover the next steps. There I have used Conatct.hbm.xml file to map the Contact class to the contact table. Below I have explained how we can use annotations to replace the table hbm.xml files in Hibernate.

For beginners, the contact table contains following fields:

Create table CONTACT(
ID int(15),
FIRSTNAME varchar(50) ,
LASTNAME varchar(50),
EMAIL varchar(150));

Change the Contact class as follows:

import javax.persistence.Column;
import javax.persistence.Entity;
import javax.persistence.Id;
import javax.persistence.Table;
import javax.persistence.*;
@Entity
@Table(name=”contact”)
public class Contact {
private String firstName;
private String lastName;
private String email;
private long id;

@Column(name=”FIRSTNAME”)
public String getFirstName() {
return firstName;
}

public void setFirstName(String string) {
firstName = string;
}

@Column(name=”LASTNAME”)
public String getLastName() {
return lastName;
}

public void setLastName(String string) {
lastName = string;
}

@Column(name=”EMAIL”)
public String getEmail() {
return email;
}
public void setEmail(String string) {
email = string;
}

@Id
@Column(name=”ID”)
public long getId() {
return id;
}

public void setId(long l) {
id = l;
}

}

Remove following lines from hibernate.cfg.xml

In above class, we have added

@Entity
@Table(name=”contact”)

annotations.

@Entity declares the class as an entity bean. @Table annotation specifies compiler that the table name in db is ‘contact’. If @Table is not specified, then the classname will be considered as table name.

@Column specifies the column name of the table. We specify it for the getter method of the field. If not specified, the field name itself is considered as the column name.

Each table should have a primary key. This will be specified by @Id annotation.

Now we can test the above configuration using the client class as follows:

import org.hibernate.Session;
import org.hibernate.SessionFactory;
import org.hibernate.cfg.AnnotationConfiguration;
import org.hibernate.cfg.Configuration;

public class MyExample {
public static void main(String[] args) {
Session session = null;

try{
// This step will read hibernate.cfg.xml and prepare hibernate for use

AnnotationConfiguration cfg = new AnnotationConfiguration();
cfg.addAnnotatedClass(Contact.class);
cfg.configure();
SessionFactory sessionFactory = cfg.buildSessionFactory();
session =sessionFactory.openSession();

//Create new instance of Contact and set values in it by reading them from form object
System.out.println(“Inserting Record”);
Contact contact = new Contact();
contact.setId(3);
contact.setFirstName(“Smitha”);
contact.setLastName(“Rao”);
contact.setEmail(“smithaxxx@yahoo.com“);
session.save(contact);
System.out.println(“Done”);
}catch(Exception e){
System.out.println(e.getMessage());
}finally{
// Actual contact insertion will happen at this step
session.flush();
session.close();

}

}
Run MyExample file.

Output would be :
log4j:WARN No appenders could be found for logger (org.hibernate.cfg.annotations.Version).
log4j:WARN Please initialize the log4j system properly.
Inserting Record
Done
Hibernate: insert into contact (FIRSTNAME, LASTNAME, EMAIL, ID) values (?, ?, ?, ?)

I hope you would be enjoying these hibernate tutorial. Please give us your feedback.

First Hibernate Tutorial –Get Hands on Experience -Part I

smitha — Wed, 05 Aug 2009 20:31:20 +0000

Part - II >>

Hibernate is a powerful, high performance object/relational persistence and query service. It maps database tables to objects so that the database tables can be queried and used as objects.

This hibernate tutorial gives a step by step solution to develop a first Hibernate application using Eclipse.

Requirements:Eclipse 3, Mysql Database, JDK 1.5, Download hibernate from https://www.hibernate.org/30.html and unzip it.
Setting Up Project :

Step 1: Create project.Open Project Wizard and create simple java project

Next Screen -> New Java Project Screen appears. Enter Project Name.

Now you can see the project being setup and listed in the package explorer(left)

Step 2: Add jars to the path Create a user Library

Right click project and select Properties

Select Libraries

Click Add Library -> User Library

Click Next

Click userlibraries

Click New Button to create new userlibrary

You can see HibernateLib library created

Open the downloaded and unzipped Hibernate directory and Add jars from downloaded Hibernate 3/lib and hibernate3.jar to HibernateLibrary.

Select TraningProject /lib directory and select all the jars –> open

Select all jars and click open. You can see jars being selectd as below:

Click ok –> Finish –> Ok. Now you can see the jars are being added to referenced libraries section in package explorer.

Also download mysql-connector.jar and include in your library.

Configuring Hibernate

Hibernate uses the hibernate.cfg.xml to create the connection pool and setup required environment.Create a file named hibernate.cfg.xml in src directory. Right click –> new –> file

Copy following contents and save.

“-//Hibernate/Hibernate Configuration DTD//EN”
“http://hibernate.sourceforge.net/hibernate-configuration-3.0.dtd”>

com.mysql.jdbc.Driver
jdbc:mysql://localhost/HibernateTest
root
yourPassword
10
true
org.hibernate.dialect.MySQLDialect
update

In the above configuration file we specified to use the ” HibernateTest ” (Replace with your Database name on mysql ) which is running on localhost and the user of the database is root with password yourPassword (Replace with your mysql db password). The dialect property is org.hibernate.dialect.MySQLDialect which tells the Hibernate that we are using MySQL Database. The property is the mapping for our contact table.

Mysql Setup:

Create new Database:

mysql> create database HibernateTest;

mysql> connect HibernateTest;

mysql> Create table CONTACT(
ID int(15),
FIRSTNAME varchar(50) ,
LASTNAME varchar(50),
EMAIL varchar(150));

Commit your changes:

mysql> commit;

Creating Persisting Class.

This class will be used to map to Contact Table:

public class Contact {
private String firstName;
private String lastName;
private String email;
private long id; public String getEmail() {
return email;
} public String getFirstName() {
return firstName;
} public String getLastName() {
return lastName;
} public void setEmail(String string) {
email = string;
} public void setFirstName(String string) {
firstName = string;
} public void setLastName(String string) {
lastName = string;
} public long getId() {
return id;
} public void setId(long l) {
id = l;
}}

Mapping the Contact Object to the Database Contact table

The file contact.hbm.xml is used to map Contact Object to the Contact table in the database. Create a file named contact.hbm.xml.Here is the code for contact.hbm.xml:

“-//Hibernate/Hibernate Mapping DTD 3.0//EN”
“http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd“>

Developing Code to Test Hibernate

Hibernate Session is the main runtime interface between a Java application and Hibernate. First we are required to get the Hibernate Session.SessionFactory allows application to create the Hibernate Sesssion by reading the configuration from hibernate.cfg.xml file. Then the save method on session object is used to save the contact information to the database:

import org.hibernate.Session;
import org.hibernate.SessionFactory;
import org.hibernate.cfg.Configuration;

public class MyExample {
public static void main(String[] args) {
Session session = null;

try{
// This step will read hibernate.cfg.xml and prepare hibernate for use
SessionFactory sessionFactory = new Configuration().configure().buildSessionFactory();
session =sessionFactory.openSession();
//Create new instance of Contact and set values in it by reading them from form object
System.out.println(“Inserting Record”);
Contact contact = new Contact();
contact.setId(3);
contact.setFirstName(“Smitha”);
contact.setLastName(“Rao”);
contact.setEmail(“smithaxxx@yahoo.com”);
session.save(contact);
System.out.println(“Done”);
}catch(Exception e){
System.out.println(e.getMessage());
}finally{
// Actual contact insertion will happen at this step
session.flush();
session.close();

}

Run the Hibernate project:

right click on the MyExample.java file –> run –> java application.

You should see something following:

Output:

log4j:WARN No appenders could be found for logger (org.hibernate.cfg.Environment).

log4j:WARN Please initialize the log4j system properly.

Inserting Record

Done

Hibernate: insert into CONTACT (FIRSTNAME, LASTNAME, EMAIL, ID) values (?, ?, ?, ?)

Hope this tutorials helps. In Next tutorial I’ll explain how you can use annotations instead of using mapping file like Contact.hbm.xml.

I am hoping this Hibernate Tutorial would have been helpful to you. Do put in your feedback and comments.

Check Part II of this tutorial to get more clarity on how the code worked

Part - II