Understanding AOP: Joinpoint Design, Advice, and Weaving in Java

Learning a module’s design starts with its interface; by examining interfaces we can infer the overall implementation and then assemble the module accordingly.

AOP Background

Object‑Oriented Programming (OOP) suffers from code duplication when the same cross‑cutting behavior (e.g., logging, security checks) must be added to many unrelated classes, making maintenance difficult.

Aspect‑Oriented Programming (AOP) complements OOP by addressing these horizontal concerns, separating them from the core business logic.

What Is AOP

AOP consists of three steps:

Identify join points – determine where in the program the cross‑cutting logic should be applied.

Write the cross‑cutting logic (advice) – the actual code that runs at the join points.

Weave – integrate the advice into the identified join points.

Developers mainly focus on writing advice; the framework handles join‑point detection and weaving.

Typical join points in Java include fields and methods (constructors, instance methods, static methods). The following example illustrates possible join points:

public class Test {
    public static void main(String[] args) {
        // @1
        B b = new B();
        // @2
        b.method();
        // @3
        B.say();
    }

    static class B {
        // field
        // @4
        private String name;
        // constructor
        public B() {
            // @1.1
        }
        // instance method
        public void method() {
            // @2.2
        }
        // static method
        static void say() {
            // @3.3
        }
    }
}

Join points can be categorized into two major groups: field‑related and method‑related (including constructors, instance methods, and static methods).

Joinpoint Interface Design

In Java, everything is an object, and a class consists of fields and methods. The AOP Alliance defines a Joinpoint interface to abstract a join point:

public interface Joinpoint {
    Object proceed() throws Throwable;
    Object getThis();
    AccessibleObject getStaticPart();
}

proceed() executes the next advice in the chain; getThis() returns the target object (null for static join points); getStaticPart() returns the reflective object (e.g., Method ).

Advice Abstraction

Advice represents the cross‑cutting behavior. In the AOP Alliance it is modeled as an interceptor; a MethodInterceptor receives a MethodInvocation (a join point) and can invoke proceed() to continue the chain:

Object invoke(MethodInvocation invocation) throws Throwable;

Weaving

Weaving integrates advice into the program and can be performed in two ways:

Static weaving – a custom class loader modifies bytecode during class loading.

Dynamic weaving – uses JDK proxies or bytecode generation libraries such as CGLIB to create proxies at runtime.

Spring AOP employs dynamic weaving by generating proxy objects that hold a chain of interceptors; method calls on the proxy trigger the advice chain.

Resources

Further reading includes Spring Boot notes, AOP Alliance interface diagrams, and examples of method‑level advice.

Overall, the article provides a clear analysis of AOP concepts, join‑point interface design, advice abstraction, and weaving mechanisms, illustrating how Spring AOP implements the AOP Alliance standards.