Aspect Oriented Programming - AOP

Aspect-Oriented Programming (AOP) is a programming paradigm focused on modularizing cross-cutting concerns—aspects of a program that affect multiple parts of the codebase and don't fit neatly into object-oriented or functional structures.

💡 Goal:

Typical cross-cutting concerns include logging, security checks, error handling, transaction management, or performance monitoring. These concerns often appear in many classes and methods. AOP allows you to write such logic once and have it automatically applied where needed.

🔧 Key Concepts:

Aspect: A module that encapsulates a cross-cutting concern.
Advice: The actual code to be executed (e.g., before, after, or around a method call).
Join Point: A point in the program flow where an aspect can be applied (e.g., method execution).
Pointcut: A rule that defines which join points are affected (e.g., "all methods in class X").
Weaving: The process of combining aspects with the main program code—at compile-time, load-time, or runtime.

🛠 Example (Java with Spring AOP):

@Aspect
public class LoggingAspect {
    @Before("execution(* com.example.service.*.*(..))")
    public void logBeforeMethod(JoinPoint joinPoint) {
        System.out.println("Calling method: " + joinPoint.getSignature().getName());
    }
}

This code automatically logs a message before any method in the com.example.service package is executed.