Saturday, 8 December 2018

Spring AOP AspectJ @Around Annotation Example | Spring Tutorial

Mastering Spring AOP: @Around AspectJ Annotation Explained

🚀 SUBSCRIBE TO RAM N JAVA FOR MORE TECH GUIDES!

What is @Around Annotation?

In Spring Aspect-Oriented Programming (AOP), the @Around annotation is one of the most powerful tools. It allows you to "wrap" a method call. This means you can run custom code before the method starts and after it finishes. It gives you full control over whether the actual method even runs!

Key Concepts in this Tutorial

Employee Service: A simple class with methods like addEmployee, modifyEmployee, and deleteEmployee.
Logging Aspect: A special class where we write our @Around logic.
ProceedingJoinPoint: This is a special parameter that represents the method being called. We use joinPoint.proceed() to let the original method run.

How it Works (Step-by-Step)

1. Before execution: The code before joinPoint.proceed() runs first (perfect for logging or security checks). 2. The Method: The original method (like adding an employee) executes. 3. After execution: The code after joinPoint.proceed() runs last.

Configuration

To make this work, you need to enable AspectJ in your Spring configuration using <aop:aspectj-autoproxy /> and define your beans for the service and the aspect classes.

Check out more Spring Tutorials:

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

Click the below Image to Enlarge:

Spring AOP AspectJ @Around 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 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() method is called");

    }

}

LoggingAspect.java

package com.ram.Aspect;

import java.util.Arrays;

import org.aspectj.lang.ProceedingJoinPoint;

import org.aspectj.lang.annotation.Around;

import org.aspectj.lang.annotation.Aspect;

@Aspect

public class LoggingAspect

{

    @Around("execution(* com.ram.service.EmployeeService.addEmployee(..))")

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

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

        employeeService.modifyEmployee();

        employeeService.deleteEmployee();

    }

}

Output

Nov 14, 2018 9:27:46 AM org.springframework.context.support.AbstractApplicationContext prepareRefresh

INFO: Refreshing org.springframework.context.support.ClassPathXmlApplicationContext@32709393: startup date [Wed Nov 14 09:27:46 IST 2018]; root of context hierarchy

Nov 14, 2018 9:27:47 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() method is called