Spring AOP 三种实现方式

最新推荐文章于 2024-07-21 11:45:00 发布
最新推荐文章于 2024-07-21 11:45:00 发布
阅读量390 收藏 1
点赞数
文章标签： spring aop java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/chenxin0312/article/details/108205365
版权
Spring AOP 三种实现方式
1.动态代理实现AOP基于XML的配置方式

业务逻辑接口

package com.chen.service;
public interface IOrderService {
    String creatNewOrder(int orderMoney);
    void payForOrder();
}

业务逻辑实现类

@Service("orderServiceBean")
public class OrderServiceImpl implements IOrderService {
    @Override
    public String creatNewOrder(int orderMoney) {
        System.out.println("【业务层】创建新订单,订单金额为："+orderMoney);
       // Integer.parseInt("soso");
        return UUID.randomUUID().toString();
    }
    @Override
    public void payForOrder() {
        System.out.println("【业务层】支付订单");
    }
}

通知类


/**
 * 日志通知
 */
public class LogAdvice implements MethodBeforeAdvice ,AfterReturningAdvice{
    /**
     * 前置通知（将会在目标对象的目标方法执行前调用）
     * @param method 目标方法
     * @param objects 参数列表
     * @param target 目标对象
     * @throws Throwable
     */
    @Override
    public void before(Method method, Object[] objects, Object target) throws Throwable {
        System.out.println("目标对象："+target);
        System.out.println("目标方法："+method.getName());
        System.out.println("传入参数："+ Arrays.toString(objects));
        System.out.println("【日志】"+target+"的"+method.getName()+"方法于"+new Date()+"被执行");
    }

    /**
     * 后置通知
     * @param result
     * @param method
     * @param objects
     * @param target
     * @throws Throwable
     */
    @Override
    public void afterReturning(Object result, Method method, Object[] objects, Object target) throws Throwable {
        System.out.println("返回值"+result);
        System.out.println("目标对象："+target);
        System.out.println("目标方法："+method.getName());
        System.out.println("传入参数："+ Arrays.toString(objects));
        System.out.println("【日志】"+target+"的"+method.getName()+"方法于"+new Date()+"执行结束");
    }
}

XML配置

<?xml version="1.0" encoding="UTF-8"?>
<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.xsd">

    <!--被代理对象    -->
    <bean id="orderServiceBean" class="com.chen.service.impl.OrderServiceImpl"/
    <!--通知    -->
    <bean id="logAdviceBean" class="com.chen.advice.LogAdvice"/>
    <bean id="performanceAdviceBean" class="com.chen.advice.PerformanceAdvice"/>

    <!--切入点:通过正则表达式描述指定切入点-->
    <bean id="methodPointcutBean" class="org.springframework.aop.support.JdkRegexpMethodPointcut">
        <!--注入正则表达式：描述哪些方法为切入点-->
        <property name="pattern" value=".*creat.*"/><!--以creat开头的方法-->
    </bean>

    <!--高级通知(Advisor) =通知(Advice)+切入点（Pointcut）-->
    <bean id="performanceAdvisorBean" class="org.springframework.aop.support.DefaultPointcutAdvisor">
<!--        注入切入点-->
        <property name="pointcut" ref="methodPointcutBean"/>
<!--        注入通知-->
        <property name="advice" ref="performanceAdviceBean"/>
    </bean>


    <!-- 自动代理创建   -->
    <bean class="org.springframework.aop.framework.autoproxy.BeanNameAutoProxyCreator">
        <!--Bean名称规则（数组）指定哪些bean创建代理      -->
        <property name="beanNames">
            <list>
                <value>*ServiceBean</value>
            </list>
        </property>
        <!--通知列表：需要执行哪些通知     -->
        <property name="interceptorNames">
            <list>
                <value>logAdviceBean</value>
                <value>performanceAdvisorBean</value>
            </list>
        </property>
    </bean>
</beans>
2.使用Aspect实现切面,使用Spring AOP 进行配置

切面类

/**
 * 使用AspectJ实现切面(普通POJO的实现方式)
 */
