В чем разница между Spring Data и Hibernate?

Разница между Spring Data и Hibernate

Это два разных инструмента разных уровней абстракции, хотя они часто используются вместе.

Определения

Hibernate — это ORM (Object-Relational Mapping) фреймворк, который преобразует объекты Java в таблицы базы данных.

Spring Data — это фреймворк, который упрощает работу с хранилищами данных (БД, cache и т.д.) через стандартные интерфейсы и абстракции.

Основные различия

1. Уровень абстракции

Hibernate:

• Низкоуровневый ORM
• Прямая работа с объектами и сессиями
• Полный контроль над mapping и SQL-запросами

Spring Data:

• Высокоуровневая абстракция поверх ORM
• Вообще не привязана к конкретной реализации
• Может работать с Hibernate, JPA, MongoDB, Redis и т.д.

2. Зависимости

Spring Data зависит от ORM:

Spring Data JPA → (использует) → Hibernate
Spring Data MongoDB → (использует) → MongoDB driver
Spring Data Redis → (использует) → Redis client

Hibernate самостоятельный:

Энтити класс ↔ Hibernate ↔ PostgreSQL/MySQL/Oracle

Пример: работа с UserRepository

Вариант 1: Только Hibernate (JPA)

@Entity
@Table(name = "users")
public class User {
    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;
    
    @Column(name = "name")
    private String name;
    
    @Column(name = "email")
    private String email;
}

// Работа с БД через EntityManager (Hibernate)
@Service
public class UserService {
    @Autowired
    private EntityManager entityManager;
    
    public User getUserById(Long id) {
        return entityManager.find(User.class, id);
    }
    
    public List<User> getAllUsers() {
        String jpql = "SELECT u FROM User u";
        return entityManager.createQuery(jpql, User.class)
            .getResultList();
    }
    
    public User createUser(User user) {
        entityManager.persist(user);
        return user;
    }
    
    public User updateUser(User user) {
        return entityManager.merge(user);
    }
    
    public void deleteUser(Long id) {
        User user = entityManager.find(User.class, id);
        if (user != null) {
            entityManager.remove(user);
        }
    }
}

Вариант 2: Spring Data JPA (над Hibernate)

@Entity
@Table(name = "users")
public class User {
    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;
    private String name;
    private String email;
}

// Repository interface - Spring Data генерирует реализацию
public interface UserRepository extends JpaRepository<User, Long> {
    // CRUD методы генерируются автоматически:
    // findById(Long id) - SELECT * FROM users WHERE id = ?
    // save(User user) - INSERT/UPDATE
    // delete(User user) - DELETE
    // findAll() - SELECT * FROM users
    
    // Кастомные методы - Spring Data создаёт реализацию из названия
    User findByEmail(String email);
    List<User> findByNameContaining(String name);
    List<User> findByNameAndEmail(String name, String email);
}

// Использование
@Service
public class UserService {
    @Autowired
    private UserRepository userRepository;
    
    public User getUserById(Long id) {
        return userRepository.findById(id)
            .orElseThrow(() -> new UserNotFoundException(id));
    }
    
    public List<User> getAllUsers() {
        return userRepository.findAll();
    }
    
    public User createUser(User user) {
        return userRepository.save(user);
    }
    
    public void deleteUser(Long id) {
        userRepository.deleteById(id);
    }
    
    public User findByEmail(String email) {
        return userRepository.findByEmail(email);
    }
}

Сравнение в таблице

Кастомные запросы

Hibernate HQL:

String hql = "FROM User WHERE email = :email";
Query query = entityManager.createQuery(hql);
query.setParameter("email", email);
List<User> results = query.getResultList();

Spring Data с @Query:

public interface UserRepository extends JpaRepository<User, Long> {
    @Query("SELECT u FROM User u WHERE u.email = :email")
    User findByEmailCustom(@Param("email") String email);
    
    // Native SQL запрос
    @Query(value = "SELECT * FROM users WHERE email = ?", nativeQuery = true)
    User findByEmailNative(String email);
}

Управление сессией

Hibernate требует явного управления:

Session session = sessionFactory.openSession();
try {
    User user = session.get(User.class, 1L);
    user.setName("New Name");
    session.update(user);
    session.getTransaction().commit();
} finally {
    session.close();
}

Spring Data автоматически управляет:

@Transactional
public User updateUser(Long id, String newName) {
    User user = userRepository.findById(id)
        .orElseThrow();
    user.setName(newName);
    return userRepository.save(user);  // Сессия управляется автоматически
}

Когда использовать

Используй только Hibernate когда:

• Нужен полный контроль над ORM
• Сложная логика маппинга и associations
• Требуется оптимизация запросов на низком уровне
• Нет предпочтения использовать Spring

Используй Spring Data когда:

• Стандартные CRUD операции
• Простые и средние проекты
• Нужна абстрактность (возможность менять ORM)
• Используешь Spring Boot (это стандарт)
• Хочешь минимум boilerplate кода

Типичная архитектура (Spring Boot)

// Entity
@Entity
public class User { ... }

// Repository (Spring Data)
public interface UserRepository extends JpaRepository<User, Long> {
    User findByEmail(String email);
}

// Service (бизнес-логика)
@Service
public class UserService {
    @Autowired
    private UserRepository userRepository;
    
    public User createUser(CreateUserRequest request) {
        User user = new User(request.getName(), request.getEmail());
        return userRepository.save(user);  // Spring Data
    }
}

// Controller (REST API)
@RestController
public class UserController {
    @Autowired
    private UserService userService;
    
    @PostMapping("/users")
    public ResponseEntity<UserDTO> createUser(@RequestBody CreateUserRequest request) {
        User user = userService.createUser(request);
        return ResponseEntity.status(HttpStatus.CREATED)
            .body(UserDTO.from(user));
    }
}

Интеграция: Spring Data + Hibernate

Они работают вместе:

┌─────────────────────────┐
│  UserService            │
│  (бизнес-логика)        │
└────────────┬────────────┘
             │
┌────────────▼────────────┐
│  UserRepository         │
│  (Spring Data)          │
│  ← Абстрактный API      │
└────────────┬────────────┘
             │
┌────────────▼────────────┐
│  HibernateJpaRepository │
│  (реализация)           │
│  ← Использует Hibernate │
└────────────┬────────────┘
             │
┌────────────▼────────────┐
│  SessionFactory         │
│  (Hibernate)            │
│  ← Работает с БД        │
└────────────┬────────────┘
             │
┌────────────▼────────────┐
│  PostgreSQL/MySQL       │
│  (База данных)          │
└─────────────────────────┘

Резюме

• Hibernate — низкоуровневый ORM для преобразования объектов в БД
• Spring Data — высокоуровневая абстракция для упрощения работы с хранилищами
• Spring Data использует Hibernate как реализацию для JPA
• Spring Boot использует Spring Data как стандартный подход
• В большинстве случаев используй Spring Data (более высокоуровневый и удобный)
• Если нужен полный контроль — работай напрямую с Hibernate/EntityManager

В современной разработке на Java/Spring стандарт — использовать Spring Data над Hibernate.