Scribd
Upload
11 views

CorejavaInterviewBooster15

Uploaded by

tellapuri.naresh
Copyright
© © All Rights Reserved
We take content rights seriously. If you suspect this is your content, claim it here.
Available Formats
Download as TXT, PDF, TXT or read online on Scribd
11 views

CorejavaInterviewBooster15

Uploaded by

tellapuri.naresh
Copyright
© © All Rights Reserved
We take content rights seriously. If you suspect this is your content, claim it here.
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