@aspectj pointcut for all methods of a class with specific annotation

Diving deeper into pointcut combination

You can tune your pointcut definition by intertwining method-level pointcuts and type-level pointcuts. Here's how you set up monitoring for any public methods stashed within classes bedecked with a specific annotation, like @Monitor, which triumphs in arenas like auditing or logging:

@Pointcut("execution(public * *(..)) && within(@org.rejeev.Monitor *)")
public void annotatedPublicMethod() {}  // All your public methods are belong to us!


Utilizing @Before and @After for advice

To make your pointcut work, combine it with AspectJ's @Before or @After to stipulate when the advice should roll out. For instance, perceive how you can log method entries:

@Before("annotatedPublicMethod()")
public void logMethodEntry(JoinPoint joinPoint) {
    // "Just stepped into the method like a boss!" logging ensues
}


And for monitoring after the method execution:

@After("annotatedPublicMethod()")
public void logMethodExit(JoinPoint joinPoint) {
    // "Smooth method exit. Slidin' out like James Bond" logging kicks in
}


Negotiating class-level annotation checks

At times, you may wish to assure that you're only keeping an eye on methods nested in classes that are explicitly emblazoned with class-level @Monitor. You can jack up your advice to scrutinize the class-level annotation presence thanks to the getClass().isAnnotationPresent().

@Before("annotatedPublicMethod() && @within(monitorAnnotation)")
public void logEntryForMonitorAnnotated(JoinPoint joinPoint, Monitor monitorAnnotation) {
    if(joinPoint.getTarget().getClass().isAnnotationPresent(Monitor.class)){
        // Log only if the class has the @Monitor tramp stamp
    }
}


This ancillary check steers clear of any undesired advice execution, fostering the isolation of concerns.

Stepping up your game with advanced @AspectJ monitoring

Targeting method-specific @annotation

Implicit rules are sometimes tricky. Keen to handle methods tagged with another specific method-level annotation like @CommitTransaction? Turn to @annotation:

@Before("@annotation(com.marcot.CommitTransaction)")
public void beforeCommitTransaction(JoinPoint joinPoint) {
    // "About to commit the transaction. Fingers crossed." code swings into action
}


Wrangling exceptions within aspects

Code within aspects isn't exempt from exceptions. Always ensure to handle exceptions like a pro inside your monitoring aspects so they don't rain on your application's parade:

@AfterThrowing(pointcut = "annotatedPublicMethod()", throwing = "ex")
public void logException(JoinPoint joinPoint, Exception ex) {
    // "Oops! Exception alert!" logging palliates the situation here
}


Adopting best practices for elevated aspectJ usage

Flexibility with wildcards

The wildcard * mirrors any return type and any method name, whereas .. matches an arbitrary number of arguments, proffering immense flexibility and a wider match reach.

Streamlining aspects for better maintainability

By isolating cross-cutting concerns into disparate aspects, you obtain an optimum structure that amps up readability and maintainability.

AOP for committed end-to-end monitoring

Aspect-Oriented Programming (AOP) isn't limited to logging. Harness it pragmatically for security audits, transaction management, and other cross-cutting concerns that warrant modular separation from core business logic.