public class LogAspect {
    /**
     * 前置通知
     * @param joinPoint
     */
    public void beforeAdvice(JoinPoint joinPoint){
        System.out.println("========【使用AspectJ实现前置通知】=========");
        System.out.println("目标对象："+joinPoint.getTarget());
        System.out.println("目标方法："+joinPoint.getSignature().getName());
        System.out.println("参数列表："+ Arrays.toString(joinPoint.getArgs()));
        System.out.println("============================================");
    }
    /**
     * 后置通知:方法正常执行后，有返回值，执行该后置通知；如果该方法执行出现异常，则不执行该后置通知
     */
    public void afterReturningAdvice(JoinPoint joinpoint,Object returnVal){
        System.out.println("==========【使用AspectJ实现后置通知】开始==================");
        System.out.println("目标对象:" + joinpoint.getTarget());
        System.out.println("目标方法：" + joinpoint.getSignature().getName());
        System.out.println("参数列表：" + joinpoint.getArgs());
        System.out.println("返回值：" + returnVal);
        System.out.println("==========【使用AspectJ实现后置通知】结束==================");
    }
    /**
     * 后置通知
     */
    public void afterAdvice(JoinPoint joinpoint){
        System.out.println("==========【使用AspectJ实现后置通知】开始==================");
        System.out.println("目标对象:" + joinpoint.getTarget());
        System.out.println("目标方法：" + joinpoint.getSignature().getName());
        System.out.println("参数列表：" + joinpoint.getArgs());
        System.out.println("==========【使用AspectJ实现后置通知】结束==================");
    }
    /**
     * 异常通知:方法出现异常时，执行该通知
     * @param joinpoint
     * @param ex
     */
    public void throwingAdvice(JoinPoint joinpoint,Exception ex){
        System.out.println("==========【使用AspectJ实现异常通知】开始==================");
        System.out.println("目标对象:" + joinpoint.getTarget());
        System.out.println("目标方法：" + joinpoint.getSignature().getName());
        System.out.println("出现异常:" + ex.getMessage());
        System.out.println("==========【使用AspectJ实现异常通知】结束==================");
    }

    /**
     * 环绕通知
     */
    public Object aroundAdvice(ProceedingJoinPoint joinpoint) throws Throwable {

        System.out.println("#########$环绕通知的前置部分$###############");
        Object returnVal = joinpoint.proceed();
        System.out.println("#########$环绕通知的后置部分$###############");

        return returnVal;
    }

}

XML配置

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:aop="http://www.springframework.org/schema/aop"
       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.xsd
                            http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop.xsd">

    <!--业务组件-->
    <bean id="orderServiceBean" class="com.chen.service.impl.OrderServiceImpl"/>
    <!-- 日志AspectJ切面-->
    <bean  id="logAspectBean" class="com.chen.advice.LogAspect"/>


    <!--使用Aspect实现切面,使用Spring AOP 进行配置-->
        <aop:config>
        <!-- 配置切面-->
        <!-- 注入切面bean-->
            <aop:aspect ref="logAspectBean">
                <!--定义Pointcut:通过expression表达式，来查找特定的方法（pointcut）-->
                <aop:pointcut id="serviceMethodPointcut" expression="execution(* com.chen.service.impl.*.creat*(..))"/>
                <!--配置前置通知 -->
                <!--在pointcut切入点（serviceMethodPointcut）查找到的方法执行前，执行当前logAspectBean的beforeAdvice-->
                <aop:before method="beforeAdvice" pointcut-ref="serviceMethodPointcut"/>

                <!--配置后置通知-->
                <!--returning属性：配置当前方法中用来接收返回值的参数名-->
                <aop:after-returning returning="returnVal" method="afterReturningAdvice" pointcut-ref="serviceMethodPointcut"/>
                <aop:after method="afterAdvice" pointcut-ref="serviceMethodPointcut"/>

                <!--配置异常通知-->
                <!--throwing属性：配置当前方法中用来接收当前异常的参数名-->
                <aop:after-throwing throwing="ex" method="throwingAdvice" pointcut-ref="serviceMethodPointcut"/>

                <!--配置环绕通知-->
                <aop:around method="aroundAdvice" pointcut-ref="serviceMethodPointcut"/>

            </aop:aspect>
        </aop:config>

    </beans>
3.使用AspectJ实现切面(注解的实现方式)

​ 切面类

​


/**
 * 使用AspectJ实现切面(注解的实现方式)
 */

//声明当前类为Aspect切面，并交给Spring容器管理
@Aspect
@Component
public class LogAnotationAspect {
    private static final String POINTCUT_EXPRESSION = "execution(* com.chen.service.impl.*.creat*(..) )";

