Hibernate tutorial with HSQLDB

This tutorial is basically an extension to the "simple" Java and JDBC tutorials. Hibernate is an ORM (Object to Relational Mapping) tool.

Step 1:  First step is to bring in the relevant Hibernate framework jar files like hibernate-xxx.jar, hibernate-annotations-xxxx.jar, and other dependent jar files that are transitively brought in from hibernate framework's pom.xml file. Here is the pom.xml file for simple Java project extended for hibernate.

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
<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>com.mytutorial</groupId>
 <artifactId>simple</artifactId>
 <version>1.0-SNAPSHOT</version>
 <packaging>jar</packaging>
 
 <name>simple</name>
 <url>http://maven.apache.org</url>
 
 <properties>
  <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
 </properties>
 
 <dependencies>
  <dependency>
   <groupId>junit</groupId>
   <artifactId>junit</artifactId>
   <version>3.8.1</version>
   <scope>test</scope>
  </dependency>
 
        <!-- jar that contains the HSQLDB driver class  -->
  <dependency>
   <groupId>org.hsqldb</groupId>
   <artifactId>hsqldb</artifactId>
   <version>2.2.8</version>
  </dependency>
 
        <!--  GA means General Availability -->
        <!--  Hibernate framework JARS-->
  <dependency>
   <groupId>org.hibernate</groupId>
   <artifactId>hibernate</artifactId>
   <version>3.2.6.GA</version>
  </dependency>
 
  <dependency>
   <groupId>org.hibernate</groupId>
   <artifactId>hibernate-annotations</artifactId>
   <version>3.3.1.GA</version>
  </dependency>
 
 
 </dependencies>
</project>
Now, if you select the "simple" project and then right-mouse-click and select "Maven --> Update Dependencies".



Step 2: Hibernate uses the hibernate.cfg.xml file to configure the session factory with the database connectivity details and define your domain classes that map to to the relational database tables. This file needs to be defined in the src/main/resources folder and be in the classpath.

Create a new folder named "resources" under the "src/main" folder and then right-mouse-click on "resources" folder and then select "Build Path --> Use as Source Folder".



The contents of the hibernate.cfg.xml will include configuring the session factory to connect to the HSQLDB that we set up in the "SQL tutorial with HSQDB" tutorial.

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
<?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>
        <!-- Database connection settings -->
        <property name="connection.driver_class">org.hsqldb.jdbcDriver</property>
        <property name="connection.url">jdbc:hsqldb:hsql://localhost/mytestdb</property>
        <property name="connection.username">sa</property>
        <property name="connection.password"></property>
          
        <!-- JDBC connection pool (use the built-in) -->
        <property name="connection.pool_size">1</property>
          
        <!-- SQL dialect -->
        <property name="dialect">org.hibernate.dialect.HSQLDialect</property>
  
        <!-- Enable Hibernate's automatic session context management -->
        <property name="current_session_context_class">thread</property>
  
        <!-- Disable the second-level cache  -->
        <property name="cache.provider_class">org.hibernate.cache.NoCacheProvider</property>
          
        <!-- Echo all executed SQL to stdout useful for debugging if set to true-->
        <property name="show_sql">false</property>
          
        <property name="hbm2ddl.auto">validate</property>
   
        <mapping class="com.mytutorial.domain.Course"/>
          
           
    </session-factory>
</hibernate-configuration>

Step 3: The next step is to define the HibernateUtil class that bootstraps the hibernate by loading theSessionFactory via  the hibernate.cfg.xml.

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
import org.hibernate.SessionFactory;
import org.hibernate.cfg.AnnotationConfiguration;
 
public class HibernateUtil {
  
  
 private static final SessionFactory sessionFactory = buildSessionFactory();
    
    private static SessionFactory buildSessionFactory() {
        try {
            // Create the SessionFactory from hibernate.cfg.xml file
         return new AnnotationConfiguration().configure().buildSessionFactory();
        } catch (Throwable ex) {
            ex.printStackTrace();
            throw new ExceptionInInitializerError(ex);
        }
         
    }
   
    public static SessionFactory getSessionFactory() {
        return sessionFactory;
    }
 
}
Step 4: Next step is to define the domain Course class that maps to the "Course" database  table that was created in the "SQL  with HSQLDB" tutorial. Annotations are used for the object to relational mapping

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
package com.mytutorial.domain;
 
import javax.persistence.Column;
import javax.persistence.Entity;
import javax.persistence.GeneratedValue;
import javax.persistence.Id;
import javax.persistence.Table;
 
 
@Entity
@Table(name="Course")
public class Course {
  
 @Id
 @GeneratedValue
 @Column(name="course_id")
 private Integer id;
  
 @Column(name="name")
 private String name;
  
 @Column(name="course")
 private String course;
  
 public Course() {}
 
 public Integer getId() {
  return id;
 }
 
 public void setId(Integer id) {
  this.id = id;
 }
 
 public String getName() {
  return name;
 }
 
 public void setName(String name) {
  this.name = name;
 }
 
 public String getCourse() {
  return course;
 }
 
 public void setCourse(String course) {
  this.course = course;
 }
}
Step 5: Define the data access layer interface and the implementation class. The CourseDao is the interface andCourseDaoImpl is the implementation class that retrieves data from the database.

Define the interface.

?
1
2
3
4
5
6
7
package com.mytutorial.dao;
 
public interface CourseDao {
  
 abstract void readAllCourses();
 
}

Define the implementation class.

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
package com.mytutorial.dao;
 
import java.util.List;
 
import org.hibernate.Query;
import org.hibernate.Session;
import org.hibernate.SessionFactory;
 
