What's the difference between Hibernate and Spring Data JPA

There are 3 different things we are using here :

1. JPA : Java persistence api which provide specification for persisting, reading, managing data from your java object to relations in database.
2. Hibernate: There are various provider which implement jpa. Hibernate is one of them. So we have other provider as well. But if using jpa with spring it allows you to switch to different providers in future.
3. Spring Data JPA : This is another layer on top of jpa which spring provide to make your life easy.

So lets understand how spring data jpa and spring + hibernate works-

Spring Data JPA:

Let's say you are using spring + hibernate for your application. Now you need to have dao interface and implementation where you will be writing crud operation using SessionFactory of hibernate. Let say you are writing dao class for Employee class, tomorrow in your application you might need to write similiar crud operation for any other entity. So there is lot of boilerplate code we can see here.

Now Spring data jpa allow us to define dao interfaces by extending its repositories(crudrepository, jparepository) so it provide you dao implementation at runtime. You don't need to write dao implementation anymore.Thats how spring data jpa makes your life easy.

I disagree SpringJPA makes live easy. Yes, it provides some classes and you can make some simple DAO fast, but in fact, it's all you can do. If you want to do something more than findById() or save, you must go through hell:

• no EntityManager access in org.springframework.data.repository classes (this is basic JPA class!)
• own transaction management (hibernate transactions disallowed)
• huge problems with more than one datasources configuration
• no datasource pooling (HikariCP must be in use as third party library)

Why own transaction management is an disadvantage? Since Java 1.8 allows default methods into interfaces, Spring annotation based transactions, simple doesn't work.

Unfortunately, SpringJPA is based on reflections, and sometimes you need to point a method name or entity package into annotations (!). That's why any refactoring makes big crash. Sadly, @Transactional works for primary DS only :( So, if you have more than one DataSources, remember - transactions works just for primary one :)

What are the main differences between Hibernate and Spring Data JPA?

Hibernate is JPA compatibile, SpringJPA Spring compatibile. Your HibernateJPA DAO can be used with JavaEE or Hibernate Standalone, when SpringJPA can be used within Spring - SpringBoot for example

When should we not use Hibernate or Spring Data JPA? Also, when may Spring JDBC template perform better than Hibernate / Spring Data JPA?

Use Spring JDBC only when you need to use much Joins or when you need to use Spring having multiple datasource connections. Generally, avoid JPA for Joins.

But my general advice, use fresh solution—Daobab (http://www.daobab.io). Daobab is my Java and any JPA engine integrator, and I believe it will help much in your tasks :)

Spring Data is a convenience library on top of JPA that abstracts away many things and brings Spring magic (like it or not) to the persistence store access. It is primarily used for working with relational databases. In short, it allows you to declare interfaces that have methods like findByNameOrderByAge(String name); that will be parsed in runtime and converted into appropriate JPA queries.

Its placement atop of JPA makes its use tempting for:

1. Rookie developers who don't know SQL or know it badly. This is a recipe for disaster but they can get away with it if the project is trivial.

2. Experienced engineers who know what they do and want to spindle up things fast. This might be a viable strategy (but read further).

From my experience with Spring Data, its magic is too much (this is applicable to Spring in general). I started to use it heavily in one project and eventually hit several corner cases where I couldn't get the library out of my way and ended up with ugly workarounds. Later I read other users' complaints and realized that these issues are typical for Spring Data. For example, check this issue that led to hours of investigation/swearing:

 public TourAccommodationRate createTourAccommodationRate( @RequestBody TourAccommodationRate tourAccommodationRate ) { if (tourAccommodationRate.getId() != null) { throw new BadRequestException("id MUST NOT be specified in a body during entry creation"); } // This is an ugly hack required for the Room slim model to work. The problem stems from the fact that // when we send a child entity having the many-to-many (M:N) relation to the containing entity, its // information is not fetched. As a result, we get NPEs when trying to access all but its Id in the // code creating the corresponding slim model. By detaching the entity from the persistence context we // force the ORM to re-fetch it from the database instead of taking it from the cache tourAccommodationRateRepository.save(tourAccommodationRate); entityManager.detach(tourAccommodationRate); return tourAccommodationRateRepository.findOne(tourAccommodationRate.getId()); } 

I ended up going lower level and started using JDBI - a nice library with just enough "magic" to save you from the boilerplate. With it, you have complete control over SQL queries and almost never have to fight the library.

If you prefer simplicity and more control on SQL queries then I would suggest going with Spring Data/ Spring JDBC.

Its good amount of learning curve in JPA and sometimes difficult to debug issues. On the other hand, while you have full control over SQL, it becomes much easier to optimize query and improve performance. You can easily share your SQL with DBA or someone who has a better understanding of Database.

Hibernate is implementation of "JPA" which is a specification for Java objects in Database.

I would recommend to use w.r.t JPA as you can switch between different ORMS.

When you use JDBC then you need to use SQL Queries, so if you are proficient in SQL then go for JDBC.

1. JPA

   • JPA is a specification provided by Java to manage relational data in applications.
   • It defines a standard set of APIs and annotations, such as @Entity, @Table, @Id, and the EntityManager interface.
   • However, JPA itself does not provide any implementation; it’s more like a guideline for ORM (Object-Relational Mapping).
   • To use JPA in your application, you need a JPA provider like Hibernate or EclipseLink. Think of JPA as the “rules” that explain what ORM should look like

2. Hibernate

• Hibernate is a JPA provider and one of the most popular implementations of the JPA specification.
• While Hibernate follows the rules set by JPA, it also offers additional features that go beyond the standard such as:
  • Caching mechanisms: First-level and second-level caching for optimized performance.
  • Hibernate Query Language (HQL): A powerful query language for database interactions.
  • Custom mappings: Flexible support for mapping complex object structures.
  • Query optimization and Criteria API: For dynamic and efficient query generation.

In many Java projects, Hibernate serves as the engine behind JPA, managing the interaction between the application and the database seamlessly

3. Spring Data JPA

Spring Data JPA is a Spring module that sits on top of JPA to simplify its usage. It provides an abstraction layer that eliminates much of the boilerplate code.

Key Features:

• Repository Interfaces: Predefined interfaces like CrudRepository and JpaRepository allow you to perform operations (e.g., saving, deleting, querying) with minimal effort.
• Query Derivation: Automatically implements methods like findByName(String name) based on method naming conventions.
• Additional Support: Built-in support for pagination, sorting, and auditing

Internally, Spring Data JPA relies on a JPA provider (e.g., Hibernate) to execute these operations, enhancing productivity without compromising flexibility.