Aspect-Oriented Programming (AOP) modularizes cross-cutting concerns—such as auditing, security, and transaction management—that traditionally scatter across application layers. By encapsulating these behaviors into reusable aspects, AOP reduces coupling between business logic and infrastructure code.

Spring implements AOP through proxy-based interception. The framework selects between JDK dynamic proxies (for interface-based targets) and CGLIB bytecode generation (for concrete classes) to weave aspects into method execution flows.

Core terminology establishes the AOP conceptual model:

• Aspect: A modularization of a cross-cutting concern, bundling advice and pointcuts
• Join Point: An identifiable execution point in program flow, typically method invocasion
• Pointcut: An expression predicate selecting specific join points for advice application
• Advice: The behavioral code executing at a join point, categorized by execution timing (before, after returning, around, after throwing)
• Target: The business object being advised
• Weaving: The runtime or compile-time process of combining aspects with targets to create proxies

The execution flow proceeds as: Advice attaches to join points matching pointcut criteria, weaving into target objects via generated proxies.

Required dependencies include spring-aop and aopalliance.

Spring supports four advice interfaces:

MethodBeforeAdvice executes prior to target method invocation. AfterReturningAdvice executes after successful method completion, receiving but unable to modify return values. MethodInterceptor (around advice) surrounds the target invocation, controlling execution flow and capable of altering results. ThrowsAdvice responds to exceptions thrown by target methods.

Implementation begins with defining service contracts:

package com.example.inventory.service;

import java.util.List;

public interface InventoryManager {
    boolean addItem(Item product);
    boolean removeItem(Integer identifier);
    boolean updateItem(Item product);
    List<Item> queryStock();
}

Concrete implementations contain core business logic:

package com.example.inventory.service;

import java.util.ArrayList;
import java.util.List;

public class InventoryManagerImpl implements InventoryManager {

    @Override
    public boolean addItem(Item product) {
        System.out.println("Processing inventory addition");
        return true;
    }

    @Override
    public boolean removeItem(Integer identifier) {
        // Simulated arithmetic exception for throws advice testing
        int calculation = 1 / 0;
        System.out.println("Processing inventory removal");
        return true;
    }

    @Override
    public boolean updateItem(Item product) {
        System.out.println("Processing inventory update");
        return true;
    }

    @Override
    public List<Item> queryStock() {
        System.out.println("Retrieving current inventory");
        return new ArrayList<>();
    }
}

Advice implementations intercept method execution:

package com.example.inventory.aspects;

import org.springframework.aop.MethodBeforeAdvice;
import java.lang.reflect.Method;

public class LoggingAspect implements MethodBeforeAdvice {
    
    @Override
    public void before(Method method, Object[] arguments, Object target) {
        System.out.println("[LOG] Initiating method: " + method.getName());
    }
}

package com.example.inventory.aspects;

import org.springframework.aop.AfterReturningAdvice;
import java.lang.reflect.Method;

public class MonitoringAspect implements AfterReturningAdvice {
    
    @Override
    public void afterReturning(Object returnValue, Method method, 
                              Object[] arguments, Object target) {
        System.out.println("[MONITOR] Method " + method.getName() + 
                          " returned: " + returnValue);
    }
}

package com.example.inventory.aspects;

import org.aopalliance.intercept.MethodInterceptor;
import org.aopalliance.intercept.MethodInvocation;

public class TransactionAspect implements MethodInterceptor {
    
    @Override
    public Object invoke(MethodInvocation invocation) throws Throwable {
        System.out.println("[TX] Starting transaction");
        Object result = invocation.proceed();
        System.out.println("[TX] Committing transaction");
        // Demonstrating result modification capability
        return result instanceof Boolean ? Boolean.TRUE : result;
    }
}

package com.example.inventory.aspects;

import org.springframework.aop.ThrowsAdvice;

public class ErrorHandlingAspect implements ThrowsAdvice {
    
    public void afterThrowing(Exception exception) {
        System.err.println("[ERROR] Intercepted exception: " + exception);
    }
}

Spring XML configuration wires targets with advice through proxy factories:

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xsi:schemaLocation="http://www.springframework.org/schema/beans 
                           http://www.springframework.org/schema/beans/spring-beans.xsd">

    <bean id="inventoryService" class="com.example.inventory.service.InventoryManagerImpl"/>
    
    <bean id="loggingAdvice" class="com.example.inventory.aspects.LoggingAspect"/>
    <bean id="monitoringAdvice" class="com.example.inventory.aspects.MonitoringAspect"/>
    <bean id="transactionAdvice" class="com.example.inventory.aspects.TransactionAspect"/>
    <bean id="errorAdvice" class="com.example.inventory.aspects.ErrorHandlingAspect"/>
    
    <bean id="loggedInventory" class="org.springframework.aop.framework.ProxyFactoryBean">
        <property name="target" ref="inventoryService"/>
        <property name="interfaces" value="com.example.inventory.service.InventoryManager"/>
        <property name="interceptorNames" value="loggingAdvice"/>
    </bean>
    
    <bean id="monitoredInventory" class="org.springframework.aop.framework.ProxyFactoryBean">
        <property name="target" ref="inventoryService"/>
        <property name="interceptorNames" value="monitoringAdvice"/>
    </bean>
    
    <bean id="transactionalInventory" class="org.springframework.aop.framework.ProxyFactoryBean">
        <property name="target" ref="inventoryService"/>
        <property name="interceptorNames" value="transactionAdvice"/>
    </bean>
    
    <bean id="protectedInventory" class="org.springframework.aop.framework.ProxyFactoryBean">
        <property name="target" ref="inventoryService"/>
        <property name="interceptorNames" value="errorAdvice"/>
    </bean>
</beans>

Unit tests validate advice execution:

package com.example.inventory.test;

import org.junit.Before;
import org.junit.Test;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
import com.example.inventory.service.InventoryManager;

public class AspectValidationTests {
    private ApplicationContext context;
    
    @Before
    public void setup() {
        context = new ClassPathXmlApplicationContext("application-context.xml");
    }
    
    @Test
    public void verifyBeforeAdviceExecution() {
        InventoryManager service = (InventoryManager) context.getBean("loggedInventory");
        service.addItem(new Item());
    }
    
    @Test
    public void verifyAfterAdviceExecution() {
        InventoryManager service = (InventoryManager) context.getBean("monitoredInventory");
        service.addItem(new Item());
    }
    
    @Test
    public void verifyAroundAdviceExecution() {
        InventoryManager service = (InventoryManager) context.getBean("transactionalInventory");
        service.addItem(new Item());
    }
    
    @Test(expected = ArithmeticException.class)
    public void verifyThrowsAdviceExecution() {
        InventoryManager service = (InventoryManager) context.getBean("protectedInventory");
        service.removeItem(1);
    }
}

Implementation considerations:

• ProxyFactoryBean generates AOP proxies combining targets with interceptors
• Interface specification remains optional when utilizing CGLIB subclassing
• After-returning advice observes return values immutably
• Around advice provides mutable control over invocation results and exception handling
• Throws advice matches exception types through method signature reflection