Как связаны JPA, Hibernate и Spring Data JPA?

Как связаны JPA, Hibernate и Spring Data JPA

Это три связанные, но разные технологии. Понимание их отношений критично для работы с базами данных в Java.

1. JPA (Java Persistence API) - спецификация

Это стандартная спецификация (интерфейс), определенная в Java:

// JPA определяет интерфейсы и аннотации
import javax.persistence.*;  // JPA интерфейсы

@Entity  // Аннотация из JPA
@Table(name = "users")  // Из JPA
public class User {
    
    @Id  // Из JPA
    @GeneratedValue(strategy = GenerationType.IDENTITY)  // Из JPA
    private Long id;
    
    @Column(name = "email")  // Из JPA
    private String email;
    
    @OneToMany  // Из JPA
    private Set<Order> orders;
}

// JPA также определяет интерфейсы
EntityManager em = entityManagerFactory.createEntityManager();
em.persist(user);  // Метод из JPA
User found = em.find(User.class, 1L);  // Метод из JPA

2. Hibernate - реализация JPA

Это конкретная реализация JPA спецификации:

// Hibernate реализует все интерфейсы JPA
// и добавляет свои расширения

import org.hibernate.Session;  // Специфично Hibernate
import org.hibernate.annotations.*;  // Специфично Hibernate

@Entity
@Cache(usage = CacheConcurrencyStrategy.READ_WRITE)  // Расширение Hibernate
public class User {
    
    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;
    
    @Column(name = "email")
    private String email;
    
    @DynamicUpdate  // Специфично Hibernate
    @DynamicInsert  // Специфично Hibernate
    private boolean active;
}

// Hibernate-специфичный код
Session session = sessionFactory.openSession();  // Не из JPA
Query query = session.createQuery(
    "FROM User WHERE email = :email",  // HQL - язык Hibernate
    User.class
);
User user = query.getSingleResult();

3. Spring Data JPA - уровень абстракции

Это слой Spring, который упростит работу с JPA/Hibernate:

// Spring Data JPA создает реализацию в runtime

import org.springframework.data.jpa.repository.JpaRepository;
import org.springframework.data.jpa.repository.Query;

// Достаточно написать интерфейс
@Repository
public interface UserRepository extends JpaRepository<User, Long> {
    
    // Spring Data сгенерирует реализацию автоматически!
    Optional<User> findByEmail(String email);
    
    List<User> findByActiveTrue();
    
    @Query("SELECT u FROM User u WHERE u.email = :email")
    Optional<User> findUserByEmail(@Param("email") String email);
    
    @Query(value = "SELECT * FROM users WHERE email = ?", 
           nativeQuery = true)
    Optional<User> findByEmailNativeQuery(String email);
}

// Spring Data использует JPA/Hibernate
// но скрывает детали реализации
UserRepository repository = // inject by Spring

User user = repository.findByEmail("john@example.com").orElse(null);

4. Слои архитектуры

Приложение (Your Code)
    ↓
Spring Data JPA Interface  ← Вы пишете только интерфейсы
    ↓
Spring Data JPA Implementation (Runtime)  ← Spring генерирует
    ↓
JPA EntityManager  ← Стандартный интерфейс
    ↓
Hibernate (реализация JPA)
    ↓
JDBC Driver
    ↓
База Данных

5. Практический пример: цепочка вызовов

// Уровень приложения
@Service
public class UserService {
    
    @Autowired
    private UserRepository userRepository;  // Spring Data JPA интерфейс
    
    public User getUserByEmail(String email) {
        // 1. Вызываем метод Spring Data JPA интерфейса
        return userRepository.findByEmail(email)
            .orElseThrow(() -> new UserNotFoundException());
    }
}

// Spring Data JPA автоматически создает реализацию
@Repository
public interface UserRepository extends JpaRepository<User, Long> {
    // 2. Spring генерирует реализацию, которая делает:
    //    - Парсит название метода (findByEmail)
    //    - Создает JPQL запрос
    //    - Вызывает EntityManager
    
    Optional<User> findByEmail(String email);
}

// Под капотом Spring Data JPA создает что-то вроде:
public class UserRepositoryImpl implements UserRepository {
    
    @PersistenceContext
    private EntityManager entityManager;  // JPA интерфейс
    