    /**
     * 前置通知
     * @param joinPoint
     */
    @Before(POINTCUT_EXPRESSION)
    public void beforeAdvice(JoinPoint joinPoint){
        System.out.println("========【使用AspectJ实现前置通知】=========");
        System.out.println("目标对象："+joinPoint.getTarget());
        System.out.println("目标方法："+joinPoint.getSignature().getName());
        System.out.println("参数列表："+ Arrays.toString(joinPoint.getArgs()));
        System.out.println("============================================");
    }
    /**
     * 后置通知:方法正常执行后，有返回值，执行该后置通知；如果该方法执行出现异常，则不执行该后置通知
     */
    @AfterReturning(value=POINTCUT_EXPRESSION,returning = "returnVal")
    public void afterReturningAdvice(JoinPoint joinpoint,Object returnVal){
        System.out.println("==========【使用AspectJ实现后置通知】开始==================");
        System.out.println("目标对象:" + joinpoint.getTarget());
        System.out.println("目标方法：" + joinpoint.getSignature().getName());
        System.out.println("参数列表：" + joinpoint.getArgs());
        System.out.println("返回值：" + returnVal);
        System.out.println("==========【使用AspectJ实现后置通知】结束==================");
    }
    /**
     * 后置通知
     */
    @After(POINTCUT_EXPRESSION)
    public void afterAdvice(JoinPoint joinpoint){
        System.out.println("==========【使用AspectJ实现后置通知】开始==================");
        System.out.println("目标对象:" + joinpoint.getTarget());
        System.out.println("目标方法：" + joinpoint.getSignature().getName());
        System.out.println("参数列表：" + joinpoint.getArgs());
        System.out.println("==========【使用AspectJ实现后置通知】结束==================");
    }
    /**
     * 异常通知:方法出现异常时，执行该通知
     * @param joinpoint
     * @param ex
     */
    @AfterThrowing(value = POINTCUT_EXPRESSION,throwing = "ex")
    public void throwingAdvice(JoinPoint joinpoint,Exception ex){
        System.out.println("==========【使用AspectJ实现异常通知】开始==================");
        System.out.println("目标对象:" + joinpoint.getTarget());
        System.out.println("目标方法：" + joinpoint.getSignature().getName());
        System.out.println("出现异常:" + ex.getMessage());
        System.out.println("==========【使用AspectJ实现异常通知】结束==================");
    }

    /**
     * 环绕通知
     */
    @Around(POINTCUT_EXPRESSION)
    public Object aroundAdvice(ProceedingJoinPoint joinpoint) throws Throwable {

        System.out.println("#########$环绕通知的前置部分$###############");
        Object returnVal = joinpoint.proceed();
        System.out.println("#########$环绕通知的后置部分$###############");

        return returnVal;
    }
}

​ XML配置

​

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:aop="http://www.springframework.org/schema/aop"
       xmlns:context="http://www.springframework.org/schema/context"
       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.xsd
                           http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop.xsd
                           http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context.xsd">

        <!--自动扫描器-->
        <context:component-scan base-package="com.chen"/>
        <!--配置AspectJ的自动代理-->
        <aop:aspectj-autoproxy/>

