Spring AOP Deep Dive — Pointcuts, Advice & Proxy Mechanics

// Force CGLIB (default in Spring Boot)
@EnableAspectJAutoProxy(proxyTargetClass = true)

// Force JDK dynamic proxy (interface-based only)
@EnableAspectJAutoProxy(proxyTargetClass = false)

@Autowired
private OrderService orderService;

public void checkProxy() {
    System.out.println(orderService.getClass().getName());
    // com.app.service.OrderService$$EnhancerBySpringCGLIB$$abc123

    System.out.println(AopUtils.isAopProxy(orderService));      // true
    System.out.println(AopUtils.isCglibProxy(orderService));    // true
    System.out.println(AopUtils.isJdkDynamicProxy(orderService)); // false
}

@Aspect
@Component
public class PointcutLibrary {

    // All public methods in service package
    @Pointcut("execution(public * com.app.service.*.*(..))")
    public void allServiceMethods() {}

    // All methods in any class annotated with @Service
    @Pointcut("within(@org.springframework.stereotype.Service *)")
    public void withinServiceClasses() {}

    // Methods annotated with custom @Loggable
    @Pointcut("@annotation(com.app.annotation.Loggable)")
    public void loggableMethods() {}

    // Methods with first argument of type Long
    @Pointcut("execution(* com.app..*(Long, ..))")
    public void methodsWithLongFirstArg() {}

    // All repository methods (by bean naming)
    @Pointcut("bean(*Repository)")
    public void repositoryBeans() {}

    // Combine pointcuts with logical operators
    @Pointcut("allServiceMethods() && !loggableMethods()")
    public void serviceMethodsExceptLoggable() {}

    // All methods in a subpackage (recursive)
    @Pointcut("within(com.app..*)")
    public void withinApp() {}
}

@Aspect
@Component
public class ValidationAspect {

    @Before("execution(* com.app.service.*.create*(..)) && args(request,..)")
    public void validateInput(JoinPoint jp, Object request) {
        if (request == null) {
            throw new IllegalArgumentException(
                "Null request for: " + jp.getSignature().getName());
        }
        log.info("Validated input for {}", jp.getSignature().toShortString());
    }
}

@Aspect
@Component
public class AuditAspect {

    @AfterReturning(
        pointcut = "execution(* com.app.service.PaymentService.process*(..))",
        returning = "result"
    )
    public void auditPayment(JoinPoint jp, PaymentResult result) {
        auditService.log(
            jp.getSignature().getName(),
            result.getTransactionId(),
            result.getAmount()
        );
    }
}

@Aspect
@Component
public class ExceptionMonitoringAspect {

    @AfterThrowing(
        pointcut = "within(com.app.service..*)",
        throwing = "ex"
    )
    public void monitorExceptions(JoinPoint jp, Exception ex) {
        log.error("Exception in {}: {}",
            jp.getSignature().toShortString(), ex.getMessage());
        metricsService.incrementCounter("service.exceptions",
            "method", jp.getSignature().getName(),
            "exception", ex.getClass().getSimpleName());
    }
}

@Aspect
@Component
public class ResourceCleanupAspect {

    @After("execution(* com.app.service.FileService.*(..))")
    public void cleanupResources(JoinPoint jp) {
        MDC.remove("operationId");
        TempFileHolder.clear();
        log.debug("Cleaned up after {}", jp.getSignature().getName());
    }
}

@Aspect
@Component
public class PerformanceAspect {

    @Around("@annotation(com.app.annotation.Timed)")
    public Object measureExecutionTime(ProceedingJoinPoint pjp) throws Throwable {
        String methodName = pjp.getSignature().toShortString();
        long start = System.nanoTime();

        try {
            Object result = pjp.proceed(); // Execute target method
            return result;
        } catch (Exception e) {
            log.error("Exception in {}: {}", methodName, e.getMessage());
            throw e;
        } finally {
            long duration = (System.nanoTime() - start) / 1_000_000;
            log.info("{} executed in {} ms", methodName, duration);
            meterRegistry.timer("method.execution",
                "method", methodName).record(duration, TimeUnit.MILLISECONDS);
        }
    }
}

