Spring AOP After-Returning Advice Example

In this spring aop example, we will learn to use AOP after returning advice using <aop:after-returning/> configuration. Methods configured as after returning advice, run immediately after the methods, which match the pointcut expression passed as argument, and which terminate normally i.e. they do not throw any exception.

In this example, We will create simple spring application, add logging aspect and then invoke aspect methods based on pointcuts information passed in <aop:after-returning/> xml configuration.

Creating Spring AOP After Returning Advice

To create a after returning advice, using xml configuration, use <aop:after-returning/> in below manner.

<aop:config> 
    <aop:aspect ref="loggingAspect">
        <aop:pointcut expression="execution(* com.howtodoinjava.app.service.impl.EmployeeManagerImpl.*(..))" id="loggingPointcuts"/>
        <!-- after returning advice -->
        <aop:after-returning method="logAfterReturingAllMethods" pointcut-ref="loggingPointcuts" returning="retVal" /> 
    </aop:aspect> 
</aop:config>

Here returning attribute enable to receive returning value from advised method, in case you want to inspect them. Here I have passed retVal named parameter which needs to be passed to advice method.

Project Structure

Spring AOP Project Structure
Spring AOP Project Structure

Spring AOP AspectJ Maven Dependencies

I have added spring core, spring aop and aspectj dependencies.

<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/xsd/maven-4.0.0.xsd;
    <modelVersion>4.0.0</modelVersion>
    <groupId>com.howtodoinjava</groupId>
    <artifactId>SpringAOPExamples</artifactId>
    <version>0.0.1-SNAPSHOT</version>
    <name>Spring AOP Examples</name>
    <dependencies>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-context</artifactId>
            <version>4.3.2.RELEASE</version>
        </dependency>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-context-support</artifactId>
            <version>4.3.2.RELEASE</version>
        </dependency>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-aop</artifactId>
            <version>4.3.2.RELEASE</version>
        </dependency>
        <dependency>
            <groupId>org.aspectj</groupId>
            <artifactId>aspectjrt</artifactId>
            <version>1.8.9</version>
        </dependency>
        <dependency>
            <groupId>org.aspectj</groupId>
            <artifactId>aspectjweaver</artifactId>
            <version>1.8.9</version>
        </dependency>
    </dependencies>
</project>

Add Spring AOP Configuration

In XML config file, you can add aop:config element to add AOP support.

<beans xmlns="http://www.springframework.org/schema/beans"
    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    xmlns:aop="http://www.springframework.org/schema/aop"
    xsi:schemaLocation="http://www.springframework.org/schema/beans
    http://www.springframework.org/schema/beans/spring-beans-3.0.xsd
    http://www.springframework.org/schema/aop/
    http://www.springframework.org/schema/aop/spring-aop-3.0.xsd ">

    <aop:config> 
        <aop:aspect ref="loggingAspect">
            <aop:pointcut expression="execution(* com.howtodoinjava.app.service.impl.EmployeeManagerImpl.*(..))" id="loggingPointcuts"/>
            <!-- after returning advice -->
            <aop:after-returning method="logAfterReturingAllMethods" pointcut-ref="loggingPointcuts" returning="retVal" />  
        </aop:aspect> 
    </aop:config> 
        
    <!-- Employee manager -->
    <bean id="employeeManager" class="com.howtodoinjava.app.service.impl.EmployeeManagerImpl" />

    <!-- Logging Aspect -->
    <bean id="loggingAspect" class="com.howtodoinjava.app.aspect.LoggingAspect" />

</beans>

Service methods on which aspects needs to be executed

EmployeeManager.java and EmployeeManagerImpl.java

public interface EmployeeManager 
{
    public EmployeeDTO getEmployeeById(Integer employeeId);

    public List<EmployeeDTO> getAllEmployee();

    public void createEmployee(EmployeeDTO employee);

    public void deleteEmployee(Integer employeeId);

    public void updateEmployee(EmployeeDTO employee);
}

public class EmployeeManagerImpl implements EmployeeManager 
{
    public EmployeeDTO getEmployeeById(Integer employeeId) 
    {
        System.out.println("Method getEmployeeById() called");
        return new EmployeeDTO();
    }

    public List<EmployeeDTO> getAllEmployee() 
    {
        System.out.println("Method getAllEmployee() called");
        return new ArrayList<EmployeeDTO>();
    }

    public void createEmployee(EmployeeDTO employee)
    {
        System.out.println("Method createEmployee() called");
    }

    public void deleteEmployee(Integer employeeId) 
    {
        System.out.println("Method deleteEmployee() called");
    }

    public void updateEmployee(EmployeeDTO employee) 
    {
        System.out.println("Method updateEmployee() called");
    }
}

Write Aspect Class and Methods

Write aspect class and methods to be executed as advice.

package com.howtodoinjava.app.aspect;

import org.aspectj.lang.JoinPoint;

public class LoggingAspect {

    public void logAfterReturingAllMethods(Object retVal) throws Throwable 
    {
        System.out.println("****LoggingAspect.logAfterReturingAllMethods() " + retVal);
    }
}

Test Spring AspectJ Configuration and Execution

Now let’s test whether above configured aspects execute on given pointcut information.

import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

import com.howtodoinjava.app.model.EmployeeDTO;
import com.howtodoinjava.app.service.EmployeeManager;

public class TestMain 
{
    @SuppressWarnings("resource")
    public static void main(String[] args) {
 
        ApplicationContext context = new ClassPathXmlApplicationContext("applicationContext.xml");
        EmployeeManager manager = (EmployeeManager) context.getBean("employeeManager");
 
        manager.getEmployeeById(1);
        manager.createEmployee(new EmployeeDTO());
    }
}
Method getEmployeeById() called

****LoggingAspect.logAfterReturingAllMethods() com.howtodoinjava.app.model.EmployeeDTO@13bc476

Method createEmployee() called

****LoggingAspect.logAfterReturingAllMethods() null

Clearly after returning aspect advices executed on relevant jointpoints.

Happy Learning !!

References:

Spring AOP Reference
AspectJ Project
Different Pointcut Expressions With Examples

Was this post helpful?

Join 7000+ Awesome Developers

Get the latest updates from industry, awesome resources, blog updates and much more.

* We do not spam !!

Leave a Comment

HowToDoInJava

A blog about Java and related technologies, the best practices, algorithms, and interview questions.