Spring AOP – Advice

In this article, you will see how to use intercept methods with Spring AOP framework.

Following advices are supported by Spring AOP :

  • Before : Before advice runs before the advised method is executed.
  • After-returning : After returning advice runs when a matched method execution returns normally.
  • After-throwing : After throwing advice runs when a matched method execution exits by throwing an exception.
  • Around : The final kind of advice is around advice. Around advice runs “around” a matched method execution.

First create a new Java Project and configure it as Maven Project. For Reference, Click Here

Add the following dependencies in pom.xml

    <!-- Proxy class need this library -->

1. Business Logic and Implementation

We will first write our business logic and then we will add Spring AOP to profile our business methods.

Create an interface BusinessService and write a following method. We will intercept this via Advice


package com.kruders.spring.aop;
public interface BusinessService {
    void doSomeThing();

Now create a class BusinessImpl.java that implements the above interface.


package com.kruders.spring.aop;
import org.springframework.stereotype.Service;
public class BusinessImpl implements BusinessService {
    public void doSomeThing() {
        System.out.println("Do Something Here");
        int x = 5/0;

2. Configure Spring AOP

Create Spring-Business.xml and write the following code


<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
    xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd">
    <bean id="businessService" class="com.kruders.spring.aop.BusinessImpl" />
    <!-- Advice -->
    <bean id="businessAdvice" class="com.kruders.spring.advice.BusinessAdvice" />
    <bean id="businessServiceProxy"
        <property name="target" ref="businessService" />
        <property name="interceptorNames">

We defined two normal Spring beans – one for our Business class and the other for Business Profiler (i.e. our advice).

We also create a new proxy object named ‘businessServiceProxy‘.

target‘ – Define which bean you want to intercept. ‘interceptorNames‘ – Define which class (advice) you want to apply on this proxy /target object.

3. Advice Class

Now write a Advice which will profile our business method.


package com.kruders.spring.advice;
import java.lang.reflect.Method;
import org.aopalliance.intercept.MethodInterceptor;
import org.aopalliance.intercept.MethodInvocation;
import org.springframework.aop.AfterReturningAdvice;
import org.springframework.aop.MethodBeforeAdvice;
import org.springframework.aop.ThrowsAdvice;
public class BusinessAdvice implements MethodBeforeAdvice, AfterReturningAdvice, ThrowsAdvice, MethodInterceptor {
    public void before(Method method, Object[] args, Object target)
            throws Throwable {
        System.out.println("Before method is called (by " + this.getClass().getName() + ")");
    public void afterReturning(Object returnValue, Method method,
            Object[] args, Object target) {
        System.out.println("After method is called (by " + this.getClass().getName() + ")");
    public void afterThrowing(ArithmeticException e) throws Throwable {
        System.out.println("After throwing method is called");
    public Object invoke(MethodInvocation method) throws Throwable {
        System.out.println("Around method is called");
        System.out.println("Around before is running");
        System.out.println("Around after is running");
        return null;

4. Helper Class

Create Main.java class that loads our Business bean from Spring Context and then calling our business method.


package com.kruders.spring.core;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
import com.kruders.spring.aop.BusinessService;
public class Main {
    public static void main(String args[]) {
        ApplicationContext appContext = new ClassPathXmlApplicationContext("Spring-Business.xml");
        BusinessService businessService = (BusinessService)appContext.getBean("businessServiceProxy");
        try {
        } catch(ArithmeticException ae) {

The folder structure of the example is shown below in Figure 14.1

Figure 14.1 Figure 14.1

You can download the source code of this example here.

No comments yet.

Leave a Reply