@Before advice in Spring Boot - Deep Dive

Overview - @Before advice

What is it?

@Before advice is a way in Spring Boot to run some code right before a specific method runs. It is part of Aspect-Oriented Programming (AOP), which helps separate extra tasks like logging or security from the main code. Using @Before advice, you can add behavior that happens before methods without changing those methods directly. This keeps your code cleaner and easier to manage.

Why it matters

Without @Before advice, you would have to add the same code inside many methods, making your program messy and hard to update. @Before advice solves this by letting you write that code once and apply it everywhere needed automatically. This saves time, reduces mistakes, and makes your app easier to maintain and extend.

Where it fits

Before learning @Before advice, you should understand basic Spring Boot, Java methods, and the idea of separating concerns in programming. After mastering @Before advice, you can explore other types of advice like @After and @Around, and learn how to build complex cross-cutting features using Spring AOP.

Mental Model

Core Idea

@Before advice runs extra code automatically right before certain methods to add behavior without changing those methods.

Think of it like...

Imagine you have a security guard who checks everyone before they enter a building. The guard doesn’t change what people do inside but makes sure certain rules are followed first. @Before advice is like that guard, running checks or actions before the main work starts.

┌───────────────┐
│ @Before Advice│
│ (runs first)  │
└──────┬────────┘
       │
       ▼
┌───────────────┐
│ Target Method │
└───────────────┘

Build-Up - 7 Steps

1

Foundation

Understanding Aspect-Oriented Programming

Concept: Learn what AOP is and why it helps separate extra tasks from main code.

Aspect-Oriented Programming (AOP) is a way to add extra behavior to your program without changing the main code. For example, logging or security checks can be added separately and applied automatically to many methods. This keeps your code clean and focused on its main job.

Result

You understand that AOP helps keep code organized by separating concerns.

Understanding AOP is key because @Before advice is one of its tools to add behavior before methods run.

2

Foundation

Basics of Spring AOP and Advice Types

Concept: Learn what advice means in Spring AOP and the different types available.

In Spring AOP, advice is code that runs at certain points in your program, like before or after a method runs. The main types are @Before (runs before), @After (runs after), and @Around (runs before and after). Each type helps add behavior at different times.

Result

You know that @Before advice runs code before methods and is one of several advice types.

Knowing advice types helps you choose when to run extra code in your app.

3

Intermediate

Writing a Simple @Before Advice Method

🤔Before reading on: Do you think @Before advice can access method parameters? Commit to your answer.

Concept: Learn how to write a method with @Before advice and how to specify which methods it applies to.

To create @Before advice, write a method in a class annotated with @Aspect. Use @Before with a pointcut expression to say which methods to run before. For example: @Aspect public class LoggingAspect { @Before("execution(* com.example.service.*.*(..))") public void logBefore() { System.out.println("Method is about to run"); } } This runs logBefore before any method in com.example.service package.

Result

Your advice method runs automatically before targeted methods, printing the message.

Understanding pointcut expressions lets you control exactly where @Before advice applies.

4

Intermediate

Using JoinPoint to Access Method Details

🤔Before reading on: Can @Before advice know the name of the method it runs before? Commit to yes or no.

Concept: Learn how to get information about the method being called inside @Before advice using JoinPoint.

You can add a JoinPoint parameter to your @Before method to get details like method name and arguments: @Before("execution(* com.example.service.*.*(..))") public void logBefore(JoinPoint joinPoint) { System.out.println("Before method: " + joinPoint.getSignature().getName()); } This prints the exact method name before it runs.

Result

Advice can dynamically know which method is running and act accordingly.

Using JoinPoint makes advice smarter and more flexible by accessing runtime info.

5

Intermediate

Combining Pointcuts for Precise Targeting

🤔Before reading on: Do you think you can combine multiple method patterns in one @Before advice? Commit to yes or no.

Concept: Learn how to combine pointcut expressions to target methods more precisely.

You can combine pointcuts using && (and), || (or), and ! (not). For example: @Before("execution(* com.example.service.*.*(..)) && !execution(* com.example.service.ExcludeService.*(..))") public void logBefore() { System.out.println("Before selected methods"); } This runs before all service methods except those in ExcludeService.

Result

Advice runs only on exactly the methods you want, avoiding unwanted cases.

Mastering pointcut logic prevents bugs and keeps advice focused.

6

Advanced

Performance Impact and Best Practices

🤔Before reading on: Does adding many @Before advices always slow down your app significantly? Commit to yes or no.

Concept: Understand how @Before advice affects app performance and how to write efficient advice.

Each @Before advice adds a small overhead before method calls. If you add many or complex advice, it can slow down your app. Best practice is to keep advice simple and limit pointcuts to only necessary methods. Also, avoid heavy computations inside advice.

Result

Your app stays fast and responsive even with advice applied.

Knowing performance impact helps you balance functionality and speed in real apps.

7

Expert

Limitations and Proxy-Based Mechanism Surprises

🤔Before reading on: Do you think @Before advice runs on private methods inside the same class? Commit to yes or no.

Concept: Learn about Spring AOP’s proxy-based mechanism and its limitations on which methods advice can intercept.

Spring AOP uses proxies to add advice, which means only public methods called from outside the class are intercepted. Private, final, or internal method calls inside the same class are NOT advised. This can surprise developers expecting advice on all methods. To advise internal calls, you need AspectJ weaving or other tools.

Result

You avoid confusion about why some methods don’t trigger advice.

Understanding proxy limitations prevents debugging headaches and guides correct tool choice.

Under the Hood

