What is the difference between the @within and @target pointcut designators?

## The two designators Both `@within` and `@target` are **type-level annotation-presence** designators — they ask 'does a *type* carry annotation Ann?' The difference is **which type** and **when it is evaluated**. ### @within(Ann) — declaring type, static `@within(Ann)` matches a method-execution join point when the **type that declares the executing method** is annotated with `Ann`. Think of it as 'the code lexically *within* a type marked @Ann'. Because the declaring type of a method is known at compile/proxy time, this is a **static** match — no per-call runtime work. ### @target(Ann) — runtime target type, dynamic `@target(Ann)` matches when the **runtime class of the target object** (the actual bean instance being proxied) is annotated with `Ann`. Because the runtime type can only be known when a call happens, this introduces a **runtime residue** — Spring inserts a runtime check on each invocation. ## Where they differ: inheritance Consider: ```java @Retention(RetentionPolicy.RUNTIME) @Target(ElementType.TYPE) public @interface Monitored {} @Monitored public class BaseService { public void base() {} } public class ExtService extends BaseService { public void ext() {} } ``` With a bean of runtime type `ExtService`: - Calling **base()** (declared in `BaseService`): `@within(Monitored)` MATCHES — the declaring type `BaseService` is annotated. `@target(Monitored)` checks `ExtService.class` — matches **only if** `@Monitored` is `@Inherited`. - Calling **ext()** (declared in `ExtService`): `@within(Monitored)` does NOT match — declaring type `ExtService` is not annotated. `@target(Monitored)` again depends on `@Inherited`. So: `@within` follows *where the method is written*; `@target` follows *the concrete object's class*. For a single, non-inherited, annotated class calling its own methods, they produce identical results — which is why people conflate them. ## @Inherited nuance Java's `@Inherited` meta-annotation only propagates a **type** annotation from a superclass to subclasses (never for interfaces, never for method annotations). This is precisely what can make `@target` on a subclass match even when the annotation is physically only on the superclass. ## Practical consequences of the static vs runtime split - **Performance / proxy eligibility:** `@target` (along with `@args`, `this`, `target`) cannot be fully resolved statically, so Spring must treat many beans as *potentially* matching. During auto-proxy creation this can cause Spring to instantiate beans early and log warnings like *'is not eligible for getting processed by all BeanPostProcessors'*. `@within` has no such cost. - **Recommendation:** prefer `@within` (or `@annotation`) when the declaring type is what you mean; reserve `@target` for cases where the *runtime* type genuinely matters. ## Requirements Both require the annotation to have `RUNTIME` retention and a `@Target` that permits `TYPE` (i.e. it can be placed on a class). ## Relation to declarative features A class-level `@Transactional` applies to all methods of the class — conceptually `@within`-like (declared-in behavior). Spring's actual implementation uses a dedicated pointcut with merged-annotation lookup, but the mental model of 'type carries the annotation ⇒ all its methods match' is the `@within` idea.