Hibernate 4 : Using In-memory Database

Friends, many times in organizations, where we work, do not allow access to even necessary developer tools such as local database installation. This could be due to quite valid reasons as well (and sometimes it seems just absurd). In this tutorial, I am giving an example of testing your hibernate code without any database installation.

In-memory Database Implementation Background

For this example, I am using HSQLDB Database for creating and accessing in-memory database through our hibernate code. If you are using plain simple JDBC then you can directly use below statement for accessing the in memory database.

Connection c = DriverManager.getConnection("jdbc:hsqldb:mem:howtodoinjava", "sa", "");

The main thing to notice here is “mem:howtodoinjava“. Here mem indicates that use the in-memory database, in stead of any physical database. Please note that though you will have to provide the default username “sa” and a blank password to get connected to database, without which you will be getting below exception.

Caused by: java.sql.SQLException: Access is denied
	at org.hsqldb.jdbc.Util.sqlException(Unknown Source)
	at org.hsqldb.jdbc.jdbcConnection.<init>(Unknown Source)
	at org.hsqldb.jdbcDriver.getConnection(Unknown Source)
	at org.hsqldb.jdbcDriver.connect(Unknown Source)
	at org.hibernate.engine.jdbc.connections.internal.DriverConnectionCreator.makeConnection(DriverConnectionCreator.java:55)
	... 15 more

In-memory Database Implementation Source code

Now go though below sourcecode files for the example of in memory database access using hibernate.

hibernate.cfg.xml

<?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">
<hibernate-configuration>
    <session-factory>
       	<property name="hibernate.archive.autodetection">class,hbm</property>  
       	<property name="hibernate.dialect">org.hibernate.dialect.HSQLDialect</property>  
       	<property name="hibernate.show_sql">true</property>    
       	<property name="hibernate.connection.driver_class">org.hsqldb.jdbcDriver</property>    
       	<property name="hibernate.connection.username">sa</property>    
       	<property name="hibernate.connection.password">1</property>    
       	<property name="hibernate.connection.url">jdbc:hsqldb:mem:howtodoinjava</property>    
       	<property name="hibernate.hbm2ddl.auto">create</property>    
       	<mapping class="com.howtodoinjava.demo.entity.EmployeeEntity"></mapping>
    </session-factory>
</hibernate-configuration>

HibernateUtil.java

package com.howtodoinjava.demo.util;

import org.hibernate.SessionFactory;
import org.hibernate.boot.registry.StandardServiceRegistryBuilder;
import org.hibernate.cfg.Configuration;
import org.hibernate.service.ServiceRegistry;

public class HibernateUtil
{
   private static SessionFactory sessionFactory = buildSessionFactory();

   private static SessionFactory buildSessionFactory()
   {
      try
      {
         if (sessionFactory == null)
         {
            Configuration configuration = new Configuration().configure(HibernateUtil.class.getResource("/hibernate.cfg.xml"));
            StandardServiceRegistryBuilder serviceRegistryBuilder = new StandardServiceRegistryBuilder();
            serviceRegistryBuilder.applySettings(configuration.getProperties());
            ServiceRegistry serviceRegistry = serviceRegistryBuilder.build();
            sessionFactory = configuration.buildSessionFactory(serviceRegistry);
         }
         return sessionFactory;
      } catch (Throwable ex)
      {
         System.err.println("Initial SessionFactory creation failed." + ex);
         throw new ExceptionInInitializerError(ex);
      }
   }

   public static SessionFactory getSessionFactory()
   {
      return sessionFactory;
   }

   public static void shutdown()
   {
      getSessionFactory().close();
   }
}

EmployeeEntity.java

package com.howtodoinjava.demo.entity;

import java.io.Serializable;

import javax.persistence.Column;
import javax.persistence.Entity;
import javax.persistence.Id;
import javax.persistence.Table;
import javax.persistence.UniqueConstraint;

@Entity
@org.hibernate.annotations.Entity(dynamicUpdate = true)
@Table(name = "Employee", uniqueConstraints = {@UniqueConstraint(columnNames = "ID"), @UniqueConstraint(columnNames = "EMAIL")})
public class EmployeeEntity implements Serializable
{
   private static final long serialVersionUID = -1798070786993154676L;
   @Id
   @Column(name = "ID", unique = true, nullable = false)
   private Integer           employeeId;
   @Column(name = "EMAIL", unique = true, nullable = false, length = 100)
   private String            email;
   @Column(name = "FIRST_NAME", unique = false, nullable = false, length = 100)
   private String            firstName;
   @Column(name = "LAST_NAME", unique = false, nullable = false, length = 100)
   private String            lastName;

   public Integer getEmployeeId()
   {
      return employeeId;
   }

   public void setEmployeeId(Integer employeeId)
   {
      this.employeeId = employeeId;
   }

   public String getEmail()
   {
      return email;
   }

   public void setEmail(String email)
   {
      this.email = email;
   }

   public String getFirstName()
   {
      return firstName;
   }

   public void setFirstName(String firstName)
   {
      this.firstName = firstName;
   }

   public String getLastName()
   {
      return lastName;
   }

