Hibernate is a solution for object relational mapping and a persistence management solution or persistent layer. This is probably not understandable for anybody learning Hibernate.

What you can imagine is probably that you have your application with some functions (business logic) and you want to save data in a database. When you use Java all the business logic normally works with objects of different class types. Your database tables are not at all objects.

Hibernate provides a solution to map database tables to a class. It copies one row of the database data to a class. In the other direction it supports to save objects to the database. In this process the object is transformed to one or more tables.

Saving data to a storage is called persistence. And the copying of tables to objects and vice versa is called object relational mapping.
Create a Java Project

Using Eclipse press the keys Ctrl+n (Strg+n) to create a new project. Select a Java project. We will call it FirstHibernateExample.
Prepare the project for Hibernate using
MyEclipse

When you are using MyEclipse, right click on your project in the package explorer and choose Add Hibernate capabilities.

Select First Hibernate Program—>In that select  New–>and then Just follow the instructions

Continue the wizard and create a new hibernate.cfg.xml in the src directory.

In the last step you can create a Hibernate SessionFactory. I prefer to create my own. You can find it below.

Random Posts

• September 20, 2008 -- Difference between session.save() and session.saveOrUpdate() (0)
• July 7, 2008 -- JSP Standard Questions (0)
• December 17, 2008 -- What is Port Number (0)
• October 5, 2008 -- Difference between GET and HEAD request methods (0)
• December 12, 2008 -- URL Connection Class (0)

Create a Test Client

Create a Java Class ?TestClient? in the package ?de.laliluna.example?.

Add the following source code. It includes methods to create entries in the database, to update and to list them.


/**
* Test application for example
* @author Sebastian Hennebrueder
* created Jan 16, 2006
* copyright 2006 by http://www.laliluna.de
*/

private static void createHoney(Honey honey) {
Transaction tx = null;
Session session = InitSessionFactory.getInstance().getCurrentSession();
try {
tx = session.beginTransaction();
session.save(honey);
tx.commit();
} catch (HibernateException e) {
e.printStackTrace();
if (tx != null && tx.isActive())
tx.rollback();
}
}
}

Congratulations. You have finished your first steps in the Hibernate world.

We wanted to give you a fast entry in the Hibernate world. There are many more complex topics and better implementation to use Hibernate. For example, the opening and closing of the session in each method is not a good practice. A session can be reused during which saves a lot of time.

When you want to learn more about best practices have a look at our seminars or other tutorials.
Copyright and disclaimer

This tutorial is copyright of Sebastian Hennebrueder, laliluna.de. You may download a tutorial for your own personal use but not redistribute it. You must not remove or modify this copyright notice.

The tutorial is provided as is. I do not give any warranty or guaranty any fitness for a particular purpose. In no event shall I be liable to any party for direct, indirect, special, incidental, or consequential damages, including lost profits, arising out of the use of this tutorial, even if I has been advised of the possibility of such damage.

Random Posts

• December 10, 2008 -- What is Thread Synchronization (1)
• September 17, 2008 -- Mapping Files in Hibernate (0)
• August 24, 2008 -- Define Session Bean and Entity Bean (0)
• April 6, 2009 -- Exception Handling and their uses (2)
• October 16, 2008 -- Dynamic and Static Web Page (0)

Create a new file named ?hibernate.cfg.xml? in your root directory if it is not already created.

Insert the following in your hibernate file. Do not forget to change the username and the password to suit your database configuration.

PostgreSQL Version:

Random Posts

• October 5, 2008 -- Difference between errortag and message tag (0)
• November 6, 2008 -- Load Factor (0)
• September 20, 2008 -- Define Session Hijacking (0)
• October 27, 2008 -- Final Variables and Methods (0)
• August 24, 2008 -- Software Architecture of EJB (0)

Create a new class named ?Honey? in the package ?de.laliluna.example?. Add three fields id, name and taste and generate (Context menu -> Source -> Generate Getter and Setter) or type the getters and setters for the fields. Then create an empty constructor.

package de.laliluna.example;

