Monday, 3 December 2018

Spring AOP AspectJ AfterReturning advise Example using XML Configuration | Spring Tutorial

Mastering Spring AOP: AspectJ AfterReturning Advice with XML Configuration

🔥 JOIN THE RAM N JAVA COMMUNITY - SUBSCRIBE NOW!

What is AfterReturning Advice?

In Spring Aspect-Oriented Programming (AOP), AfterReturning Advice is a specific type of logic that executes only after a method successfully finishes its execution and returns a value. Unlike "After Advice" (which runs regardless of the outcome), AfterReturning ensures that your logic only triggers if no exceptions occurred.

The Power of XML Configuration

While many developers use annotations, configuring AOP via XML is a classic and powerful way to keep your Java code completely free of AOP-specific metadata. This is excellent for maintaining a clean "Separation of Concerns" where your business logic remains pure.

Core Components of the Implementation

The Service: A standard Java bean (like EmployeeService) that returns data.
The Aspect: A logging or monitoring class that captures the returned value.
The returning attribute: In XML, you use the returning attribute to map the method's return value to a parameter in your advice method.

Why is this Useful?

This pattern is perfect for logging the results of a database query, calculating the execution time of successful methods, or even modifying the return value before it reaches the caller. It centralizes your logic and prevents code duplication across your application.

More Java & Spring Guides from Ram N Java:

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

Click the below Image to Enlarge:

Spring AOP AspectJ AfterReturning advise 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 String addEmployee()

    {

        System.out.println("addEmployee() is called");

        return "Employee Peter information is added successfully";

    }

    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 logAfterReturning(JoinPoint joinPoint, Object result)

    {

        System.out.print("logAfterReturning() is running!");

        System.out.println(", after "

                + joinPoint.getSignature().getName() + " method");

        System.out.println("Method returned value is = " + result);

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

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

            <aop:after-returning method="logAfterReturning"

                returning="result" pointcut-ref="pointCutAfterReturning" />

        </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 11, 2018 10:35:40 AM org.springframework.context.support.AbstractApplicationContext prepareRefresh

INFO: Refreshing org.springframework.context.support.ClassPathXmlApplicationContext@32709393: startup date [Sun Nov 11 10:35:40 IST 2018]; root of context hierarchy

Nov 11, 2018 10:35:41 AM org.springframework.beans.factory.xml.XmlBeanDefinitionReader loadBeanDefinitions

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

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

addEmployee() is called

logAfterReturning() is running!, after addEmployee method

Method returned value is = Employee Peter information is added successfully

******

modifyEmployee() is called

deleteEmployee() is called