import com.mytutorial.HibernateUtil;
import com.mytutorial.domain.Course;
 
public class CourseDaoImpl implements CourseDao {
 
 public void readAllCourses() {
  SessionFactory sf = HibernateUtil.getSessionFactory();
  Session session = sf.openSession();
  Query q = session.createQuery("from Course");
  @SuppressWarnings("unchecked")
  List<Course> courses = q.list();
   
  for (Course course : courses) {
   System.out.println(course.getName() + " - " + course.getCourse());
  }
 
 }
 
}

Step 6: This step is to define a class with a main method that makes use of the CourseDao.

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
package com.mytutorial;
 
import com.mytutorial.dao.CourseDaoImpl;
import com.mytutorial.dao.CourseDao;
 
public class HibernateTutorial {
  
  
 public static void main(String[] args) {
  CourseDao cDao = new CourseDaoImpl();
  cDao.readAllCourses();
 }
 
}
You should now have the required Java files defined.



Step 7: Before you can run the HibernateTutorial.java, you need to make sure that the HSQL database is running with the Course database as demonstrated in the "SQL tutorial with HSQLDB".

?
1
c:\Tools\hsqldb-2.2.9\hsqldb>java -cp ./lib/hsqldb.jar org.hsqldb.server.Server
?
1
2
3
4
5
6
7
8
9
10
11
12
[Server@79616c7]: [Thread[main,5,main]]: checkRunning(false) entered
[Server@79616c7]: [Thread[main,5,main]]: checkRunning(false) exited
[Server@79616c7]: Startup sequence initiated from main() method
[Server@79616c7]: Loaded properties from [C:\Tools\hsqldb-2.2.9\hsqldb\server.properties]
[Server@79616c7]: Initiating startup sequence...
[Server@79616c7]: Server socket opened successfully in 198 ms.
[Server@79616c7]: Database [index=0, id=0, db=file:mydatabases/tutorialdb, alias=mytestdb] opened sucessfully in 1073 ms
.
[Server@79616c7]: Startup sequence completed in 1277 ms.
[Server@79616c7]: 2012-10-09 11:35:07.347 HSQLDB server 2.2.9 is online on port 9001
[Server@79616c7]: To close normally, connect and execute SHUTDOWN SQL
[Server@79616c7]: From command line, use [Ctrl]+[C] to abort abruptly

Step 8: The final step is to right-mouse-click on HibernateTutorial.java and then select "Run As --> Java Application".

You should get an output like:

?
1
2
3
4
5
6
Sam - Java
peter - J2EE
paul - JSF
jonathan - Hibernate
james - Spring
Lewis - JDBC
You should also see, hibernate logs as shown below

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
INFO: configuring from resource: /hibernate.cfg.xml
...
INFO: autocommit mode: false
09/10/2012 11:37:30 AM org.hibernate.connection.DriverManagerConnectionProvider configure
INFO: using driver: org.hsqldb.jdbcDriver at URL: jdbc:hsqldb:hsql://localhost/mytestdb
09/10/2012 11:37:30 AM org.hibernate.connection.DriverManagerConnectionProvider configure
INFO: connection properties: {user=sa, password=****}
....
INFO: Using dialect: org.hibernate.dialect.HSQLDialect
09/10/2012 11:37:31 AM org.hibernate.transaction.TransactionFactoryFactory buildTransactionFactory
INFO: Using default transaction strategy (direct JDBC transactions)
....
INFO: fetching database metadata
09/10/2012 11:37:31 AM org.hibernate.tool.hbm2ddl.TableMetadata <init>
INFO: table found: PUBLIC.PUBLIC.COURSE
09/10/2012 11:37:31 AM org.hibernate.tool.hbm2ddl.TableMetadata <init>
INFO: columns: [course, name, course_id]

In the Spring 3.0 tutorial, I will extend this tutorial to show how we can use Spring to inject CourseDao intoHibernateTutorial.

Comments

Post a Comment

Popular posts from this blog

SQL Tutorial with HSQLDB

Image
This assumes that you have Java setup on your machine as illustrated in the "simple" Java tutorial. Q.  Why use  HSQLB ? A.  It can be useful in a number of ways. Easy to get started and if you are a beginner, you can acquire or sharpen your SQL and database skills. It is open-sourced, hence you can use it for your self-taught projects as a database. An alternative to MySQL  database. It is used in commercial projects to write unit tests for your data access layer. Apache Derby database is another alternative. It is used in the ensuing tutorials on  JDBC  and  Hibernate  as the database. Step 1 : Download the latest version of HSQLB from   http://hsqldb.org/ . I downloaded  hsqldb-2.2.9.zip  at the time of writing and extracted zip files. The HSQLDB is unpacked under  c:\Tools  as as hown below. Step 2 : You can start the server with the following command. ? 1 c:\Tools\hsqldb-2.2.9>java -cp ./h...
Read more

Java Interview Questions & Answers: user defined key class

Image
This is one of my favorite core Java interview questions as not knowing this can cause subtle and intermittent issues in Java. The issues that arise from not understanding equals( ) and hashCode( ) contract can be hard to debug.    Q.  When providing a user defined key class for storing objects in a  Map (e.g. HashMap) , what methods do you have to provide or override (i.e. method overriding)? A.  You should override the  equals( ... )  and  hashCode( .. )  methods from the  Object  class. The default implementation of the  equals( ... )  and  hashCode( ... )  methods are inherited from the  java.lang.Object  class  uses an object instance’s memory location (e.g. MyObject@6c60f2ea). This can cause problems when two instances of car objects have the same color but the inherited  equals( .. )  will return false because it uses the memory location as oppose to the color, which is different ...
Read more