Spring AOP Example – Advice

最新推荐文章于 2025-09-06 09:33:29 发布
转载 最新推荐文章于 2025-09-06 09:33:29 发布 · 283 阅读 · 0
文章标签：

#spring #aop

本文详细介绍了Spring AOP的实现方式，包括四种类型的建议（前置、返回后、抛出异常后、环绕），并提供了简单的Spring项目示例来展示如何在实际应用中使用这些特性。通过创建自定义切面类，实现对方法执行过程的拦截和增强，展示了如何在不同的场景下灵活运用Spring AOP进行功能扩展。

Spring AOP (Aspect-oriented programming) framework is used to modularize cross-cutting concerns in aspects. Put it simple, it’s just an interceptor to intercept some processes, for example, when a method is execute, Spring AOP can hijack the executing method, and add extra functionality before or after the method execution.

In Spring AOP, 4 type of advices are supported :

  • Before advice – Run before the method execution
  • After returning advice – Run after the method returns a result
  • After throwing advice – Run after the method throws an exception
  • Around advice – Run around the method execution, combine all three advices above.
    切面有几个可以思考的问题？
    切面如何访问jointpoint方法的参数？
    可以传递参数给切面方法吗？

Following example show you how Spring AOP advice works.

Simple Spring example

Create a simple customer service class with few print methods for demonstration later.

package com.mkyong.customer.services;

public class CustomerService {
    private String name;
    private String url;

    public void setName(String name) {
        this.name = name;
    }

    public void setUrl(String url) {
        this.url = url;
    }

    public void printName() {
        System.out.println("Customer name : " + this.name);
    }

    public void printURL() {
        System.out.println("Customer website : " + this.url);
    }

    public void printThrowException() {
        throw new IllegalArgumentException();
    }

}

File : Spring-Customer.xml – A bean configuration file

<beans xmlns="http://www.springframework.org/schema/beans"
    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    xsi:schemaLocation="http://www.springframework.org/schema/beans
    http://www.springframework.org/schema/beans/spring-beans-2.5.xsd">

    <bean id="customerService" class="com.mkyong.customer.services.CustomerService">
        <property name="name" value="Yong Mook Kim" />
        <property name="url" value="http://www.mkyong.com" />
    </bean>

</beans>

Run it

package com.mkyong.common;

import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

import com.mkyong.customer.services.CustomerService;

public class App {
    public static void main(String[] args) {
        ApplicationContext appContext = new ClassPathXmlApplicationContext(
                new String[] { "Spring-Customer.xml" });

        CustomerService cust = (CustomerService) appContext.getBean("customerService");

        System.out.println("*************************");
        cust.printName();
        System.out.println("*************************");
        cust.printURL();
        System.out.println("*************************");
        try {
            cust.printThrowException();
        } catch (Exception e) {

        }

    }
}

Output

*************************
Customer name : Yong Mook Kim
*************************
Customer website : http://www.mkyong.com
*************************

A simple Spring project to DI a bean and output some Strings.

Spring AOP Advices

Now, attach Spring AOP advices to above customer service.

1. Before advice

It will execute before the method execution. Create a class which implements MethodBeforeAdvice interface.

package com.mkyong.aop;

import java.lang.reflect.Method;
import org.springframework.aop.MethodBeforeAdvice;

public class HijackBeforeMethod implements MethodBeforeAdvice
{
    @Override
    public void before(Method method, Object[] args, Object target)
        throws Throwable {
            System.out.println("HijackBeforeMethod : Before method hijacked!");
    }
}

In bean configuration file (Spring-Customer.xml), create a bean for HijackBeforeMethod class , and a new proxy object named ‘customerServiceProxy‘.

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

