What happens if you write a Spring AOP pointcut using an AspectJ designator like call(), get(), or set()?

## Supported vs unsupported — and the failure mode ### The supported set (memorize this) Spring AOP accepts these AspectJ **pointcut designators (PCDs)**: - `execution(...)` — match method execution join points. The workhorse; you'll use it 90% of the time. - `within(...)` — limit to join points within given types (e.g. `within(com.acme.service..*)`). - `this(...)` — the **proxy** object is an instance of the given type. - `target(...)` — the **target** (raw) object is an instance of the given type. - `args(...)` — the method **arguments** are instances of the given types. - `@target(...)` — the target's **class** carries the given annotation. - `@args(...)` — the runtime **argument types** carry the given annotation. - `@within(...)` — join points within types carrying the given annotation. - `@annotation(...)` — the executing **method** carries the given annotation. Plus one **Spring-specific** PCD that is not AspectJ at all: - `bean(...)` — match by Spring **bean name**, e.g. `bean(*Service)` or `bean(orderService)`. ### The unsupported ones Everything else in AspectJ is rejected: `call`, `get`, `set`, `initialization`, `preinitialization`, `staticinitialization`, `handler`, `withincode`, `cflow`, `cflowbelow`, `adviceexecution`, `if`, `@this`. These correspond to join points (field access, construction, control-flow, call-site) that a proxy simply cannot observe. ### The failure mode — NOT silent A common misconception is that unsupported designators are 'silently ignored.' They are **not**. Spring wraps the AspectJ pointcut parser (`AspectJExpressionPointcut`); when it encounters an unsupported primitive it throws **`IllegalArgumentException`** with a message like: > "...supported Pointcut primitives: [EXECUTION, ARGS, REFERENCE, THIS, TARGET, WITHIN, @ANNOTATION, @WITHIN, @ARGS, @TARGET]" This surfaces as a `BeanCreationException` during application-context startup — **fail fast**. (What IS genuinely silent is a different thing: a validly-parsed pointcut that just never matches — e.g. because of self-invocation or because you targeted a non-bean class — matches zero join points and quietly does nothing.) ### `call` vs `execution` — the classic confusion - `execution(...)` matches at the **callee** side — where the method runs. - `call(...)` (AspectJ only) matches at the **caller** side — where the method is invoked. Spring AOP has no caller-side join point, so `call` is unsupported and you always express things via `execution`. ### `this` vs `target` gotcha With a **JDK dynamic proxy**, the proxy implements the interface but is NOT an instance of the concrete class, so `this(ConcreteClass)` won't match while `target(ConcreteClass)` will. With **CGLIB**, the proxy is a subclass of the concrete class, so both can match. This trips people up when they flip `proxyTargetClass`. ### When to reach for each - Broad, signature-based selection → `execution`. - Package/layer scoping → `within` or `bean`. - Annotation-driven cross-cutting (your own `@Audited`) → `@annotation`. - Passing an argument or annotation into advice → `args` / `@annotation` binding.