/**
* @return Returns the id.
*/
public Integer getId() {
return id;
}
/**
* @param id The id to set.
*/
public void setId(Integer id) {
this.id = id;
}
/**
* @return Returns the name.
*/
public String getName() {
return name;
}
/**
* @param name The name to set.
*/
public void setName(String name) {
this.name = name;
}
/**
* @return Returns the taste.
*/
public String getTaste() {
return taste;
}
/**
* @param taste The taste to set.
*/
public void setTaste(String taste) {
this.taste = taste;
}
}

Random Posts

• July 24, 2008 -- JSF Important Questions (2)
• August 24, 2008 -- Define Local Interfaces (0)
• August 15, 2008 -- Life Cycle of Thread (0)
• June 17, 2008 -- AWT Interview Questions (0)
• August 10, 2008 -- Example programs of lifecycle of servlets (0)

Using PostgreSql use the following script to create your table:

CREATE TABLE “public”.”honey” (
id SERIAL,
name text,
taste text,
PRIMARY KEY(id)
);

Using MySql use the following script:

CREATE TABLE `honey` (
`id` int(11) NOT NULL auto_increment,
`name` varchar(250) default NULL,
`taste` varchar(250) default NULL,
PRIMARY KEY (`id`)
) ENGINE=MyISAM CHARSET=latin1

MySQL Version:

Random Posts

• June 8, 2008 -- Applet Interview Question (4)
• August 24, 2008 -- Define business logic and business method (0)
• May 22, 2008 -- Core Java Interview Questions (1)
• February 15, 2009 -- Providing current date and time using Stateless session bean (0)
• September 22, 2008 -- Difference between Print() and Println() Methods in Java (0)

Even Hibernate needs a database driver to access a database. Open the project properties, click on ?Java Build Path?, select ?Add External Jars? and add your database driver. When you use PostgreSQL you can find your database driver on http://jdbc.postgresql.org when you use MySQL have a look here http://www.mysql.de/products/connector/j
Create database and tables.

Random Posts

• July 7, 2008 -- JSP Standard Questions (0)
• September 22, 2008 -- What is Default Package in Java (0)
• July 15, 2008 -- Springs Interview Questions (0)
• July 7, 2008 -- JSP Interview Questions (1)
• September 22, 2008 -- What are Command Line Arguments in Java (0)

As you can see above we added the log4j library. This library does like a configuration file in the source directory or it welcomes you with the following error.

log4j:WARN No appenders could be found for logger (TestClient).
log4j:WARN Please initialize the log4j system properly.

Create a file named log4j.properties in the root directory and insert the following:

### direct log messages to stdout ###
log4j.appender.stdout=org.apache.log4j.ConsoleAppender
log4j.appender.stdout.Target=System.out
log4j.appender.stdout.layout=org.apache.log4j.PatternLayout
log4j.appender.stdout.layout.ConversionPattern=%d{ABSOLUTE} %5p %c{1}:%L – %m%n

### set log levels – for more verbose logging change ‘info’ to ‘debug’ ###

log4j.rootLogger=debug, stdout

log4j.logger.org.hibernate=info
#log4j.logger.org.hibernate=debug

### log HQL query parser activity
#log4j.logger.org.hibernate.hql.ast.AST=debug

### log just the SQL
log4j.logger.org.hibernate.SQL=debug

### log JDBC bind parameters ###
log4j.logger.org.hibernate.type=info

### log schema export/update ###
log4j.logger.org.hibernate.tool.hbm2ddl=info

### log HQL parse trees
#log4j.logger.org.hibernate.hql=debug

### log cache activity ###
log4j.logger.org.hibernate.cache=info

### log transaction activity
#log4j.logger.org.hibernate.transaction=debug

### log JDBC resource acquisition
#log4j.logger.org.hibernate.jdbc=debug

### enable the following line if you want to track down connection ###
### leakages when using DriverManagerConnectionProvider ###
#log4j.logger.org.hibernate.connection.DriverManagerConnectionProvider=trace

Random Posts

• August 24, 2008 -- What are synchronized methods and synchronized statements? (0)
• December 16, 2008 -- Define Array in Java (1)
• August 9, 2008 -- Some important methos in Applets (0)
• June 23, 2008 -- Java Basic Questions (1)
• August 24, 2008 -- Define Local Interfaces (0)

A session factory is important for Hibernate. It implements a design pattern, that ensures that only one instance of the session is used per thread. You should only get your Hibernate session from this factory.

