Backend interview prep

Start

Spring AOP Interview Questions and Answers

Master Spring AOP with interview questions covering Aspect-Oriented Programming, Aspects, Advice, Join Points, Pointcuts, Proxies, Weaving, @Aspect, @Around, @Before, @After, and production best practices.

Introduction

Enterprise applications contain business logic along with cross-cutting concerns like:

  • Logging
  • Security
  • Transactions
  • Auditing
  • Exception Handling
  • Performance Monitoring
  • Caching

If every service implements these concerns manually, the code becomes repetitive and difficult to maintain.

Aspect-Oriented Programming (AOP) solves this problem by separating cross-cutting concerns from business logic.

Spring AOP is built on proxy-based runtime weaving and is widely used throughout the Spring ecosystem.

Examples

  • @Transactional
  • Spring Security
  • Logging
  • Method execution monitoring

Spring AOP Architecture

flowchart LR

Client --> Proxy

Proxy --> Aspect

Aspect --> TargetService

Q1. What is Spring AOP?

Answer

Spring AOP (Aspect-Oriented Programming) is a programming paradigm that separates cross-cutting concerns from business logic.

Instead of duplicating common functionality,

AOP executes reusable logic before, after, or around method execution.

Benefits

  • Cleaner code
  • Better modularity
  • Code reuse
  • Easier maintenance
  • Centralized cross-cutting concerns

Q2. What are Cross-Cutting Concerns?

Cross-cutting concerns affect multiple modules.

Examples

  • Logging
  • Authentication
  • Authorization
  • Transactions
  • Performance Monitoring
  • Auditing
  • Exception Handling

Without AOP

flowchart LR

CustomerService --> Logging

PaymentService --> Logging

LoanService --> Logging

With AOP

flowchart LR

Aspect --> Logging

Logging --> CustomerService

Logging --> PaymentService

Logging --> LoanService

Q3. What is an Aspect?

An Aspect is a class containing cross-cutting logic.

Example

@Aspect

@Component

public class LoggingAspect {

}

An aspect groups related advice into a reusable module.

Q4. What is Advice?

Advice defines when an aspect should execute.

Types

Advice Executes
@Before Before method execution
@After After method execution
@AfterReturning After successful completion
@AfterThrowing After exception
@Around Before and after method execution

Example

@Before(

"execution(* com.bank.service.*.*(..))")

public void log(){

}

Q5. What is a Join Point?

A Join Point is a point during program execution where an aspect can be applied.

Examples

  • Method execution
  • Exception handling
  • Constructor execution (AspectJ)

In Spring AOP, method execution is the primary supported join point.

Q6. What is a Pointcut?

A Pointcut specifies which Join Points should execute an Advice.

Example

@Pointcut(

"execution(* com.bank.service.*.*(..))")

public void serviceLayer(){

}

Pointcut Flow

flowchart LR

Pointcut --> CustomerService

Pointcut --> PaymentService

Pointcut --> LoanService

Only matching methods trigger the advice.

Q7. What is a Proxy?

Spring AOP works by creating a proxy object.

Client requests are intercepted by the proxy.

The proxy executes aspects before invoking the target method.

Proxy Architecture

flowchart LR

Client --> Proxy

Proxy --> LoggingAspect

Proxy --> SecurityAspect

Proxy --> TargetService

Spring uses

  • JDK Dynamic Proxy (interface-based)
  • CGLIB Proxy (class-based)

Q8. What is Weaving?

Weaving is the process of applying aspects to target objects.

Types

  • Compile-time Weaving
  • Load-time Weaving
  • Runtime Weaving (Spring AOP)

Spring performs weaving dynamically using proxies.

Q9. What is @Around Advice?

@Around is the most powerful advice.

It executes

  • Before the method
  • After the method
  • On exception
  • Can modify the result
  • Can prevent execution

Example

@Around(

"serviceLayer()")

public Object log(

ProceedingJoinPoint pjp)