    @Override
    public Optional<User> findByEmail(String email) {
        // 3. Использует JPA EntityManager
        TypedQuery<User> query = entityManager.createQuery(
            "SELECT u FROM User u WHERE u.email = :email",
            User.class
        );
        query.setParameter("email", email);
        
        // 4. Hibernate реализует EntityManager
        //    и выполняет запрос через JDBC
        return query.getResultList().stream().findFirst();
    }
}

6. Различия в синтаксисе

// JPA - стандартный способ
EntityManager em = entityManagerFactory.createEntityManager();
em.getTransaction().begin();
User user = new User();
user.setEmail("test@example.com");
em.persist(user);  // JPA метод
em.getTransaction().commit();

// Hibernate - дополнительные возможности
Session session = sessionFactory.openSession();
Transaction tx = session.beginTransaction();
User user = new User();
user.setEmail("test@example.com");
session.save(user);  // Hibernate метод (отличается от persist)
tx.commit();

// Spring Data JPA - самый простой
UserRepository repo = // Spring inject
User user = new User();
user.setEmail("test@example.com");
repo.save(user);  // Spring Data метод

7. Когда используется что

// Используем Spring Data JPA в 95% случаев
@Service
public class OrderService {
    
    @Autowired
    private OrderRepository orderRepository;  // Spring Data
    
    public void createOrder(Order order) {
        orderRepository.save(order);
    }
}

// Используем JPA EntityManager для сложных операций
@Service
public class ComplexQueryService {
    
    @PersistenceContext
    private EntityManager entityManager;  // Используем JPA
    
    public List<User> complexSearch(String query) {
        return entityManager
            .createQuery("SELECT u FROM User u WHERE " + query, User.class)
            .getResultList();
    }
}

// Используем Hibernate Session только если действительно нужны
// специфичные для Hibernate возможности
@Service
public class HibernateSpecificService {
    
    @Autowired
    private SessionFactory sessionFactory;  // Специфично Hibernate
    
    public void batchInsert(List<User> users) {
        Session session = sessionFactory.openSession();
        for (int i = 0; i < users.size(); i++) {
            session.save(users.get(i));
            if (i % 50 == 0) {
                session.flush();  // Специфично Hibernate
                session.clear();   // Очистить кэш
            }
        }
        session.close();
    }
}

8. Аннотации: где они из

@Entity  // ← JPA (javax.persistence)
@Table   // ← JPA
@Id      // ← JPA
@Column  // ← JPA
@OneToMany  // ← JPA
@ManyToOne  // ← JPA
@JoinColumn  // ← JPA

// Расширения Hibernate
@Cache   // ← Hibernate (org.hibernate.annotations)
@DynamicUpdate  // ← Hibernate
@BatchSize  // ← Hibernate
@Fetch   // ← Hibernate
@CreationTimestamp  // ← Hibernate
@UpdateTimestamp    // ← Hibernate

// Spring Data
@Repository  // ← Spring
@Query       // ← Spring Data
@Modifying   // ← Spring Data

9. Выбор стратегии генерации ID

// JPA стандартная конфигурация
@Entity
public class User {
    
    @Id
    @GeneratedValue(strategy = GenerationType.AUTO)  // JPA стандарт
    private Long id;
}

// Специфично Hibernate
@Entity
public class Product {
    
    @Id
    @GeneratedValue(generator = "native")  // Hibernate специфично
    @GenericGenerator(name = "native", strategy = "native")
    private Long id;
}

// Spring Data способ
@Entity
public class Order {
    
    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;  // Стандартный JPA способ
}

10. Полная схема: как все работает вместе

// 1. Пишем интерфейс Spring Data
@Repository
public interface UserRepository extends JpaRepository<User, Long> {
    @Query("SELECT u FROM User u WHERE u.status = 'ACTIVE'")
    List<User> findActiveUsers();
}

// 2. Spring создает реализацию, которая:
//    - Использует JPA EntityManager
//    - Создает JPQL запрос
//    - Передает управление Hibernate

// 3. Hibernate:
//    - Парсит JPQL
//    - Преобразует в SQL
//    - Кэширует результаты (L1, L2)
//    - Управляет транзакциями
//    - Выполняет запрос через JDBC

// 4. JDBC отправляет запрос в БД

users = repository.findActiveUsers();
// SELECT * FROM users WHERE status = 'ACTIVE'

Вывод: JPA - это спецификация (интерфейс), Hibernate - реализация спецификации, Spring Data JPA - слой упрощающий работу с JPA/Hibernate. В большинстве проектов используется именно эта комбинация: JPA + Hibernate + Spring Data JPA.