Create a class named HibernateSessionFactory in the package de.laliluna.hibernate and add the source code below.

/**

*

* @author

* created Feb 22, 2006

*/

package de.laliluna.hibernate;

import javax.naming.InitialContext;

import org.apache.log4j.Logger;

import org.hibernate.HibernateException;

import org.hibernate.Session;

import org.hibernate.SessionFactory;

import org.hibernate.cfg.Configuration;

import org.hibernate.cfg.Environment;

/**

* @author says This class guaranties that only one single SessionFactory

*         is instanciated and that the configuration is done thread safe as

*         singleton. Actually it only wraps the Hibernate SessionFactory.

*         When a JNDI name is configured the session is bound to to JNDI,

*         else it is only saved locally.

*         You are free to use any kind of JTA or Thread transactionFactories.

*/

public class InitSessionFactory {

/**

* Default constructor.

*/

private InitSessionFactory() {

}

/**

* Location of hibernate.cfg.xml file. NOTICE: Location should be on the

* classpath as Hibernate uses #resourceAsStream style lookup for its

* configuration file. That is place the config file in a Java package – the

* default location is the default Java package.<br>

* <br>

* Examples: <br>

* <code>CONFIG_FILE_LOCATION = “/hibernate.conf.xml”.

* CONFIG_FILE_LOCATION = “/com/foo/bar/myhiberstuff.conf.xml”.</code>

*/

private static String CONFIG_FILE_LOCATION = “/hibernate.cfg.xml”;

/** The single instance of hibernate configuration */

private static final Configuration cfg = new Configuration();

/** The single instance of hibernate SessionFactory */

private static org.hibernate.SessionFactory sessionFactory;

/**

* initialises the configuration if not yet done and returns the current

* instance

*

* @return

*/

public static SessionFactory getInstance() {

if (sessionFactory == null)

initSessionFactory();

return sessionFactory;

}

/**

* Returns the ThreadLocal Session instance. Lazy initialize the

* <code>SessionFactory</code> if needed.

*

* @return Session

* @throws HibernateException

*/

public Session openSession() {

return sessionFactory.getCurrentSession();

}

/**

* The behaviour of this method depends on the session context you have

* configured. This factory is intended to be used with a hibernate.cfg.xml

* including the following property <property

* name=”current_session_context_class”>thread</property> This would return

* the current open session or if this does not exist, will create a new

* session

*

* @return

*/

public Session getCurrentSession() {

return sessionFactory.getCurrentSession();

}

/**

* initializes the sessionfactory in a safe way even if more than one thread

* tries to build a sessionFactory

*/

private static synchronized void initSessionFactory() {

/*

* [laliluna] check again for null because sessionFactory may have been

* initialized between the last check and now

*

*/

Logger log = Logger.getLogger(InitSessionFactory.class);

if (sessionFactory == null) {

try {

cfg.configure(CONFIG_FILE_LOCATION);

String sessionFactoryJndiName = cfg

.getProperty(Environment.SESSION_FACTORY_NAME);

if (sessionFactoryJndiName != null) {

cfg.buildSessionFactory();

log.debug(“get a jndi session factory”);

sessionFactory = (SessionFactory) (new InitialContext())

.lookup(sessionFactoryJndiName);

} else{

log.debug(“classic factory”);

sessionFactory = cfg.buildSessionFactory();

}

} catch (Exception e) {

System.err

.println(“%%%% Error Creating HibernateSessionFactory %%%%”);

e.printStackTrace();

throw new HibernateException(

“Could not initialize the Hibernate configuration”);

}

}

}

public static void close(){

if (sessionFactory != null)

sessionFactory.close();

sessionFactory = null;

}

}

Random Posts

• September 22, 2008 -- What is JRE ? Explain (1)
• July 15, 2008 -- Springs Interview Questions (7)
• July 7, 2008 -- EJB INTERVIEW QUESTIONS (1)
• September 2, 2008 -- Define Session (0)
• August 15, 2008 -- What is Thread, How to Use Threads? (0)

Hibernate is a solution for object relational mapping and a persistence management solution or persistent layer. This is probably not understandable for anybody learning Hibernate.

What you can imagine is probably that you have your application with some functions (business logic) and you want to save data in a database. When you use Java all the business logic normally works with objects of different class types. Your database tables are not at all objects.

