Какие знаешь виды каскадов в Hibernate?

Виды каскадов в Hibernate

###概念和введение

Каскады в Hibernate (CascadeType) — это механизм для автоматического распространения операций (сохранение, удаление, обновление) от родительской сущности к дочерним сущностям. Это критически важно при работе с отношениями между сущностями.

1. PERSIST - Сохранение

CascadeType.PERSIST автоматически сохраняет дочерние сущности при сохранении родительской:

import javax.persistence.*;

@Entity
@Table(name = "users")
public class User {
    
    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;
    
    private String name;
    
    // Каскадное сохранение: если сохраняем User, сохраняются и его Address
    @OneToOne(cascade = CascadeType.PERSIST)
    @JoinColumn(name = "address_id")
    private Address address;
    
    public void setAddress(Address address) {
        this.address = address;
    }
}

@Entity
@Table(name = "addresses")
public class Address {
    
    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;
    
    private String street;
    private String city;
}

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

Address address = new Address();
address.setStreet("123 Main St");
address.setCity("Boston");

user.setAddress(address);

// Сохраняем только user - address будет сохранен автоматически
userRepository.save(user);

2. MERGE - Объединение

CascadeType.MERGE автоматически обновляет дочерние сущности:

@Entity
@Table(name = "products")
public class Product {
    
    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;
    
    private String name;
    private BigDecimal price;
    
    // Каскадное обновление при merge
    @OneToMany(cascade = CascadeType.MERGE)
    @JoinColumn(name = "product_id")
    private List<Review> reviews;
}

@Entity
@Table(name = "reviews")
public class Review {
    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;
    
    private String comment;
    private int rating;
}

// Использование:
Product product = productRepository.findById(1L);
product.setPrice(new BigDecimal("99.99"));

Review review = new Review();
review.setComment("Great product!");
review.setRating(5);
product.getReviews().add(review);

// merge обновит product и все связанные reviews
productRepository.save(product);

3. REMOVE - Удаление

CascadeType.REMOVE автоматически удаляет дочерние сущности при удалении родителя:

@Entity
@Table(name = "posts")
public class Post {
    
    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;
    
    private String title;
    private String content;
    
    // Каскадное удаление: удалим Post - удалятся все Comments
    @OneToMany(mappedBy = "post", cascade = CascadeType.REMOVE, orphanRemoval = true)
    private List<Comment> comments = new ArrayList<>();
    
    public void addComment(Comment comment) {
        comment.setPost(this);
        comments.add(comment);
    }
}

@Entity
@Table(name = "comments")
public class Comment {
    
    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;
    
    private String text;
    
    @ManyToOne
    @JoinColumn(name = "post_id")
    private Post post;
}

// Использование:
Post post = postRepository.findById(1L);
postRepository.delete(post); // Все comments будут удалены автоматически

4. REFRESH - Обновление данных

CascadeType.REFRESH переигрывает сущности со значениями из БД:

@Entity
@Table(name = "orders")
public class Order {
    
    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;
    
    private BigDecimal totalAmount;
    
    // Каскадное обновление при refresh
    @OneToMany(cascade = CascadeType.REFRESH)
    @JoinColumn(name = "order_id")
    private List<OrderItem> items;
}

@Entity
@Table(name = "order_items")
public class OrderItem {
    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;
    
    private String productName;
    private int quantity;
}

// Использование:
Order order = orderRepository.findById(1L);
// Изменяем данные в памяти
order.setTotalAmount(new BigDecimal("500"));

// refresh перечитает из БД и восстановит оригинальные значения
session.refresh(order);

5. DETACH - Отсоединение

CascadeType.DETACH отсоединяет сущность от session:

@Entity
@Table(name = "departments")
public class Department {
    
    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;
    
    private String name;
    
    // При detach - отсоединим department и всех его employees
    @OneToMany(mappedBy = "department", cascade = CascadeType.DETACH)
    private List<Employee> employees;
}

@Entity
@Table(name = "employees")
public class Employee {
    
    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;
    
    private String name;
    
    @ManyToOne
    @JoinColumn(name = "department_id")
    private Department department;
}

