Table of Contents

• Prerequisites
• Creating a database table
• Creating POJO class
• Create hibernate configuration file
• Writing and executing code

Hibernate is an ORM framework that helps in accessing database tables from Java code. It is an object-oriented way of accessing database tables and it eliminates boilerplate code that is required with JDBC.

In this article, I will be explaining how you can create a basic Hibernate application that saves a record into a database table via Hibernate.

Prerequisites

Before writing code, you need to ensure that you have installed and configured the database that you will be connecting to from your Hibernate code. I will be using a MySQL database. You also need to ensure that you have the database driver JAR files as well as Hibernate JAR files. If you are using a MySQL database and Maven as the dependency management tool, you can add the following dependencies:

  <dependencies>
  	<dependency>
  		<groupId>org.hibernate</groupId>
  		<artifactId>hibernate-core</artifactId>
  		<version>5.3.4.Final</version>
  	</dependency>
  	<dependency>
  		<groupId>mysql</groupId>
  		<artifactId>mysql-connector-java</artifactId>
  		<version>8.0.12</version>
  	</dependency>
  </dependencies>

Creating a database table

Once the database is configured, you will need to create a database table which you will access via Hibernate. I will be using a table called STUDENT. You can create this table by running the following SQL:

create table STUDENT (
   id INT NOT NULL auto_increment,
   full_name VARCHAR(50),
   marks     DOUBLE ,
   PRIMARY KEY (id)
);

So, this is a Student table that capture student information. It has columns corresponding to the name of the Student and the marks obtained by the student. It also has an id column which is the primary key column.

Creating POJO class

Hibernate requires you to create a simple POJO class that has fields corresponding to the columns in the database table. The following code demonstrates a Student class corresponding to the Student table:

@Entity
@Table(name = "Student")
public class Student {

	@Id
	@GeneratedValue(strategy=GenerationType.IDENTITY)
	int id;
	
@Column(name="full_name")
String name;
	
	double marks;
}

The Student class has some Hibernate annotations which tell Hibernate how to map this class to the database table. These are as follows:

Create hibernate configuration file

Hibernate requires you to provide a configuration file that contains all the database related information like the database username, password etc. Hibernate uses this information to connect to the database.  

The following is a basic Hibernate configuration file:

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE hibernate-configuration PUBLIC
		"-//Hibernate/Hibernate Configuration DTD 3.0//EN"
		"http://hibernate.org/dtd/hibernate-configuration-3.0.dtd">
<hibernate-configuration>
	<session-factory>
<property name="hibernate.dialect">org.hibernate.dialect.MySQL5Dialect</property> 
<property name="hibernate.connection.driver_class">com.mysql.jdbc.Driver</property>
		<property name="hibernate.connection.url">URL</property>
		<property name="hibernate.connection.username">username</property>
		<property name="hibernate.connection.password">password</property>
		<mapping class="demo.Student" />
	</session-factory>
</hibernate-configuration>

In addition, there are other several other properties that can be specified in the configuration file.

Writing and executing code

After creating the POJO class and the Hibernate configuration file, the next step is to write the code that connects to the database as shown below:

public class Main {
	public static void main(String args[]) {
SessionFactory sessionFactory = new Configuration().configure().buildSessionFactory();
		Session session = sessionFactory.openSession();
		Transaction tx = session.beginTransaction();
		Student student = new Student("John Doe",87.5);
		session.save(student);
		tx.commit();
		session.close();
		sessionFactory.close();
	}

} 

This code creates a new Student object and saves it to the database. Let us take a closer look at the main parts of this code:

When this code is executed, a database record will be inserted into the Student table.

The post Create Basic Hibernate Program appeared first on Automation Dojos.

Table of Contents

• Introduction
  • How JDBC works
  • Problems with JDBC
  • What is Hibernate
  • Why Hibernate
  • How Hibernate works
• Hibernate Integration with JPA
• Conclusion

Introduction

