Что подразумевает Java Persistence API

# Java Persistence API (JPA)

Java Persistence API (JPA) — это стандарт и спецификация для работы с реляционными БД в Java приложениях. JPA предоставляет ORM (Object-Relational Mapping) функционал.

Определение

Java Persistence API — это набор интерфейсов и аннотаций для:

• Преобразования объектов Java в записи БД (ORM)
• Запросов к БД через объектно-ориентированный API
• Управления жизненным циклом объектов
• Работы с транзакциями и отношениями между объектами

Основные компоненты JPA

1. Entity Manager

Основной интерфейс для работы с персистентностью:

@Service
public class UserService {
    @PersistenceContext
    private EntityManager entityManager;
    
    // Сохранение сущности
    public void createUser(User user) {
        entityManager.persist(user);
    }
    
    // Получение сущности
    public User getUserById(Long id) {
        return entityManager.find(User.class, id);
    }
    
    // Обновление
    public User updateUser(User user) {
        return entityManager.merge(user);
    }
    
    // Удаление
    public void deleteUser(User user) {
        entityManager.remove(user);
    }
    
    // Flush (синхронизация с БД)
    public void flush() {
        entityManager.flush();
    }
    
    // Clear кэш
    public void clear() {
        entityManager.clear();
    }
}

2. Entity — сущность

Класс, который отображается на таблицу в БД:

@Entity
@Table(name = "users")
public class User {
    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;
    
    @Column(nullable = false, unique = true)
    private String email;
    
    @Column(length = 255)
    private String name;
    
    @Transient  // Не сохраняется в БД
    private String temporaryData;
    
    @CreationTimestamp
    private LocalDateTime createdAt;
    
    @UpdateTimestamp
    private LocalDateTime updatedAt;
}

3. JPQL (Java Persistence Query Language)

Объектно-ориентированный язык запросов:

@Repository
public interface UserRepository extends JpaRepository<User, Long> {
    // JPQL запрос
    @Query("SELECT u FROM User u WHERE u.email = :email")
    Optional<User> findByEmail(@Param("email") String email);
    
    // Также работает с методами
    List<User> findByNameContaining(String name);
    
    @Query("SELECT COUNT(u) FROM User u")
    long countAllUsers();
    
    @Query("DELETE FROM User u WHERE u.id = :id")
    void deleteUserById(@Param("id") Long id);
}

4. Отношения между сущностями

One-to-Many

@Entity
public class Author {
    @Id
    private Long id;
    
    private String name;
    
    @OneToMany(mappedBy = "author", cascade = CascadeType.ALL)
    private List<Book> books = new ArrayList<>();
}

@Entity
public class Book {
    @Id
    private Long id;
    
    private String title;
    
    @ManyToOne
    @JoinColumn(name = "author_id")
    private Author author;
}

Many-to-Many

@Entity
public class Student {
    @Id
    private Long id;
    
    private String name;
    
    @ManyToMany
    @JoinTable(
        name = "student_course",
        joinColumns = @JoinColumn(name = "student_id"),
        inverseJoinColumns = @JoinColumn(name = "course_id")
    )
    private List<Course> courses = new ArrayList<>();
}

@Entity
public class Course {
    @Id
    private Long id;
    
    private String name;
    
    @ManyToMany(mappedBy = "courses")
    private List<Student> students = new ArrayList<>();
}

5. Жизненный цикл Entity

New (Transient)
    |
    v
Managed (Persistent)
    |
    v
Detached
    |
    v
Removed

Практический пример:

// 1. Создание объекта — Transient
User user = new User("John", "john@example.com");

// 2. Сохранение в БД — Managed
entityManager.persist(user);

// 3. Изменение — изменения отслеживаются
user.setName("Jane");

// 4. При коммите транзакции — UPDATE выполняется автоматически
transactionManager.commit();

// 5. После закрытия sesion — Detached
session.close();

// 6. Удаление — Removed
entityManager.remove(user);

6. Batch операции

@Service
public class BatchService {
    @PersistenceContext
    private EntityManager entityManager;
    
    @Transactional
    public void batchInsert(List<User> users) {
        for (int i = 0; i < users.size(); i++) {
            entityManager.persist(users.get(i));
            
            // Flush каждые 20 элементов
            if (i % 20 == 0) {
                entityManager.flush();
                entityManager.clear();
            }
        }
    }
}

Реализации JPA

JPA vs Hibernate

JPA — спецификация (интерфейсы, аннотации). Hibernate — конкретная реализация, может выйти за рамки JPA.

// JPA стандарт
EntityManager entityManager;  // JPA interface

// Hibernate extension
Session session = entityManager.unwrap(Session.class);
session.createCriteria(User.class);  // Hibernate API

Лучшие практики

1. Используй Spring Data JPA вместо EntityManager напрямую
2. Аннотация @Repository для интерфейсов
3. Избегай N+1 запросов — используй @EntityGraph или JOIN FETCH
4. Ленивая загрузка (LAZY) по умолчанию для отношений
5. Вместо JPQL используй QueryDSL для типобезопасности
6. Тестируй с @DataJpaTest аннотацией
7. Следи за dirty checking — больших объектов не держи в памяти
8. Используй @Transactional(readOnly = true) для чтения

Пример Spring Data JPA

public interface UserRepository extends JpaRepository<User, Long> {
    Optional<User> findByEmail(String email);
    List<User> findByNameContaining(String name);
    
    @Modifying
    @Query("UPDATE User u SET u.active = true WHERE u.id = :id")
    void activateUser(@Param("id") Long id);
}

@Service
public class UserService {
    @Autowired
    private UserRepository repository;
    
    @Transactional
    public void registerUser(String email, String name) {
        User user = new User(email, name);
        repository.save(user);  // INSERT
    }
    
    @Transactional(readOnly = true)
    public User getUserByEmail(String email) {
        return repository.findByEmail(email).orElse(null);
    }
}

Выводы

JPA — это стандартный подход в Java для работы с БД:

• Преобразует объекты в записи БД
• Управляет жизненным циклом объектов
• Предоставляет объектно-ориентированный API
• Поддерживает отношения между таблицами
• Используется практически во всех Java приложениях