@Aspect annotation in Spring Boot - Step-by-Step Execution

Concept Flow - @Aspect annotation

Define Aspect Class

↓

Add @Aspect Annotation

↓

Define Pointcut Expression

↓

Define Advice Method (e.g., @Before)

↓

Spring AOP Proxy Created

↓

Target Method Called

↓

Advice Runs Before/After Target Method

↓

Target Method Executes

↓

Return to Caller

This flow shows how an @Aspect class is defined, advice methods are set, and how Spring AOP runs advice around target method calls.

Execution Sample

Spring Boot

import org.aspectj.lang.annotation.*;

@Aspect
public class LoggingAspect {
  @Before("execution(* com.example.service.*.*(..))")
  public void logBefore() {
    System.out.println("Method is about to run");
  }
}

Defines an aspect with a @Before advice that logs before any method in com.example.service package runs.

Execution Table

Step	Action	Evaluation	Result
1	Spring scans for @Aspect classes	Finds LoggingAspect	LoggingAspect registered as aspect
2	Spring creates proxy for target beans	Target beans in com.example.service	Proxies wrap target beans
3	Client calls target method serviceMethod()	Matches pointcut expression	Advice logBefore() triggered
4	Advice logBefore() runs	Prints message	Output: 'Method is about to run'
5	Target method serviceMethod() runs	Executes original logic	Target method completes
6	Return to client	Method call ends	Execution finished

💡 Execution stops after target method completes and returns to caller

Variable Tracker

Variable	Start	After Step 3	After Step 4	After Step 5	Final
LoggingAspect instance	null	created	active	active	active
Target method call	none	invoked	waiting	executing	completed
Advice triggered	false	true	true	false	false

Key Moments - 3 Insights

Why does the advice run before the target method?

Because the @Before annotation tells Spring AOP to run the advice method before the matched target method, as shown in execution_table step 4.

How does Spring know which methods to apply the advice to?

Spring uses the pointcut expression in the @Before annotation to match method signatures, as seen in execution_table step 3.

Is the original target method replaced by the advice?

No, the advice runs around the target method but does not replace it; the target method still executes after advice, as shown in steps 5 and 6.

Visual Quiz - 3 Questions

Look at the execution_table, what happens at step 4?

A The target method starts executing

B Spring scans for @Aspect classes

C The advice method logBefore() runs and prints a message

D The client receives the method result

💡 Hint

Check the 'Action' and 'Result' columns at step 4 in execution_table

At which step does the target method actually execute?

A Step 5

B Step 4

C Step 3

D Step 6

💡 Hint

Look for 'Target method runs' in the 'Action' column of execution_table

If the pointcut expression did not match any method, what would change in the execution_table?

A Advice would still run before the target method

B Advice would never run, target method runs normally

C Spring would not create any proxies

D The target method would be replaced by advice

💡 Hint

Refer to step 3 where matching triggers advice; no match means no advice

Concept Snapshot

@Aspect annotation marks a class as an aspect.
Use pointcut expressions to select methods.
Advice methods (@Before, @After, etc.) run around target methods.
Spring creates proxies to apply advice.
Advice runs without replacing original methods.
Useful for logging, security, transactions.

Full Transcript

The @Aspect annotation in Spring Boot marks a class as an aspect that contains advice methods. Spring scans for these classes and creates proxies for target beans matching pointcut expressions. When a client calls a target method, Spring runs the advice method first if annotated with @Before, then executes the target method. This allows adding behavior like logging without changing the original code. The execution flow starts with scanning, proxy creation, method call, advice execution, target method execution, and finally returning to the caller. Variables like the aspect instance and advice trigger state change during execution. Common confusions include why advice runs before the method, how Spring matches methods, and that advice does not replace the target method. Visual quizzes reinforce understanding of each step.