Intro To Spring's Aspects

What Is A Spring Aspect? 😲

Simply put, it's a reusable part of code (Advice) that is injected into a certain part (joinPoint) of the application (defined by Pointcuts) at runtime.

Why Use it? 🤨

Address common concerns across our application.

Like what?

• Logging 📝

• Transaction management 🗄

• Caching 🔗

• Security 🔐

It's used all over the place in Spring framework

• Aspect Oriented Programming (AOP) is one of the two core concepts that the Spring framework is built on, the second one being Dependency Injection.

---

Let's Get To Know the agents behind Spring Aspects 🥷🏽

Join point 🔧

• A joinpoint is a candidate point in the Program Execution of the application where an aspect can be plugged in.

• This point could be a method being called, an exception being thrown, or even a field being modified.

• These are the points where your aspect’s code can be inserted into the normal flow of your application to add new behavior.

Advice 📖

• The code that addresses system wide concerns (logging, security checks, etc...) representing the action to perform at a joinpoint specified by a pointcut.

Pointcut 📌

• A pointcut is an expression that defines at what joinpoints, the associated Advice should be applied.

Aspect 🔍

• Aspect is the class that defines the aspect’s behavior and a pointcut defining where the aspect should be executed.

---

Ready For Some Coding? 🤩

Let's write a simple use-case of logging something to the console on the call of a certain method.

We'll start by adding the maven dependency for AOP

<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-aop</artifactId>
</dependency>

Then, let's create a class and annotate it with @Aspect to mark that this class will contain Advice methods and Pointcuts.
We also need to annotate it with @Component so it becomes managed by Spring.

This class will handle the simple task of logging to the console.

@Component
@Aspect
public class LoggingAspect {
    @Pointcut("@annotation(Loggable)")
    public void logAllMethodCallsPointcut(){    
    }
    @Before("logAllMethodCallsPointcut()")
    public void logAllMethodCallsAdvice(){
        System.out.println("From Aspect");
    }
}

We need to create the loggable annotation

@Target(ElementType.METHOD)  
@Retention(RetentionPolicy.RUNTIME)  
public @interface Loggable {  
}

---

What did we just write? 👀

• @Pointcut("@annotation(Loggable)") declares the logAllMethodCallsPointcut method as a pointcut for all method annotated with Loggable.
• @Before("logAllMethodCallsPointcut()") declares logAllMethodCallsAdvice advice which will be called before any method annotated with Loggable.

Now let's create a service that will act as our join point 🧠

@Service  
public class HomeService {  
  @Loggable
  // this here is what's called a join point  
  public void homePage(){  
        System.out.println("From Service");  
    }  
}

Now when we call the homePage method, the logAllMethodCallsAdvice advice method will be called before it.

So we will see the following logs 👇

From Aspect
From Service

---

Remind Me Why Are We doing This? 😢

This example seems useless for the simple case we have, however imagine having a system with hundreds of methods that you want to log something about them.

• Would you call the same code before each and everyone? 🤔
• What happens if you want to change the implementation of the logging process?
  • You need to search for all the usages and change them 😖
• Or, you can create a service and call it from all those places, but imagine having more things other than logging.
  • You need to create and call separate service for everyone 😤

Aspects are a life saver as you can now see. 😍😍

---

Conclusion 🙌

• Aspects is one of the most important concepts of the Spring framework.
• It's quite handy and provides a mean for clean reusable code.
• It has a wide range of use-cases (We only discuss logging).

---

For more details you can check this rich resource 🤝.

Source code on GitHub 💻.