```mermaid theme={null}
sequenceDiagram
participant Caller
participant Proxy as AOP Proxy
participant Aspect as LoggingAspect
participant Target as UserService
Caller->>Proxy: saveUser()
Proxy->>Aspect: @Before logic
Aspect-->>Proxy: ok
Proxy->>Target: saveUser()
Target-->>Proxy: return
Proxy->>Aspect: @After logic
Aspect-->>Proxy: ok
Proxy-->>Caller: return
```
### JDK vs CGLIB
* **JDK Dynamic Proxy:** Used if the target implements an **Interface**. Only creates proxies for interfaces.
* **CGLIB (Code Generation Library):** Used if the target is a **Class** (no interface). Spring generates a subclass of your bean at runtime.
> **Interview Tip:** Since Spring Boot 2.0, CGLIB is the default (even for interfaces) to ensure consistency (prevents `ClassCastException` if you autowire the impl class).
## 5. Pitfall: Self-Invocation
This is the single most common AOP bug in Spring, and it bites developers at every experience level.
**Problem:** Using `@Transactional` or `@Async` on a method called from *within the same class* does not work.
```java theme={null}
@Service
public class OrderService {
public void createOrder() {
// ...
sendEmail(); // THIS WILL NOT BE ASYNC! The @Async annotation is ignored.
}
@Async
public void sendEmail() { ... }
}
```
**Reason:** When Spring creates the `OrderService` bean, it wraps it in a proxy. External callers (controllers, other services) call the proxy, which intercepts `@Async` and runs it on a separate thread. But inside `createOrder()`, the call to `sendEmail()` is `this.sendEmail()` -- `this` refers to the **Target Object** (the real `OrderService`), not the proxy. The proxy is completely bypassed, and the `@Async` annotation is invisible.
**Solutions (pick one):**
```java theme={null}
// Solution 1: Move the method to a separate service (cleanest)
@Service
public class EmailService {
@Async
public void sendEmail() { ... } // Now external call goes through proxy
}
// Solution 2: Self-inject via ApplicationContext (use sparingly)
@Service
public class OrderService {
@Lazy
@Autowired
private OrderService self; // Spring injects the PROXY, not 'this'
public void createOrder() {
self.sendEmail(); // Goes through the proxy -- @Async works
}
}
```
**A senior engineer would note:** This same self-invocation trap applies to `@Transactional`, `@Cacheable`, `@Retryable`, and every other annotation that relies on Spring AOP proxies. If you call an annotated method from within the same class, the annotation is silently ignored. When you see mysterious "transaction not rolling back" or "cache not working" bugs, self-invocation should be the first thing you check.
***
## Interview Deep-Dive