JAVAbyNATARAJ

JDBC Vs Hibernate

>> Saturday, March 19, 2011

Why is Hibernate better than JDBC

1) Relational Persistence for JAVA

Working with both Object-Oriented software and Relational Database is complicated task with JDBC because there is mismatch between how data is represented in objects versus relational database. So with JDBC, developer has to write code to map an object model's data representation to a relational data model and its corresponding database schema. Hibernate is flexible and powerful ORM solution to map Java classes to database tables. Hibernate itself takes care of this mapping using XML files so developer does not need to write code for this.

2) Transparent Persistence

The automatic mapping of Java objects with database tables and vice versa is called Transparent Persistence. Hibernate provides transparent persistence and developer does not need to write code explicitly to map database tables tuples to application objects during interaction with RDBMS. With JDBC this conversion is to be taken care of by the developer manually with lines of code.

Hibernate communication with RDBMS

General steps:

1. Load the Hibernate configuration file and create configuration object. It will automatically load all hbm mapping files.
2. Create session factory from configuration object
3. Get one session from this session factory.
4. Create HQL query.
5. Execute query to get list containing Java objects.

Example: Retrieve list of employees from Employee table using Hibernate. /* Load the hibernate configuration file */

Configuration cfg = new Configuration(); cfg.configure(CONFIG_FILE_LOCATION);

/* Create the session factory */

SessionFactory sessionFactory = cfg.buildSessionFactory();

/* Retrieve the session */

Session session = sessionFactory.openSession();

/* create query */

Query query = session.createQuery("from EmployeeBean”);

/* execute query and get result in form of Java objects */ List finalList = query.list();

EmployeeBean.hbm.xml File

"-//Hibernate/Hibernate Mapping DTD 3.0//EN" "http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd">

4. Introduction to Hibernate

Hibernate is an Object-Relational Mapping (ORM) solution for JAVA. It is a powerful, high performance object/relational persistence and query service. It allows us to develop persistent classes following object-oriented idiom – including association, inheritance and polymorphism.

Hibernate Architecture

Hibernate:

1) itself opens connection to database,
2) converts HQL (Hibernate Query Language) statements to database specific statement,
3) receives result set,
4) then performs mapping of these database specific data to Java objects which are directly used by Java application.

Hibernate uses the database specification from Hibernate Properties file. Automatic mapping is performed on the basis of the properties defined in hbm XML file defined for particular Java object.

3.Interaction with RDBMS

These are the General steps to follow while usingn JDBC.

1) Load the RDBMS specific JDBC driver because this driver actually communicates with the database.
2) Open the connection to database which is then used to send SQL statements and get results back.
3) Create JDBC Statement object. This object contains SQL query.
4) Execute statement which returns resultset(s). ResultSet contains the tuples of database table as a result of SQL query.
5) Process the result set.
6) Close the connection.

Example: Retrieve list of employees from Employee table using JDBC.

String url = “jdbc:odbc:” + dbName;

List employeeList = new ArrayList();

//load the jdbc-odbc driver 

class.forName(“sun.jdbc.odbc.JdbcOdbcDriver”);

//Open a connection to database

Connection con = DriverManager.getConnection(url);

//create Statement object

Statement stmt = con.createStatement();

//execute statement
ResultSet rs = stmt.executeQuery("SELECT * FROM Sells"); while ( rs.next() ){
  EmployeeBean eb = new Employeebean(); 
  eb.setName(rs.getString("name")); 
  eb.setSalary(rs.getFloat("salary")); 
  employeeList.add(eb);
}

Reference Books: