anchor.diff:  			method="doAccessCheck"/>
   
   		...
  -
   	</aop:aspect>
   ----
   
  
positive.code: 			} while(numAttempts <= this.maxRetries);
  			throw lockFailureException;
  		}
  
  	}
  ----
  [source,kotlin,indent=0,subs="verbatim,quotes",role="secondary"]
  
negative.code: 		fun doReleaseLock() {
  			// ...
  		}
  	}
  ----
  
  [NOTE]
  ====
  Note that `@After` advice in AspectJ is defined as "after finally advice", analogous
  to a finally block in a try-catch statement. It will be invoked for any outcome,
  normal return or exception thrown from the join point (user-declared target method),
  in contrast to `@AfterReturning` which only applies to successful normal returns.
  ====
  
  
  [[aop-ataspectj-around-advice]]
  ==== Around Advice
  
  The last kind of advice is around advice. Around advice runs "`around`" a matched
  method's execution. It has the opportunity to do work both before and after the method
  runs and to determine when, how, and even if the method actually gets to run at all.
  Around advice is often used if you need to share state before and after a method
  execution in a thread-safe manner (starting and stopping a timer, for example).
  Always use the least powerful form of advice that meets your requirements (that is,
  do not use around advice if before advice would do).
  
  Around advice is declared by using the `@Around` annotation. The first parameter of the
  advice method must be of type `ProceedingJoinPoint`. Within the body of the advice,
  calling `proceed()` on the `ProceedingJoinPoint` causes the underlying method to run.
  The `proceed` method can also pass in an `Object[]`. The values in the array are used
  as the arguments to the method execution when it proceeds.
  
  NOTE: The behavior of `proceed` when called with an `Object[]` is a little different than
  the behavior of `proceed` for around advice compiled by the AspectJ compiler. For around
  advice written using the traditional AspectJ language, the number of arguments passed to
  `proceed` must match the number of arguments passed to the around advice (not the number
  of arguments taken by the underlying join point), and the value passed to proceed in a
  