Hibernate is a framework which allows you to access database tables from Java code. Before Hibernate came into existence, JDBC was widely used. JDBC is an API to access a relational database from a java program. JDBC basically allows you to execute SQL statements from Java code, so any SQL statement which you can run on a database directly, you can run it from your Java code via JDBC.

How JDBC works

JDBC requires writing code for connecting to the database, executing an SQL query and obtaining the results. The following code demonstrates this:

Class.forName("com.mysql.jdbc.Driver"); //Register JDBC Driver
Connection conn = DriverManager.getConnection(url, username, password); //Open a //connection
Statement stmt = conn.createStatement(); //create a statement
ResultSet rs = stmt.executeQuery("Select * from person");// Execute a query
Person person = new Person();
while(rs.next()){ //iterate through the resultset
      String name = rs.getString("name"); 
	person.setName(name);
       //more code for other fields
 }
 rs.close();
 stmt.close();
 conn.close();

This code queries a table called Person via JDBC. So, as you can see, you need to write a lot of code in order to query a table. The JDBC code needs you to register the JDBC driver, open a database connection, create a statement, execute the query, iterate through the results, map each field to the fields in an object and finally close the Resultset, Statement and Connection objects.

Problems with JDBC

This code written via JDBC is not only bulky and difficult to read, but it has several other disadvantages too. It uses SQL directly in the code. So, if you use database specific SQL syntax, it becomes tedious to migrate to a different database. Secondly, it has a lot of boilerplate code like creating connections/statements and closing them. Also, it is not object oriented and it is hard to map database tables to objects in the code. Finally, it is not extensible. For example, if you want to make a change to a database table like adding or removing a column, the code needs to be modified in order for the changes to work.

What is Hibernate

Hibernate is an ORM tool. ORM is a programming technique that allows you to map Java objects to database tables and vice versa. Hibernate is one such ORM tool available for Java. There are other ORM tools like TopLink, Spring DAO, etc.

Why Hibernate

Hibernate or any ORM tool for that matter does away with most of the boilerplate stuff that is required by JDBC.  The code that you need to write is more object oriented and directly maps the Java code with database tables.

The above code can be rewritten using Hibernate as follows:

SessionFactory sessionFactory = HibernateUtil.getSessionFactory();
Session session = sessionFactory.openSession();
Transaction tx = session.beginTransaction();
Person person = session.load(Person.class, 2);
tx.commit();
session.close();
HibernateUtil.closeSessionFactory();

So, if you look at this code, it’s much cleaner. There are no SQL statements since your objects are mapped to tables.

How Hibernate works

In order to use Hibernate in your application you need to do the following:

Hibernate uses the information in the configuration file to establish a database connection. It then uses the mapping information and maps the POJO class to the corresponding database table. When you invoke code to perform database operations, Hibernate automatically converts your code into SQL statements.  So, compared to JDBC, Hibernate provides a much cleaner and easy to use approach.

Hibernate Integration with JPA

JPA stands for Java Persistence API. Over time, just like Hibernate several ORM frameworks were developed. Each framework had its proprietary code. So, if developers wanted to switch from one framework to another, it was not possible. To address this issue, Java introduced the JPA specification. JPA was developed as a standard way to access relational tables from Java code. JPA is just a specification, it is not an implementation. So, if the proprietary frameworks implemented the JPA specification, it was possible to switch from one framework to the other.

Over time, Hibernate was made JPA compatible, that is, it was made to implement the JPA specification. So, in addition to its own proprietary methods, Hibernate also supports JPA methods. So, if your application code uses the JPA specific methods in Hibernate, then it becomes easy to replace Hibernate with some other JPA implementation.

Conclusion

Hibernate was developed to overcome the shortcomings of the JDBC framework.  Compared to JDBC, it provides a more object oriented and cleaner approach to access database tables from Java code.  In addition, Hibernate is also a JPA provider and implements the JPA specification.

The post Getting Started With Hibernate appeared first on Automation Dojos.