@Before advice in Spring Boot works by creating a proxy object that wraps the original object. When you call a method on the proxy, it first runs the @Before advice code, then calls the actual method. This proxy intercepts calls only on public methods accessed from outside the object. The advice method is triggered by matching the pointcut expression to the method signature.

Why designed this way?

Spring AOP uses proxies because they are simple to implement and integrate with Spring’s dependency injection. This design avoids modifying original classes or bytecode at runtime, making it safer and easier to use. Alternatives like full bytecode weaving exist but are more complex and require extra setup.

┌───────────────┐       calls       ┌───────────────┐
│ Client Code   │ ───────────────▶ │ Proxy Object  │
└───────────────┘                  └──────┬────────┘
                                           │
                                           ▼
                                ┌────────────────────┐
                                │ @Before Advice Runs │
                                └─────────┬──────────┘
                                          │
                                          ▼
                                ┌────────────────────┐
                                │ Original Method Run │
                                └────────────────────┘

Myth Busters - 4 Common Misconceptions

Quick: Does @Before advice run on private methods inside the same class? Commit to yes or no.

Common Belief: People often think @Before advice runs on all methods, including private ones inside the same class.

Reality: @Before advice only runs on public methods called from outside the class because Spring AOP uses proxies.

Why it matters: Expecting advice on private methods leads to bugs and confusion when advice does not trigger.

Quick: Can @Before advice modify the return value of a method? Commit to yes or no.

Common Belief: Some believe @Before advice can change what a method returns.

Reality: @Before advice runs before the method and cannot change the return value; for that, @Around advice is needed.

Why it matters: Misusing @Before advice for return modification causes design errors and unexpected behavior.

Quick: Does adding many @Before advices always cause big performance problems? Commit to yes or no.

Common Belief: Many think that any use of @Before advice will drastically slow down the app.

Reality: While advice adds some overhead, well-written advice with limited scope has minimal impact.

Why it matters: Avoiding advice due to fear of performance loss can lead to duplicated code and harder maintenance.

Quick: Is @Before advice the only way to add behavior before methods in Spring? Commit to yes or no.

Common Belief: People often think @Before advice is the only option for pre-method behavior.

Reality: Spring also supports @Around advice which can run code before and after methods, offering more control.

Why it matters: Knowing alternatives helps choose the right tool for the task and avoid overcomplicated code.

Expert Zone

1

Pointcut expressions can be combined with annotations to target methods with specific metadata, enabling very fine-grained advice application.

2

Spring AOP proxies are by default JDK dynamic proxies if interfaces exist, otherwise CGLIB proxies; this affects how advice is applied and can cause subtle bugs.

3

Using @Before advice for security checks is common, but it should be combined with proper exception handling to avoid silent failures.

When NOT to use

Do not use @Before advice when you need to modify method results or control method execution flow; use @Around advice instead. Also, avoid @Before advice for private or internal method calls within the same class, as it won’t work due to proxy limitations. For full bytecode weaving and advising all methods, consider AspectJ instead of Spring AOP proxies.

Production Patterns

In real-world Spring Boot apps, @Before advice is often used for logging method entry, checking user permissions before service calls, or validating input parameters. It is combined with custom annotations to mark methods needing advice. Teams also use centralized aspects for consistent behavior across many classes, improving maintainability.

Connections

Middleware in Web Servers

Both add behavior before main processing steps in a chain.

Understanding @Before advice helps grasp how middleware intercepts requests before reaching the main handler, showing a shared pattern of pre-processing.

Event Listeners in GUI Programming

Both respond to events or actions before or during main processing.

Knowing how @Before advice triggers before methods clarifies how event listeners can intercept user actions to add behavior.

Pre-flight Checks in Aviation

Both perform necessary checks before the main operation starts.

Seeing @Before advice as a pre-flight checklist highlights the importance of running safety or setup code before critical actions.

Common Pitfalls

#1 Expecting @Before advice to run on private methods inside the same class.

Wrong approach:

@Before("execution(private * com.example.MyClass.*(..))")
public void advice() {
System.out.println("Runs before private methods");
}

Correct approach:

@Before("execution(public * com.example.MyClass.*(..))")
public void advice() {
System.out.println("Runs before public methods");
}

Root cause:

Misunderstanding that Spring AOP proxies only intercept public method calls from outside the class.

#2 Trying to change method return values using @Before advice.

Wrong approach:

@Before("execution(* com.example.*.*(..))")
public Object changeReturn() {
return "Changed!";
}

Correct approach:

@Around("execution(* com.example.*.*(..))")
public Object changeReturn(ProceedingJoinPoint pjp) throws Throwable {
Object result = pjp.proceed();
return "Changed!";
}

Root cause:

Confusing @Before advice with @Around advice capabilities.

#3 Writing heavy logic inside @Before advice causing slow app response.

Wrong approach:

@Before("execution(* com.example.*.*(..))")
public void heavyTask() {
// complex database queries or long loops
}

Correct approach:

@Before("execution(* com.example.*.*(..))")
public void lightweightTask() {
System.out.println("Quick log");
}

Root cause:

Not realizing advice runs on every matched method call, so heavy tasks multiply overhead.

Key Takeaways

@Before advice lets you run code automatically before specific methods without changing those methods.

It works by creating proxy objects that intercept method calls and run advice first, but only on public methods called from outside.

Pointcut expressions control exactly which methods get advice, making it flexible and powerful.

@Before advice cannot change method results or run on private/internal calls; for that, other advice types or tools are needed.

Using @Before advice wisely keeps your code clean, reusable, and easier to maintain, but be mindful of performance and proxy limitations.