Spring AOP全局拦截抛出异常遇阻：切面仅部分方法生效

Hey there! Your observations are totally on point—this is exactly how Spring AOP behaves by default, and there are a few key reasons behind the behavior you're seeing:

• Spring AOP relies on dynamic proxies (JDK or CGLIB) out of the box, and JDK proxies only work with public methods. Even CGLIB, which can proxy classes instead of interfaces, skips non-public methods unless explicitly configured.
• Methods in Spring configuration classes (like @Bean methods) execute during container initialization, when the AOP infrastructure is already up and running. For other beans, if you’re making internal method calls (e.g., this.myMethod()), those bypass the proxy entirely, so the aspect never triggers.

Let’s break down the fixes to get your exception-handling aspect working for all methods as intended:

1. Configure CGLIB to proxy non-public methods #

First, switch to CGLIB proxying (since JDK proxies can’t handle non-public methods at all) and tweak its settings to allow proxying protected/private methods:

Step 1: Enable CGLIB proxying #

Update your Spring configuration to force CGLIB instead of JDK proxies:

@Configuration
@EnableAspectJAutoProxy(proxyTargetClass = true) // Forces CGLIB proxying
public class AopConfig {
    // Your bean definitions here
}

Step 2: Allow CGLIB to proxy non-public methods #

By default, CGLIB skips non-public methods. To change this, set a system property or configure it via a BeanPostProcessor:

@Bean
public BeanPostProcessor cglibProxyConfigurer() {
    return new BeanPostProcessor() {
        @Override
        public Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException {
            if (bean instanceof Advised) {
                // Enable proxy exposure (useful for internal calls too)
                ((Advised) bean).setExposeProxy(true);
                // Tell CGLIB to proxy non-public methods
                System.setProperty("cglib.proxy.non-public", "true");
            }
            return bean;
        }
    };
}

2. Fix internal method call issues #

If your target methods are being called internally (e.g., this.doSomething()), the call doesn’t go through the Spring proxy, so the aspect won’t run. Here are two workarounds:

Option A: Extract methods to a separate bean #

Move the method you want to intercept into a dedicated bean, then inject it into the original class:

// New bean with the interceptable method
@Component
public class WorkService {
    public void doCriticalWork() {
        // Logic that might throw exceptions
    }
}

// Original class using the new bean
@Component
public class RequestHandler {
    private final WorkService workService;

    public RequestHandler(WorkService workService) {
        this.workService = workService;
    }

    public void processRequest() {
        workService.doCriticalWork(); // This goes through the proxy, so aspect triggers
    }
}

Option B: Use AopContext to get the proxy #

If you can’t extract the method, enable proxy exposure and use AopContext to call the method via the proxy:

@Configuration
@EnableAspectJAutoProxy(proxyTargetClass = true, exposeProxy = true) // Enable proxy exposure
public class AopConfig {}

// In your target class
@Component
public class WorkService {
    public void process() {
        // Instead of this.doCriticalWork()
        ((WorkService) AopContext.currentProxy()).doCriticalWork();
    }

    protected void doCriticalWork() { // This protected method will now be intercepted
        // Your logic here
    }
}

3. Switch to AspectJ Weaving (for full method coverage) #

If you need to intercept all methods—including private ones, constructors, and internal calls—Spring AOP’s dynamic proxies won’t be enough. AspectJ uses direct bytecode manipulation, so it’s far more powerful.

Step 1: Add AspectJ dependencies #

Add these to your pom.xml (Maven):

<dependencies>
    <dependency>
        <groupId>org.aspectj</groupId>
        <artifactId>aspectjrt</artifactId>
        <version>1.9.20</version>
    </dependency>
    <dependency>
        <groupId>org.aspectj</groupId>
        <artifactId>aspectjweaver</artifactId>
        <version>1.9.20</version>
    </dependency>
</dependencies>

Step 2: Enable AspectJ Load-Time Weaving (LTW) #

Add this to your Spring configuration:

@Configuration
@EnableLoadTimeWeaving(aspectjWeaving = EnableLoadTimeWeaving.AspectJWeaving.ENABLED)
public class AspectJConfig {}

Then run your app with the AspectJ weaver agent as a JVM argument:

-javaagent:/path/to/aspectjweaver-1.9.20.jar

Step 3: Update your aspect #

Your aspect can stay mostly the same, but now it will intercept all methods regardless of access modifier or call type:

@Aspect
public class GlobalExceptionHandlingAspect {
    @AfterThrowing(pointcut = "execution(* com.yourpackage..*(..))", throwing = "ex")
    public void handleException(Exception ex) {
        // Your exception handling logic
        System.out.println("Caught exception: " + ex.getMessage());
    }
}

With these changes, your exception-handling aspect should trigger for every thrown exception, no matter what kind of method it comes from.

内容的提问来源于stack exchange，提问作者user3285241