Saturday, 8 December 2018

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

🚀 Master Spring Framework!

Join the Ram N Java community for practical, step-by-step tutorials that make complex coding concepts simple.

Mastering Spring AOP: Around Advice with XML

Aspect-Oriented Programming (AOP) allows developers to handle "cross-cutting concerns" like logging and security separately from main business logic. Among all advice types, Around Advice is the most powerful and flexible.

What is Around Advice?

Around Advice surrounds a method execution. It gives you full control, allowing you to perform actions both before and after the method runs. You can even decide whether the method should execute at all or provide your own custom return value.

Why Use XML Configuration?

While annotations are popular, XML configuration keeps your Java classes clean and completely decoupled from AOP logic. This is especially useful in legacy systems or when you want a centralized place to manage all your application's aspects without touching the source code.

Practical Use Cases

Around Advice is perfect for performance monitoring. You can start a timer, let the method run, stop the timer, and log the total execution time—all in one place! It’s also ideal for caching and complex security checks.

Key Takeaway: Around Advice provides the ultimate level of control over method execution, making your Spring applications more modular and powerful.

Check Out More From Ram N Java

Keep your momentum going with these top-rated tutorials from my channel:

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

Click the below Image to Enlarge:

Spring AOP AspectJ Around 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 String addEmployee(String name)

    {

        System.out

                .println("addEmployee(String name) method 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 java.util.Arrays;

import org.aspectj.lang.ProceedingJoinPoint;

public class LoggingAspect

{

    public void logAround(ProceedingJoinPoint proceedingJoinPoint)

            throws Throwable

    {

        System.out.println("logAround() is running!");

        System.out.println("hijacked method = "

                + proceedingJoinPoint.getSignature().getName());

        System.out.println("hijacked arguments = "

                + Arrays.toString(proceedingJoinPoint.getArgs()));

        System.out.println("Around before is running!");

        proceedingJoinPoint.proceed(); // continue on the intercepted

                                        // method

        System.out.println("Around after is running!");

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

            <!-- @Around -->

            <aop:pointcut id="pointCutAround"

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

            <aop:around method="logAround" pointcut-ref="pointCutAround" />

        </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("Peter");

        employeeService.modifyEmployee();

        employeeService.deleteEmployee();

    }

}

Output

Nov 15, 2018 10:41:50 AM org.springframework.context.support.AbstractApplicationContext prepareRefresh

INFO: Refreshing org.springframework.context.support.ClassPathXmlApplicationContext@32709393: startup date [Thu Nov 15 10:41:50 IST 2018]; root of context hierarchy

Nov 15, 2018 10:41:50 AM org.springframework.beans.factory.xml.XmlBeanDefinitionReader loadBeanDefinitions

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

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

logAround() is running!

hijacked method = addEmployee

hijacked arguments = [Peter]

Around before is running!

addEmployee(String name) method is called

Around after is running!

******

modifyEmployee() is called

deleteEmployee() is called