My Profile Photo

Aravind Vasudevan


An inquisitive polyglot developer and Machine Learning enthusiast.


Introduction to Aspect Oriented Programming

In a medium to large codebase, many-a-time, you might notice code that shouldn’t be in some class/method by design but is necessary. This can be anything from simple logging to transaction handling. As the codebase scales, this keeps adding up to a point where the code becomes laborious to manage.

codebase on fire!

Aspect-Oriented Programming provides a way to modularize these kinds of cross-cutting concerns with Aspects. Here is a basic example,

@Aspect
class LoggingAspect { // Aspect
    Logger LOGGER = Logger.getLogger(LoggingAspect.class.getName());

    @After("execution(* *(..))") // Pointcut
    void logExecutionAdvice(JoinPoint joinPoint) { // Advice
        LOGGER.info(joinPoint.getSignature().getName() + " executed");
    }
}

Aspect

An Aspect is a special class that contains the cross-cutting concerns. In Java, this can be created using annotations, like as above, or by using the non-java aspect format.

Pointcut

A pointcut is a special regex-like string that is used to specify where to inject your code. This can be any point in the program’s execution (a.k.a the joinpoint). A Joinpoint could be a method-body, a method-call, an exception handler, a class, an object, etc.

Advice

An advice contains the cross-cutting logic. Based on when to execute, it can be one of the below:

Advice Type Description
Before Runs before the joinpoint’s execution.
After Runs after the joinpoint’s execution.
AfterReturning Runs after the successful execution of the joinpoint.
AfterThrowing Runs after the joinpoint if it throws an exception.
Around Gives the before and after control to the advice.

Here is a more complex example that you might see in a production environment:

@Aspect
class TransactionAspect {
    @Around("@annotation(com.example.Transaction)") // Injects to joinpoint with @Transaction annotation
    public Object transactionAdvice(ProceedingJoinPoint joinPoint) throws Throwable {
        Object result;
        try {
            TransactionManager.begin();
            Object result = joinPoint.proceed(); // execution returns to the joinpoint
            TransactionManager.commit();
        } catch (Exception e) {
            TransactionManager.rollback();
            throw e;
        }

        return result;
    }
}

The above example runs the @Transaction annotated methods in a transaction.

TransactionAspect working

Weaving

Weaving is the process of injecting cross-cutting concerns into joinpoints. Based on when it is done, it is classified into of the following:

Weaving Type Description
Runtime Weaving The advice is injected at runtime. Frameworks like Spring AOP use proxies to achieve this and are comparatively slower.
Compile Time Weaving The advice is injected during compilation. Frameworks like AspectJ have their own compiler to achieve this.
Binary Weaving The injection is done after compilation, i.e., into class/jar files.
Load Time Weaving The injection is done when the classes are loaded by the classloader. Frameworks like AspectJ use a javaagent to achieve this.

Hope this gave you a basic idea of what AOP can do and all its terminologies. So long!

References

comments powered by Disqus