Spring Data JPA Vs JPA Vs Hibernate

What is Spring Data JPA?

Spring Data JPA is a part of the larger Spring Data family. It is a Spring framework module designed to simplify data access and manipulation in Java applications, specifically for JPA-based data stores. JPA (Java Persistence API) is a specification, and Spring Data JPA acts as an abstraction layer on top of it, making it easier to work with JPA.

Spring Data JPA provides additional features such as:

• Automatic query generation based on method names.
• Custom query support using JPQL, native SQL, or criteria API.
• Pagination and sorting capabilities.
• Integration with Spring Boot for easy configuration.

Key Features of Spring Data JPA

1. Repository Abstraction

   • Provides pre-defined repository interfaces like CrudRepository, PagingAndSortingRepository, and JpaRepository for common CRUD operations.

2. Query Method Derivation

   • Allows automatic query generation based on method names.
   • Example: findByFirstName(String firstName) automatically generates a query like SELECT e FROM Entity e WHERE e.firstName = :firstName.

3. Custom Queries

   • Supports custom queries using JPQL, native SQL, or named queries.

   • Example:

     @Query("SELECT e FROM Employee e WHERE e.salary > :salary")
     List<Employee> findEmployeesWithHighSalary(@Param("salary") double salary);
     
     

4. Pagination and Sorting

   • Built-in support for pagination and sorting.

   • Example:

     Page<Employee> findByDepartment(String department, Pageable pageable);
     
     

5. Specifications and QueryDSL

   • Supports complex query building using Specification and integration with QueryDSL.

---

Example: Spring JPA vs Spring Data JPA

Spring JPA Example (Manual Approach)

@Repository
public class EmployeeDAO {
    @PersistenceContext
    private EntityManager entityManager;

    @Transactional
    public Employee findEmployeeById(Long id) {
        return entityManager.find(Employee.class, id);
    }

    @Transactional
    public List<Employee> findEmployeesByDepartment(String department) {
        return entityManager.createQuery("SELECT e FROM Employee e WHERE e.department = :department", Employee.class)
                            .setParameter("department", department)
                            .getResultList();
    }
}

Spring Data JPA Example (Simplified Approach)

public interface EmployeeRepository extends JpaRepository<Employee, Long> {
    // Automatically generated query
    List<Employee> findByDepartment(String department);

    // Custom query
    @Query("SELECT e FROM Employee e WHERE e.salary > :salary")
    List<Employee> findEmployeesWithHighSalary(@Param("salary") double salary);
}

---

Which One to Use?

• Use Spring JPA:

  • When you need fine-grained control over how JPA interacts with the database.
  • For custom or highly optimized data access layers where abstractions might not suffice.

• Use Spring Data JPA:

  • For most cases where you want to focus on business logic and let Spring handle the data layer.
  • When you want to leverage built-in features like derived queries, pagination, and auditing.

---

Example Scenarios

Scenario 1: Fetching All Products

• Spring JPA:

  public List<Product> findAll() {
      return entityManager.createQuery("SELECT p FROM Product p", Product.class).getResultList();
  }
  
  

• Spring Data JPA:

  List<Product> findAll(); // JpaRepository provides this automatically
  
  

Scenario 2: Finding Products by Name

• Spring JPA:

  public List<Product> findByName(String name) {
      return entityManager.createQuery("SELECT p FROM Product p WHERE p.name = :name", Product.class)
                          .setParameter("name", name)
                          .getResultList();
  }
  
  

• Spring Data JPA:

  List<Product> findByName(String name); // Query generated automatically
  
  

Scenario 3: Paginated Queries

• Spring JPA:

  public List<Product> findPaginated(int page, int size) {
      return entityManager.createQuery("SELECT p FROM Product p", Product.class)
                          .setFirstResult(page * size)
                          .setMaxResults(size)
                          .getResultList();
  }
  
  

• Spring Data JPA:

  Page<Product> findAll(Pageable pageable); // Built-in support
  
  

