Будут ли работать конструкции с приватным методом, помеченным @Transactional

# @Transactional на приватных методах — работает ли это?

Ответ: НЕТ, не будет работать. @Transactional на приватных методах игнорируется Spring. Это одна из самых частых ошибок при работе с транзакциями в Spring.

Почему это не работает?

Механизм @Transactional в Spring

Spring использует AOP (Aspect-Oriented Programming) для реализации @Transactional:

@Transactional на методе
        ↓
Spring создаёт прокси-объект
        ↓
Прокси перехватывает вызов извне
        ↓
Определяет конфигурацию транзакции
        ↓
Создаёт транзакцию
        ↓
Вызывает реальный метод
        ↓
Коммитит/откатывает транзакцию

Проблема: приватные методы вызываются ВНУТРИ объекта, не через прокси!

Пример, что НЕ работает

@Service
public class UserService {
    @Autowired
    private UserRepository userRepository;
    
    // ❌ Это НЕ будет работать!
    @Transactional
    private void saveUserPrivate(User user) {
        userRepository.save(user);
    }
    
    public void createUser(String name) {
        User user = new User(name);
        // Вызываем приватный метод
        saveUserPrivate(user);  // ПРОБЛЕМА: это не через прокси!
    }
}

// Что происходит:
// 1. Spring создаёт прокси для UserService
// 2. При вызове createUser() → прокси перехватывает (нет @Transactional)
// 3. Выполняется createUser() из реального объекта
// 4. Внутри createUser() вызывается saveUserPrivate()
// 5. Это прямой вызов, не через прокси! → @Transactional ИГНОРИРУЕТСЯ
// 6. Кода спасатель: если нет @Transactional на createUser(),
//    то saveUserPrivate выполняется БЕЗ транзакции

Последствия: ошибка RuntimeException

@Service
public class ProblematicService {
    @Autowired
    private UserRepository userRepository;
    
    @Transactional
    private void saveAndThrow(User user) throws Exception {
        userRepository.save(user);  // Сохранили пользователя
        throw new RuntimeException("Ошибка!");
        // @Transactional игнорируется → НЕТ ROLLBACK!
    }
    
    public void process(User user) {
        try {
            saveAndThrow(user);  // Вызов через this
        } catch (Exception e) {
            System.out.println("Ошибка произошла, но пользователь сохранён!");
            // User уже в БД, хотя был exception! Ошибка!
        }
    }
}

Правильные решения

Решение 1: Сделай метод публичным

// ✅ Правильно
@Service
public class UserService {
    @Autowired
    private UserRepository userRepository;
    
    @Transactional  // На публичном методе
    public void saveUser(User user) {
        userRepository.save(user);
    }
    
    public void createUser(String name) {
        User user = new User(name);
        saveUser(user);  // Через прокси!
    }
}

// Что происходит:
// 1. Spring создаёт прокси
// 2. createUser() вызывается → прокси не лезет (нет @Transactional)
// 3. Внутри createUser() вызывается saveUser()
// 4. НО: вызов через this, НЕ через прокси!
// → ВСЁ ЕЩЕ НЕ РАБОТАЕТ!

Решение 2: Внедри другой сервис через @Autowired

// ✅ ПРАВИЛЬНО - используем инъекцию
@Service
public class UserService {
    @Autowired
    private UserRepository userRepository;
    
    @Autowired
    private UserTransactionService transactionService;
    
    public void createUser(String name) {
        User user = new User(name);
        // Вызов через инъектированный бин → через прокси!
        transactionService.saveUserWithTransaction(user);
    }
}

@Service
public class UserTransactionService {
    @Autowired
    private UserRepository userRepository;
    
    @Transactional  // На публичном методе
    public void saveUserWithTransaction(User user) {
        userRepository.save(user);
    }
}