   public void setLastName(String lastName)
   {
      this.lastName = lastName;
   }
}

Now test above code.

TestHibernate.java

package com.howtodoinjava.test;

import org.hibernate.Session;

import com.howtodoinjava.demo.entity.EmployeeEntity;
import com.howtodoinjava.demo.util.HibernateUtil;

public class TestHibernate
{
   public static void main(String[] args)
   {
      Session session = HibernateUtil.getSessionFactory().openSession();
      session.beginTransaction();
      // Add new Employee object
      EmployeeEntity emp = new EmployeeEntity();
      emp.setEmployeeId(1);
      emp.setEmail("demo-user@mail.com");
      emp.setFirstName("demo");
      emp.setLastName("user");
      session.save(emp);
      session.getTransaction().commit();
      HibernateUtil.shutdown();
   }
}

Output:

Hibernate: drop table Employee if exists
Hibernate: create table Employee (ID integer not null, EMAIL varchar(100) not null, FIRST_NAME varchar(100) not null, LAST_NAME varchar(100) not null, primary key (ID))
Hibernate: alter table Employee add constraint UK_ardf0f11mfa6tujs3hflthwdv  unique (EMAIL)
Hibernate: insert into Employee (EMAIL, FIRST_NAME, LAST_NAME, ID) values (?, ?, ?, ?)

Project Structure and Dependencies

Below is the project structure for this example.

Please go through the pom.xml file if you need any help in setting up the maven dependencies for this example.

pom.xml

<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
  <modelVersion>4.0.0</modelVersion>
  <groupId>ABC</groupId>
  <artifactId>ABC</artifactId>
  <version>0.0.1-SNAPSHOT</version>
  <packaging>jar</packaging>
  <build>
    <sourceDirectory>src</sourceDirectory>
    <plugins>
      <plugin>
        <artifactId>maven-compiler-plugin</artifactId>
        <version>2.3.2</version>
        <configuration>
          <source>1.7</source>
          <target>1.7</target>
        </configuration>
      </plugin>
    </plugins>
  </build>
  <dependencies>
  	<dependency>
		<groupId>org.hibernate</groupId>
		<artifactId>hibernate-core</artifactId>
		<version>4.3.6.Final</version>
	</dependency>
	<!-- for JPA, use hibernate-entitymanager instead of hibernate-core -->
	<dependency>
	    <groupId>org.hibernate</groupId>
	    <artifactId>hibernate-entitymanager</artifactId>
	    <version>4.3.6.Final</version>
	</dependency>
	<!-- optional -->
	<dependency>
	    <groupId>org.hibernate</groupId>
	    <artifactId>hibernate-osgi</artifactId>
	    <version>4.3.6.Final</version>
	</dependency>
	<dependency>
	    <groupId>org.hibernate</groupId>
	    <artifactId>hibernate-envers</artifactId>
	    <version>4.3.6.Final</version>
	</dependency>
	<dependency>
	    <groupId>org.hibernate</groupId>
	    <artifactId>hibernate-c3p0</artifactId>
	    <version>4.3.6.Final</version>
	</dependency>
	<dependency>
	    <groupId>org.hibernate</groupId>
	    <artifactId>hibernate-proxool</artifactId>
	    <version>4.3.6.Final</version>
	</dependency>
	<dependency>
	    <groupId>org.hibernate</groupId>
	    <artifactId>hibernate-infinispan</artifactId>
	    <version>4.3.6.Final</version>
	</dependency>
	<dependency>
	    <groupId>org.hibernate</groupId>
	    <artifactId>hibernate-ehcache</artifactId>
	    <version>4.3.6.Final</version>
	</dependency>
  	<dependency>
	    <groupId>antlr</groupId>
	    <artifactId>antlr</artifactId>
	    <version>2.7.6</version>
	</dependency>
	<dependency>
	    <groupId>commons-collections</groupId>
	    <artifactId>commons-collections</artifactId>
	    <version>3.1</version>
	</dependency>
	<dependency>
	    <groupId>dom4j</groupId>
	    <artifactId>dom4j</artifactId>
	    <version>1.6.1</version>
	</dependency>
	<dependency>
	    <groupId>javassist</groupId>
	    <artifactId>javassist</artifactId>
	    <version>3.4.GA</version>
	</dependency>
	<dependency>
	    <groupId>javax.transaction</groupId>
	    <artifactId>jta</artifactId>
	    <version>1.1</version>
	</dependency>
	<dependency>
	    <groupId>org.slf4j</groupId>
	    <artifactId>slf4j-api</artifactId>
	    <version>1.5.6</version>
	</dependency>
	<dependency>
	    <groupId>org.slf4j</groupId>
	    <artifactId>slf4j-log4j12</artifactId>
	    <version>1.5.6</version>
	</dependency>
	<dependency>  
    	<groupId>hsqldb</groupId>  
	    <artifactId>hsqldb</artifactId>  
	    <version>1.8.0.10</version>  
	</dependency>
  </dependencies>
</project>

That’s all for this quick tutorial about Using In-memory Database With Hibernate.

Happy Learning !!