Thursday, 22 November 2018

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.

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

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