@Before advice in Spring Boot - Step-by-Step Execution

Concept Flow - @Before advice

Method call starts

↓

@Before advice runs

↓

Original method executes

↓

Method call ends

When a method is called, the @Before advice runs first, then the original method runs, then the call ends.

Execution Sample

Spring Boot

import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.annotation.Before;

@Aspect
public class MyAspect {
  @Before("execution(* MyService.doWork(..))")
  public void beforeAdvice() {
    System.out.println("Before advice runs");
  }
}

This code runs the beforeAdvice method before MyService.doWork() executes.

Execution Table

Step	Action	Output	Next Step
1	Call MyService.doWork()	No output yet	Run @Before advice
2	Run @Before advice	Prints: Before advice runs	Run original method
3	Run original method doWork()	Original method output (if any)	Method call ends
4	Method call ends	No further action	Exit

💡 Method call completes after original method runs

Variable Tracker

Variable	Start	After Step 2	After Step 3	Final
methodCall	not started	beforeAdvice executed	original method executed	completed

Key Moments - 2 Insights

Does the original method run before or after the @Before advice?

The @Before advice runs first, then the original method runs, as shown in execution_table step 2 and 3.

Can @Before advice change the return value of the original method?

No, @Before advice runs before the method but cannot change its return value; it only runs code before the method executes.

Visual Quiz - 3 Questions

Look at the execution table, what happens at step 2?

A The original method runs

B The @Before advice runs

C The method call ends

D No action happens

💡 Hint

Check the 'Action' column for step 2 in the execution_table

At which step does the original method execute?

A Step 3

B Step 2

C Step 1

D Step 4

💡 Hint

Look at the 'Action' column in execution_table for when the original method runs

If the @Before advice prints a message, when will it appear relative to the original method's output?

A After the original method's output

B At the same time as the original method's output

C Before the original method's output

D It will not appear

💡 Hint

Refer to the order of outputs in execution_table steps 2 and 3

Concept Snapshot

@Before advice runs before the target method.
It cannot change the method's return value.
Use @Before("pointcut") to specify where it applies.
It is useful for logging or setup before method runs.
Execution order: @Before advice -> original method -> end.

Full Transcript

When a method matched by the pointcut is called, the @Before advice runs first. This means any code inside the @Before method executes before the original method starts. For example, if you have a method doWork() and a @Before advice on it, the advice prints a message before doWork() runs. The method call then continues to the original method. The @Before advice cannot change the return value or stop the method; it only runs code before the method executes. This is useful for logging or preparing data before the main method runs.

Practice

1. What is the main purpose of the @Before advice in Spring AOP?

easy

A. To replace the matched method entirely

B. To run code right before the matched method executes

C. To run code after the matched method completes

D. To handle exceptions thrown by the matched method

Solution

1. Step 1: Understand the role of @Before advice

   @Before advice is designed to execute code just before the target method runs.

2. Step 2: Compare with other advice types

   @After runs after method completion, @Around can replace, and @AfterThrowing handles exceptions.

3. Final Answer:

   To run code right before the matched method executes -> Option B

4. Quick Check:

   @Before advice = runs before method [OK]

Hint: Remember: @Before means before method starts [OK]

Common Mistakes:

• Confusing @Before with @After or @Around advice
• Thinking @Before replaces the method
• Assuming @Before handles exceptions

2. Which of the following is the correct syntax to define a @Before advice method in Spring AOP?

easy

A. @Before("execution(* com.example.service.*.*(..))") public void logBefore() {}

B. @Before public void logBefore() { execution(* com.example.service.*.*(..)); }

C. @Before public void logBefore() execution(* com.example.service.*.*(..)) {}

D. @Before("logBefore()") public void execution(* com.example.service.*.*(..)) {}

Solution

1. Step 1: Identify correct @Before annotation usage

   The @Before annotation requires a pointcut expression as a string parameter inside parentheses and quotes.

2. Step 2: Check method signature and placement

   The method should be public void with no parameters or with JoinPoint if needed, and the pointcut is inside @Before("...").

3. Final Answer:

   @Before("execution(* com.example.service.*.*(..))") public void logBefore() {} -> Option A

4. Quick Check:

   @Before("pointcut") public void method() {} [OK]

Hint: Look for @Before with pointcut string in parentheses [OK]

Common Mistakes:

• Placing pointcut expression outside quotes
• Missing parentheses after @Before
• Incorrect method signature or missing public

3. Given the following code snippet, what will be printed when service.process() is called?

@Aspect
@Component
public class LoggingAspect {
  @Before("execution(* com.example.service.Service.process(..))")
  public void beforeProcess() {
    System.out.println("Before process");
  }
}

@Service
public class Service {
  public void process() {
    System.out.println("Processing");
  }
}

medium

A. Before process\nProcessing

B. Processing\nBefore process

C. Before process

D. Processing

Solution

1. Step 1: Understand @Before advice execution timing

   @Before advice runs before the matched method, so "Before process" prints first.

2. Step 2: Analyze method call output

   Then the actual method prints "Processing" after the advice.

3. Final Answer:

   Before process\nProcessing -> Option A

4. Quick Check:

   @Before prints first, then method output [OK]

Hint: @Before prints before method output [OK]

Common Mistakes:

• Assuming method prints before advice
• Thinking advice replaces method output
• Ignoring advice execution order

4. Identify the error in this @Before advice definition:

@Before("execution(* com.example..*(..))")
public void beforeMethod() {
  System.out.println("Before method");
}

medium

A. Advice method cannot have a body

B. Pointcut expression syntax is invalid

C. Method must return a value

D. Missing @Aspect annotation on the class

Solution

1. Step 1: Check class-level annotations

   For @Before advice to work, the class must be annotated with @Aspect to mark it as an aspect.

2. Step 2: Validate pointcut and method

   The pointcut expression is valid, and advice methods can have bodies and return void.

3. Final Answer:

   Missing @Aspect annotation on the class -> Option D

4. Quick Check:

   @Aspect missing = advice won't run [OK]

Hint: Always add @Aspect on the class with advice [OK]

Common Mistakes:

• Forgetting @Aspect on the aspect class
• Assuming advice methods must return values
• Misreading pointcut syntax errors

5. You want to log a message before any method in com.example.repository package is called, but only for methods starting with save. Which @Before pointcut expression correctly matches this?

hard

A. @Before("execution(* com.example.repository.save*(..))")

B. @Before("execution(* com.example.repository.*save*(..))")

C. @Before("execution(* com.example.repository..save*(..))")

D. @Before("execution(* com.example.repository.*.save*(..))")

Solution

1. Step 1: Understand pointcut syntax for package, class, and method

   To match methods starting with 'save' in any class of the com.example.repository package, use execution(* com.example.repository.*.save*(..)). However, if you want to include subpackages as well, use '..' instead of a single '*'.

2. Step 2: Analyze each option

   A matches only methods named save* in the package directly (no class wildcard), B is invalid syntax, C matches methods in any class in the package but not subpackages, D matches methods starting with save in the package and all subpackages.

3. Final Answer:

   @Before("execution(* com.example.repository..save*(..))") -> Option C

4. Quick Check:

   package..save*(..) = matches package and subpackages [OK]

Hint: Use package..save* to include subpackages and methods starting with save [OK]

Common Mistakes:

• Using incorrect wildcards or dots in method name
• Matching subpackages unintentionally
• Misplacing wildcards in pointcut expression