Advices в Spring AOP играют ключевую роль в определении поведения аспектов. Они описывают, что именно делает аспект в определенные моменты выполнения программы. Иными словами, если бы ваш аспект был сценаристом фильма, то advices определили бы, какие именно сцены и когда следует показать.

Давайте рассмотрим каждый из видов advices подробнее:

1. Before Advice

Как можно догадаться по названию, “Before Advice” выполняется до вызова целевого метода. Но что это значит на практике? Это как будто перед тем, как вы начнете готовить обед, зазвонил будильник, напоминающий о том, что нужно помыть руки. “Before Advice” действует как этот будильник — он перехватывает выполнение и добавляет действие, которое должно произойти до основного действия.

2. After Returning Advice

Этот тип advice выполняется после того, как целевой метод успешно завершен, и возвращает результат. Представьте, что после приготовления обеда у вас есть традиция записывать, какой ингредиент вы использовали больше всего. “After Returning Advice” именно так и работает: он отслеживает результат и позволяет вам добавить дополнительное действие после успешного завершения основного метода.

3. After Throwing Advice

Если в процессе выполнения целевого метода возникает исключение, именно здесь вступает в действие “After Throwing Advice”. Это как если бы вы пытались приготовить новое блюдо, и что-то пошло не так — например, вы пересолили. Вместо того чтобы просто отбросить все и начать сначала, вы решили бы заметить свою ошибку и занести её в книгу кулинарных ошибок. Этот advice помогает обрабатывать исключения и реагировать на них соответствующим образом.

4. After (or After Finally) Advice

“After Advice” гарантирует, что определенный код будет выполнен после вызова целевого метода, независимо от того, завершился ли метод успешно или с исключением. Это как если бы после приготовления обеда, независимо от результата, вы бы всегда молились в благодарность за еду. Это гарантированный шаг, который следует сразу после основного действия.

5. Around Advice

Этот тип advice был упомянут ранее и является одним из самых мощных. Он позволяет вам обернуть вызов метода, добавив код до и после его выполнения, а также модифицировать результат или исключение. Это как если бы вы могли контролировать весь процесс приготовления обеда от начала до конца, включая выбор ингредиентов, способ приготовления и даже презентацию блюда на столе. Понимание различных advices и их возможностей критически важно для эффективного использования AOP в Spring, так как именно они определяют, как и когда ваш аспект будет вмешиваться в выполнение приложения.

Before Advice

Before Advice — это действительно интересная штука. Если рассматривать его в контексте кино, то это как предыстория перед основным фильмом или как короткая реклама перед основным шоу. 

Что такое Before Advice?

“Before Advice” в Spring AOP позволяет вам выполнять определенный код перед вызовом целевого метода. Вы можете считать его своеобразным “стражем” или “предвестником”, который выполняет свою работу прежде, чем основное действие начинается. 

Зачем это может быть полезно?

В мире программирования есть множество ситуаций, когда перед выполнением основного метода необходимо выполнить предварительную проверку или какое-то действие. Например:

1. Проверить, имеет ли пользователь необходимые права доступа для вызова метода.

2. Залогировать информацию о вызове метода.

3. Инициировать какой-то ресурс. 

Пример кода с Before Advice:

Допустим, у нас есть веб-приложение, и мы хотим логировать информацию о том, когда пользователи пытаются получить доступ к некоторой защищенной странице.

1. Сначала определим наш аспект:

@Component
@Aspect
public class LoggingAspect {

    2. Теперь добавим Before Advice, который будет логировать каждый вызов
    метода viewProtectedPage():

    @Before("execution(* com.example.service.UserService.viewProtectedPage(..))")
    public void logBeforeAccess() {
        System.out.println("Попытка доступа к защищенной странице!");
    }
}

В этом коде execution(* com.example.service.UserService.viewProtectedPage(..)) — это точка соединения (pointcut), которая указывает, когда именно будет срабатывать наш advice. В нашем случае, он срабатывает перед каждым вызовом метода viewProtectedPage() в классе UserService. Таким образом, каждый раз, когда этот метод вызывается, перед его выполнением в консоль будет выводиться сообщение “Попытка доступа к защищенной странице!”.

After Advice

Думаю, многие из нас помнят момент в кино, когда после основного фильма появляется дополнительная сцена. Это чаще всего дает нам какой-то интересный поворот или намек на будущие события. В мире Spring AOP, “After Advice” действует именно так! Что такое After Advice? “After Advice” в Spring AOP позволяет вам выполнить код непосредственно после вызова целевого метода, независимо от того, был ли вызов успешным или завершился исключением. Это похоже на тот момент, когда, закончив книгу, вы начинаете прочитывать послесловие автора. 

Почему это может быть полезно?

1. Логирование завершения работы метода или результата его работы.

2. Освобождение ресурсов.

3. Закрытие соединений или других важных операций, которые должны быть выполнены после основного действия. 

Пример кода с After Advice:

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

1. Создадим аспект:

@Component
@Aspect
public class TaskCompletionAspect {

    2. Добавим After Advice для отслеживания завершения задания:
    
    @After("execution(* com.example.service.TaskService.completeTask(..))")
    public void logAfterTaskCompletion() {
        System.out.println("Задание успешно завершено!");
    }
}

