Spring AOP AspectJ @After Annotation Example | Spring Tutorial

🚀 Level Up Your Java Skills!

If you found this tutorial helpful, don't miss out on more expert coding guides.

SUBSCRIBE TO RAM N JAVA

Mastering the @After Annotation in Spring AOP

Welcome! In this tutorial, we are exploring one of the most useful features of Spring Aspect-Oriented Programming (AOP): the @After advice. This annotation allows you to run specific code automatically after a method finishes its execution.

What is @After Advice?

Think of @After advice like a "finally" block in Java. No matter what happens inside your method—even if it runs successfully or throws an error—the code marked with @After will always run. It's perfect for tasks like closing resources or final logging.

Key Components We Use

• EmployeeService: This is our main class containing business logic like addEmployee and deleteEmployee.
• LoggingAspect: This class holds our "Aspect" logic. We use the @Aspect annotation to tell Spring this class contains cross-cutting concerns.
• The @After Method: Inside our aspect, we create a method (like logAfter) and decorate it with @After to intercept our service calls.

Setting Up the Configuration

To make this work, we need to enable AspectJ support in our Spring configuration file. By adding <aop:aspectj-autoproxy />, Spring knows to look for classes with the @Aspect annotation and apply them to our beans automatically.

Real-World Benefits

Using @After makes your code much cleaner. Instead of adding logging or cleanup code to every single method in your project, you write it once in an Aspect and let Spring handle the rest. It keeps your business logic focused and easy to read!

Explore More Tutorials

➜ MCP Deep Dive: Why Developers Are Switching to This Architecture ➜ The Secret History of Generative AI ➜ Home Loan Basics: What You Need to Know

---

Click here to watch on Youtube:
https://www.youtube.com/watch?v=qVDkf0KF19I&list=UUhwKlOVR041tngjerWxVccw

Click the below Image to Enlarge:

Spring AOP AspectJ @After Annotation Example | Spring Tutorial

Spring AOP AspectJ @After Annotation Example | Spring Tutorial

Spring AOP AspectJ @After Annotation Example | Spring Tutorial

pom.xml

<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/maven-v4_0_0.xsd">
    <modelVersion>4.0.0</modelVersion>
    <groupId>com.ram.core</groupId>
    <artifactId>SpringDemo</artifactId>
    <packaging>jar</packaging>
    <version>1.0-SNAPSHOT</version>
    <name>SpringDemo</name>
    <url>http://maven.apache.org</url>

    <properties>
        <spring.version>5.0.5.RELEASE</spring.version>
    </properties>

    <dependencies>
        <dependency>
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>
            <version>3.8.1</version>
            <scope>test</scope>
        </dependency>

        <!-- Spring 5 dependencies -->
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-core</artifactId>
            <version>${spring.version}</version>
        </dependency>

        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-context</artifactId>
            <version>${spring.version}</version>
        </dependency>

        <!-- Spring AOP + AspectJ -->
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-aop</artifactId>
            <version>${spring.version}</version>
        </dependency>
       
        <dependency>
            <groupId>org.aspectj</groupId>
            <artifactId>aspectjrt</artifactId>
            <version>1.9.1</version>
        </dependency>
       
        <dependency>
            <groupId>org.aspectj</groupId>
            <artifactId>aspectjweaver</artifactId>
            <version>1.9.1</version>
        </dependency>

    </dependencies>

</project>

EmployeeService.java

package com.ram.service;

public class EmployeeService
{
    public void addEmployee()
    {
        System.out.println("Add Employee ");
    }
   
    public void modifyEmployee()
    {
        System.out.println("Modify Employee");
    }
   
    public void deleteEmployee()
    {
        System.out.println("Delete Employee");
    }

}

LoggingAspect.java

package com.ram.Aspect;

import org.aspectj.lang.JoinPoint;
import org.aspectj.lang.annotation.After;
import org.aspectj.lang.annotation.Aspect;

@Aspect
public class LoggingAspect
{

    @After("execution(* com.ram.service.EmployeeService.addEmployee())")
    public void logAfter(JoinPoint joinPoint)
    {

        System.out.print("logAfter() is running!");
        System.out.println(", after "
                + joinPoint.getSignature().getName() + " method");
        System.out.println("******");
    }

}

applicationContext.xml

<beans xmlns="http://www.springframework.org/schema/beans"
    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    xmlns:context="http://www.springframework.org/schema/context"
    xmlns:aop="http://www.springframework.org/schema/aop"
    xsi:schemaLocation="http://www.springframework.org/schema/beans
    http://www.springframework.org/schema/beans/spring-beans-4.3.xsd
    http://www.springframework.org/schema/context
    http://www.springframework.org/schema/context/spring-context-4.3.xsd
    http://www.springframework.org/schema/aop
    http://www.springframework.org/schema/aop/spring-aop-4.3.xsd">

    <aop:aspectj-autoproxy />

    <bean id="employeeService" class="com.ram.service.EmployeeService"></bean>
   
    <!-- Aspect -->
    <bean id="logAspect" class="com.ram.Aspect.LoggingAspect" />

