Что такое каскадная операция?

Каскадные операции в JPA и Hibernate

Каскадная операция (cascade operation) — это автоматическое распространение действия из родительского объекта на дочерние связанные объекты. Вместо того чтобы вручную сохранять, удалять или обновлять каждый объект, можно применить операцию к родителю, и она автоматически пройдёт по цепочке связей.

Основное понятие

Без каскада:

@Entity
public class User {
    @Id
    private Long id;
    private String name;
    
    @OneToMany
    private List<Post> posts;  // Без каскада
}

// Использование:
User user = new User();
user.setName("John");
userRepository.save(user);  // Сохраняется только User

Post post1 = new Post();
post1.setTitle("My post");
post1.setUser(user);
postRepository.save(post1);  // Нужно отдельно сохранять

Post post2 = new Post();
post2.setTitle("Another post");
post2.setUser(user);
postRepository.save(post2);  // И ещё раз

С каскадом:

@Entity
public class User {
    @Id
    private Long id;
    private String name;
    
    @OneToMany(cascade = CascadeType.PERSIST)
    private List<Post> posts;  // С каскадом!
}

// Использование:
User user = new User();
user.setName("John");

Post post1 = new Post();
post1.setTitle("My post");
user.getPosts().add(post1);

Post post2 = new Post();
post2.setTitle("Another post");
user.getPosts().add(post2);

userRepository.save(user);  // Все посты сохраняются автоматически!

Типы каскадных операций

1. CascadeType.PERSIST — Сохранение

@OneToMany(cascade = CascadeType.PERSIST)
private List<Post> posts;

Если ты сохранил User, автоматически сохранятся все новые Post в списке:

User user = new User();
Post post = new Post();
user.getPosts().add(post);

userRepository.save(user);  // post ТОЖЕ сохранится

2. CascadeType.MERGE — Обновление

@OneToMany(cascade = CascadeType.MERGE)
private List<Post> posts;

Если ты обновил User, обновятся и все Post:

User user = userRepository.findById(1L).get();
Post post = user.getPosts().get(0);
post.setTitle("Updated title");

userRepository.save(user);  // post ТОЖЕ обновится

3. CascadeType.REMOVE — Удаление

@OneToMany(cascade = CascadeType.REMOVE)
private List<Post> posts;

Если удалил User, удалятся и все Post:

User user = userRepository.findById(1L).get();
userRepository.delete(user);  // Все его посты ТОЖЕ удалятся

Это опасно — будь осторожен!

4. CascadeType.REFRESH — Обновление из БД

@OneToMany(cascade = CascadeType.REFRESH)
private List<Post> posts;

5. CascadeType.DETACH — Отсоединение

@OneToMany(cascade = CascadeType.DETACH)
private List<Post> posts;

6. CascadeType.ALL — Все операции

@OneToMany(cascade = CascadeType.ALL)
private List<Post> posts;  // PERSIST + MERGE + REMOVE + REFRESH + DETACH

Это эквивалентно:

cascade = {CascadeType.PERSIST, CascadeType.MERGE, CascadeType.REMOVE,
           CascadeType.REFRESH, CascadeType.DETACH}

Реальные примеры

Пример 1: User с Posts (один-ко-многим)

@Entity
public class User {
    @Id
    @GeneratedValue
    private Long id;
    private String name;
    
    @OneToMany(mappedBy = "user", cascade = CascadeType.ALL)
    private List<Post> posts = new ArrayList<>();
}

@Entity
public class Post {
    @Id
    @GeneratedValue
    private Long id;
    private String title;
    
    @ManyToOne
    private User user;
}

// Использование
User user = new User();
user.setName("Alice");

Post post1 = new Post();
post1.setTitle("First post");
post1.setUser(user);
user.getPosts().add(post1);

Post post2 = new Post();
post2.setTitle("Second post");
post2.setUser(user);
user.getPosts().add(post2);

userRepository.save(user);  // Оба поста сохранятся

Пример 2: Company с Employees (опасный каскад)

@Entity
public class Company {
    @Id
    private Long id;
    private String name;
    