Здесь execution(* com.example.service.TaskService.completeTask(..)) — это точка соединения (pointcut), которая указывает, когда будет активирован наш advice. В данном случае, после каждого вызова метода completeTask() в классе TaskService. Так, после завершения задания в консоли мы увидим сообщение: “Задание успешно завершено!”. “After Advice” отличный способ убедиться, что определенный код будет выполнен после основной логики в вашем приложении, что делает его незаменимым инструментом при создании надежных и масштабируемых приложений на Spring. 

AfterReturning Advice

Помните, когда вы впервые приготовили что-то сложное, например, торт, и не могли дождаться, чтобы узнать, насколько вкусно получилось? Или когда вы делаете что-то важное и хотите быть уверены, что все прошло гладко? Вот именно этот момент охватывает “AfterReturning Advice” в мире Spring AOP!

Что такое AfterReturning Advice?

“AfterReturning Advice” в Spring AOP позволяет вам выполнить код после успешного завершения целевого метода, то есть когда метод выполнен и не выбрасывает исключения. Этот advice особенно полезен, когда вы хотите что-то сделать с возвращаемым значением метода.

Почему это может быть полезно?

1. Модифицировать возвращаемое значение.

2. Логировать результат работы метода.

3. Выполнить дополнительные проверки или действия на основе возвращаемого значения.

Пример кода с AfterReturning Advice:

Допустим, у нас есть сервис, который возвращает некоторое сообщение для пользователя на основе его действий в приложении.

1. Определите аспект: 

@Component
@Aspect
public class MessageAspect {

   2. Добавим AfterReturning Advice, чтобы логировать возвращаемое сообщение:
    
@AfterReturning(pointcut = "execution(* com.example.service.MessageService.getUserMessage(..))", returning = "message")
public void logUserMessage(String message) {
        System.out.println("Возвращаемое сообщение: " + message);
        }
}

Здесь execution(* com.example.service.MessageService.getUserMessage(..)) — это точка соединения (pointcut), которая определяет, когда срабатывает наш advice. С помощью атрибута returning, мы указываем, что хотим получить возвращаемое значение метода и использовать его в нашем advice. Таким образом, когда метод getUserMessage() будет вызван и успешно завершен, в консоль будет выводиться сообщение, возвращаемое этим методом. “AfterReturning Advice” предоставляет нам мощный инструмент для работы с возвращаемыми значениями методов, что позволяет добавить дополнительную функциональность и контроль в наше приложение. 

AfterThrowing Advice 

“AfterThrowing Advice” в Spring AOP позволяет вам выполнить код в случае, если целевой метод выбрасывает исключение. Это отличный способ управлять исключениями и предоставлять информацию о том, что пошло не так. 

Почему это может быть полезно?

1. Логирование исключений.

2. Отправка оповещений разработчикам или системам мониторинга

3. Предоставление пользователю дружественного сообщения об ошибке.

 Пример кода с AfterThrowing Advice:

Допустим, у нас есть сервис для обработки платежей, и мы хотим узнать, когда происходит ошибка.

@Component
@Aspect
public class PaymentAspect {

@AfterThrowing(pointcut = "execution(* com.example.service.PaymentService.processPayment(..))", throwing = "exception")
public void logPaymentError(Exception exception) {
        System.out.println("Произошла ошибка при обработке платежа: " +
        exception.getMessage());
        }
}

Здесь execution(* com.example.service.PaymentService.processPayment(..)) — это точка соединения (pointcut). Атрибут throwing позволяет нам захватить исключение, выброшенное целевым методом, и использовать его в нашем advice. Таким образом, если метод processPayment() выбросит исключение, мы увидим сообщение об ошибке в консоли. “AfterThrowing Advice” дает нам возможность эффективно реагировать на исключения и улучшать устойчивость нашего приложения к ошибкам. 

Around Advice

Что такое Around Advice?

“Around Advice” в Spring AOP оборачивает целевой метод, предоставляя вам возможность выполнения действий и до, и после его вызова, а также контролировать сам процесс вызова. Это самый мощный тип advice, так как дает полный контроль над выполнением метода

Почему это может быть полезно?

. Измерение времени выполнения метода.

2. Транзакционное управление.

3. Изменение аргументов или возвращаемого значения метода.

4. Предотвращение вызова целевого метода под определенными условиями. 

@Component
@Aspect
public class PerformanceAspect {    
    @Around("execution(* com.example.service.HeavyDutyService.performTask(..))")
    public Object measureExecutionTime(ProceedingJoinPoint joinPoint)
            throws Throwable {
        long startTime = System.currentTimeMillis();
        Object result = joinPoint.proceed(); // вызов целевого метода
        long endTime = System.currentTimeMillis();
        System.out.println("Метод " + joinPoint.getSignature() + " выполнялся " +
                (endTime - startTime) + " миллисекунд.");

        return result; // возвращаем результат выполнения целевого метода
    }

}

Здесь метод joinPoint.proceed() вызывает целевой метод. Время, затраченное на его выполнение, измеряется и выводится в консоли. “Around Advice” — это, безусловно, мощный инструмент в вашем арсенале Spring AOP, который предоставляет гибкость и контроль над выполнением методов.