import com.example.model.User;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;

import javax.persistence.EntityManager;
import javax.persistence.PersistenceContext;
import java.util.List;
import java.util.Optional;

@Service
public class UserService {

    @PersistenceContext
    private EntityManager entityManager;

    @Transactional
    public User saveUser(User user) {
        entityManager.persist(user); 
        return user;
    }

    @Transactional
    public User updateUser(User user) {
        return entityManager.merge(user);  
    }

    @Transactional
    public Optional<User> getUserById(Long id) {
        User user = entityManager.find(User.class, id);  
        return Optional.ofNullable(user);
    }

    @Transactional
    public List<User> getAllUsers() {
        return entityManager.createQuery("SELECT u FROM User u", User.class).getResultList();  
    }

    @Transactional
    public void deleteUser(Long id) {
        User user = entityManager.find(User.class, id); 
        if (user != null) {
            entityManager.remove(user);  
        }
    }
}

Manual EntityManager Handling:

• In pure JPA, you are manually injecting the EntityManager via @PersistenceContext and explicitly using its methods (persist(), merge(), find(), remove()) for all CRUD operations.
• In Spring Data JPA, the EntityManager is handled behind the scenes, and most operations (CRUD) are abstracted away in the repository layer.

No Spring Data JPA Repositories:

• In pure JPA, there is no use of the repository interface, such as JpaRepository or CrudRepository. You have to manually write the methods to interact with the database.
• In Spring Data JPA, you typically define an interface that extends JpaRepository, and Spring Data JPA automatically provides implementations for common CRUD operations like save(), findById(), findAll(), etc., without needing to manually manage them.

public interface UserRepository extends JpaRepository<User, Long> {
}

And you wouldn't have to write code for basic operations, like finding a user by ID or saving a user.

JPQL Queries:

• In pure JPA, you need to write the JPQL queries manually using EntityManager.createQuery(), as shown in your getAllUsers() method.
• In Spring Data JPA, you can avoid writing these queries by using query method names (such as findByFirstName(), findByLastName()), and Spring Data JPA will automatically generate the JPQL for you based on the method name.

List<User> findByFirstName(String firstName);

Transactional Management:

• In both pure JPA and Spring Data JPA, you can use the @Transactional annotation to manage transactions. The difference is that in pure JPA, you must explicitly specify transactional boundaries when using EntityManager methods (i.e., when persisting or removing entities).
• In Spring Data JPA, Spring automatically wraps repository methods in a transaction, so you often don't need to manage the @Transactional annotation explicitly.

More Control:

• Using pure JPA gives you more control over the lifecycle and behavior of the EntityManager. This is beneficial in situations where fine-tuned control is required (e.g., complex transactional boundaries, performance tuning).
• With Spring Data JPA, while convenient, you have less control over the EntityManager because most of the complexity is abstracted away.

No Repository Abstraction:

• With pure JPA, you write all the CRUD logic manually using the EntityManager. You are responsible for ensuring that the proper SQL or JPQL is written, and you must manage the interactions with the database directly.
• Spring Data JPA hides much of the complexity. It automatically handles common operations and allows you to focus on custom queries or operations beyond basic CRUD.

//Pure JPA
@Transactional
public User saveUser(User user) {
    entityManager.persist(user);
    return user;
}

//Spring Data JPA
@Autowired
private UserRepository userRepository;

public User saveUser(User user) {
    return userRepository.save(user);
}

and how Hibernate is different then?

• Hibernate is a specific implementation of the JPA specification and provides additional features beyond the JPA standard.
• It offers features like caching, connection pooling, and support for complex data types, which are not specified in JPA.
• While using Hibernate, you can take advantage of Hibernate-specific features like Criteria API, Hibernate Query Language (HQL), and more.

We can often identify which implementation (JPA, Spring Data JPA, or Hibernate) is being used by looking at the annotations in your Java code.