Почему не выполнится транзакция с помощью приватного метода с аннотацией Transactional?

# Почему не выполнится транзакция с помощью приватного метода с @Transactional

Транзакция НЕ выполнится на приватном методе с аннотацией @Transactional из-за того, как Spring реализует управление транзакциями через прокси и отражение (Reflection).

Как работает @Transactional

Spring создаёт прокси-объект (обёртку) вокруг класса с аннотацией @Transactional. Этот прокси перехватывает вызовы методов и оборачивает их в транзакции.

@Service
public class UserService {
    
    @Autowired
    private UserRepository userRepository;
    
    @Transactional // Работает на public методе
    public void createUser(String name) {
        userRepository.save(new User(name));
    }
    
    @Transactional // НЕ работает на private методе
    private void sendNotification(User user) {
        // Это не выполнится в транзакции
    }
}

// Spring создаёт примерно такой прокси:
public class UserServiceProxy extends UserService {
    @Override
    public void createUser(String name) {
        TransactionManager txManager = ...
        Transaction tx = txManager.begin();
        try {
            super.createUser(name); // Вызов исходного метода
            txManager.commit(tx);
        } catch (Exception e) {
            txManager.rollback(tx);
            throw e;
        }
    }
}

Проблема: Приватные методы не переопределяются

Прокси работает через переопределение методов. Но приватные методы:

1. Не могут быть переопределены (final по сути)
2. Видны только внутри класса
3. Не входят в интерфейс класса

@Service
public class UserService {
    
    @Transactional
    public void publicMethod() {
        privateMethod(); // Прямой вызов, БЕЗ прокси!
    }
    
    @Transactional
    private void privateMethod() {
        // НИКОГДА не выполнится в транзакции
        // Потому что это прямой вызов, не через прокси
    }
}

// Эквивалент происходит так:
public class UserServiceProxy extends UserService {
    @Override
    public void publicMethod() {
        // Прокси оборачивает в транзакцию
        tx.begin();
        try {
            super.publicMethod(); // Вызывает исходный публичный метод
            // Внутри publicMethod() вызывается this.privateMethod()
            // это.privateMethod() = this != proxy, это прямой вызов БЕЗ прокси
            tx.commit();
        }
    }
}

Пример проблемы

@Service
public class OrderService {
    
    @Autowired
    private OrderRepository orderRepository;
    
    @Transactional
    public void placeOrder(Order order) {
        orderRepository.save(order); // Работает в транзакции
        sendConfirmation(order);      // Вызывает приватный метод
    }
    
    @Transactional // ИГНОРИРУЕТСЯ!
    private void sendConfirmation(Order order) {
        // Если здесь произойдёт ошибка — плейс НЕ откатится
        // Потому что это не в транзакции
        sendEmail(order); // Может упасть без откатки заказа
    }
}

Решение 1: Сделать метод public

@Service
public class OrderService {
    
    @Transactional
    public void placeOrder(Order order) {
        orderRepository.save(order);
        sendConfirmation(order);
    }
    
    @Transactional // Теперь работает!
    public void sendConfirmation(Order order) {
        sendEmail(order);
    }
}

Решение 2: Вызвать через другой бин

@Service
public class OrderService {
    
    @Autowired
    private NotificationService notificationService; // Внедряем другой сервис
    
    @Transactional
    public void placeOrder(Order order) {
        orderRepository.save(order);
        notificationService.sendConfirmation(order); // Вызываем через инъекцию
    }
}

@Service
public class NotificationService {
    
    @Transactional
    public void sendConfirmation(Order order) {
        // Теперь это работает в отдельной транзакции
        sendEmail(order);
    }
}

Решение 3: Получить прокси через ApplicationContext

@Service
public class OrderService implements ApplicationContextAware {
    
    private ApplicationContext applicationContext;
    
    @Override
    public void setApplicationContext(ApplicationContext ctx) {
        this.applicationContext = ctx;
    }
    
    @Transactional
    public void placeOrder(Order order) {
        orderRepository.save(order);
        // Получаем прокси версию самого себя
        OrderService proxy = applicationContext.getBean(OrderService.class);
        proxy.sendConfirmation(order); // Теперь через прокси!
    }
    
    @Transactional
    public void sendConfirmation(Order order) {
        sendEmail(order);
    }
}

Почему Spring не может это сделать на приватных методах

1. Отражение (Reflection) — не может переопределить приватные методы
2. Контракт Java — приватные методы не входят в открытый интерфейс класса
3. Безопасность — приватность должна соблюдаться
4. Инкапсуляция — приватный метод это деталь реализации

Важное правило

// ✅ Правильно
@Service
public class MyService {
    @Transactional
    public void publicMethod() { }
}

// ❌ Неправильно
@Service
public class MyService {
    @Transactional
    private void privateMethod() { }
}

// ❌ Также не работает
@Service
public class MyService {
    @Transactional
    protected void protectedMethod() { } // Тоже может не работать из-за видимости
}

Вывод: Всегда используй public для методов с @Transactional, если хочешь, чтобы аннотация работала корректно.