Scribd
Upload
11 views

CorejavaInterviewBooster15

Uploaded by

tellapuri.naresh
Copyright
© © All Rights Reserved
Available Formats
Download as TXT, PDF, TXT or read online on Scribd
11 views

CorejavaInterviewBooster15

Uploaded by

tellapuri.naresh
Copyright
© © All Rights Reserved
Available Formats
Download as TXT, PDF, TXT or read online on Scribd
You are on page 1/ 3

### **Spring AOP (Aspect-Oriented Programming)**

Spring AOP is a key module of the Spring Framework that allows developers to
implement cross-cutting concerns (like logging, security, transaction management,
etc.) separately from the main business logic. It promotes modularity by allowing
the separation of concerns.

---

### **Key Concepts in Spring AOP**

1. **Aspect**
- A modular unit of cross-cutting concern.
- Example: Logging, security, or transaction management.
- Declared using `@Aspect` annotation in Spring.

2. **Join Point**
- A specific point during the execution of a program, such as the execution of a
method or the handling of an exception.
- Spring AOP supports method execution join points.

3. **Advice**
- Action taken by an aspect at a particular join point.
- Types of Advice:
- **Before Advice**: Executes before the method.
- **After Advice**: Executes after the method.
- **After Returning Advice**: Executes after the method successfully returns.
- **After Throwing Advice**: Executes if the method throws an exception.
- **Around Advice**: Executes before and after the method.

4. **Pointcut**
- A predicate or expression that matches join points.
- Example: Match all methods in a specific package or class.

5. **Weaving**
- The process of linking aspects with other application types or objects to
create an advised object.
- Spring AOP uses **runtime weaving** (proxies).

---

### **How Spring AOP Works**


Spring AOP is implemented using proxies:
- **JDK Dynamic Proxy**: Used when the target object implements an interface.
- **CGLIB Proxy**: Used when the target object does not implement an interface.

---

### **Example of Spring AOP**

#### **1. Logging Aspect**


```java
import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.annotation.Before;
import org.springframework.stereotype.Component;

@Aspect
@Component
public class LoggingAspect {
// Pointcut: Executes for all methods in the service package
@Before("execution(* com.example.service.*.*(..))")
public void logBeforeMethod() {
System.out.println("Logging before method execution...");
}
}
```

#### **2. Main Application**


```java
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;

@SpringBootApplication
public class AopExampleApplication {
public static void main(String[] args) {
SpringApplication.run(AopExampleApplication.class, args);
}
}
```

#### **3. Service Class**


```java
import org.springframework.stereotype.Service;

@Service
public class MyService {
public void performTask() {
System.out.println("Executing task...");
}
}
```

#### **Output:**
```
Logging before method execution...
Executing task...
```

---

### **Types of Advice with Example**

#### **Around Advice**


```java
@Around("execution(* com.example.service.*.*(..))")
public Object aroundAdvice(ProceedingJoinPoint joinPoint) throws Throwable {
System.out.println("Before method execution");
Object result = joinPoint.proceed(); // Proceed with the method
System.out.println("After method execution");
return result;
}
```

#### **After Returning Advice**


```java
@AfterReturning(pointcut = "execution(* com.example.service.*.*(..))", returning =
"result")
public void afterReturningAdvice(Object result) {
System.out.println("Method returned: " + result);
}
```

---

### **Advantages of Spring AOP**


1. **Separation of Concerns**: Business logic and cross-cutting concerns are
decoupled.
2. **Code Reusability**: Common logic can be reused across multiple modules.
3. **Improved Maintainability**: Changes in cross-cutting concerns are easier to
manage.

---

### **Spring AOP vs AspectJ**


| Feature | Spring AOP | AspectJ |
|--------------------|--------------------------|----------------------------|
| **Weaving** | Runtime (Proxies) | Compile-time, load-time, runtime |
| **Performance** | Slightly slower | Faster due to compile-time weaving
|
| **Usage** | Simpler, Spring-specific| Comprehensive, standalone |

---

### **Interview Questions on Spring AOP**


1. What is AOP, and how is it implemented in Spring?
2. What is the difference between Aspect, Advice, and Pointcut?
3. How does Spring AOP use proxies to achieve cross-cutting?
4. What is the difference between Spring AOP and AspectJ?
5. Explain the purpose of `@Around`, `@Before`, and `@AfterReturning` annotations.
6. What are some common use cases of AOP in a Spring application?
==================================

You might also like