Software architects face an important technical problem when they must decide how to best interact with backend database systems. The decision often comes down to the Hibernate vs. JDBC debate, as the two database technologies provide decidedly different approaches to how to work with persistent data.
It's important to distinguish between the two database APIs. JDBC and Hibernate have some similarities, and their names are often used interchangeably, but they are not the same.
The difference between JDBC and Hibernate
The short answer on the fundamental difference between JDBC and Hibernate is that Hibernate performs an object-relational mapping framework, while JDBC is simply a database connectivity API. The long answer requires a history lesson on database access with Java.
The JDBC API was packaged as part of the Java Standard Edition (Java SE) ever since the 1997 release of JDK 1.1, and provides a collection of easy-to-use classes and methods that allow developers to write code that can connect to a wide range of databases.
Java uses the database language SQL to speak to the database it connects to. SQL is a database standard that requires knowledge about the structure of the tables, rows and columns that exist in the backend database. Responses returned to a Java program from a typical SQL query are usually in a tabular format.
The JDBC API provides classes, such as the ResultSet and the PreparedStatement, which allows the tabular data to be consumed and transformed into components that are compatible with Java's object-oriented constructs. However, this transformation process from JDBC results to object-oriented components requires a great deal of boiler-plate code, and it is tedious, cumbersome and error-prone.
The fact that data in an object-oriented system is not compatible with the way data is stored in a relational database is known as the object-relational impedance mismatch. JDBC makes it possible to transfer data back and forth between a Java program and a relational database, but it's not easy, nor is it elegant. Developers who need to address these shortcomings find the tip of the iceberg on the Hibernate vs. JDBC debate.
Hibernate vs. JDBC for database interactions
Unlike JDBC, Hibernate allows developers to write their database-driven Java applications using normal, object-oriented semantics.
More database API questions answered
If you have questions about other terms and technologies in this article, here are a few supplemental links on database APIs that might help:
The Hibernate API then lets developers decorate their Java code with minimally obtrusive JPA annotations. Said annotations describe how a given Java class and its variables map to a given table and its columns within a database. The Hibernate framework then takes care of all the tedious and error-prone coding required to convert between the object-oriented Java code and the backend database.
If developers worry that code annotation couples the database too tightly with the application, Hibernate also provides the opportunity to write the entire database configuration in a completely external XML file. While XML files can become cumbersome for large systems, they have the valuable benefit of completely externalizing the configuration, which means that none of the Java code remains clean of any information that pertains to the external database system. This loose database-application coupling starkly contrasts the JDBC approach, in which SQL statements exist directly within the code.
The Hibernate and JDBC dependency
Hibernate and JPA-based applications do not eliminate the need for JDBC. When you use Hibernate, all database interactions still occur with the JDBC APIs. Hibernate and JPA are actually built on top of the JDBC API.
Hibernate and JPA act as an abstraction layer and subsequently hide the low-level JDBC calls from the developer, which makes database programming much easier.
Hibernate vs. JDBC benefits and drawbacks
From a developer’s perspective, the key benefit of Hibernate over JDBC is the fact that developers can code their Java applications based on object-oriented principles and best practices without worrying about database semantics. As a result, development can happen faster, especially when software developers don't have a strong understanding of SQL and relational databases. Also, since the interaction between the database and the Java program is done through a heavily-tested and robust framework, you'll likely see a drop in errors from within the database mapping layer.
Of course, the fact that a JPA framework such as Hibernate abstracts away a great deal of an application's database interactions isn't always a good thing.
At runtime, the Hibernate framework will generate all of the SQL required to interact with the backend database. However, software developers with strong database skills might be able to write their own SQL queries that are more concise, exact and efficient. Furthermore, some developers believe that the Hibernate framework hides too much of the database from the developer, which eliminates their ability to tweak and tinker with one of the most important integration points of any modern enterprise application. When you choose between Hibernate and JDBC, these are the types of concerns your team will need to address.
Hibernate vs. JDBC performance
Some software architects worry that a framework between a Java application and the backend database might incur a performance hit, but this concern is largely unfounded.
For the most part, a JPA framework performs the exact marshalling data tasks that would need to be coded even if a JPA framework wasn't in use. The difference between Hibernate and JDBC in this instance is simply who performs the coding -- the Hibernate framework or the local developer. You'll need to address the object-relation impedance mismatch either way.
JPA frameworks such as Hibernate, DataNucleus and TopLink are incredibly efficient at what they do. Any extra clock-cycles they might consume compared to an application written purely in JDBC are trivial compared to the resources consumed by a relational database that performs a query, or the network latency involved when you transport a ResultSet back and forth across the wire.
Even so, a poorly written Hibernate application that abuses the API with various JPA anti-patterns and incorrectly uses advanced features such as multi-table mappings and eager loading can bring a database to a crawl. Hibernate has its benefits, but, if it's used incorrectly, it can indeed diminish performance.
In fairness, JDBC performance can also be abysmally slow when SQL queries are written incorrectly. The performance question really shouldn't be a source of contention when you choose between the two technologies, as competent developers are more than capable of creating Java applications that perform equally well regardless of the technology used.
The difference between Hibernate and JPA
It's also worth noting that in much of this discussion, the terms Hibernate and JPA could be used interchangeably. Hibernate itself is a project, sponsored by Red Hat, that is itself an object-relational mapping (ORM) tool. Other ORM tools include the aforementioned TopLink and DataNucleus, along with Open JPA, JDO and EclipseLink.
In the late 2000s, a number of vendors provided ORM frameworks to Java developers. All of them performed the same basic tasks, but they used a different set of classes, packages, methods, annotations and XML mappings. The Java community decided it would be best for these different projects to come together under standardized APIs, which led to the birth of JPA, the Java Persistence API. Hibernate is now simply one of many different implementations of the JPA specification.
Hibernate has always been the most popular open-source ORM tool in the Java ecosystem. Even today, more than ten years after the release of JPA 1.0, people often use the term Hibernate to generically refer to any JPA framework.