Spring: Difference Between AspectJ Annotations and XML Configuration

Understanding the difference between AspectJ Annotations and XML Configuration in Spring AOP Aspect-Oriented-Programming is a most powerful programming paradigm in Spring that allows developers to separate cross-cutting concerns such as logging, security, or transaction management and exception handling.

The main difference between  AspectJ Annotations and XML Configuration

• AspectJ Annotations: It is a Java-based annotation approach for defining aspects directly in code.
• XML Configuration: It is a declarative, external configuration to define aspects via XML.

AspectJ Annotations vs XML Configuration

We have discussed the core differences, now let's take a closer look at each component. Let, us discuss them in brief first.

AspectJ Annotations-Based AOP

AspectJ Annotations-Based AOP provides a simple way to use Aspect-Oriented Programming in Java by defining aspects with annotations instead of XML or separate syntax. Commonly used in Spring, it allows you to add cross-cutting concerns like logging or security directly in regular Java classes, making the code cleaner and easier to manage.

Some of the most common AspectJ annotations used to create advice are as follows:

• @Aspect: It is used to declare a class as an aspect class.
• @Before: Run a particular piece of code before the execution of the method.
• @After: Run a particular advice after the execution of the method.
• @AfterReturning: It runs advice after the method is completed successfully.
• @AfterThrowing: This annotation allows you to run advice after a method throws an exception.
• @Around: It runs advice before and after method execution.
• @Pointcut: Pointcut is a signature that matches the join points.

Let's take an example of using AspectJ Annotations in Spring

@Aspect // It marks this class as an Aspect
@Component
// Indicates this class is a Spring-managed component
public class LoggingAspect {
    // It define a reusable pointcut expression that matches
    // execution of any method in com.example.service
    // package
    @Pointcut("execution(* com.example.service.*.*(..))")
    public void serviceMethod()
    {
    }
    // This method execute before any method matched by
    // serviceMethod() pointcut

    @Before("serviceMethod()")
    public void logBefore(JoinPoint joinPoint)
    {
        System.out.println(
            "Before service method: "
            + joinPoint.getSignature().getName());
    }
    // This method start executioon after successful
    // completion of a method matched by serviceMethod()

    @AfterReturning(pointcut = "serviceMethod()",
                    returning = "result")
    public void
    logAfterReturning(JoinPoint joinPoint, Object result)

    {
        // Prints the result returned by the method
        System.out.println("Method returned: " + result);
    }

    // This method execute if there is an exception is
    // thrown by a method matched by serviceMethod()
    @AfterThrowing(pointcut = "serviceMethod()",
                   throwing = "exeception")
    public void
    logAfterThrowing(JoinPoint joinPoint, Throwable ex)
    {
        System.out.println("Exception thrown in method: "
                           + ex);
    }
}

Explanation:

• The class is marked with @Aspect to define it as an aspect.
• @Component allows Spring to manage the class as a bean.
• @Pointcut matches all methods in the com.example.service package.
• @Before advice logs the method name before execution.
• @AfterReturning advice logs the result after successful execution.
• @AfterThrowing advice logs any exception thrown by the method.

Advantages of Annotation-Based AOP with AspectJ

• Code is clean and readable.
• There is no need for XML configuration
• It provides seamless integration with Spring AOP.
• It is good for modularizing cross-cutting concerns in AOP

XML-Based AOP Configuration

In the Spring Framework, AOP can be configured using XML-based configuration instead of annotations. This approach is very useful in scenarios where we want to separate concerns between code and configuration or in legacy class where annotations are not used.

Let's look at the XML components that describe advice

1. aop:before: It's used before the main logic procedure is called.
2. aop:after: It is used after the main logic method has been called.
3. aop:after-returning: It is applied after invoking the actual business logic method used. It may be used to intercept the advisory return value.
4. aop:around: It is used both before and after the main business logic method is called.
5. aop:after-throwing: If the real business logic procedure throws an exception, it is used.

XML Configuration:

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans/"
    xmlns:xsi="https://www.w3.org/2001/XMLSchema-instance" 
    xmlns:aop="http://www.springframework.org/schema/aop/"
    xsi:schemaLocation="http://www.springframework.org/schema/beans/
    http://www.springframework.org/schema/beans//spring-beans-3.0.xsd 
    http://www.springframework.org/schema/aop/ 
    http://www.springframework.org/schema/aop//spring-aop-3.0.xsd ">

<aop:aspectj-autoproxy />

<bean id="opBean" class="com.Geeksforgeeks.Operation"></bean>
    
<bean id="trackAspect" class="com.Geeksforgeeks.TrackOperation"></bean>
        
<aop:config>
  <aop:aspect id="myaspect" ref="trackAspect" >
     <!-- @Before -->
     <aop:pointcut id="pointCutBefore"    expression="execution(* com.Geeksforgeeks.Operation.*(..))" />
     <aop:before method="myadvice" pointcut-ref="pointCutBefore" />
  </aop:aspect>
</aop:config>
    
</beans>

Explanation:

• Enables AOP support using <aop:aspectj-autoproxy/>.
• Declares a bean opBean for the com.Geeksforgeeks.Operation class.
• Declares a bean trackAspect for the com.Geeksforgeeks.TrackOperation class, which contains the advice method.
• Defines an aspect myaspect using the trackAspect bean.
• Sets up a pointcut pointCutBefore to match execution of any method in com.Geeksforgeeks.Operation.
• Configures a before advice using <aop:before>, which links the myadvice method to the defined pointcut.