Hibernate provides a solution to map database tables to a class. It copies one row of the database data to a class. In the other direction it supports to save objects to the database. In this process the object is transformed to one or more tables.

Saving data to a storage is called persistence. And the copying of tables to objects and vice versa is called object relational mapping.

Create a Java Project

Using Eclipse press the keys Ctrl+n (Strg+n) to create a new project. Select a Java project. We will call it FirstHibernateExample.

Prepare the project for Hibernate using MyEclipse

When you are using MyEclipse, right click on your project in the package explorer and choose Add Hibernate capabilities.

–>Select the Package Explorer in the Left Side of  the EclipseIDE and in that
–>Select FirstHibernateProgram
|
|___Select MyEclipse
|
|__Add Hibernate Capabilities

After that

Continue the wizard and create a new hibernate.cfg.xml in the src directory.

In the last step you can create a Hibernate SessionFactory. I prefer to create my own. You can find it below.
Prepare the project for Hibernate for anybody

When you do not use MyEclipse download Hibernate from the website http://www.hibernate.org/

Extract the file. Hibernate comes with a long list of libraries. You do not need all of them. There is a REAME file in the lib directory explaining what is required. Open your project properties, select ?Java Build Path?, click on ?Add External Jars? and add the libaries shown below to your project path.
—>xml-apis.jar
—>asm.jar
—>asm-attrs.jar
—>c3p0-0.9.0.jar
—>cglib-2.1.3.jar
—>commons-logging-1.0.4.jar
—>concurrent-1.3.2.jar
—>dom4j-1.6.1.jar
—>ehcache-1.1.jar
—>hibernate3.jar
—>jacc-1_0-fr.jar
—>jaxen-1.1-beta-7.jar
—>jdbc2_0-stdext.jar
—>jta.jar
—>log4j-1.2.11.jar
—>antlr-2.7.6rc1.jar

Random Posts

• October 5, 2008 -- Difference between errortag and message tag (0)
• October 5, 2008 -- Explain executeQuery Method (0)
• September 20, 2008 -- Hibernate Basics (0)
• August 24, 2008 -- Define ServletOutputStream object in Jsp (0)
• July 21, 2010 -- Explain Briefly about Serialization (0)

The Eclipse class loading mechanism and problems with integrating with third party libraries has been the subject of much discussion, and previous solutions have involved using Thread.currentThread().setContextClassLoader(this.getClass().getClassLoader()) in the appropriate places, which are not obvious to me nor to most naive users. However, Eclipse 3.1 has a “buddy loading” facility that solves this problem nearly trivially. Credit for telling me the solution belongs to snpesnpe, but is presented here to help with this problem.

The issue is that the Hibernate libraries cannot know, in advance, where a user will install relevant code, particularly the hibernate.cfg.xml and related hbm.xml files. Placing the hibernate.cfg.xml file at the root of the classpath is the usual solution, but since the Hibernate libraries don’t even know that your plugin exists, there is no way for them to know what classpath to explore for this file. Enter the buddy system.

In the MANIFEST.MF file of the Hibernate plugin (which NEEDS the buddy loading), such as org.hibernate.eclipse, add a line:

Eclipse-BuddyPolicy:registered

and in the MANIFEST.MF file of your plugin project or RCP project, add the line:

Eclipse-RegisterBuddy:org.hibernate.eclipse

Important to notice the syntax – our plugin is willing to be seen by the hibernate library, using Eclipse-RegisterBuddy, and Hibernate is registering itself with Eclipse-BuddyPolicy. While this is stated clearly in the Eclipse Help (in retrospect!) it is critical to get the syntax precisely correct.

Finally, if you are using HibernateUtil as your main entry point into Hibernate, then in your plugin start method add the line:

Class.forName(“myPlugin.HibernateUtil”); //full class name should go here

This works – assumption is that hibernate.cfg.xml is in the src directory of your plugin and this is in the classpath.

Random Posts

• November 8, 2008 -- Which of the Collection Classes will not allow duplicate values (1)
• September 23, 2008 -- Naming Conventions in Java (0)
• July 7, 2008 -- Servlet Interview Questions (1)
• October 4, 2008 -- How application creates a connection (0)
• October 3, 2008 -- Jsp Scriplets and Templets (0)