?? Day 11: My Spring Boot Learning Journey ??

Today, I delved into Spring Boot AOP (Aspect-Oriented Programming) and gained insights into how it helps in modularizing cross-cutting concerns in an application.

Here’s what I learned:

1?? What is AOP?

• Spring Boot AOP is an application development tool that uses Aspect-Oriented Programming (AOP) to break code into modules and implement cross-cutting concerns.?
• AOP is a programming technique that separates code into modules, or aspects, to implement cross-cutting concerns. Cross-cutting concerns are functions that affect the entire application but are separate from the business logic. AOP adds extra behavior to existing code without modifying it.?
• Spring Boot AOP is implemented in Java and can be used in servlet containers or application servers. It enables the implementation of cross-cutting concerns like logging, auditing, and security without cluttering the code.?
• Spring Boot is a tool that helps developers create standalone, production-grade Spring applications. Spring Boot applications can run locally without an internet connection or other services.?

2?? Core Concepts of AOP

Key Concepts of AOP

1. Aspect

• An aspect is a module that encapsulates a concern that cuts across multiple classes. In Spring, aspects are implemented using regular classes annotated with @Aspect.

2. Join Point

• A join point is a point during the execution of a program, such as the execution of a method or handling an exception. In Spring AOP, a join point always represents a method execution.

3. Advice

• Advice is the action taken by an aspect at a particular join point. Spring AOP supports

4. Pointcut

• A pointcut is an expression that matches join points. It defines where an advice should be applied.

5. Weaving

• Weaving is the process of linking aspects with other application types or objects to create an advised object. Weaving can be done at compile-time, load-time, or at runtime. Spring AOP performs weaving at runtime.

AOP vs. OOP

The differences between AOP and OOP are as follows:

Types of AOP Advices

There are five types of AOP advices are as follows:

• Before Advice
• After Advice
• Around Advice
• After Throwing
• After Returning

1. Before Advice: An advice that executes before a join point, is called before advice. We use @Before annotation to mark an advice as Before advice.
2. After Advice: An advice that executes after a join point, is called after advice. We use @After annotation to mark an advice as After advice.
3. Around Advice: An advice that executes before and after of a join point, is called around advice.
4. After Throwing Advice: An advice that executes when a join point throws an exception.
5. After Returning Advice: An advice that executes when a method executes successfully.

Before implementing the AOP in an application, we are required to add Spring AOP dependency in the pom.xml file.

Spring Boot Starter AOP

• Spring Boot Starter AOP is a dependency that provides Spring AOP and AspectJ. Where AOP provides basic AOP capabilities while the AspectJ provides a complete AOP framework.

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

3?? Spring Boot AOP Annotations

• Spring Boot AOP annotations are markers that instruct the Spring framework on how to process components, classes, or methods using Aspect-Oriented Programming (AOP):?

1. @Before: Marks an advice that executes before a join point?
2. @After: Marks an advice that executes after a join point?
3. @Around: Marks an advice that executes before and after a join point?
4. @AfterThrowing: Marks an advice that executes when a join point throws an exception?
5. @AfterReturning: Marks an advice that executes when a method executes successfully?

AOP is a programming paradigm that addresses concerns that cut across multiple classes in application development, such as: logging, security, and transaction management.?

AOP allows developers to:?

• Modularize cross-cutting concerns into separate units called aspects
• Write the same logic once in an aspect and apply it to multiple join points
• Enhance code readability and maintainability

To implement AOP in an application, you can:?

1. Add the Spring AOP dependency in the pom.xml file
2. Use the Spring Boot Starter AOP dependency, which provides Spring AOP and AspectJ

4?? Advantages of AOP

Aspect-Oriented Programming (AOP) has several advantages, including:

Code readability

• AOP separates cross-cutting concerns like security and logging from the main code, making it easier to understand and change.?

Reduced repetition

• AOP encourages writing code once and using it many times, reducing redundancy and making code more efficient.

Improved maintainability

• AOP makes it easier to maintain code by keeping the core code clean and focused.?

Better scalability

• AOP supports a cleaner, more organized code structure, which helps with scalability as the codebase grows.

Improved testing

• Separating concerns makes it easier to conduct independent testing, which can promote better software quality.?

Increased modularity

• AOP promotes modularity by ensuring that each part of the application focuses on a distinct concern.

Greater flexibility

• AOP makes it easier to adapt applications to changing requirements by decoupling aspects from the main logic.?

Better management of cross-cutting concerns

• AOP makes it easier to implement changes uniformly across the entire application.?