Explain the @Async self-invocation pitfall and the ways to work around it.

**Why it happens.** With `@EnableAsync` in its default `AdviceMode.PROXY`, Spring doesn't modify your class. It creates a **proxy** around the bean (JDK dynamic proxy if there's an interface, else a CGLIB subclass). The async interception logic lives in the proxy. When another bean calls your method, it holds a reference to the *proxy*, so the interceptor runs and dispatches to the executor. But when a method inside the class calls a sibling `@Async` method as `this.doWork()` (or an unqualified `doWork()`), the call goes straight to the **real object's** method — `this` is the raw target, not the proxy. The proxy never sees the call, no interceptor fires, and the method runs **inline, synchronously, on the caller's thread**. It looks annotated but behaves as if it isn't. This is identical to the self-invocation problem for `@Transactional`, `@Cacheable`, `@Retryable` — anything proxy-based. **Symptoms.** The method 'works' but never runs on a background thread; thread-name prefixes show the caller's thread; parallelism you expected doesn't materialize; a request that should return fast still blocks on the slow work. **Workarounds (default proxy mode):** 1. **Extract to another bean (recommended).** Put the `@Async` method on a different `@Service`/`@Component` and inject it. The call now crosses a proxy boundary: ```java @Service class Worker { @Async void run() { ... } } @Service class Orchestrator { private final Worker worker; Orchestrator(Worker worker) { this.worker = worker; } void handle() { worker.run(); } // goes through Worker's proxy -> async } ``` 2. **Self-injection.** Inject the bean into itself so you hold your own proxy: ```java @Service class Reports { @Autowired private Reports self; // Spring injects the proxy void handle() { self.build(); } // async @Async void build() { ... } } ``` (Constructor self-injection causes a cycle; use a setter/field, or `@Lazy`, or fetch from `ApplicationContext`.) 3. **AopContext.currentProxy().** With `@EnableAsync(... )` plus proxy exposure enabled (`@EnableAspectJAutoProxy(exposeProxy = true)` or the corresponding setting), call `((Reports) AopContext.currentProxy()).build();`. Works but couples code to Spring AOP internals. 4. **AspectJ mode.** `@EnableAsync(mode = AdviceMode.ASPECTJ)` weaves the async advice directly into the class bytecode (compile-time or load-time weaving), so there is no proxy indirection — internal `this` calls and even non-public methods become async. Requires `spring-aspects` and the AspectJ weaver; heavier to set up but eliminates the pitfall entirely. **Related constraints in proxy mode.** The method must be **public** (private/package methods aren't proxied). Final classes/methods can't be CGLIB-proxied. These are all facets of the same proxy model. **When to worry.** Any time you refactor a slow method into an `@Async` one and keep calling it from the same class. The safest default is to keep proxied concerns on collaborator beans so the boundary is always crossed.