Why Do final, static, and private Methods Escape Spring AOP Proxying?

1. Spring AOP proxy mechanisms

JDK dynamic proxy (interface‑based)

Trigger condition: target class implements an interface.

Implementation principle: at runtime a class implementing the interface is generated; the proxy object implements the interface and wraps the target instance.

Core limitation: only public instance methods declared in the interface can be intercepted.

Fatal shortcoming: interfaces cannot declare private, static or final methods, so these methods are invisible to the proxy.

CGLIB dynamic proxy (subclass‑based, default in Spring Boot)

Trigger condition: target class has no interface or CGLIB is forced.

Implementation principle: at runtime a subclass bytecode of the target class is generated; the subclass overrides the parent methods to insert advice.

Core dependency: Java inheritance + method‑override mechanism.

Applicable range: all non‑final, non‑private, non‑static public instance methods.

Spring AOP is proxy‑based enhancement, not source‑code modification. Any method that cannot be overridden, inherited, or called on an instance proxy is completely un‑interceptable.

2. Why private, static and final methods cannot be proxied

Private methods

Java language restriction: private methods are visible only inside the declaring class; subclasses cannot see them.

Bytecode level: CGLIB generates a subclass that never sees the private method, so it cannot override it.

Result: a pointcut may match the method name, but the generated proxy never intercepts the call; the call goes directly to the original method.

Self‑invocation: a call like this.xxx() uses the raw target object, bypassing the Spring proxy.

Static methods

Java core rule: static methods belong to the class, not to an instance.

Proxy conflict: both JDK and CGLIB proxies work on bean instances; a static call such as ClassName.method() never passes through the proxy.

CGLIB limitation: a subclass cannot override a static method; it can only hide it, leaving the original logic untouched.

Final methods

Final semantics: the method cannot be overridden by a subclass.

CGLIB effect: the subclass cannot insert advice, so the call bypasses the proxy.

Final class: if the whole class is final, CGLIB cannot create a subclass at all, making the bean completely unmanaged by AOP.

JDK proxy: interfaces cannot declare final methods, so the limitation is the same.

3. Comparison of the two proxy mechanisms

private

JDK proxy failure: interfaces have no private methods, no interception entry.

CGLIB proxy failure: subclass cannot see or override private methods.

Core essence: access‑level isolation.

static

JDK proxy failure: interfaces do not support static method proxying.

CGLIB proxy failure: no overriding mechanism; static belongs to class, not instance.

Core essence: detached from instance proxy system.

final

JDK proxy failure: interfaces have no final methods.

CGLIB proxy failure: language forbids overriding final methods.

Core essence: method locked by syntax.

4. Code demonstration

Service with four kinds of methods

@Service
public class AopFailService {
    // normal public instance method – works
    public void normalPublicMethod() {
        System.out.println("【正常】public业务方法执行");
    }
    // private method – fails
    private void privateMethod() {
        System.out.println("【失效】private私有方法执行");
    }
    // static method – fails
    public static void staticMethod() {
        System.out.println("【失效】static静态方法执行");
    }
    // final method – fails
    public final void finalMethod() {
        System.out.println("【失效】final禁止重写方法执行");
    }
    // internal self‑call – all bypass proxy
    public void innerCallTest() {
        normalPublicMethod();
        privateMethod();
        staticMethod();
        finalMethod();
    }
}

Universal aspect

@Aspect
@Component
public class UniversalAspect {
    // match all methods in com.demo.service package
    @Pointcut("execution(* com.demo.service.*.*(..))")
    public void point() {}
    @Before("point()")
    public void beforeAdvice(JoinPoint joinPoint) {
        System.out.println("✅ 切面拦截成功：" + joinPoint.getSignature().getName());
    }
}

Console output shows that only normalPublicMethod is intercepted; the other three methods execute without advice.

5. Practical notes

Self‑invocation via this uses the raw object, so even a public method may not be intercepted. Inject the bean’s own proxy and call through it.

Transactional annotations on private methods are ineffective; the transaction will not roll back on exception.

Marking a service class as final prevents CGLIB from creating a proxy subclass, disabling all AOP features for that bean.

Java 8 interface default or static methods cannot be intercepted by either proxy mechanism.