<beans xmlns="http://www.springframework.org/schema/beans"
    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    xsi:schemaLocation="http://www.springframework.org/schema/beans
        http://www.springframework.org/schema/beans/spring-beans-2.5.xsd">

    <bean id="customerService" class="com.mkyong.customer.services.CustomerService">
        <property name="name" value="Yong Mook Kim" />
        <property name="url" value="http://www.mkyong.com" />
    </bean>

    <bean id="hijackBeforeMethodBean" class="com.mkyong.aop.HijackBeforeMethod" />

    <bean id="customerServiceProxy" 
                 class="org.springframework.aop.framework.ProxyFactoryBean">

        <property name="target" ref="customerService" />

        <property name="interceptorNames">
            <list>
                <value>hijackBeforeMethodBean</value>
            </list>
        </property>
    </bean>
</beans>

Note
To use Spring proxy, you need to add CGLIB2 library. Add below in Maven pom.xml file.

    <dependency>
        <groupId>cglib</groupId>
        <artifactId>cglib</artifactId>
        <version>2.2.2</version>
    </dependency>

Run it again, now you get the new customerServiceProxybean instead of the original customerService bean.

package com.mkyong.common;

import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
import com.mkyong.customer.services.CustomerService;

public class App {
    public static void main(String[] args) {
        ApplicationContext appContext = new ClassPathXmlApplicationContext(
                new String[] { "Spring-Customer.xml" });

        CustomerService cust = 
                                (CustomerService) appContext.getBean("customerServiceProxy");

        System.out.println("*************************");
        cust.printName();
        System.out.println("*************************");
        cust.printURL();
        System.out.println("*************************");
        try {
            cust.printThrowException();
        } catch (Exception e) {

        }

    }
}

Output

*************************
HijackBeforeMethod : Before method hijacked!
Customer name : Yong Mook Kim
*************************
HijackBeforeMethod : Before method hijacked!
Customer website : http://www.mkyong.com
*************************
HijackBeforeMethod : Before method hijacked!

It will run the HijackBeforeMethod’s before() method, before every customerService’s methods are execute.

2. After returning advice

It will execute after the method is returned a result. Create a class which implements AfterReturningAdvice interface.

package com.mkyong.aop;

import java.lang.reflect.Method;
import org.springframework.aop.AfterReturningAdvice;

public class HijackAfterMethod implements AfterReturningAdvice
{
    @Override
    public void afterReturning(Object returnValue, Method method,
        Object[] args, Object target) throws Throwable {
            System.out.println("HijackAfterMethod : After method hijacked!");
    }
}

Bean configuration file

<beans xmlns="http://www.springframework.org/schema/beans"
    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    xsi:schemaLocation="http://www.springframework.org/schema/beans
        http://www.springframework.org/schema/beans/spring-beans-2.5.xsd">

    <bean id="customerService" class="com.mkyong.customer.services.CustomerService">
        <property name="name" value="Yong Mook Kim" />
        <property name="url" value="http://www.mkyong.com" />
    </bean>

    <bean id="hijackAfterMethodBean" class="com.mkyong.aop.HijackAfterMethod" />

    <bean id="customerServiceProxy" 
                class="org.springframework.aop.framework.ProxyFactoryBean">

        <property name="target" ref="customerService" />

        <property name="interceptorNames">
            <list>
                <value>hijackAfterMethodBean</value>
            </list>
        </property>
    </bean>
</beans>

Run it again, Output

*************************
Customer name : Yong Mook Kim
HijackAfterMethod : After method hijacked!
*************************
Customer website : http://www.mkyong.com
HijackAfterMethod : After method hijacked!
*************************

It will run the HijackAfterMethod’s afterReturning() method, after every customerService’s methods that are returned result.

3. After throwing advice

It will execute after the method throws an exception. Create a class which implements ThrowsAdvice interface, and create a afterThrowing method to hijack the IllegalArgumentException exception.

package com.mkyong.aop;

import org.springframework.aop.ThrowsAdvice;

public class HijackThrowException implements ThrowsAdvice {
    public void afterThrowing(IllegalArgumentException e) throws Throwable {
        System.out.println("HijackThrowException : Throw exception hijacked!");
    }
}

Bean configuration file