</beans>

App.java

package com.ram.core;

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

import com.ram.service.EmployeeService;

public class App
{
    public static void main(String[] args)
    {
        ApplicationContext context = new ClassPathXmlApplicationContext(
                "applicationContext.xml");

        System.out.println("---------------------------------------");

        EmployeeService employeeService = context
                .getBean("employeeService", EmployeeService.class);

        employeeService.addEmployee();

        employeeService.modifyEmployee();

        employeeService.deleteEmployee();

    }

}

Output

Nov 07, 2018 10:10:23 AM org.springframework.context.support.AbstractApplicationContext prepareRefresh
INFO: Refreshing org.springframework.context.support.ClassPathXmlApplicationContext@32709393: startup date [Wed Nov 07 10:10:23 IST 2018]; root of context hierarchy
Nov 07, 2018 10:10:24 AM org.springframework.beans.factory.xml.XmlBeanDefinitionReader loadBeanDefinitions
INFO: Loading XML bean definitions from class path resource [applicationContext.xml]
---------------------------------------
Add Employee
logAfter() is running!, after addEmployee method
******
Modify Employee
Delete Employee

Click the below link to download the code:
https://sites.google.com/site/ramj2eev2/java_basics/SpringDemo_AspectJ_after.zip?attredirects=0&d=1

Github Link:
https://github.com/ramram43210/javaee/tree/master/Spring_2018/SpringDemo_AspectJ_after

Bitbucket Link:
https://bitbucket.org/ramram43210/spring/src/a5cdfdc3da3c676ee6dec77cfdb6b5c635be29d3/Spring_2018/SpringDemo_AspectJ_after/?at=master

See also:

All JavaEE Videos Playlist

All JavaEE Videos

All JAVA EE Links

Spring Tutorial

Servlets Tutorial

All Design Patterns Links

JDBC Tutorial

Java Collection Framework Tutorial

JAVA Tutorial

Kids Tutorial

Cooking Tutorial

Spring AOP AspectJ Before Advice example using XML configuration | Spring Tutorial

🚀 Ready to Master Java Development?

Don't miss out on the latest Spring Framework tutorials! Join thousands of learners today.

SUBSCRIBE NOW

Understanding Spring AOP: Before Advice

In this guide, we break down one of the most powerful features of Spring Aspect-Oriented Programming (AOP): the Before Advice. This allows you to run specific logic right before your main method starts its work.

What is Before Advice?

The "Before Advice" is a piece of code that executes before the actual business logic method is called. It is commonly used for security checks, logging, or setting up prerequisites. In this tutorial, we focus on implementing it using XML Configuration.

Key Project Parts

• EmployeeService: Our target class containing methods like addEmployee().
• LoggingAspect: The class where we write the "advice" (the logging code).
• XML Config: The file where we tell Spring to link the two together.

How It Works in Simple Steps

To set this up, we use the <aop:before> tag inside our XML configuration. We define a Pointcut, which is essentially a rule that tells Spring: "Every time someone calls the addEmployee method, run our logging code first." This keeps your business code clean and focused on just adding employees!

Why Use XML Instead of Annotations?

While modern projects often use annotations, XML configuration is fantastic for legacy systems or when you want to manage your aspects in one single place without modifying your actual Java classes. It's a great skill for any professional Java developer to have.

More Great Content from My Channel

➜ Google Pay Mobile Recharge: The Easiest Way to Top Up ➜ Mutual Funds: Don't Invest Until You Know These Basics ➜ Google Pay Water Bill Payment: Everything You Need to Know

---

Click here to watch on Youtube:
https://www.youtube.com/watch?v=7jN64twSuxk&list=UUhwKlOVR041tngjerWxVccw

Click the below Image to Enlarge:

Spring AOP AspectJ Before Advice example using XML configuration | Spring Tutorial

Spring AOP AspectJ Before Advice example using XML configuration | Spring Tutorial

Spring AOP AspectJ Before Advice example using XML configuration | Spring Tutorial

pom.xml

