Partner – Microsoft – NPI (cat= Spring)
announcement - icon

Azure Spring Apps is a fully managed service from Microsoft (built in collaboration with VMware), focused on building and deploying Spring Boot applications on Azure Cloud without worrying about Kubernetes.

And, the Enterprise plan comes with some interesting features, such as commercial Spring runtime support, a 99.95% SLA and some deep discounts (up to 47%) when you are ready for production.

>> Learn more and deploy your first Spring Boot app to Azure.

You can also ask questions and leave feedback on the Azure Spring Apps GitHub page.

1. Overview

Aspect-oriented programming (AOP) improves program design by separating a cross-cutting concern into a base unit, called an aspect, from the main application logic. Spring AOP is a framework that helps us implement aspects with ease.

AOP aspects are no different from other software components. They require different tests to verify their correctness. In this tutorial, we’ll learn how to conduct unit and integration tests on Spring AOP aspects.

2. What Is AOP?

AOP is a programming paradigm that complements object-oriented programming (OOP) to modularize cross-cutting concerns, which are functions spanning the main application. A class is a base unit in OOP, while an aspect is the base unit in AOP. Logging and transaction management are typical examples of cross-cutting concerns.

An aspect is composed of two components. One is the advice that defines the logic of the cross-cutting concern, while the other is a pointcut that specifies when we should apply the logic during application execution.

The following table provides an overview of the common AOP terms:

Term Description
Concern Specific functionality of an application.
Cross-cutting concern Specific functionality that spans multiple parts of the applications.
Aspect An AOP base unit that contains advices and pointcuts to implement cross-cutting concerns.
Advice The specific logic we want to invoke in cross-cutting concerns.
Pointcut An expression selecting join points that will apply the advice.
Join Point An execution point of an application such as a method.

3. Execution Time Logging

In this section, let’s create a sample aspect that logs the execution time around a join point.

3.1. Maven Dependency

There are different Java AOP frameworks, such as Spring AOP and AspectJ. In this tutorial, we’ll use Spring AOP and include the following dependency in our pom.xml:


For the logging part, we’re choosing SLF4J as the API and SLF4J simple provider for the logging implementation. SLF4J is a facade that provides a unified API across different logging implementations.

As such, we include the SLF4J API and SLF4J simple provider dependencies in our pom.xml as well:


3.2. Execution Time Aspect

Our ExecutionTimeAspect class is simple and only contains an advice logExecutionTime(). We annotate our class with @Aspect and @Component to declare it an aspect and enable Spring to manage it:

public class ExecutionTimeAspect {
    private Logger log = LoggerFactory.getLogger(ExecutionTimeAspect.class);

    @Around("execution(* com.baeldung.unittest.ArraySorting.sort(..))")
    public Object logExecutionTime(ProceedingJoinPoint joinPoint) throws Throwable {
        long t = System.currentTimeMillis();
        Object result = joinPoint.proceed();"Execution time=" + (System.currentTimeMillis() - t) + "ms");
        return result;

The @Around annotation indicates the advice logExecutionTime() runs around the target join point defined by the pointcut expression execution(…). In Spring AOP, a join point is always a method.

4. Unit Test on Aspect

From a unit test perspective, we’re testing solely the logic inside the aspect without any dependencies, including the Spring application context. In this example, we use Mockito to mock the joinPoint and the logger, and then inject the mocks into our testing aspect.

The unit test class is annotated with @ExtendsWith(MockitoExtension.class) to enable the Mockito functionalities for JUnit 5. It automatically initializes mocks and injects them into our testing unit that’s annotated with @InjectMocks:

class ExecutionTimeAspectUnitTest {
    private ProceedingJoinPoint joinPoint;

    private Logger logger;

    private ExecutionTimeAspect aspect;

    void whenExecuteJoinPoint_thenLoggerInfoIsCalled() throws Throwable {
        verify(joinPoint, times(1)).proceed();
        verify(logger, times(1)).info(anyString());

In this test case, we expect the joinPoint.proceed() method to be invoked once in the aspect. Also, the logger info() method should be invoked once as well to log the execution time.

To verify the logging message more precisely, we could use the ArgumentCaptor class to capture the log message. This enables us to assert the message produced beginning with “Execution time=“:

ArgumentCaptor<String> argumentCaptor = ArgumentCaptor.forClass(String.class);
verify(logger, times(1)).info(argumentCaptor.capture());
assertThat(argumentCaptor.getValue()).startsWith("Execution time=");

5. Integration Test on Aspect

From a integration test perspective, we’ll need the class implementation ArraySorting to apply our advice to the target class via pointcut expression. The sort() method simply calls the static method Collections.sort() to sort a list:

public class ArraySorting {
    public <T extends Comparable<? super T>> void sort(List<T> list) {

A question may arise: why don’t we apply our advice to the Collections.sort() static method instead? It’s a limitation of Spring AOP that it doesn’t work on static methods. Spring AOP creates dynamic proxies to intercept method calls. This mechanism requires invoking the actual method on the target object, while a static method can be invoked without an object. If we need to intercept static methods, we must adopt another AOP framework, such as AspectJ, that supports compile-time weaving.

In the integration test, we need the Spring application context to create a proxy object to intercept the target method and apply the advice. We annotate the integration test class with @SpringBootTest to load the application context that enables AOP and dependency injection capabilities:

class ExecutionTimeAspectIntegrationTest {
    private ArraySorting arraySorting;

    private List<Integer> getRandomNumberList(int size) {
        List<Integer> numberList = new ArrayList<>();
        for (int n=0;n<size;n++) {
            numberList.add((int) Math.round(Math.random() * size));
        return numberList;

    void whenSort_thenExecutionTimeIsPrinted() {
        ByteArrayOutputStream baos = new ByteArrayOutputStream();
        PrintStream originalSystemOut = System.out;
        System.setOut(new PrintStream(baos));


        String logOutput = baos.toString();
        assertThat(logOutput).contains("Execution time=");

The test method can be divided into three parts. Initially, it redirects the output stream to a dedicated buffer for the  assertion later. Subsequently, it calls the sort()  method that invokes the advice within the aspect. It’s important to inject the ArraySorting instance via @Autowired instead of instantiating an instance with new ArraySorting(). This ensures Spring AOP is activated on the target class. Finally, it asserts whether the log is present in the buffer.

6. Conclusion

In this article, we discussed the fundamental concepts of AOP and saw how to use a Spring AOP aspect on a target class. We also looked into testing aspects with unit tests and integration tests to verify the correctness of the aspects.

As always, the code examples are available over on GitHub.

Course – LS (cat=Spring)

Get started with Spring and Spring Boot, through the Learn Spring course:

res – REST with Spring (eBook) (everywhere)
Notify of
Inline Feedbacks
View all comments