<beans xmlns="http://www.springframework.org/schema/beans"
    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    xsi:schemaLocation="http://www.springframework.org/schema/beans
        http://www.springframework.org/schema/beans/spring-beans-2.5.xsd">

    <bean id="customerService" class="com.mkyong.customer.services.CustomerService">
        <property name="name" value="Yong Mook Kim" />
        <property name="url" value="http://www.mkyong.com" />
    </bean>

    <bean id="hijackThrowExceptionBean" class="com.mkyong.aop.HijackThrowException" />

    <bean id="customerServiceProxy" 
                 class="org.springframework.aop.framework.ProxyFactoryBean">

        <property name="target" ref="customerService" />

        <property name="interceptorNames">
            <list>
                <value>hijackThrowExceptionBean</value>
            </list>
        </property>
    </bean>
</beans>

Run it again, output

*************************
Customer name : Yong Mook Kim
*************************
Customer website : http://www.mkyong.com
*************************
HijackThrowException : Throw exception hijacked!

It will run the HijackThrowException’s afterThrowing() method, if customerService’s methods throw an exception.

4. Around advice

It combines all three advices above, and execute during method execution. Create a class which implements MethodInterceptor interface. You have to call the “methodInvocation.proceed();” to proceed on the original method execution, else the original method will not execute.

package com.mkyong.aop;

import java.util.Arrays;

import org.aopalliance.intercept.MethodInterceptor;
import org.aopalliance.intercept.MethodInvocation;

public class HijackAroundMethod implements MethodInterceptor {
    @Override
    public Object invoke(MethodInvocation methodInvocation) throws Throwable {

        System.out.println("Method name : "
                + methodInvocation.getMethod().getName());
        System.out.println("Method arguments : "
                + Arrays.toString(methodInvocation.getArguments()));

        // same with MethodBeforeAdvice
        System.out.println("HijackAroundMethod : Before method hijacked!");

        try {
            // proceed to original method call
            Object result = methodInvocation.proceed();

            // same with AfterReturningAdvice
            System.out.println("HijackAroundMethod : Before after hijacked!");

            return result;

        } catch (IllegalArgumentException e) {
            // same with ThrowsAdvice
            System.out.println("HijackAroundMethod : Throw exception hijacked!");
            throw e;
        }
    }
}

Bean configuration file

<beans xmlns="http://www.springframework.org/schema/beans"
    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    xsi:schemaLocation="http://www.springframework.org/schema/beans
        http://www.springframework.org/schema/beans/spring-beans-2.5.xsd">

    <bean id="customerService" class="com.mkyong.customer.services.CustomerService">
        <property name="name" value="Yong Mook Kim" />
        <property name="url" value="http://www.mkyong.com" />
    </bean>

    <bean id="hijackAroundMethodBean" class="com.mkyong.aop.HijackAroundMethod" />

    <bean id="customerServiceProxy" 
                class="org.springframework.aop.framework.ProxyFactoryBean">

        <property name="target" ref="customerService" />

        <property name="interceptorNames">
            <list>
                <value>hijackAroundMethodBean</value>
            </list>
        </property>
    </bean>
</beans>

Run it again, output

*************************
Method name : printName
Method arguments : []
HijackAroundMethod : Before method hijacked!
Customer name : Yong Mook Kim
HijackAroundMethod : Before after hijacked!
*************************
Method name : printURL
Method arguments : []
HijackAroundMethod : Before method hijacked!
Customer website : http://www.mkyong.com
HijackAroundMethod : Before after hijacked!
*************************
Method name : printThrowException
Method arguments : []
HijackAroundMethod : Before method hijacked!
HijackAroundMethod : Throw exception hijacked!

It will run the HijackAroundMethod’s invoke() method, after every customerService’s method execution.

Conclusion

Most of the Spring developers are just implements the ‘Around advice ‘, since it can apply all the advice type, but a better practice should choose the most suitable advice type to satisfy the requirements.

Pointcut
In this example, all the methods in a customer service class are intercepted (advice) automatically. But for most cases, you may need to use Pointcut and Advisor to intercept a method via it’s method name.

