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

Learning a module’s design starts with its interface; once the interfaces are known, implementation becomes straightforward.

The article begins with the background of AOP, describing why cross‑cutting concerns like logging and security are problematic in pure OOP and introducing AOP as a horizontal programming paradigm.

AOP Background

In OOP, adding the same behavior to unrelated classes leads to duplicated code. AOP addresses this by allowing developers to define cross‑cutting logic separately and apply it at designated join points.

What Is AOP?

AOP consists of three processes:

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

Define the cross‑cutting logic (advice) – the code that will run at those points.

Weave – integrate the advice into the join points.

Developers mainly focus on writing the advice; the framework determines the join points.

Joinpoint Interface Design

In Java, everything is an object, and a class contains fields and methods (constructors, instance methods, static methods). The AOP Alliance defines a Joinpoint interface to abstract a join point:

public interface Joinpoint {

  Object proceed() throws Throwable;

  Object getThis();

  AccessibleObject getStaticPart();

}

The methods provide:

proceed() – chain the execution of multiple advices.

getThis() – obtain the current target object (null for static methods).

getStaticPart() – return the reflective object representing the static part (e.g., a Method ).

Additional sub‑interfaces can describe specific join points such as method invocation or field access.

Weaving Strategies

Weaving can be performed statically using a custom class loader that modifies bytecode during class loading, or dynamically using proxies (JDK Proxy) or bytecode generation libraries (cglib). Spring AOP adopts dynamic weaving by creating proxy objects that hold the chain of interceptors.

Example Code

A simple Java class used to illustrate 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 }
    }
}

This example shows that join points can be categorized into field access and various method invocations.

Overall, the article provides a clear overview of AOP concepts, interface design, and weaving mechanisms, useful for backend developers working with Java frameworks.