@Aspect
@Component
@Order(1) // Executes FIRST (outermost)
public class SecurityAspect {
    @Before("execution(* com.app.service.*.*(..))")
    public void checkSecurity(JoinPoint jp) {
        // Security check runs first
    }
}

@Aspect
@Component
@Order(2) // Executes SECOND
public class LoggingAspect {
    @Before("execution(* com.app.service.*.*(..))")
    public void logEntry(JoinPoint jp) {
        // Logging runs after security
    }
}

@Aspect
@Component
@Order(3) // Executes THIRD (innermost)
public class MetricsAspect {
    @Around("execution(* com.app.service.*.*(..))")
    public Object recordMetrics(ProceedingJoinPoint pjp) throws Throwable {
        // Metrics wraps closest to target
        return pjp.proceed();
    }
}

@Service
public class OrderService {

    @Transactional
    public void processOrder(Order order) {
        // Called from outside -- PROXY intercepts, transaction works
        saveOrder(order);
        notifyCustomer(order); // Internal call -- bypasses proxy!
    }

    @Transactional(propagation = Propagation.REQUIRES_NEW)
    public void notifyCustomer(Order order) {
        // This @Transactional is IGNORED when called internally!
        emailService.send(order.getCustomerEmail(), "Order confirmed");
    }
}

@Aspect
@Component
public class RetryAspect {

    @Around("@annotation(retryable)")
    public Object retry(ProceedingJoinPoint pjp, Retryable retryable) throws Throwable {
        int attempts = 0;
        Exception lastException = null;

        while (attempts < retryable.maxAttempts()) {
            try {
                return pjp.proceed();
            } catch (Exception e) {
                lastException = e;
                attempts++;
                if (attempts < retryable.maxAttempts()) {
                    Thread.sleep(retryable.backoffMs() * attempts);
                    log.warn("Retry attempt {} for {}",
                        attempts, pjp.getSignature().toShortString());
                }
            }
        }
        throw lastException;
    }
}

@Target(ElementType.METHOD)
@Retention(RetentionPolicy.RUNTIME)
public @interface Retryable {
    int maxAttempts() default 3;
    long backoffMs() default 1000;
}

// Usage
@Retryable(maxAttempts = 3, backoffMs = 500)
public ExternalResponse callExternalApi(String payload) {
    return restClient.post(payload);
}

@Aspect
@Component
public class RateLimitAspect {

    private final Map<String, RateLimiter> limiters = new ConcurrentHashMap<>();

    @Around("@annotation(rateLimit)")
    public Object enforceRateLimit(ProceedingJoinPoint pjp, RateLimit rateLimit)
            throws Throwable {
        String key = pjp.getSignature().toShortString();
        RateLimiter limiter = limiters.computeIfAbsent(key,
            k -> RateLimiter.create(rateLimit.permitsPerSecond()));

        if (!limiter.tryAcquire(rateLimit.timeoutMs(), TimeUnit.MILLISECONDS)) {
            throw new RateLimitExceededException("Rate limit exceeded for " + key);
        }
        return pjp.proceed();
    }
}

@Aspect
@Component
public class CacheAspect {

    @Around("@annotation(cached)")
    public Object cache(ProceedingJoinPoint pjp, Cached cached) throws Throwable {
        String key = buildCacheKey(pjp, cached.keyExpression());
        Object cachedValue = cacheManager.get(cached.cacheName(), key);

        if (cachedValue != null) {
            log.debug("Cache hit: {} -> {}", cached.cacheName(), key);
            return cachedValue;
        }

        Object result = pjp.proceed();
        cacheManager.put(cached.cacheName(), key, result, cached.ttlSeconds());
        return result;
    }
}

@Aspect
@Component
@Order(0)
public class TracingAspect {

    @Around("within(com.app.service..*)")
    public Object propagateTrace(ProceedingJoinPoint pjp) throws Throwable {
        Span span = tracer.nextSpan()
            .name(pjp.getSignature().toShortString())
            .start();

        try (Tracer.SpanInScope ws = tracer.withSpanInScope(span)) {
            return pjp.proceed();
        } catch (Exception e) {
            span.error(e);
            throw e;
        } finally {
            span.end();
        }
    }
}