Java Hibernate Cookbook

The first and most basic JAR file needed is a JDBC driver. The JDBC driver is a bridge or an API between Java and the database. The JDBC driver provides us with the generic classes that will help us communicate with the database. Generally, the driver is either provided by the database provider or developed by communities; however, you have to get it yourself. This also depends on the type of the database you are using. As we will use the MySQL database for this book, we will use the Mysql-Connector.jar file.

Let's come back to the library section. Apart from JDBC, you will need the JAR files for hibernate. Perform the following steps:

If you use the Maven project, it would get rid of your headache of finding all the JAR files for hibernate and the dependent libraries. You can use the following Maven configuration for hibernate.

Using this method, Maven will download all the required JAR files related to hibernate and the dependent libraries required for hibernate.

By POJO, we mean that we will create a Java class that satisfies the following requirements:

We will now create a persistent class and name it Employee. The following table shows a representation of the Employee class:

Now the preceding class satisfies all the requirements listed before to be a persistent class.

The preceding class now contains the following:

Now, let's see how to design a POJO for tables having references between the Department and Employee tables:

The following code is the definition for the Department class in Department.java:

public class Department{
  private long id;
  private String deptName;

  //default constructor
  public void Department(){
  }

  //getters and setters
  public long getId() {
    return id;
  }

  public void setId(long id) {
    this.id = id;
  }

  public String getDeptName() {
    return deptName;
  }

  public void setDeptName(String deptName) {
    this.deptName = deptName;
  }

}

The following code is the definition for the Employee class in Employee.java:

public class Employee{
  private long id;
  private String firstName;
  private double salary;
  private Department department; // reference to Department.

  //default constructor
  public void Employee(){
  }

  //getters and setters
  public long getId() {
    return id;
  }

  public void setId(long id) {
    this.id = id;
  }

  public String getFirstName() {
    return firstName;
  }

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

  public double getSalary() {
    return salary;
  }

  public void setSalary(double salary) {
    this.salary = salary;
  }

  public Department getDepartment(){
    return department;
  }

  public setDepartment(Department department){
    this.department = department;
  }
  
}

To provide hibernate mapping based on XML, perform the following steps:

Here, <hibernate-mapping> is a root element that contains all the <class> elements. The <class> tag contains the following attributes:

The <id> tag defines the primary key column for the database table. It contains the following attributes:

Usually, we create a mapping file called hbm (hibernate mapping). It is a normal XML schema file that contains custom hibernate XML tags. This helps the hibernate engine to map the class to the table and the class field to the table column, along with the given attributes.

All the mapping definitions for hibernate are bundled under the <hibernate-mapping> ... </hibernate-mapping> tag. In <hibernate-mapping> ... </hibernate-mapping>, we can add any number of class-to-table mapping definitions.

Now, let's create the XML mapping for the POJO having a reference with another POJO. Here, we will create two different mapping files. To achieve this using an XML-based mapping, we have to create different class mappings for each POJO that has a dependency.

The following is a code that represents the mapping for the Department class. The mapping is in the Department.hbm.xml file:

…
<hibernate-mapping>
  <class name="Department" table="department">
    <id name="id" type="long" column="id">
      <generator class="auto" />
    </id>

    <property column="deptName" name="deptName" />
    <!-- other properties mapping -->
  </class>  
</hibernate-mapping>
…

Next, we will create a mapping for the Employee class. Its definition is present in the Employee.hbm.xml file:

…
<hibernate-mapping>
  <class="Employee" table="employee">
    <id name="id" type="long" column="id">
      <generator class="auto" />
    </id>

    <property column="firstName" name="firstName" />
    <property column="salary" name="salary" />
    <many-to-one name="department" class="Department" >
      <column name="department"/>
    </many-to-one>
    <!-- other properties mapping-->
  </class>
</hibernate-mapping>
…

In the preceding example, we mapped the Department entity with the Employee entity. This will refer to the department column in the employee table. This means that it will create a foreign key that is referenced to the department table.

Here, we will use the <many-to-one> relationship, which means that either many employees are connected with one department, or one department is used by many employees.

The properties are as follows:

The two possible options for lazy are true and false. In our example, Employee is a parent class, whereas Department is a child of the Employee class. Now, while fetching, if we set lazy as true, it means that it will only fetch employee records. No child records will be fetched with Employee, and hibernate will use a separate query if we try to access a child record, which is employee.getDepartment(). If we set lazy as false, hibernate will fetch the child records with the parent, which means that the department information will also be fetched, along with that of the employee. Hibernate will use a join query to fetch the child records.

Now, let's create the class that contains the annotation-based mapping. As we used the Employee class to provide XML-based mapping here, we will use the same class with annotations:

Now, compare the annotations with the XML mapping to gain a better understanding of the difference between the two methods.

@Entity
@Table(name="employee")
public class Employee{...}

<class name="Employee" table="employee">

@Id
@Column(name="id")
@GeneratedValue(strategy = GenerationType.AUTO)
private long id;

