В чем разница между @After и @AfterReturning?

Разница между @After и @AfterReturning в Spring AOP

Это две разные аннотации в Spring AOP (Aspect-Oriented Programming), которые используются для выполнения кода ПОСЛЕ вызова метода, но с разными особенностями и условиями выполнения.

Краткое объяснение

• @After — выполняется ВСЕГДА после метода (и при успехе, и при ошибке)
• @AfterReturning — выполняется ТОЛЬКО если метод вернул результат (без исключения)

Детальное сравнение

import org.aspectj.lang.annotation.*;
import org.springframework.stereotype.Component;

@Component
@Aspect
public class PaymentAspect {
    
    // ===== @After =====
    // Выполняется ВСЕГДА, независимо от результата
    @After("execution(* com.example.PaymentService.pay(..))")
    public void afterMethod(JoinPoint joinPoint) {
        System.out.println("[@After] Метод завершил работу (успешно или с ошибкой)");
        System.out.println("[@After] Имя метода: " + joinPoint.getSignature().getName());
        // Используется для очистки ресурсов, логирования, уведомлений
    }
    
    // ===== @AfterReturning =====
    // Выполняется ТОЛЬКО если метод вернул результат (без исключения)
    @AfterReturning(
        pointcut = "execution(* com.example.PaymentService.pay(..))",
        returning = "result"
    )
    public void afterReturning(JoinPoint joinPoint, Object result) {
        System.out.println("[@AfterReturning] Метод успешно завершил работу");
        System.out.println("[@AfterReturning] Результат: " + result);
        // Используется для обработки результата
    }
    
    // ===== @AfterThrowing =====
    // Выполняется ТОЛЬКО если метод выбросил исключение
    @AfterThrowing(
        pointcut = "execution(* com.example.PaymentService.pay(..))",
        throwing = "exception"
    )
    public void afterThrowing(JoinPoint joinPoint, Exception exception) {
        System.out.println("[@AfterThrowing] Метод выбросил исключение");
        System.out.println("[@AfterThrowing] Ошибка: " + exception.getMessage());
        // Используется для обработки ошибок
    }
}

Пример с реальным методом

@Service
public class PaymentService {
    
    public PaymentResult pay(double amount) {
        // Сценарий 1: успешный платёж
        if (amount > 0) {
            System.out.println("[PAY] Платёж на сумму " + amount);
            return new PaymentResult("SUCCESS", "Платёж выполнен");
        }
        
        // Сценарий 2: ошибка
        throw new IllegalArgumentException("Сумма должна быть положительной");
    }
}

Сценарий 1: Успешный платёж (amount = 100)

Вывод:
[PAY] Платёж на сумму 100
[@AfterReturning] Метод успешно завершил работу
[@AfterReturning] Результат: PaymentResult(status=SUCCESS, message=Платёж выполнен)
[@After] Метод завершил работу (успешно или с ошибкой)

@After выполнилась ПОСЛЕ @AfterReturning

Сценарий 2: Ошибка (amount = -100)

Вывод:
[PAY] Платёж на сумму -100
[@AfterThrowing] Метод выбросил исключение
[@AfterThrowing] Ошибка: Сумма должна быть положительной
[@After] Метод завершил работу (успешно или с ошибкой)

❌ [@AfterReturning] НЕ выполнилась, потому что было исключение!

Таблица сравнения

Практические примеры

Пример 1: Логирование (используй @After)

@Component
@Aspect
public class LoggingAspect {
    
    @After("execution(* com.example.UserService.*(..))")
    public void logMethodExecution(JoinPoint joinPoint) {
        String methodName = joinPoint.getSignature().getName();
        Object[] args = joinPoint.getArgs();
        
        System.out.println("[LOG] Метод " + methodName + " завершился");
        System.out.println("[LOG] Параметры: " + Arrays.toString(args));
    }
}

Пример 2: Обработка результата (используй @AfterReturning)

@Component
@Aspect
public class ResultProcessingAspect {
    
    @AfterReturning(
        pointcut = "execution(* com.example.UserService.getUser(..))",
        returning = "user"
    )
    public void processUser(JoinPoint joinPoint, User user) {
        if (user != null) {
            System.out.println("[PROCESS] Обработка пользователя: " + user.getName());
            // Дополнительная обработка результата
            user.setProcessedAt(LocalDateTime.now());
        }
    }
}

