Spring AOP AspectJ @AfterReturning Annotation Example

In this spring aop example, we will learn to use aspectj @AfterReturning annotation. @AfterReturning annotated methods run after the method (matching with pointcut expression) is executed normally and do no throw any error/exception.

In this example, We will create simple spring application, add logging aspect and then invoke aspect methods based on pointcuts information passed in @AfterReturning annotation.

AspectJ @AfterReturning Annotation Usage

AspectJ @AfterReturning advice is executed after a join point completes normally, for example, if the method returns without throwing an exception.

@Aspect
public class LoggingAspect {

    @AfterReturning("execution(* com.howtodoinjava.app.service.impl.EmployeeManagerImpl.*(..))")
    public void logAroundAllMethods() { ... }

    @AfterReturning(pointcut="execution(* com.howtodoinjava.app.service.impl.EmployeeManagerImpl.getEmployeeById(..))", returning="retVal") 
    public void logAroundGetEmployee(Object retVal) { ... }
}

Sometimes you need access the actual return value – that was returned from method, you can get that return value as shown using returning attribute inside @AfterReturning annotation.

The name used in the returning attribute must correspond to the name of a parameter in the advice method. When a method execution returns, the return value will be passed to the advice method as the corresponding argument value.

Please note that any returning clause also restricts matching to only those method executions that return a value of the specified type ( Object or it’s subtypes in this case, which will match any return value).

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>

Enable AspectJ Support

In XML config file, you can add aop:aspectj-autoproxy element to enable @AspectJ annotation 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 ">

    <!-- Enable @AspectJ annotation support  -->
    <aop:aspectj-autoproxy />
    
    <!-- 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 AspectJ Annotated Class and Methods

Write aspectj annotated class and methods with pointcut information.

@Aspect
public class LoggingAspect {

    @AfterReturning("execution(* com.howtodoinjava.app.service.impl.EmployeeManagerImpl.*(..))")
    public void logAfterReturningAllMethods() throws Throwable 
    {
        System.out.println("****LoggingAspect.logAfterReturningAllMethods() ");
    }

    @AfterReturning(pointcut="execution(* com.howtodoinjava.app.service.impl.EmployeeManagerImpl.getEmployeeById(..))", returning="retVal") 
    public void logAfterReturningGetEmployee(Object retVal) throws Throwable 
    {
        System.out.println("****LoggingAspect.logAfterReturningGetEmployee() ");
        System.out.println(((EmployeeDTO)retVal).getId());
    }

    @AfterReturning("execution(* com.howtodoinjava.app.service.impl.EmployeeManagerImpl.createEmployee(..))")
    public void logAfterReturningCreateEmployee() throws Throwable 
    {
        System.out.println("****LoggingAspect.logAfterReturningCreateEmployee() ");
    }
}

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.logAfterReturningAllMethods() 
****LoggingAspect.logAfterReturningGetEmployee() 

null //As there is no employee id as of now

Method createEmployee() called

****LoggingAspect.logAfterReturningAllMethods() 
****LoggingAspect.logAfterReturningCreateEmployee() 

Clearly aspect advices executed on relevant jointpoints.

Happy Learning !!

References:

Spring AOP Reference
@AfterReturning Annotation
@Aspect Annotation
AspectJ Annotation Config Example
Different Pointcut Expressions With Examples

Leave a Reply

0 Comments
Inline Feedbacks
View all comments

About Us

HowToDoInJava provides tutorials and how-to guides on Java and related technologies.

It also shares the best practices, algorithms & solutions, and frequently asked interview questions.

Our Blogs

REST API Tutorial