What do the perthis and pertarget aspect instantiation models do in Spring AOP, and how must the aspect bean be scoped?

**Recap of the default.** By default an aspect is a **singleton** — one shared instance for everything. The other models let the aspect keep state tied to individual advised objects. **perthis.** Declared as `@Aspect("perthis(<pointcut>)")`. A **new aspect instance is created for each unique object executing** a join point matched by the pointcut — i.e. per unique `this`. In Spring AOP, `this` at a join point is the **AOP proxy**, so you get one aspect instance per advised (proxied) object. The instance is created **lazily** the first time that particular object hits a matched join point, and it lives as long as that object does. **pertarget.** Declared as `@Aspect("pertarget(<pointcut>)")`. A **new aspect instance per unique target object** — the actual bean instance behind the proxy. In typical Spring AOP setups (singleton target beans, one proxy each) perthis and pertarget behave very similarly; the distinction matters more when `this` (proxy) and target differ, or under AspectJ semantics where `this` can be a caller. **Mandatory prototype scope.** Because these models require Spring to create **multiple** aspect instances, the aspect bean **must be declared with prototype scope** (`@Scope("prototype")` or `scope="prototype"`). A singleton-scoped bean cannot be instantiated per object, so the model would not work. This is the single most important practical rule and a frequent interview point. **Why use them.** When the cross-cutting concern needs **per-object state**: e.g. a per-service-instance call counter, a per-object circuit breaker / rate limiter, or accumulating metrics isolated per target. With a singleton aspect you'd have to build that isolation yourself (e.g. a `Map` keyed by object); perthis/pertarget give it to you structurally. **What Spring does NOT support.** AspectJ additionally defines **percflow**, **percflowbelow**, and **pertypewithin** instantiation models. **Spring AOP supports only singleton, perthis, and pertarget.** Claiming Spring supports percflow/pertypewithin is a red flag. **Pointcut in the model vs advice pointcuts.** The pointcut named inside `perthis(...)`/`pertarget(...)` governs *when a new aspect instance is created* (which objects get their own aspect); your advice methods still have their own pointcuts for *what they intercept*. **Lifecycle / memory considerations.** Since one aspect instance can exist per advised object, and instances are created lazily and retained, be mindful of memory if there are many distinct advised objects. For long-lived singleton service beans this is bounded and fine; for many short-lived proxied objects it can add overhead. **Gotchas.** - Forgetting `@Scope("prototype")` — the model silently won't behave as intended / bean creation fails to multiply. - Expecting perthis to give per-*invocation* isolation — it is per-*object*, not per-call. - Assuming these are common — they are relatively rare; most real aspects are singletons, and per-object state is often handled with a keyed map instead.