JAVA EE: Spring AOP AspectJ After Advice example using XML configuration

Monday, 3 December 2018

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

🚀 Love Spring Framework Tutorials?

Join our community of developers! Subscribe to Ram N Java for more easy-to-follow Java guides.

Understanding After Advice in Spring AOP

In this tutorial, we dive into Aspect-Oriented Programming (AOP) specifically focusing on the After Advice. If you are new to AOP, think of Advice as the action taken by an aspect at a particular join point.

What is After Advice?

The "After Advice" is a type of advice that executes regardless of whether the method finishes successfully or throws an exception. It is often referred to as "After (Finally) Advice" because it behaves like a finally block in Java.

Core Components of the Project

EmployeeService Class: Contains our business logic with methods like addEmployee(), modifyEmployee(), and deleteEmployee().
LoggingAspect Class: This contains our "cross-cutting concern" (the logging logic) that we want to run after our service methods.
XML Configuration: We use the applicationContext.xml file to link the service and the aspect together using the <aop:config> tag.

How the Configuration Works

To implement this, we define a Pointcut. A pointcut is a set of one or more join points where an advice should be executed. In our example, we target the addEmployee() method. Once configured, Spring will automatically trigger our logging method immediately after the employee is added!

Why Use XML Configuration?

While annotations are popular, XML configuration keeps your Java code clean and decoupled from the AOP logic. It provides a centralized place to manage all your aspects without touching the business logic classes.

Watch More from Ram N Java

Check out these other helpful tutorials from my channel:

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

Click the below Image to Enlarge:

Spring AOP AspectJ After 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 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">

    <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">

            <!-- @After -->

            <aop:pointcut id="pointCutAfter"

                expression="execution(* com.ram.service.EmployeeService.addEmployee()))" />

            <aop:after method="logAfter" pointcut-ref="pointCutAfter" />

        </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 08, 2018 11:12:29 AM org.springframework.context.support.AbstractApplicationContext prepareRefresh

INFO: Refreshing org.springframework.context.support.ClassPathXmlApplicationContext@32709393: startup date [Thu Nov 08 11:12:29 IST 2018]; root of context hierarchy

Nov 08, 2018 11:12:30 AM org.springframework.beans.factory.xml.XmlBeanDefinitionReader loadBeanDefinitions

INFO: Loading XML bean definitions from class path resource [applicationContext.xml]

---------------------------------------

addEmployee() is called

logAfter() is running!, after addEmployee method

******

modifyEmployee() is called

deleteEmployee() is called