<id name="id" type="long" column="id">
  <generator class="auto" />
</id>

@JoinColumn(name="department")
@ManyToOne
private Department department;

<many-to-one name="department" class="Department">
  <column name="department"/>
</many-to-one>

In the previous section you learned how to reference a class using hibernate. In this section, we will take a look at how to provide the reference of one class in another class in detail.

Do not get confused when writing Employee.java again to show the reference object annotation.

The following code represents the annotation-based mapping for the Employee class that has the reference field in Employee.java:

import javax.persistence.Column;
import javax.persistence.Entity;
import javax.persistence.GeneratedValue;
import javax.persistence.Id;
import javax.persistence.ManyToOne;
import javax.persistence.Table;

@Entity
@Table(name="employee")
public class Employee{

   @Id
   @Column(name="id")
   @GeneratedValue(strategy = GenerationType.AUTO)
   private long id;
   
   @Column(name="firstname")
   private String firstName;
   
   @Column(name = "salary")
   private double salary;
   
   @JoinColumn(name="department")
   @ManyToOne
   private Department department;
   
   // default constructor
   public Employee() {
   }
   
   // getters & setters
   public long getId() {
   return id;
   }
   
   public void setId(long id) {
   this.id = id;
   }
   
   public String getFirstName() {
   return firstName;
   }
   
   public void setFirstName(String firstName) {
   this.firstName = firstName;
   }
   
   public double getSalary() {
   return salary;
   }
   
   public void setSalary(double salary) {
   this.salary = salary;
   }
   
   public Department getDepartment(){
   return department;
   }

  public setDepartment(Department department){
    this.department = department;
  }
}

The following code represents the annotation-based mapping for the Department class in Department.java:

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

@Entity
@Table //If name is not supplied hibernate will use class name as table name
public class Department{
  @Id
  @Column //If name is not supplied hibernate will use field name as column name
  @GeneratedValue(strategy = GenerationType.AUTO)
  private long id;

  @Column
  private String deptName;
  
  public long getId() {
    return id;
  }

  public void setId(long id) {
    this.id = id;
  }

  public String getDeptName() {
    return deptName;
  }

  public void setDeptName(String deptName) {
    this.deptName = deptName;
  }

}

Now, we will create the XML file that shows the configuration for MySQL:

Here, we will take a look at only the basic configuration parameters. Let's understand the meaning of each property:

Here are some useful properties used in hibernate:

Now, we will create a file called hibernate.properties in our classpath and write the following properties in the file. The following code represents hibernate.cfg.xml in the hibernate.properties file:

…
hibernate.dialect=org.hibernate.dialect.MySQLDialect
hibernate.connection.driver_class=com.mysql.jdbc.Driver
hibernate.connection.url=jdbc:mysql://localhost:3306/kode12
hibernate.connection.username=root
hibernate.connection.password=root
show_sql=true
hbm2ddl.auto=update
…

When we create an instance of the Configuration class, it will look for hibernate.cfg.xml or hibernate.properties in our classpath. If we use a .properties file, it'll get all of the property defined in the file, rather than create a Configuration object.

First, write the following code:

Configuration configuration = new Configuration();

This will create an instance of the Configuration class using hibernate.cfg.xml or hibernate.properties, whichever is found in the classpath.

Provide the following mapping files to the configuration:

configuration = configuration.addResource("Employee.hbm.xml");
configuration = configuration.addResource("Department.hbm.xml");

You can use an alternate way, as shown in the following code:

Configuration configuration = new Configuration().addResource("Employee.hbm.xml").addResource("Department.hbm.xml");

We can also provide a direct mapping using the class, as shown in the following code:

configuration = configuration.addClass("Department.class");

This will also look for Department.hbm.xml.

We can also set a custom property. To set up the custom property, use the following method:

configuration.setProperty(propertyName, value);

For example, consider the following code:

configuration.setProperty("show_sql", true);

To set up multiple properties using the properties object, execute the following code:

configuration.setProperties(java.util.Properties properties);

Here is an example:

Properties properties = new Properties();
properties.put("hibernate.dialect", "org.hibernate.dialect.MySQLDialect");
properties.put("hibernate.connection.driver_class", "com.mysql.jdbc.Driver");
properties.put("hibernate.connection.url", "jdbc:mysql://localhost:3306/kode12");
properties.put("hibernate.connection.username", "root");
properties.put("hibernate.connection.password", "root");
properties.put("show_sql", "true");
properties.put("hbm2ddl.auto", "update");
configuration.setProperties(properties);

To read the mapping from the URL, you can use the following code:

configuration = configuration.addURL(java.net.URL url);

To read the mapping from the XML file, you can use the following code:

configuration = configuration.addXML(String xml);

When we select the programmatic configuration option, the Configuration class is very important. Using the instance of the Configuration class, we will build a SessionFactory object, as shown in the following code:

SessionFactory sessionFactory = new Configuration().buildSessionFactory();

When the preceding code is executed, it creates a SessionFactory object using a .properties or .cfg file or whichever source is provided to create the configuration.