Пример 3: Обработка ошибок (используй @AfterThrowing)

@Component
@Aspect
public class ErrorHandlingAspect {
    
    private static final Logger logger = LoggerFactory.getLogger(ErrorHandlingAspect.class);
    
    @AfterThrowing(
        pointcut = "execution(* com.example.PaymentService.*(..)))",
        throwing = "ex"
    )
    public void handlePaymentError(JoinPoint joinPoint, Exception ex) {
        logger.error("[ERROR] Ошибка в методе " + joinPoint.getSignature().getName());
        logger.error("[ERROR] Message: " + ex.getMessage());
        
        // Отправить уведомление
        sendErrorNotification(ex);
        
        // Записать в лог ошибок
        recordError(joinPoint, ex);
    }
}

Пример 4: Полный контроль (используй @Around)

@Component
@Aspect
public class PerformanceAspect {
    
    @Around("execution(* com.example.*.*(..))")
    public Object measurePerformance(ProceedingJoinPoint joinPoint) throws Throwable {
        long start = System.currentTimeMillis();
        
        System.out.println("[BEFORE] " + joinPoint.getSignature().getName() + " начался");
        
        try {
            Object result = joinPoint.proceed(); // Вызов оригинального метода
            
            long duration = System.currentTimeMillis() - start;
            System.out.println("[AFTER_SUCCESS] Метод выполнен за " + duration + "ms");
            System.out.println("[RESULT] " + result);
            
            return result;
        } catch (Exception ex) {
            long duration = System.currentTimeMillis() - start;
            System.out.println("[AFTER_ERROR] Метод выполнен за " + duration + "ms");
            System.out.println("[ERROR] " + ex.getMessage());
            
            throw ex;
        }
    }
}

Когда использовать что

@After используй когда:

• Нужно выполнить код независимо от результата
• Нужно освободить ресурсы (как finally блок)
• Нужно записать логи выполнения
• Нужно отправить метрики мониторинга

@AfterReturning используй когда:

• Нужно обработать результат метода
• Результат нужно преобразовать или дополнить
• Нужно логировать только успешные вызовы
• Нужно выполнить действие только при успехе

@AfterThrowing используй когда:

• Нужно обработать исключения специфически
• Нужно логировать ошибки
• Нужно отправить алерт об ошибке
• Нужно выполнить cleanup при ошибке

@Around используй когда:

• Нужен полный контроль над выполнением
• Нужно перехватить результат или исключение
• Нужно измерить время выполнения
• Нужно подменить результат
• Нужно решить, вызывать ли оригинальный метод

Важный момент: Порядок выполнения

@Aspect
public class ExecutionOrderAspect {
    
    @Before("execution(* test(..))")
    public void before() { System.out.println("1. @Before"); }
    
    @AfterReturning("execution(* test(..))")
    public void afterReturning() { System.out.println("3. @AfterReturning"); }
    
    @AfterThrowing("execution(* test(..))")
    public void afterThrowing() { System.out.println("3. @AfterThrowing"); }
    
    @After("execution(* test(..))")
    public void after() { System.out.println("4. @After"); }
    
    @Around("execution(* test(..))")
    public Object around(ProceedingJoinPoint jp) throws Throwable {
        System.out.println("0. @Around (до)");
        Object result = jp.proceed();
        System.out.println("5. @Around (после)");
        return result;
    }
}

Порядок при успехе:

0. @Around (до)
1. @Before
[МЕТОД]
3. @AfterReturning
4. @After
5. @Around (после)

Порядок при ошибке:

0. @Around (до)
1. @Before
[МЕТОД]
3. @AfterThrowing
4. @After
5. @Around (после/exception)

Заключение

Ключевые отличия:

• @After = finally блок (выполняется всегда)
• @AfterReturning = обработка успешного результата
• @AfterThrowing = обработка исключений
• @Around = полный контроль (когда нужна комбинация всех вышеперечисленных)

Это важный вопрос для позиции Java Developer, так как показывает знание Spring AOP и понимание жизненного цикла методов.