    @OneToMany(mappedBy = "company", cascade = CascadeType.REMOVE)
    private List<Employee> employees;
}

// ОСТОРОЖНО!
Company company = companyRepository.findById(1L).get();
companyRepository.delete(company);  // ВСЕ сотрудники УДАЛЯТСЯ!

Этого часто не хотят. Лучше:

@OneToMany(mappedBy = "company", cascade = CascadeType.PERSIST)
private List<Employee> employees;  // Только сохранение, не удаление

Пример 3: Order с Items (правильный каскад)

@Entity
public class Order {
    @Id
    @GeneratedValue
    private Long id;
    
    @OneToMany(mappedBy = "order", cascade = CascadeType.ALL, orphanRemoval = true)
    private List<OrderItem> items = new ArrayList<>();
    
    public void addItem(OrderItem item) {
        items.add(item);
        item.setOrder(this);
    }
    
    public void removeItem(OrderItem item) {
        items.remove(item);
        item.setOrder(null);
    }
}

@Entity
public class OrderItem {
    @Id
    @GeneratedValue
    private Long id;
    
    @ManyToOne
    private Order order;
}

// Использование
Order order = new Order();
OrderItem item1 = new OrderItem();
order.addItem(item1);

orderRepository.save(order);  // Item тоже сохранится

// Удаление item
order.removeItem(item1);
orderRepository.save(order);  // Item удалится (благодаря orphanRemoval)

orphanRemoval — Удаление сирот

orphanRemoval работает с каскадом, но решает другую проблему — удаление объектов, у которых нет родителя.

@OneToMany(mappedBy = "order", cascade = CascadeType.ALL, orphanRemoval = true)
private List<OrderItem> items;

// Если убрать item из списка, он автоматически удалится из БД
items.remove(item);  // item станет "сиротой" и удалится

Без orphanRemoval:

@OneToMany(mappedBy = "order", cascade = CascadeType.ALL)
private List<OrderItem> items;

items.remove(item);  // item остаётся в БД со значением order_id = NULL

Проблемы и опасности

Проблема 1: Случайное удаление

// Опасно!
@OneToMany(cascade = CascadeType.REMOVE)
private List<Tag> tags;  // Теги используются в других местах

// Если удалить Post, удалятся ВСЕ его теги из БД!
postRepository.delete(post);

Решение: Используй конкретные каскады

@OneToMany(cascade = CascadeType.PERSIST)  // Только сохранение
private List<Tag> tags;

Проблема 2: Производительность

// Может быть медленно при большом количестве объектов
@OneToMany(cascade = CascadeType.REMOVE)
private List<Post> posts;  // 100 тысяч постов

postRepository.delete(user);  // Будет удалять по одному

Решение: Используй Bulk Delete

@Query("DELETE FROM Post p WHERE p.user.id = :userId")
void deleteAllPostsByUserId(Long userId);

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

1. Используй CascadeType.PERSIST + CascadeType.MERGE

@OneToMany(cascade = {CascadeType.PERSIST, CascadeType.MERGE})
private List<Post> posts;

Это безопасно и удобно.

2. Избегай CascadeType.REMOVE

// Лучше явно удаляй дочерние объекты
postRepository.deleteByUserId(userId);
userRepository.delete(user);

3. Используй orphanRemoval для зависимых объектов

@OneToMany(mappedBy = "order", cascade = CascadeType.ALL, orphanRemoval = true)
private List<OrderItem> items;  // OrderItem имеет смысл только с Order

4. Всегда явно устанавливай связь в обе стороны

Order order = new Order();
OrderItem item = new OrderItem();

order.addItem(item);  // Установи связь в обе стороны
orderRepository.save(order);

Таблица: Когда использовать каскады

Итог

Каскадные операции автоматизируют работу с связанными объектами, но требуют осторожности:

• PERSIST и MERGE — безопасны и полезны
• REMOVE — опасен, используй редко
• orphanRemoval — используй для зависимых объектов
• Всегда думай о семантике: объект действительно должен удаляться при удалении родителя?