Java Interview Questions

Create a database with MySql or PostgreSQL or anything you like. Call it ?firsthibernate?.

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:

Add the database driver

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.

Configuring Log4J

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

Create a SessionFactory

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;

}

}