skip to content

What does the within() pointcut designator match in Spring AOP, and how is it different from execution()?

level: juniorimportance: should knowfreq 45%

answer

  1. within = declaring type / package
  2. static match, decided at proxy creation
  3. ..* means package + subpackages
  4. coarse: whole classes, no method signature
  5. combine with execution() for method filter

basics

~10 s

within() matches all join points where the executing method is declared inside a given type or package — for example within(com.example.service..*). It filters by location, not by method signature.

solid answer

~30 s

within() is a pointcut designator that matches join points based on the declaring type — i.e. where the code that is running lives. within(com.example.service.OrderService) matches every method executed on that class; within(com.example.service..*) matches every class in that package and subpackages. It is a purely static, type-signature match, so it is cheap and evaluated at weaving/proxy-creation time. execution() is finer-grained: it matches an individual method signature (return type, name, args). You typically combine them, e.g. execution(public * *(..)) && within(com.example.service..*), to say 'any public method inside the service package'. within() alone is coarse — it targets whole classes/packages, not specific methods.

code

java · 16 lines
java
@Aspect
@Component
public class ServiceLoggingAspect {

    // Every public method-execution of any class under the service package tree.
    @Pointcut("within(com.example.service..*)")
    void inServiceLayer() {}

    @Pointcut("execution(public * *(..))")
    void anyPublicMethod() {}

    @Before("anyPublicMethod() && inServiceLayer()")
    void logEntry(JoinPoint jp) {
        System.out.println("-> " + jp.getSignature().toShortString());
    }
}

go deeper

for a junior

Know within() targets a type or package (..* = subpackages) and does not look at method names.

for a middle

Contrast with execution(); know within() is commonly ANDed with a signature filter to scope an aspect to a layer.

for a senior

Articulate that within() is a static PCD resolved at proxy creation, hence cheap and used to decide whether to proxy a bean at all.

for a principal

Frame within() as the layer/module scoping tool and reason about static-vs-dynamic matching cost across a large bean graph.

## What within() is In Spring AOP a **pointcut** is an expression that selects **join points** (in Spring, join points are always *method executions* on Spring beans). **Pointcut designators (PCDs)** are the keywords you use to build that expression: `execution`, `within`, `this`, `target`, `args`, `@annotation`, `bean`, etc. `within(TypePattern)` matches **all join points where the executing code is declared within the given type or package**. It is about *where the method lives*, not what the method looks like. ### Examples - `within(com.example.service.OrderService)` — every method-execution join point on `OrderService`. - `within(com.example.service.*)` — every class directly in the `service` package (one level). - `within(com.example.service..*)` — the `..` means *this package and all sub-packages*, so every class under `service`. - `within(@org.springframework.stereotype.Repository *)` — every type annotated with `@Repository` (type-level annotation form). ## within() vs execution() `execution(modifiers? ret-type declaring-type?.method(params) throws?)` matches a **specific method signature**. `within()` matches by **declaring type only** and cannot express method name/return type/arguments. Practically: ``` execution(* com.example.service.OrderService.*(..)) // all methods of OrderService within(com.example.service.OrderService) // same set of join points ``` These two are equivalent for a single class. `within()` shines when you want *everything in a package* concisely, and it is commonly **combined** with a signature filter: ``` execution(public * *(..)) && within(com.example..service..*) ``` ## Static matching → cheap `within()` is a **static** PCD: it can be fully decided from the type signature at **proxy-creation time**, with no runtime state. That means Spring decides *whether to create a proxy at all* for a bean using such expressions, and there is no per-invocation cost. This contrasts with dynamic PCDs like `args()`, `this()` and `target()` which may need a runtime check per call. ## Gotchas - Spring AOP only advises **Spring-managed beans** and only **method executions** (no field access, no constructor join points, no call join points — that is full AspectJ, not Spring's proxy-based AOP). So even a broad `within()` never advises non-bean classes or private/final self-invocations. - `within()` matches the **declaring type of the executing code**, which is subtle for inheritance: a method inherited from a superclass executes with the subclass as the runtime bean but the join point's declaring type is where the method body lives. In practice for Spring beans you rarely hit this; prefer `within(TargetInterfaceOrClass..*)` on your own packages. - `within()` does **not** bind anything — you cannot capture the object or arguments from it. Use `this()`/`target()`/`args()` for binding. ## When to use Use `within()` to scope an aspect to a **module/layer** (a package tree) cheaply and statically — e.g. 'log every service call', 'apply metrics to the whole persistence package'. Combine with `execution()` when you also need to filter by method shape.

  • Is within() a static or dynamic pointcut, and why does that matter for performance?
    Static — it is decided entirely from the type signature at proxy-creation time, so there is no per-invocation runtime check. Dynamic PCDs like args()/this()/target() can require a runtime test on every call.

context

resolving links…