As aspect-oriented programming (AOP) becomes more prevalent in modern applications, understanding its core interfaces—particularly JoinPoint and ProceedingJoinPoint—is essential for effective interception and behavior customization.

While foundational concepts like JDK dynamic proxies and CGLIB-based bytecode generation are prerequisites, it’s critical to recognize that Spring-managed beans are the only ones eligible for AOP interception. Manually instantiated proxies bypass Spring’s interception mechanism and require alternative approaches like servlet filters or interceptors.

Core Interface: JoinPoint

public interface JoinPoint {
    String toString();          // Full description of join point location
    String toShortString();     // Brief description
    String toLongString();      // Detailed description
    Object getThis();           // Proxy instance (e.g., com.sun.proxy.$Proxy18)
    Object getTarget();         // Actual target object (e.g., service or DAO implementation)
    Object[] getArgs();         // Arguments passed to the intercepted method
    Signature getSignature();   // Method signature — getName() returns FQN like "void com.example.Service.save()"
    SourceLocation getSourceLocation(); // Source file and line info
    String getKind();           // Type of join point (method-call, field-access, etc.)
    StaticPart getStaticPart(); // Immutable metadata about the join point
}

Extended Interface: ProceedingJoinPoint

public interface ProceedingJoinPoint extends JoinPoint {
    Object proceed() throws Throwable;               // Invokes the original method
    Object proceed(Object[] args) throws Throwable;  // Invokes with modified arguments
}

The proceed() method is what enables around advice to control whether and how the target method executes. This distinguishes it from before/after advice, wich cannot alter execution flow.

StaticPart Interface

public interface StaticPart {
    Signature getSignature();
    String getKind();
    int getId();                // Unique identifier for the join point
    String toString();
    String toShortString();
    String toLongString();
}

Practical Usage Example

public Object aroundAdvice(ProceedingJoinPoint joinPoint) throws Throwable {
    Signature sig = joinPoint.getSignature();
    Class> targetClass = AopUtils.getTargetClass(joinPoint.getTarget());
    
    // Retrieve generic interfaces implemented by the target
    Type[] interfaces = targetClass.getGenericInterfaces();
    if (interfaces.length > 0) {
        Annotation anno = ((Class>) interfaces[0]).getAnnotation(Nologging.class);
    }

    MethodSignature methodSig = (MethodSignature) sig;
    Method method = methodSig.getMethod();

    // Optionally modify behavior before/after invocation
    try {
        return joinPoint.proceed(); // Continue down the proxy chain
    } catch (Exception e) {
        // Handle exception or rethrow
        throw e;
    }
}

Type vs Class in Java Reflection

The java.lang.reflect.Type interface, introduced in Java 5, serves as the supertype for all types—including parameterized types, arrays, primitives, and raw types (represented by Class).

public interface Type {
    default String getTypeName() {
        return toString();
    }
}

• Type is the parent of Class.
• Class represents raw/class types, while Type covers generics, arrays, etc.
• Useful for inspecting generic signatures at runtime, especially in AOP scenarios involving generic interfaces (e.g., MyBatis mappers).

Debugging Tip

To inspect generated proxy classes during development, enable:

-Dsun.misc.ProxyGenerator.saveGeneratedFiles=true

This dumps proxy bytecode to disk—useful for learning, but never anable in production.

Important Limitations

Standard Spring AOP using @annotation(...) only matches annotations on concrete methods—not those declared on interfaces. To intercept interface-level annotations, consider implementing BeanPostProcessor to create proxies manually during bean initialization.