// Что происходит:
// 1. Spring создаёт прокси для обоих сервисов
// 2. createUser() вызывает transactionService.saveUserWithTransaction()
// 3. Это вызов через инъектированный бин → ЧЕРЕЗ ПРОКСИ!
// 4. Прокси видит @Transactional и создаёт транзакцию
// 5. ✓ РАБОТАЕТ!

Решение 3: Используй self-call через ApplicationContext

// ✓ Работает, но не рекомендуется
@Service
public class UserService {
    @Autowired
    private ApplicationContext applicationContext;
    
    @Autowired
    private UserRepository userRepository;
    
    public void createUser(String name) {
        User user = new User(name);
        // Получаем прокси этого сервиса
        UserService proxy = applicationContext.getBean(UserService.class);
        proxy.saveUser(user);  // Вызов через прокси!
    }
    
    @Transactional  // Теперь это работает!
    public void saveUser(User user) {
        userRepository.save(user);
    }
}

Решение 4: Используй protected или package-private (если наследуется)

// ✓ Если класс наследуется
@Service
public class UserService {
    @Autowired
    private UserRepository userRepository;
    
    @Transactional  // protected — видим в подклассах
    protected void saveUser(User user) {
        userRepository.save(user);
    }
    
    public void createUser(String name) {
        User user = new User(name);
        // Нужно убедиться, что вызов через прокси!
        // Лучше использовать решение 2
    }
}

Практический пример: что работает, что нет

@Service
public class PaymentService {
    @Autowired
    private PaymentRepository paymentRepository;
    
    // ❌ НЕ РАБОТАЕТ: приватный метод
    @Transactional
    private void processPaymentPrivate(Payment payment) {
        paymentRepository.save(payment);
    }
    
    // ✓ РАБОТАЕТ: публичный метод, но нужно вызывать из другого бина
    @Transactional
    public void processPaymentPublic(Payment payment) {
        paymentRepository.save(payment);
    }
    
    // ❌ НЕ РАБОТАЕТ: this.processPaymentPublic()
    public void buyProduct(String productId) {
        Payment payment = new Payment(productId);
        // Это вызов через this, не через прокси!
        this.processPaymentPublic(payment);  // ← @Transactional ИГНОРИРУЕТСЯ
    }
    
    // ✓ РАБОТАЕТ: вызов через инъектированный бин
    @Autowired
    private TransactionProcessor processor;
    
    public void buyProductCorrect(String productId) {
        Payment payment = new Payment(productId);
        // Вызов через инъектированный бин → через прокси!
        processor.process(payment);  // ← @Transactional РАБОТАЕТ
    }
}

@Service
public class TransactionProcessor {
    @Autowired
    private PaymentRepository paymentRepository;
    
    @Transactional
    public void process(Payment payment) {
        paymentRepository.save(payment);
    }
}

Таблица: что работает, а что нет

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

✓ @Transactional на public методах сервисов ✓ Вызывай транзакционные методы через инъектированные бины ✓ НЕ используй this.method() для вызова @Transactional методов ✓ Если нужен self-call, используй @Autowired зависимость ✓ Тестируй транзакции в интеграционных тестах, не unit-тестах ✓ Помни, что @Transactional это AOP proxy magic

Сложный случай: внутренние вызовы

@Service
public class OrderService {
    @Autowired
    private OrderRepository orderRepository;
    
    @Autowired
    private OrderService self;  // Инъектируем сами себя!
    
    public void createOrder(Order order) {
        // Используем инъектированную копию для вызова @Transactional методов
        self.saveOrderWithValidation(order);
    }
    
    @Transactional
    public void saveOrderWithValidation(Order order) {
        validateOrder(order);  // this.validateOrder OK
        orderRepository.save(order);
    }
    
    private void validateOrder(Order order) {
        // Валидация
    }
}

// Что происходит:
// 1. self — это прокси (инъектируется Spring)
// 2. createOrder() вызывает self.saveOrderWithValidation()
// 3. Это вызов через прокси! @Transactional РАБОТАЕТ!
// 4. ✓ РАБОТАЕТ ПРАВИЛЬНО!