Spring AOP 详解
2301_80035594的博客
10-19 6333
Spring AOP（Aspect-Oriented Programming，面向切面编程）是Spring框架提供的一种编程范式，它允许开发者将横切关注点（如日志、事务管理、权限检查等）与业务逻辑分离，从而提高代码的模块化和可维护性。Spring AOP 基于代理机制实现，它为Spring应用提供了声明式事务管理等功能。
【Spring】AOP——通知（Advice）
wosixiaokeai的博客
05-23 1230
1.1简介1.2常见的通知类型。
Spring AOP Example – Pointcut , Advisor
09-06 553
In last Spring AOP advice examples, the entire methods of a class are intercepted automatically. But for most cases, you may just need a way to intercept only one or two methods, this is what ‘Pointcut
Spring AOP详解
2303_80195175的博客
05-04 1421
面向切面编程（AOP，Aspect-Oriented Programming）是一种编程范式，旨在通过分离横切关注点（cross-cutting concerns）来提升代码的模块化。AOP 的核心思想横切关注点：指那些分散在多个模块中的通用功能（如日志、事务、安全等），传统OOP难以集中管理，导致代码冗余。切面（Aspect）：将横切关注点封装为独立模块，通过声明式或编程方式注入到业务逻辑中，实现关注点分离。关键概念切面（Aspect）封装横切逻辑的模块（如日志切面），包含通知和切点定义。
SpringAOP(图文详解)
热门推荐
lhj520cb的博客
07-16 5万+
Spring实现的AOP是代理模式，给调用者使用的实际是已经过加工的对象，你编程时方法体里只写了A，但调用者拿到的对象的方法体却是xAy。x和y总还是需要你来写的，这就是增强。x和y具体在什么时候被调用总还是需要你来规定的，虽然是基于约定的声明这种简单的规定，这就是切点。
Spring AOP
2301_76161469的博客
11-04 4959
AOP（Aspect-Oriented Programming，面向切面编程）：是一种软件开发的编程范式，旨在将横切关注点（cross-cutting concerns）与核心业务逻辑分离，以提高代码的模块化性、可维护性和复用性
Spring AOP中通知 (Advice) 是什么？
专注于技术分享
06-19 657
通知 (Advice)是切面（Aspect）的具体动作，它封装了你希望在目标方法执行时插入的代码逻辑。简单来说，如果切面（Aspect）回答了“我要对谁（Pointcut）做什么（Advice）”，那么通知（Advice）就是那个具体的“做什么通知类型定义了“何时”定义了“做什么”关键特征@Before方法执行前前置处理逻辑（如参数校验）无法阻止方法执行，无法获取返回值@After方法执行后资源清理等finally型逻辑无论成功或异常都会执行方法成功返回后针对成功结果的后处理。
【JavaEE】Spring AOP的注解实现
yj20040627的博客
05-25 1万+
基于注解@annotation 和 execution 的方式实现SPring AOP
Spring AOP实现日志管理
Pompey_wp的博客
03-15 960
😔记录一下Spring AOP的日志管理实现。
SpringAOP.rar_springAOP
09-23
《Spring AOP：面向切面编程的深度解析》 在软件开发中，Spring框架以其强大的功能和灵活性，已经成为Java企业级应用的首选框架之一。其中，Spring AOP（Aspect Oriented Programming，面向切面编程）是Spring框架...
简单spring aop 例子
03-24
Spring AOP（面向切面编程）是Spring框架的重要组成部分，它提供了一种模块化和声明式的方式来处理系统中的交叉关注点问题，如日志、事务管理、安全性等。本示例将简要介绍如何在Spring应用中实现AOP，通过实际的...
基于SpringBoot和uni-app开发的陪诊陪护软件系统源码
最新发布
程序员创业中
09-06 700
中国60岁以上人口已突破3.1亿，独居老人超1.3亿，而一线城市三甲医院日均门诊量超万人次。在这组数据背后，是无数家庭面临的困境：子女异地工作无法陪同父母就医，独居老人因不会操作智能设备在挂号机前徘徊，异地患者因不熟悉流程在医院迷路……当“就医”从个人事务演变为社会难题，陪诊陪护系统正以“专业服务+技术赋能”的双重模式，成为破解这一困局的关键。
基于SpringBoot景区商户管理系统
Rookie
09-03 661
开发语言：Java框架：springboot VueJDK版本：JDK1.8服务器：tomcat7数据库：mysql数据库工具：Navicat11开发软件：eclipse/myeclipse/ideaMaven包：Maven系统采用模块化设计思想，遵循高内聚、低耦合原则，将核心业务拆分为独立功能模块，便于开发、维护与扩展。模块划分基于银行客户管理的核心业务流程，结合 Spring Boot 的组件化开发特性，确保各模块职责清晰、协作高效。
SpringBoot【集成 Druid 01】使用 druid-spring-boot-starter 实现监控数据库
シ風
09-04 434
本文介绍了如何使用druid-spring-boot-starter实现数据库监控。Druid是一个包含代理Driver、高效连接池和SQL解析器的JDBC组件，具有监控性能、替换传统连接池、密码加密、SQL日志记录和扩展JDBC等功能。配置步骤包括添加核心依赖、设置数据源参数（如连接数、慢SQL阈值等），配置完成后可通过/druid/login.html访问监控页面查看SQL执行情况。Druid提供了比DBCP/C3P0更强大的连接池管理能力，并能有效保障数据库访问安全。
在线视频教育平台|基于Springboot的在线视频教育平台系统设计与实现(源码+数据库+文档)
伟庭的博客
09-04 870
本文介绍了一个基于SpringBoot框架开发的在线视频教育平台系统。该系统采用Mysql数据库，使用Tomcat服务器运行，具有前台课程展示、购物车功能和后台用户/教师管理等功能模块。系统设计注重交互性和管理协调，包含课程信息管理、收藏管理和订单管理等核心功能。文章详细阐述了系统架构、功能设计、数据库结构以及核心代码实现，并提供了源码获取方式。该平台有效提升了教育管理的灵活性和效率，具有良好的可扩展性和易维护性。
【SpringBoot】22 核心功能 - Web开发原理 - 拦截器- 原理、实现、执行时机、登录检查与静态资源放行
技术改变世界，阅读塑造人生，质量决定成败
09-04 891
本文详细介绍了Spring Boot中拦截器的实现与应用。拦截器基于HandlerInterceptor接口，通过preHandle、postHandle和afterCompletion方法在请求处理的不同阶段执行自定义逻辑。关键实现包括登录检查、静态资源放行等，通过WebMvcConfigurer注册拦截器并配置拦截路径。文中还分析了拦截器的执行时机与原理，说明其基于HandlerExecutionChain的顺序执行和短路机制。拦截器适合用于权限控制、日志记录等场景，是Spring MVC中重要的功能扩
【CouponHub开发记录】SpringAop和分布式锁进行自定义注解实现防止重复提交
2302_81153890的博客
09-03 255
当我们创建优惠券时，可能会出现由于网络延时等问题导致用户重复点击创建优惠券模板的操作。我们可以通过分布式锁，给当前线程进行加锁。如果获取锁失败说明重复提交。该语句是接着执行切点之后的逻辑，也就是创建优惠券。但是这样直接写到业务当中导致代码比较繁琐，冗余。因此我们可以创建自定义注解，将该逻辑抽离出来。接着去执行获取分布式锁、然后执行相应逻辑。该环绕通知会拦截所有带这个注解的方法。直接再创建优惠券之前进行加锁。
Spring AOP基础示例：初识advice应用
Spring AOP（面向切面编程）是Spring框架的一个重要组件，它允许开发者将横切关注点（cross-cutting concerns），比如日志记录、安全性、事务管理等，从应用的业务逻辑中分离出来，通过声明式的方式将这些横切关注点...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值