// Использование:
Department dept = departmentRepository.findById(1L);
session.detach(dept); // Отсоединим department и всех employees

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

CascadeType.ALL эквивалент для всех типов каскадов сразу:

@Entity
@Table(name = "companies")
public class Company {
    
    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;
    
    private String name;
    
    // Каскад для всех операций
    @OneToMany(mappedBy = "company", cascade = CascadeType.ALL, orphanRemoval = true)
    private List<Branch> branches = new ArrayList<>();
}

@Entity
@Table(name = "branches")
public class Branch {
    
    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;
    
    private String location;
    
    @ManyToOne
    @JoinColumn(name = "company_id")
    private Company company;
}

// ALL эквивалентно:
// cascade = {PERSIST, MERGE, REMOVE, REFRESH, DETACH}

7. Комбинирование каскадов

Можно комбинировать несколько типов каскадов:

@Entity
@Table(name = "projects")
public class Project {
    
    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;
    
    private String name;
    
    // Комбинация: сохранение и удаление, но не merge/refresh
    @OneToMany(mappedBy = "project", cascade = {CascadeType.PERSIST, CascadeType.REMOVE})
    private List<Task> tasks = new ArrayList<>();
}

@Entity
@Table(name = "tasks")
public class Task {
    
    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;
    
    private String description;
    
    @ManyToOne
    @JoinColumn(name = "project_id")
    private Project project;
}

OrphanRemoval - Удаление сирот

orphanRemoval = true удаляет сущности, когда они удалены из коллекции родителя:

@Entity
@Table(name = "documents")
public class Document {
    
    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;
    
    private String title;
    
    // orphanRemoval удалит Page если убрать его из коллекции
    @OneToMany(mappedBy = "document", orphanRemoval = true)
    private List<Page> pages = new ArrayList<>();
}

@Entity
@Table(name = "pages")
public class Page {
    
    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;
    
    @ManyToOne
    @JoinColumn(name = "document_id")
    private Document document;
}

// Использование:
Document doc = documentRepository.findById(1L);

// Удаляем страницу из коллекции
doc.getPages().remove(0); // Страница будет удалена из БД!

documentRepository.save(doc);

Сравнение каскадов

Best Practices

1. Используйте CascadeType.PERSIST для relationships — безопаснее чем ALL
2. CascadeType.REMOVE требует тщательного обдумывания — можно случайно удалить важные данные
3. orphanRemoval = true очень мощный — используйте для действительно зависимых сущностей
4. Избегайте CascadeType.ALL без необходимости — может привести к неожиданному поведению
5. Документируйте каскады — разработчик должен понимать влияние операций
6. Тестируйте каскадное удаление — убедитесь что правильно удаляются зависимые сущности

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

@Entity
@Table(name = "blog_posts")
public class BlogPost {
    
    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;
    
    private String title;
    private String content;
    
    // Комментарии - каскадное удаление + orphanRemoval
    @OneToMany(mappedBy = "post", cascade = CascadeType.PERSIST, orphanRemoval = true)
    private List<Comment> comments = new ArrayList<>();
    
    // Теги - только PERSIST
    @ManyToMany(cascade = CascadeType.PERSIST)
    @JoinTable(
        name = "post_tags",
        joinColumns = @JoinColumn(name = "post_id"),
        inverseJoinColumns = @JoinColumn(name = "tag_id")
    )
    private Set<Tag> tags = new HashSet<>();
    
    public void addComment(Comment comment) {
        comment.setPost(this);
        comments.add(comment);
    }
}

// Использование:
BlogPost post = new BlogPost();
post.setTitle("Java Cascades");

Comment comment = new Comment();
comment.setText("Great article!");
post.addComment(comment);

// Сохранит post и comment
postRepository.save(post);

// Удалит post и все его comments
postRepository.delete(post);

Выводы

Каскады в Hibernate:

• PERSIST — самый безопасный, используйте по умолчанию
• REMOVE — мощный, требует внимания
• ALL — удобный но опасный
• orphanRemoval — для действительно зависимых сущностей
• Правильное использование каскадов критично для data integrity