Around advice is declared by annotating a method with the
@Around annotation. The method should declare
Object as its return type, and the first parameter of the method must be of type
ProceedingJoinPoint. Within the body of the advice method, you must invoke
proceed() on the
ProceedingJoinPoint in order for the underlying method to run. Invoking
proceed() without arguments will result in the caller’s original arguments being supplied to the underlying method when it is invoked. For advanced use cases, there is an overloaded variant of the
proceed() method which accepts an array of arguments (
Object). The values in the array will be used as the arguments to the underlying method when it is invoked.
The value returned by the around advice is the return value seen by the caller of the method. For example, a simple caching aspect could return a value from a cache if it has one or invoke
proceed() (and return that value) if it does not. Note that
proceed may be invoked once, many times, or not at all within the body of the around advice. All of these are legal.
If you declare the return type of your around advice method as
null will always be returned to the caller, effectively ignoring the result of any invocation of
proceed(). It is therefore recommended that an around advice method declare a return type of
Object. The advice method should typically return the value returned from an invocation of
proceed(), even if the underlying method has a
void return type. However, the advice may optionally return a cached value, a wrapped value, or some other value depending on the use case.