Spring Framework AspectJ-Based AOP

Back to: Spring Framework Tutorials

Spring Framework AspectJ-Based AOP

In this article, I am going to discuss Spring Framework AspectJ-Based AOP with Examples. Please read our previous article, where we discussed Spring Framework XML-Based AOP.

What is AspectJ-Based AOP in Spring Framework?

AspectJ-based Aspect-Oriented Programming (AOP) in Spring is an approach that integrates the powerful AspectJ framework with the Spring Framework to provide enhanced AOP capabilities. AspectJ is a mature and feature-rich AOP framework that offers advanced functionality and language constructs for defining aspects and weaving them into the application code.

In AspectJ-based AOP, aspects are defined using AspectJ syntax, which extends the capabilities of traditional AOP concepts. AspectJ supports various types of advice, such as “before,” “after,” “around,” and more, allowing fine-grained control over the application’s behavior at specific join points. Additionally, AspectJ provides additional features like pointcuts, join point context information and advanced weaving mechanisms.

Spring integrates AspectJ seamlessly, allowing developers to leverage AspectJ’s expressive syntax and features within the Spring application context. Aspects can be defined as regular Java classes with AspectJ annotations or using XML-based configuration.

Using AspectJ-based AOP in Spring offers several benefits. It provides a powerful and flexible AOP solution that can address complex cross-cutting concerns efficiently. The integration with Spring enables the seamless integration of aspects into Spring-managed beans, allowing aspects to be applied to Spring components easily. AspectJ also provides advanced pointcut expressions that allow developers to precisely select join points based on specific conditions, method signatures, or even annotations.

AspectJ-based AOP in Spring is particularly useful for scenarios that require advanced AOP capabilities, such as distributed transaction management, performance monitoring, security enforcement, and more. It offers a robust and comprehensive AOP solution that complements the core features of the Spring Framework.

Features of AspectJ-Based AOP in Spring Framework:

1. Aspect-Oriented Programming: AspectJ allows you to modularize cross-cutting concerns by defining aspects and applying them to specific join points in your application.
2. Rich Pointcut Expressions: AspectJ offers a powerful and expressive syntax for defining pointcuts, allowing you to precisely select join points based on various criteria.
3. Advanced Advice Types: AspectJ supports various types of advice, including before, after, around, after-returning, and after-throwing advice, giving you fine-grained control over the behavior applied at specific join points.
4. Aspect Inheritance: AspectJ allows aspects to inherit from each other, providing a way to define common behavior in a parent aspect and specialize it in child aspects.
5. Load-Time Weaving: AspectJ supports load-time weaving, which allows you to weave aspects into classes at runtime, even for classes that are not directly managed by the Spring container.

Implementing AspectJ-Based AOP in Spring Framework

Before starting the project, ensure that the required JAR files are in the project’s “Referenced Libraries” folder.

Apart from these JAR files, another JAR file is required for AspectJ. It can be found at http://www.java2s.com/Code/JarDownload/aspectjrt/aspectjrt-1.6.11.jar.zip. This file will be downloaded as a ZIP file. Extract it (to obtain a JAR file) and paste the JAR into the “Referenced Libraries” directory.

Step 1: Create a new file called Logging.java in the src/ directory. Add the following contents to the file:

import org.aspectj.lang.annotation.After;
import org.aspectj.lang.annotation.AfterReturning;
import org.aspectj.lang.annotation.AfterThrowing;
import org.aspectj.lang.annotation.Before;
import org.aspectj.lang.annotation.Pointcut;

public class Logging
{
    @Pointcut("execution(* *.*(..))")
    private void selectAll() {}

    @Before("selectAll()")
    public void beforeAdvice()
    {System.out.println("Going to setup employee object.");}

    @After("selectAll()")
    public void afterAdvice()
    {System.out.println("Employee object is ready.");}

    @AfterReturning(pointcut = "selectAll()", returning = "retVal")
    public void afterReturningAdvice (Object retVal)
    {System.out.println("Returning: " + retVal.toString());}

    @AfterThrowing(pointcut = "selectAll()", throwing = "e")
    public void afterThrowingAdvice (IllegalArgumentException e)
    {System.out.println("Exception: " + e.toString());}
}

These functions will be called before, after, and after returning advice.

Step 2: Create a new file called Employee.java in the src/ directory. Add the following contents to the file:

public class Employee
{
    private int age;
    private String name;

    public int getAge()
    {
        return age;
    }
    public void setAge(int age)
    {
        this.age = age;
    }
    public String getName()
    {
        return name;
    }
    public void setName(String name)
    {
        this.name = name;
    }

    @Override
    public String toString()
    {
        return "Employee [name=" + name + " age=" + age + "]";
    }

    public void printThrowException()
    {
        System.out.println("Exception raised!");
    }
}

This class is a POJO class that will be used to store employees. This is the same file as the previous article.

Step 3: In the src/there must be a file called App.java. This file contains the main function and was created when the project was created (by VS Code). Modify the file as follows:

import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

public class App
{
    public static void main(String[] args)
    {
        ApplicationContext context = new ClassPathXmlApplicationContext("Beans.xml");
        Employee e = (Employee) context.getBean("employee");
        System.out.println(e.toString());
        e.printThrowException();
    }
}

The main function creates an employee bean from the Beans.xml file and prints it. It then throws an exception (on purpose) to demonstrate the AOP implemented in the program. Note that this is also the same file as the previous article.

Step 4: Create a new file called Beans.xml in the src/ directory. Add the following contents to the file:

<?xml version = "1.0" encoding = "UTF-8"?>
<beans xmlns = "http://www.springframework.org/schema/beans"
   xmlns:xsi = "http://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 = "employee" class = "Employee">
      <property name = "name" value = "Employee A" />
      <property name = "age"  value = "25"/>      
   </bean>

   <!-- Definition for logging aspect -->
   <bean id = "logging" class = "Logging"/> 
</beans>

This file is also similar to the file from the previous article. The only difference is that the aspects are managed in the Logging.java file rather than the Beans.xml file.

Step 5: Compile and execute the application. Ensure compilation is successful. Ensure that the output is as expected:

As can be seen, all the required statements execute (before advice, after advice, etc.)

Congratulations! You have completed the AspectJ-based AOP application in Spring Framework!

In the next article, I am going to discuss Spring Framework JDBC. Here, in this article, I try to explain Spring Framework AspectJ-Based AOP with Examples. I hope you enjoy this Spring Framework AspectJ-Based AOP article.