</beans>
xiaochengogogo
关注
Spring AOP的三种实现方式
02-09 1万+
一、浅析AOP参考：https://docs.spring.io/spring/docs/current/spring-framework-reference/core.html#aop-apiAOP意味面向切面编程，是通过预编译方式和运行期动态代理，实现在不修改源代码的情况下给程序动态统一添加功能的一种技术。1、方面（Aspect）：一个关注点的模块化，这个关注点实现可能另外横切多个对象。事务管...
Spring实现AOP的4种方式
10-25
Spring中实现AOP有很多方式，这里总结了四种，有基于代理的实现方式，也有基于AspectJ 的注解方式，还有基于AOP标签的配置
Spring AOP四种实现方式Demo详解与相关知识探究
热门推荐
Leeon的博客
08-27 3万+
一、前言 在网络上看到一篇博客Spring实现AOP的4种方式，博主写的很通俗易懂，但排版实在抓狂，对于我这么一个对排版、代码格式有强迫症的人来说，实在是不能忍受~~~~(>_ 我亲手实现了一遍，重新整理，加上了一些不易关注到的细节、漏掉的知识，以及自己对AOP的一些理解，写成这篇博客。 二、AOP相关概念 （1）AOP是什么？AOP与拦截器的区别？ 太抽象的不说，如果你知道St
Spring AOP详解
最新发布
2302_77758423的博客
07-21 1264
AOP英文全称：Aspect Oriented Programming（面向切面编程、面向方面编程），其实说白了，面向切面编程就是面向特定方法编程。使用场景（记录操作日志、权限控制、事务管理）。AOP的优势：减少重复代码、提高开发效率、维护方便、代码无侵入。案例某部分功能运行较慢，定位执行耗时较长的业务方法，此时需要统计每一个业务的执行耗时。我们可以在方法开始前，获取方法开始时间，方法结束后获取结束时间，由此计算执行耗时。这个思路是正确的，但是过于繁琐。动态代理是面向切面编程最主流的实现。
Spring实现AOP的三种方式
你好，Java！的博客
07-27 852
AOP AOP：Aspect Oriented Programming （面向切面编程）通过预编译方式和运行期动态代理实现程序功能的统一 维护的一种技术。AOP是OOP的延续，是软件开发中的一个热点，也是Spring框架中的一个重要内容，是函数式编 程的一种衍生范型。利用AOP可以对业务逻辑的各个部分进行隔离，从而使得业务逻辑各部分之间的耦合度降低， 提高程序的可重用性，同时提高了开发的效率。 ...
aop实现的三种方式
Lin_home
11-08 648
经典的基于代理的AOP+aop:config的标签实现 通过注解实现（AspectJ注解） 自定义切面实现aop 1、第一种经典方法使用 a、5大增强类方法 Before(前) org.apringframework.aop.MethodBeforeAdvice After-returning(返回后) org.springframework.aop.AfterReturningAdvice After-throwing(抛出后) org.springframework.aop.ThrowsAdvic.
springAOP的三种实现方式示例代码
08-18
Spring AOP 三种实现方式示例代码 Spring AOP（Aspect-Oriented Programming）是 Spring 框架中的一种面向方面编程技术，主要用于解决横切关注点的问题。AOP 的主要思想是将横切逻辑代码从业务逻辑代码中分离出来，...
Spring AOP的几种实现方式总结
08-31
Spring AOP，即面向切面编程，是Spring框架的一个重要特性，它允许程序员在不修改原有业务代码的情况下，通过预编译方式和运行期动态代理实现程序功能的统一维护的一种技术。下面我们将深入探讨Spring AOP的核心概念...
spring AOP三种开发方式以及demo
10-17
Spring AOP，即Spring的面向切面编程，是一种强大的设计模式，它允许程序员在不修改源代码的情况下，插入额外的功能，比如日志记录...记得结合实际项目需求，选择最合适的AOP实现方式，以优化代码结构，提高代码质量。
Spring AOP 常用的四种实现方式
05-03
NULL 博文链接：https://junle.iteye.com/blog/2429125
spring aop的三种简单实现方式
qq_36669347的博客
06-15 227
spring aop的三种简单实现方式 方式一：spring api实现 方式二：自定义增强类与方法 方式三：注解配置实现
Spring AOP及其三种实现方式
halo321的博客
09-29 409
AOPAOP什么是AOPAOP的三种实现方式方式一：使用原生spring API接口方式二：自定义类方式三：注解实现总结 AOP 什么是AOP AOP(Aspect-Oriented Programming) 面向切面编程，听起来挺难理解，其实很像我上一篇整理的动态代理里面的加打印log的处理方法。比如有增删改查四个方法，想要在方法执行前打印“开始”执行后打印“结束”，这时候就可以用AOP了。 形象一点的比喻就是好比堆乐高，有四个部分都需要拼接同样形状的积木，我就整了一个功能一样的让四部分共用，大致是这样意
spring AOP 实现aop 的几种方式
来啊 搬砖啊
08-20 785
一、 注解实现 @Aspect public class CoutomAOP{ @Before("execution(* service.UserServiceImpl.*(..))") public void before(){ System.out.println("方法执行前"); } @After("execution(* service.UserServiceImpl.*(..))") public void after(){
实现AOP的三种方式
clf20731的博客
03-25 2262
实现AOP的三种方式 概念 在软件业，AOP为Aspect Oriented Programming的缩写，意为：面向切面编程，通过预编译方式和运行期间动态代理实现程序功能的统一维护的一种技术。AOP是OOP的延续，是软件开发中的一个热点，也是Spring框架中的一个重要内容，是函数式编程的一种衍生范型。利用AOP可以对业务逻辑的各个部分进行隔离，从而使得业务逻辑各部分之间的耦合度降低，提高程序的可重用性，同时提高了开发的效率。 AOP在Spring中的作用 提供声明性事务 允许用户自定义切面 使用Spri
使用Spring实现Aop三种方法
vengu733的博客
08-05 3283
** 方式一 ：使用spring的AP接口 方式二 ： 自定义来实现AOP (主要是切面定义) 方式三 ：使用注解实现AOP **使用AOP 植入 ，需要导入依赖包aspectj 方式一 ：使用spring的AP接口 定义uservice接口 接口实现类userviceImpl 创建要做代理 为uservice 添加日志 的log类 创建afterlog 类 ben.xml 创建测试： div 自定义一个类 bean.xml 测试结果： 分析： 创建annotation类 bean.xml 测试
SpringAOP的3种实现方式
Dark_Blue__的博客
06-05 339
SpringAOP的3种实现方式方式一：通过实现spring提供的接口实现方式二：通过自定义方式织入实现方式三：通过注解的方式实现 AOP （Aspect Orient Programming）,直译过来就是 面向切面编程。AOP 是一种编程思想，是面向对象编程（OOP）的一种补充。面向对象编程将程序抽象成各个层次的对象，而面向切面编程是将程序抽象成各个切面。 方式一：通过实现spring提供的接口实现 配置文件 <?xml version="1.0" encoding="UTF-8"?> &l
Spring AOP 实现方式详解
"本文总结了Spring AOP的几种实现方式，包括核心概念的解析以及具体的实现技术，如Java动态代理和AspectJ编织等。" 在软件开发中，Spring AOP（面向切面编程）是一种强大的工具，它允许程序员将关注点分离，使代码...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值