throws Throwable{

    return pjp.proceed();

}

Typical use cases

  • Performance monitoring
  • Caching
  • Security
  • Retry logic

Q10. Spring AOP Best Practices

Keep Aspects Focused

One responsibility per aspect.

Use @Around Carefully

Only when full method control is needed.

Avoid Business Logic in Aspects

Keep aspects dedicated to cross-cutting concerns.

Apply Pointcuts Precisely

Avoid broad expressions.

Monitor Performance

Excessive proxying may introduce unnecessary overhead.

Banking Example

flowchart TD

CustomerController --> PaymentServiceProxy

PaymentServiceProxy --> LoggingAspect

PaymentServiceProxy --> SecurityAspect

PaymentServiceProxy --> TransactionAspect

PaymentServiceProxy --> PaymentService

PaymentService --> PostgreSQL

Every payment request is automatically logged, secured, and executed within a transaction.

Common Interview Questions

  • What is Spring AOP?
  • What are Cross-Cutting Concerns?
  • What is an Aspect?
  • What is Advice?
  • Types of Advice?
  • What is a Join Point?
  • What is a Pointcut?
  • What is a Proxy?
  • JDK Proxy vs CGLIB?
  • Spring AOP best practices?

Quick Revision

Topic Summary
AOP Separate cross-cutting concerns
Aspect Cross-cutting module
Advice Action executed by aspect
Join Point Method execution point
Pointcut Select matching join points
Proxy Intercepts method calls
Weaving Apply aspects to target
@Before Execute before method
@Around Full method interception
Spring AOP Runtime proxy-based AOP

Spring AOP Execution Flow

sequenceDiagram
Client->>Proxy: Call Service
Proxy->>Before Advice: Execute
Before Advice-->>Proxy: Continue
Proxy->>Around Advice: Before
Around Advice->>Target Service: Execute Method
Target Service-->>Around Advice: Return Result
Around Advice->>AfterReturning Advice: Execute
AfterReturning Advice-->>Proxy: Complete
Proxy-->>Client: Response

Production Example – Banking Fund Transfer

A banking application exposes a Fund Transfer Service.

Business Requirements

  • Log every transfer request.
  • Authenticate the customer.
  • Execute the transfer within a database transaction.
  • Measure execution time.
  • Record audit information after successful completion.
  • Capture failures for monitoring.

Implementation

  • LoggingAspect uses @Before to log incoming requests.
  • SecurityAspect validates user permissions.
  • TransactionAspect manages transactions using @Around.
  • PerformanceAspect measures execution time.
  • AuditAspect uses @AfterReturning to record successful transfers.
  • ExceptionAspect uses @AfterThrowing to log failures.
flowchart LR

Client --> PaymentServiceProxy

PaymentServiceProxy --> LoggingAspect

PaymentServiceProxy --> SecurityAspect

PaymentServiceProxy --> PerformanceAspect

PaymentServiceProxy --> TransactionAspect

PaymentServiceProxy --> PaymentService

PaymentService --> PostgreSQL

PaymentServiceProxy --> AuditAspect

PaymentServiceProxy --> ExceptionAspect

The business service remains focused only on payment processing while AOP transparently manages logging, security, auditing, transactions, and monitoring.

Key Takeaways

  • Spring AOP separates cross-cutting concerns from business logic, resulting in cleaner and more maintainable applications.
  • Aspects encapsulate reusable functionality such as logging, security, transactions, and auditing.
  • Advice defines when an aspect executes, with @Around providing the greatest flexibility.
  • Pointcuts determine which methods should be intercepted.
  • Spring AOP uses runtime proxy-based weaving through JDK Dynamic Proxies or CGLIB proxies.
  • Features such as @Transactional, Spring Security, and performance monitoring are built on AOP concepts.
  • Keep aspects focused, avoid embedding business logic inside aspects, and write precise pointcut expressions.
  • Mastering Spring AOP is essential for understanding many advanced Spring Framework features and enterprise application architecture.