<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/maven-v4_0_0.xsd">
    <modelVersion>4.0.0</modelVersion>
    <groupId>com.ram.core</groupId>
    <artifactId>SpringDemo</artifactId>
    <packaging>jar</packaging>
    <version>1.0-SNAPSHOT</version>
    <name>SpringDemo</name>
    <url>http://maven.apache.org</url>

    <properties>
        <spring.version>5.0.5.RELEASE</spring.version>
    </properties>

    <dependencies>
        <dependency>
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>
            <version>3.8.1</version>
            <scope>test</scope>
        </dependency>

        <!-- Spring 5 dependencies -->
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-core</artifactId>
            <version>${spring.version}</version>
        </dependency>

        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-context</artifactId>
            <version>${spring.version}</version>
        </dependency>

        <!-- Spring AOP + AspectJ -->
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-aop</artifactId>
            <version>${spring.version}</version>
        </dependency>
       
        <dependency>
            <groupId>org.aspectj</groupId>
            <artifactId>aspectjrt</artifactId>
            <version>1.9.1</version>
        </dependency>
       
        <dependency>
            <groupId>org.aspectj</groupId>
            <artifactId>aspectjweaver</artifactId>
            <version>1.9.1</version>
        </dependency>

    </dependencies>

</project>

EmployeeService.java

package com.ram.service;

public class EmployeeService
{
    public void addEmployee()
    {
        System.out.println("addEmployee() is called");
    }
   
    public void modifyEmployee()
    {
        System.out.println("modifyEmployee() is called");
    }
   
    public void deleteEmployee()
    {
        System.out.println("deleteEmployee() is called");
    }

}

LoggingAspect.java

package com.ram.Aspect;

import org.aspectj.lang.JoinPoint;

public class LoggingAspect
{
    public void logBefore(JoinPoint joinPoint)
    {

        System.out.print("logBefore() is running!");
        System.out.println(", before "
                + joinPoint.getSignature().getName() + " method");
        System.out.println("******");
    }

}

applicationContext.xml

<beans xmlns="http://www.springframework.org/schema/beans"
    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    xmlns:context="http://www.springframework.org/schema/context"
    xmlns:aop="http://www.springframework.org/schema/aop"
    xsi:schemaLocation="http://www.springframework.org/schema/beans
    http://www.springframework.org/schema/beans/spring-beans-4.3.xsd
    http://www.springframework.org/schema/context
    http://www.springframework.org/schema/context/spring-context-4.3.xsd
    http://www.springframework.org/schema/aop
    http://www.springframework.org/schema/aop/spring-aop-4.3.xsd">

    <bean id="employeeService" class="com.ram.service.EmployeeService"></bean>

    <!-- Aspect -->
    <bean id="logAspect" class="com.ram.Aspect.LoggingAspect" />

    <aop:config>

        <aop:aspect id="aspectLoggging" ref="logAspect">

            <!-- @Before -->
            <aop:pointcut id="pointCutBefore"
                expression="execution(* com.ram.service.EmployeeService.addEmployee()))" />

            <aop:before method="logBefore" pointcut-ref="pointCutBefore" />

        </aop:aspect>

    </aop:config>

</beans>

App.java

package com.ram.core;

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

import com.ram.service.EmployeeService;

public class App
{
    public static void main(String[] args)
    {
        ApplicationContext context = new ClassPathXmlApplicationContext(
                "applicationContext.xml");

        System.out.println("---------------------------------------");

        EmployeeService employeeService = context
                .getBean("employeeService", EmployeeService.class);

        employeeService.addEmployee();

        employeeService.modifyEmployee();

        employeeService.deleteEmployee();

    }

}

Output

Nov 07, 2018 9:14:40 AM org.springframework.context.support.AbstractApplicationContext prepareRefresh
INFO: Refreshing org.springframework.context.support.ClassPathXmlApplicationContext@32709393: startup date [Wed Nov 07 09:14:40 IST 2018]; root of context hierarchy
Nov 07, 2018 9:14:40 AM org.springframework.beans.factory.xml.XmlBeanDefinitionReader loadBeanDefinitions
INFO: Loading XML bean definitions from class path resource [applicationContext.xml]
---------------------------------------
logBefore() is running!, before addEmployee method
******
addEmployee() is called
modifyEmployee() is called
deleteEmployee() is called

Click the below link to download the code:
https://sites.google.com/site/ramj2eev2/java_basics/SpringDemo_aspectj_before_xml_config.zip?attredirects=0&d=1

Github Link:
https://github.com/ramram43210/javaee/tree/master/Spring_2018/SpringDemo_aspectj_before_xml_config

Bitbucket Link:
https://bitbucket.org/ramram43210/spring/src/a5cdfdc3da3c676ee6dec77cfdb6b5c635be29d3/Spring_2018/SpringDemo_aspectj_before_xml_config/?at=master

See also:

All JavaEE Videos Playlist

All JavaEE Videos

All JAVA EE Links

Spring Tutorial

Servlets Tutorial

All Design Patterns Links

JDBC Tutorial

Java Collection Framework Tutorial

JAVA Tutorial

Kids Tutorial

Cooking Tutorial