Gabriel Márquez

Field note / Aspect-Oriented Programming

Demystifying Aspect-Oriented Programming (AOP) in Java: A Practical Introduction

An introduction to AOP in Java with a practical example of automatic cache invalidation.

2 min read

  • Aspect-Oriented Programming
  • Spring AOP
  • Java Annotations
  • Caching

If you’ve been coding in Java for a while, you’ve likely faced a situation where you needed to perform cross-cutting tasks—like logging, caching, or security checks—across multiple parts of your application. Wouldn’t it be nice to handle these tasks elegantly, without cluttering your core business logic? Enter Aspect-Oriented Programming (AOP).

In this post, we’ll dive into the basics of AOP in Java and show you how to use it with a practical example: automatically invalidating a cache after saving a user. Let’s go!

What Is Aspect-Oriented Programming?

AOP is a programming paradigm that helps you separate cross-cutting concerns (tasks that affect multiple modules, like logging or caching) from your business logic. Instead of sprinkling these tasks throughout your codebase, you can define them in one place and “weave” them into the parts of your application where they’re needed.

Think of it like adding a spell to your application: “Whenever a method matching this pattern is called, apply this magical behavior.”

Key AOP Terminology

  • Aspect: A module that encapsulates a cross-cutting concern (e.g., caching or logging).
  • Advice: The action to perform. Types include:
    • @Before: Runs before a method execution.
    • @After: Runs after a method execution.
    • @Around: Wraps a method, running custom logic before and after.
  • Join Point: A specific point in your application, like a method call.
  • Pointcut: An expression that matches join points.

A Practical Example: Caching with AOP

Let’s say you’re building a user management system with a UserRepository and a cache (fullUserCache). When a user is saved, you need to invalidate their cache entry—without modifying the repository code.

Step 1: Add Dependencies

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

Step 2: Write the Aspect

import org.aspectj.lang.annotation.After;
import org.aspectj.lang.annotation.Aspect;
import org.springframework.stereotype.Component;

@Aspect
@Component
public class UserCacheAspect {

    private final FullUserCache fullUserCache;

    public UserCacheAspect(FullUserCache fullUserCache) {
        this.fullUserCache = fullUserCache;
    }

    @After("execution(* com.test.repository.UserRepository.save(..)) && args(user)")
    public void onSaveUserRemove(User user) {
        fullUserCache.invalidate(user.getId());
        System.out.println("Cache invalidated for user ID: " + user.getId());
    }
}

Step 3: Break Down the Code

  • @Aspect: Marks this class as an aspect.
  • Pointcut Expression: execution(* com.test.repository.UserRepository.save(..)) && args(user) targets the save method and captures the User argument.
  • @After: Ensures the advice runs after save finishes.

Step 4: Test the Magic

User user = new User(1, "Alice");
userRepository.save(user);
// Output: Cache invalidated for user ID: 1

Why Use AOP?

  1. Cleaner Code: Keep your business logic focused on its core responsibility.
  2. Reusability: Write cross-cutting logic once, apply it everywhere.
  3. Maintainability: Centralize logic for easier updates.

When Not to Use AOP

  • It can make your application harder to debug (hidden logic).
  • Complex pointcut expressions might confuse future developers.
  • You lose explicitness; not everyone likes “magic.”

Conclusion

Aspect-Oriented Programming in Java, especially with Spring AOP, is a powerful tool for managing cross-cutting concerns like caching, logging, and security. In this post, we saw how to use an aspect to invalidate a cache after a method is called, leaving your repository logic clean and focused.

← All writing