Можно ли написать два разных объекта в одной транзакции?

# Сохранение нескольких объектов в одной транзакции

Краткий ответ

Да, абсолютно можно! Это одна из основных возможностей транзакций. Несколько операций сохранения (INSERT, UPDATE, DELETE) разных объектов в одной транзакции либо все выполнятся успешно, либо все откатятся вместе.

Суть транзакции (ACID)

Транзакция — это группа операций с гарантией ACID:

• Atomicity (Атомарность) — либо все операции выполнены, либо ни одна
• Consistency (Консистентность) — база остается в согласованном состоянии
• Isolation (Изоляция) — транзакции не влияют друг на друга
• Durability (Долговечность) — результаты сохраняются постоянно

Это позволяет безопасно записывать несколько объектов без риска частичного обновления.

Пример 1: Spring Data JPA с @Transactional

Это самый распространенный способ:

@Service
public class OrderService {
    @Autowired
    private OrderRepository orderRepository;
    
    @Autowired
    private OrderItemRepository orderItemRepository;
    
    @Autowired
    private UserRepository userRepository;
    
    @Transactional // ← Все операции в одной транзакции
    public void createOrder(User user, Order order, List<OrderItem> items) {
        // 1. Сохраняем пользователя (если он новый)
        userRepository.save(user);
        
        // 2. Сохраняем заказ
        orderRepository.save(order);
        
        // 3. Сохраняем все элементы заказа
        for (OrderItem item : items) {
            orderItemRepository.save(item);
        }
        
        // 4. Если произойдет исключение ДО этой строки,
        //    все изменения откатятся (rollback)
        System.out.println("Заказ создан успешно");
    }
}

Пример 2: Явное использование EntityManager

@Service
public class OrderService {
    @PersistenceContext
    private EntityManager entityManager;
    
    @Transactional
    public void createComplexOrder() {
        // Все операции в одной транзакции
        User user = new User("Иван", "ivan@example.com");
        entityManager.persist(user);
        
        Order order = new Order(user, LocalDateTime.now());
        entityManager.persist(order);
        
        OrderItem item1 = new OrderItem(order, "Товар 1", 100);
        OrderItem item2 = new OrderItem(order, "Товар 2", 200);
        entityManager.persist(item1);
        entityManager.persist(item2);
        
        // При выходе из метода все сохранится в одной транзакции
    }
}

Пример 3: Обработка ошибок

@Service
public class OrderService {
    @Autowired
    private OrderRepository orderRepository;
    
    @Autowired
    private PaymentRepository paymentRepository;
    
    @Transactional
    public void createOrderWithPayment(Order order, Payment payment) {
        try {
            // Сохраняем заказ
            orderRepository.save(order);
            
            // Сохраняем платеж
            paymentRepository.save(payment);
            
            // Если платеж отклонен
            if (!payment.isApproved()) {
                throw new PaymentException("Платеж отклонен");
                // Обе записи откатятся (rollback)
            }
        } catch (PaymentException e) {
            // Все изменения отменены благодаря @Transactional
            System.out.println("Ошибка, ничего не сохранено");
        }
    }
}

Пример 4: Сохранение объектов с cascade

Если объекты связаны (parent-child), можно сохранить через parent:

@Entity
@Table(name = "orders")
public class Order {
    @Id
    @GeneratedValue
    private Long id;
    
    private String orderNumber;
    
    // CASCADE persists automatikally saves items
    @OneToMany(cascade = CascadeType.ALL, mappedBy = "order")
    private List<OrderItem> items = new ArrayList<>();
}

@Service
public class OrderService {
    @Autowired
    private OrderRepository orderRepository;
    
    @Transactional
    public void createOrderWithItems() {
        Order order = new Order();
        order.setOrderNumber("ORD-001");
        
        // Добавляем items
        OrderItem item1 = new OrderItem();
        item1.setProduct("Товар 1");
        order.addItem(item1);
        
        OrderItem item2 = new OrderItem();
        item2.setProduct("Товар 2");
        order.addItem(item2);
        
        // Сохраняем только order, items сохранятся автоматически благодаря CASCADE
        orderRepository.save(order);
    }
}

Пример 5: Batch операции

Для больших объемов данных:

@Service
public class BatchOrderService {
    @Autowired
    private OrderRepository orderRepository;
    
    @Transactional
    public void createManyOrders(List<Order> orders) {
        for (int i = 0; i < orders.size(); i++) {
            orderRepository.save(orders.get(i));
            
            // Batch размер 50
            if ((i + 1) % 50 == 0) {
                // Flush промежуточные результаты
                // но в рамках одной транзакции
            }
        }
        
        // Все 1000 заказов сохранятся в одной транзакции
    }
}

Пример 6: Жизненный цикл объектов в транзакции

@Service
public class UserOrderService {
    @Autowired
    private UserRepository userRepository;
    
    @Autowired
    private OrderRepository orderRepository;
    
    @Transactional
    public void complexOperation() {
        // 1. NEW — объект только создан, не в контексте
        User user = new User("Иван", "ivan@example.com");
        
        // 2. MANAGED — после save стал управляемым
        User savedUser = userRepository.save(user);
        
        // 3. Изменение managed объекта
        savedUser.setEmail("newemail@example.com");
        
        // 4. Создание и сохранение второго объекта
        Order order = new Order(savedUser);
        Order savedOrder = orderRepository.save(order);
        
        // 5. При выходе из @Transactional метода:
        //    - Все managed объекты flush'ятся в БД
        //    - Выполняются SQL UPDATE/INSERT для измененных объектов
        //    - Если ошибка — все откатится
    }
}

Пример 7: Контроль точки Commit

@Service
public class OrderService {
    @Autowired
    private OrderRepository orderRepository;
    
    // Propagation.REQUIRES_NEW — новая транзакция
    @Transactional(propagation = Propagation.REQUIRES_NEW)
    public void saveWithNewTransaction(Order order) {
        orderRepository.save(order);
        // Commit произойдет здесь
    }
    
    // Propagation.NESTED — вложенная транзакция (savepoint)
    @Transactional(propagation = Propagation.NESTED)
    public void saveWithSavepoint(Order order) {
        orderRepository.save(order);
        // При ошибке откатится только до savepoint
    }
}

Пример 8: Откат транзакции

@Service
public class OrderService {
    @Autowired
    private OrderRepository orderRepository;
    
    @Autowired
    private PaymentService paymentService;
    
    @Transactional
    public void createOrderWithValidation(Order order) throws ValidationException {
        // Сохраняем заказ
        orderRepository.save(order);
        
        // Проверяем платеж
        if (!paymentService.validate(order.getPayment())) {
            // Выбрасываем checked exception
            throw new ValidationException("Платеж невалиден");
            // Весь заказ откатится благодаря @Transactional
        }
    }
}

Важно: По умолчанию @Transactional откатывает только на RuntimeException и Error, а не на checked Exception.

Для откатки на checked exception:

@Transactional(rollbackFor = {ValidationException.class})
public void createOrderWithValidation(Order order) throws ValidationException {
    // ...
}

Пример 9: Лучше НЕ делать

// ❌ Плохо — нет @Transactional, каждый save это отдельная транзакция
@Service
public class BadOrderService {
    @Autowired
    private OrderRepository orderRepository;
    
    @Autowired
    private PaymentRepository paymentRepository;
    
    public void createOrder(Order order, Payment payment) {
        orderRepository.save(order);    // Транзакция 1 (commit)
        paymentRepository.save(payment); // Транзакция 2 (commit)
        
        // Если платеж отклонен ПОСЛЕ save payment:
        // Заказ уже в БД, но платежа нет!
    }
}

Практическое сравнение

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

✅ Используй @Transactional на уровне Service — для логических операций

✅ Группируй связанные операции — в одном методе

✅ Обрабатывай исключения явно — для контролируемого поведения

✅ Указывай rollbackFor если нужна откатка на checked exception

✅ Используй cascade для связанных объектов

❌ Не смешивай транзакции — одна логическая операция = одна транзакция

❌ Не игнорируй исключения — они сигнализируют о откатке

Заключение

Транзакции в Java/Spring позволяют безопасно сохранять множество объектов в одной "атомной" операции. Если происходит ошибка — всё откатывается, обеспечивая целостность данных. Это один из самых важных инструментов при работе с базами данных.