Aspect-Oriented Programming (AOP) is a programming paradigm that aims to increase modularity by allowing the separation of cross-cutting concerns. It does this by adding additional behavior to existing code (known as advice) without modifying the code itself, instead specifying externally which code is affected via a "pointcut" specification[6].
In traditional Object-Oriented Programming (OOP), modularity is achieved through classes. However, some concerns such as logging, security, or transaction management often span multiple classes and methods, affecting various parts of an application. These are known as cross-cutting concerns because they cut across multiple points of an application[6][7].
AOP addresses these concerns by allowing them to be specified separately from the classes they affect. This separation is achieved through several key AOP concepts:
Aspect: This is the module or class in AOP that encapsulates the cross-cutting concern. An aspect can contain several kinds of advice and may be applied at various join points within the application[6][7].
Join Point: A point in the control flow of a program where an aspect can be applied. This could be a method call, method execution, or even exception handling[6].
Advice: This defines the action to be taken at a specified join point. Advice types include "before", "after", and "around", indicating when the code should be executed in relation to the join point[6].
Pointcut: A predicate that matches join points. Pointcuts help specify where advice should be applied, thus determining the exact points in the application where the aspect's code should be executed[6].
Weaving: The process of linking aspects with other application types or objects to create an advised object. This can happen at compile time, load time, or runtime[6].
