Skip to main content

Hibernate Introduction

Hibernate is a Object relational mapping framework. What it will help us is in saving the objects into the relational world.

Employee.java

public class Employee {

private String Name;

private int Emp_Id;

private String Designation;

private String Reportee;

private int Access_Carad_No;

    

    public String getName() {

        return Name;

    }

    public void setName(String name) {

        Name = name;

    }

    public int getEmp_Id() {

        return Emp_Id;

    }

    public void setEmp_Id(int emp_Id) {

        Emp_Id = emp_Id;

    }

    public String getDesignation() {

        return Designation;

    }

    public void setDesignation(String designation) {

        Designation = designation;

    }

    public String getReportee() {

        return Reportee;

    }

    public void setReportee(String reportee) {

        Reportee = reportee;

    }

    public int getAccess_Carad_No() {

        return Access_Carad_No;

    }

    public void setAccess_Carad_No(int access_Carad_No) {

        Access_Carad_No = access_Carad_No;

    }


 


 

}


 

Now we have the domain class definition with us. Now we will put a mapping file which will map this class to the data model in the database. We are not creating the table in the database as we will use hibernate to generate the data model. Though in real life application you would have your data model already created and placed in the database.

Employee.hbm.xml

<?xml version="1.0"?>

<!DOCTYPE hibernate-mapping PUBLIC

"-//Hibernate/Hibernate Mapping DTD 3.0//EN"

"http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd">

<hibernate-mapping>    

<class name="Employee.java" table="Employee" schema="hiberpract">

<id name="Emp_Id" column="EMP_ID">

<generator class="increment"></generator>

</id>


 

<property name="Name" column="NAME"></property>

<property name="Designation" column="DESIGNATION"></property>

<property name="Reportee" column="REPORTEE"></property>

<property name="Access_Carad_No" column="ACCCESS_CARD_NO"></property>


 


 

</class>

</hibernate-mapping>

Now we will provide hibernate the details to connect to the database. Similar to JDBC coding, the connection details and drivers need to be provided to Hibernate. This is done in a XML file

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>

<!-- Database connection settings -->

<property name="connection.driver_class">com.mysql.jdbc.Driver </property>

<property name="connection.url">jdbc:mysql://localhost:3306/Hiberpract </property>

<property name="connection.username">root</property>

<property name="connection.password">root</property>


 

<!-- JDBC connection pool (use the built-in) -->

<property name="connection.pool_size">1

</property>


 

<!-- SQL dialect - This tells the SQL grammer to be used -->

<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>


 

<!-- Log out all the sql that hibernate is issuing to datbase.

This is very useful for debugging -->

<property name="show_sql">true</property>


 

<!-- Create the table looking at class and mapping. Very useful in development

Use validate in production environments. -->

<property name="hbm2ddl.auto">create</property>

        <property name="format_sql">true</property>

<!-- Mapping file. -->

<mapping resource="Employee.hbm.xml"/>


 

</session-factory>

</hibernate-configuration>

Now we will write a utility class which will start the session factory of hibernate, if it is not started and will return the Session factory. This is the most used pattern of boot strapping Hibernate. Session factory contains all the configuration information at runtime. A Session is retrieve from the Session factory. A session is a light weight object which provide services to interact with database. You can think of Session like JDBC connection, thought it may not open the database connection if not required.

HiberUtil.java:

import org.hibernate.SessionFactory;

import org.hibernate.cfg.Configuration;


 


 


 

public class HiberUtil

    {


 

        private static SessionFactory sessionFactory;


 

        static{

            try{

                //By default it will look for hibernate.cfg.xml in the class path

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

            }catch(Throwable ex){

                throw new ExceptionInInitializerError(ex);

            }

        }


 

        public static SessionFactory getSessionFactory(){

            return sessionFactory;

        }


 

        public static void shutdown(){

            //Close caches and connection pool

            getSessionFactory().close();

        }


 

    }


 


Now Let's create the base class having main method..

HiberBase.java

import org.hibernate.Session;

import org.hibernate.Transaction;


 


 

public class HiberBase {


 

    public static void main(String[] args) {


 

        //Get the session from the Session factory

        Session session = HiberUtil.getSessionFactory().openSession();


 

        Transaction tx= session.beginTransaction();


 

        Employee Emp = new Employee();

        Emp.setName("Utkarsh");


 

        session.save(Emp);


 

        //System.out.println(studentId);


 

        tx.commit();

        session.close();

    }

}

In the above example we saw how to configure hibernate using XML mapping.
Labels:

Popular posts from this blog

Primitive Obsession with Example

Primitive Obsession is the name of a code smell that occurs when we use primitive data types to represent domain ideas. For example, we use a string to represent a message or an integer to represent an amount of money. For Example: Code with Primitive Obsession // primitiveObsession.java public class primitiveObsession { public static void main ( String args []) { Integer [] cityPopulations = { 13000000 , // London 21903623 , // New York 12570000 , // Tokyo 1932763 , // Stockholm 1605602 , // Barcelona 4119190 // Sydney }; for ( Integer cityPopulation : cityPopulations ) { System . out . println ( cityPopulation ); } } } public class City { private final String name ; private final int population ; private final Continent continent ; public String getName () { return name ; } public int getPopulation () { return population ; } public Continent ge...
Read more

Factory Pattern

This pattern is used when it must be decided at run time which one of several compatible classes is to be instantiated. For example, the abstract Collator class's getInstance() method returns a collation object that is appropriate for the default locale, as determined by java.util.Locale.getDefault() : Like other locale-sensitive classes, you can use the static factory method, getInstance, to obtain the appropriate Collator object for a given locale.  The following example shows how to compare two strings using the Collator for the default locale. Compare two strings in the default locale Collator myCollator = Collator.getInstance(); if( myCollator.compare("abc", "ABC") < 0 ) System.out.println("abc is less than ABC"); else System.out.println("abc is greater than or equal to ABC");
Read more

Singleton Pattern

Lazy Initialization :- The instantiation of an object can be delayed until it is actually needed. Usage: This especially beneficial when the constructor is doing a costly job like, accessing a remote database. Example: This code demonstrates how the Singleton pattern can be used to create a counter to provide unique sequential numbers, such as might be required for use as primary keys in a Database:   Sequence.java   public class Sequence { private static Sequence instance; private static int counter; private Sequence() { counter = 0; // May be necessary to obtain // starting value elsewhere... } public static synchronized Sequence getInstance() { if(instance==null) // Lazy instantiation { instance = new Sequence(); } return instance; } public static synchronized int getNext() { return ++counter; } }   Some things to note about this implementation: Synchronized methods are used to ensure that the class is thread-safe. This class cannot be subclassed because the constructor is private ...
Read more