spring之AOP

最新推荐文章于 2024-05-12 17:59:27 发布
最新推荐文章于 2024-05-12 17:59:27 发布
阅读量172 收藏
点赞数
分类专栏： spring 文章标签： spring
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_52681702/article/details/121003099
版权

一、aop介绍

1、AOP关键性概念：

        连接点（Joinpoint）：程序执行过程中明确的点，如方法的调用，或者异常的抛出

        目标（Target）:被通知（被代理）的对象。——注1：完成具体的业务逻辑。

        通知（Advice）:在某个特定的连接点上执行的动作，同时Advice也是程序代码的具体实现，例如一个实现日志记录的代码（通知有些书上也称为处理）——注2：完成切面编程。

        代理（Proxy）:将通知应用到目标对象后创建的对象（代理=目标+通知）。例子：外科医生+护士——注3：只有代理对象才有AOP功能，而AOP的代码是写在通知的方法里面的。

        切入点（Pointcut）：多个连接点的集合，定义了通知应该应用到那些连接点。（也将Pointcut理解成一个条件，此条件决定了容器在什么情况下将通知和目标组合成代理返回给外部程序）

        适配器（Advisor）:适配器=通知（Advice）+切入点（Pointcut）

2、如何实现AOP
        目标对象只负责业务逻辑代码
        通知对象负责AOP代码，这二个对象都没有AOP的功能，只有代理对象才有
 

二、前置通知

MyMethodBeforeAdvice类：

package com.pjl.aop.advice;


import java.lang.reflect.Method;
import java.util.Arrays;

import org.springframework.aop.MethodBeforeAdvice;

public class MyMethodBeforeAdvice implements MethodBeforeAdvice{
//	target:目标对象
//	method：被触发的目标对象的方法
//	args：目标对象的目标方法的携带的参数
	public void before(Method method, Object[] args, Object target) throws Throwable {
		String targetName = target.getClass().getName();
		String methodName = method.getName();
		String params = Arrays.toString(args);
		String msg = "【系统日志】：正在调用->"+targetName+"."+methodName+",携带的参数："+params;
		System.out.println(msg);
 
	}

}

IBookBiz类：

package com.pjl.aop.biz;

public interface IBookBiz {
	// 购书
	public boolean buy(String userName, String bookName, Double price);

	// 发表书评
	public void comment(String userName, String comments);
}

PriceException类：

package com.pjl.aop.exception;

public class PriceException extends RuntimeException {

	public PriceException() {
		super();
	}

	public PriceException(String message, Throwable cause, boolean enableSuppression, boolean writableStackTrace) {
		super(message, cause, enableSuppression, writableStackTrace);
	}

	public PriceException(String message, Throwable cause) {
		super(message, cause);
	}

	public PriceException(String message) {
		super(message);
	}

	public PriceException(Throwable cause) {
		super(cause);
	}
	
}

spring-context.xml：

（将目标对象配置到配置文件中）

<!-- 目标 -->
<bean name="bookBiz" class="com.pjl.aop.biz.impl.BookBizImpl"></bean>

测试：写一个AopTest类

package com.pjl.aop.test;

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

import com.pjl.aop.biz.IBookBiz;

public class AopTest {
     public static void main(String[] args) {
    		ApplicationContext applicationContext=new ClassPathXmlApplicationContext("/spring-context.xml");
    		IBookBiz bookBiz=(IBookBiz) applicationContext.getBean("proxyFactoryBean");
    		bookBiz.buy("小小", "小红书",9.9d);
    		bookBiz.comment("小小", "学穿搭");
	}
}

结果：

运用前置通知：

        配置文件中spring-context.xml:

<!-- 前置通知  -->
<bean name="myBefore"  class="com.pjl.aop.advice.MyMethodBeforeAdvice"></bean>
<!--生成代理对象（目标+通知）  -->
<bean class="org.springframework.aop.framework.ProxyFactoryBean"
        id="proxyFactoryBean">
       <!-- 目标对象 -->
        <property name="target" ref="bookBiz"></property>
        <!-- 代理工厂生产的代理需要实现的接口列表 -->
        <property name="proxyInterfaces">
            <list>
                <value>com.pjl.aop.biz.IBookBiz</value>
            </list>
        </property>
        <property name="interceptorNames">
            <list>
                <value>myBefore</value>
             
    
            </list>
        </property>
    </bean>

 拿到代理对象：

package com.pjl.aop.test;

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

import com.pjl.aop.biz.IBookBiz;

public class AopTest {
     public static void main(String[] args) {
            ApplicationContext applicationContext=new ClassPathXmlApplicationContext("/spring-context.xml");
            IBookBiz bookBiz=(IBookBiz) applicationContext.getBean("proxyFactoryBean");

//        这个buy是先去获取前置通知的代码，再去调用目标对象的业务代码
            bookBiz.buy("小小", "小红书",9.9d);
            bookBiz.comment("小小", "学穿搭");
    }
}

结果： 

三、后置通知

价值：事务提交，关闭session

 MyAfterReturningAdvice类：

package com.pjl.aop.advice;

import java.lang.reflect.Method;
import java.util.Arrays;

import org.springframework.aop.AfterReturningAdvice;

public class MyAfterReturningAdvice implements AfterReturningAdvice{

	public void afterReturning(Object returnValue, Method method, Object[] args, Object target) throws Throwable {
		String targetName = target.getClass().getName();
		String methodName = method.getName();
		String params = Arrays.toString(args);
		String msg = "【返利通知：返利3元】：正在调用->" + targetName + "." + methodName + ",携带的参数：" + params + ";目标对象所调用的方法的返回值："
				+ returnValue;
		System.out.println(msg);
	}
}

进行配置spring-context.xml：

<!-- 后置通知 -->
<bean name="myAfter" class="com.pjl.aop.advice.MyAfterReturningAdvice"></bean>
<!-- 生成代理（目标对象+通知） -->
    <bean class="org.springframework.aop.framework.ProxyFactoryBean"
        id="proxyFactoryBean">
        <!-- 目标对象 -->
        <property name="target" ref="bookBiz"></property>
        <!-- 代理工厂生产的代理需要实现的接口列表 -->
        <property name="proxyInterfaces">
            <list>
                <value>com.pjl.aop.biz.IBookBiz</value>
            </list>
        </property>
        <property name="interceptorNames">
            <list>
                <value>myBefore</value>
                <value>myAfter</value>
            </list>
        </property>
    </bean>

AopTest测试，执行结果为，先走前置通知，再走目标对象，再走后置对象

 注：前置通知与后置通知能让你专注于业务代码 

四、环绕通知

   价值：包含了前置通知与后置通知

MyMethodInterceptor：

package com.pjl.aop.advice;

import java.lang.reflect.Method;
import java.util.Arrays;

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

public class MyMethodInterceptor implements MethodInterceptor{
//	invocation:可以执行被代理的目标对象的业务方法
	public Object invoke(MethodInvocation invocation) throws Throwable {
		Object target = invocation.getThis();
		Method method = invocation.getMethod();
		Object[] args = invocation.getArguments();
		// a.jsp window.open(b.jsp)
		// b.jsp xxx->返回object->b.jsp window.close();window.getArguments;
		String targetName = target.getClass().getName();
		String methodName = method.getName();
		String params = Arrays.toString(args);
		String msg = "【环绕通知】：正在调用->" + targetName + "." + methodName + ",携带的参数：" + params;
		System.out.println(msg);
	//invocation可以执行被代理的目标对象的业务方法
		Object returnValue = invocation.proceed();
		String msg2 = "【环绕通知】：目标对象所调用的方法的返回值：" + returnValue;
		System.out.println(msg2);
		return returnValue;
	}
}

配置：

<!-- 环绕通知 -->
<bean name="myFilterAdvice" class="com.pjl.aop.advice.MyMethodInterceptor"></bean>

<!--生成代理对象（目标+通知）  -->
<bean class="org.springframework.aop.framework.ProxyFactoryBean"
        id="proxyFactoryBean">
       <!-- 目标对象 -->
        <property name="target" ref="bookBiz"></property>
        <!-- 代理工厂生产的代理需要实现的接口列表 -->
        <property name="proxyInterfaces">
            <list>
                <value>com.pjl.aop.biz.IBookBiz</value>
            </list>
        </property>
        <property name="interceptorNames">
            <list>
                <value>myBefore</value>
               <value>myAfter</value>
                    <value>myFilterAdvice</value>
            </list>
        </property>
    </bean>

AopTest 测试：

五、异常通知

  价值：处理异常数据，事务回滚

MyThrowsAdvice：

package com.pjl.aop.advice;

import org.springframework.aop.ThrowsAdvice;

import com.pjl.aop.exception.PriceException;

public class MyThrowsAdvice implements ThrowsAdvice{
	public void afterThrowing( PriceException ex ) {
		System.out.println("价格输入有误，购买失败，请重新输入！！！");
	}

}

配置：

<!-- 异常通知 -->
<bean name="MyExceptionAdvice" class="com.pjl.aop.advice.MyThrowsAdvice"></bean>

<!--生成代理对象（目标+通知）  -->
<bean class="org.springframework.aop.framework.ProxyFactoryBean"
        id="proxyFactoryBean">
       <!-- 目标对象 -->
        <property name="target" ref="bookBiz"></property>
        <!-- 代理工厂生产的代理需要实现的接口列表 -->
        <property name="proxyInterfaces">
            <list>
                <value>com.pjl.aop.biz.IBookBiz</value>
            </list>
        </property>
        <property name="interceptorNames">
            <list>
                <value>myBefore</value>
                <value>myAfter</value>       
                    <value>myFilterAdvice</value>
                      <value>MyExceptionAdvice</value>

运行测试代码，故意给出错误的数据，会运行异常通知：

package com.pjl.aop.test;

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

import com.pjl.aop.biz.IBookBiz;

public class AopTest {
     public static void main(String[] args) {
            ApplicationContext applicationContext=new ClassPathXmlApplicationContext("/spring-context.xml");
            IBookBiz bookBiz=(IBookBiz) applicationContext.getBean("proxyFactoryBean");
            bookBiz.buy("小小", "小红书",-9.9d);
            bookBiz.comment("小小", "学穿搭");
    }
}
 

结果：

  六、过滤通知

过滤具有后置通知的buy方法、del方法

<!-- 过滤通知  -->
 <bean class="org.springframework.aop.support.RegexpMethodPointcutAdvisor"
        id="myAfter2">
        <property name="advice" ref="myAfter"></property>
        <!-- .*buy:[.*]任意字符0~n个，以buy结尾的方法 -->
        <!-- <property name="pattern" value=".*buy"></property> -->
        <property name="patterns">
            <list>
                <value>.*buy</value>
                <value>.*del</value>
            </list>
        </property>
    </bean>
<!--生成代理对象（目标+通知）  -->
<bean class="org.springframework.aop.framework.ProxyFactoryBean"
        id="proxyFactoryBean">
       <!-- 目标对象 -->
        <property name="target" ref="bookBiz"></property>
        <!-- 代理工厂生产的代理需要实现的接口列表 -->
        <property name="proxyInterfaces">
            <list>
                <value>com.pjl.aop.biz.IBookBiz</value>
            </list>
        </property>
        <property name="interceptorNames">
            <list>
                <value>myBefore</value>
                <!--  <value>myAfter</value>  -->
                    <value>myAfter2</value> 
                    <value>myFilterAdvice</value>
                      <value>MyExceptionAdvice</value>
    
            </list>
        </property>
    </bean>

结果：

酱苓的码农之路
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
SpringAOP学习--SpringAOP简介及原理
drhrht的博客
08-02 3909
为了标准化AOP，Spring引入了一套AOP顶级API--AOP联盟，用来定义和使用AOP。底层根据配置生成JDK或CGLIB动态代理对象。SpringAOP不是一种新的AOP实现，使用JDK动态代理和CGLIB动态代理实现SpringAOP配置方式核心是Advisor，可以自定义Advisor，也可以通过AspectJ间接定义AdvisorSpringAOP的实现遵循了AOP联盟规范，AOP联盟顶级API接口贯穿了整个AOP过程httpshttpshttpshttpshttps。...
图文详解Spring AOP，你学会了吗？
qq_39652397的博客
04-28 2998
如果说 IOC 是 Spring 的核心，那么面向切面编程AOP就是 Spring 另外一个最为重要的核心，需要重点掌握@mikechen 本篇主要会详解以下六点： 1.AOP的定义 2.AOP的作用 3.AOP的应用场景 4.Spring AOP的术语 AOP核心概念 Spring AOP 通知分类 Spring AOP 织入时期 5.Spring AOP三种使用方式 方式1：使用Spring自带的AOP 方式2：使用Aspectj实现切面(普通POJO的实现方式) 方式3：使用As
SpringAOP(图文详解)
热门推荐
lhj520cb的博客
07-16 3万+
Spring实现的AOP是代理模式，给调用者使用的实际是已经过加工的对象，你编程时方法体里只写了A，但调用者拿到的对象的方法体却是xAy。x和y总还是需要你来写的，这就是增强。x和y具体在什么时候被调用总还是需要你来规定的，虽然是基于约定的声明这种简单的规定，这就是切点。
Spring高手之路18——从XML配置角度理解Spring AOP
最新发布
卓越无关环境，保持空杯心态——靡不有初，鲜克有终
05-12 1万+
本文是全面解析面向切面编程的实践指南。通过深入讲解切面、连接点、通知等关键概念，以及通过XML配置实现Spring AOP的步骤。
图文详解 Spring AOP，看完必懂！
良月柒
03-18 2155
程序员的成长之路互联网/程序员/技术/资料共享关注阅读本文大概需要 4 分钟。来自：blog.csdn.net/duxd185120/article/details/109210224学...
Spring之AOP
m0_46220187的博客
08-23 169
文章目录AOP中关键性概念通知接口 AOP中关键性概念 连接点(Joinpoint) 程序执行过程中明确的点，如方法的调用，或者异常的抛出. 目标(Target) 被通知(被代理)的对象 通知(Advice) 在某个特定的连接点上执行的动作，同时Advice也是程序代码的具体实现，例如一个实现日志记录的代码(通知有些书上也称为处理) 代理(Proxy) 将通知应用到目标对象后创建的对象(代理=目标+通知),请注意：只有代理对象才有AOP功能，而AOP的代码是写在通知的方法里面的 切入点(Po
死磕Spring之AOP篇 - Spring AOP两种代理对象的拦截处理（csdn）————程序.pdf
12-05
Spring AOP 是一种面向切面编程的技术，它允许我们在不修改源代码的情况下，对应用程序的特定部分（如方法调用）进行增强。在 Spring 中，AOP 的实现主要依赖于代理模式，有两种代理方式：JDK 动态代理和 CGLIB 动态...
spring 之aop
03-06
博文链接：https://yunhaifeiwu.iteye.com/blog/198956
spring之AOP（动态代理）
09-06
spring之AOP（动态代理），包括jdk动态代理和CGLib动态代理
Spring AOP 详解
yyhgo_的博客
01-23 6259
Spring AOP 详解
细说Spring——AOP详解（AOP概览）
Cx330_0217的博客
06-23 4335
一、对AOP的初印象 首先先给出一段比较专业的术语（来自百度）：在软件业，AOP为Aspect Oriented Programming的缩写，意为：面向切面编程，通过预编译方 式和运行期动态代理实现程序功能的统一维护的一种技术。AOP是OOP的延续，是软件开发中的一个 热点，也是Spring框架中的一个重要内容，是函数式编程的一种衍生范型。利用AOP可以对业务逻辑 的各个部分进行隔离，从而使得业务逻辑各部分之间的耦合度降低，提高程序的可重用性，同时提高 了开发的效率。 然后我们举一个比较容易理解的例子（
SpringAOP超详细图文解释（深入学习笔记可用于面试）
sakura的博客
09-23 1816
记录什么高频面径之SpringAOP底层原理以及对应的开发使用详细讲解；AOP 面向方面编程（Aspect-oriented Programming，151）通过提供关于程序结构的另一种思考方式，补充了面向对象编程。在 OOP 中，模块化的关键单元是类，而在 AOP 中，模块化的单元是方面。方面支持跨多个类型和对象的关注（例如事务管理）的模块化。
SpringAOP详解+快速入门
zhaolk的博客
06-04 2113
本文介绍了 Spring AOP 的实现原理，并通过实例解析详细阐述了其实现过程。在使用 Spring AOP时，我们需要定义切面类，并为需要实现AOP的方法添加注解。 Spring 会自动将切面逻辑插入到这些方法中，从而实现AOP的功能。
Spring高手之路17——动态代理的艺术与实践
卓越无关环境，保持空杯心态——靡不有初，鲜克有终
04-11 1万+
本文深入分析了JDK和CGLIB两种动态代理技术在Spring框架中的应用。讨论了动态代理的基础概念，通过实例展示了如何实现和应用这两种方法，并比较了它们的性能差异及适用场景。进一步，探讨了在动态代理中实现熔断限流和日志监控的策略，以及如何利用动态代理优化Spring应用的设计和功能。
Spring AOP —— 详解、实现原理、简单demo
CYK_byte的博客
03-05 2310
AOP 就是面向切面的编程， 是一种思想，是对某一类事情的集中处理。
Spring框架之AOP详解
qq_45515347的博客
09-05 1924
Spring AOP 详解，并实现demo
Spring——AOP原理及流程详解
共勉
11-28 7977
基于5.3.9 版本的Spring源码，对AOP原理及流程详解，AOP是在Bean生成流程中什么位置介入处理的？各个通知方法又是怎么组装的？AOP真的只是动态代理这么简单吗？
Spring AOP详解（AOP概览）
future_n的博客
08-17 647
在软件业，AOP为Aspect Oriented Programming的缩写，意为：面向切面编程，通过预编译方式和运行期间动态代理实现程序功能的统一维护的一种技术。AOP是OOP的延续，是软件开发中的一个热点，也是Spring框架中的一个重要内容，是函数式编程的一种衍生范型。利用AOP可以对业务逻辑的各个部分进行隔离，从而使得业务逻辑各部分之间的耦合度降低，提高程序的可重用性，同时提高了开发的效率。AOP:它是面向切面编程的语言，它可以让你的业务代码和非业务代码进行隔离。
spring aop aopalliance
08-07
Spring AOP是基于AOP联盟（aopalliance）的API构建的框架。AOP联盟定义了一系列的接口，用于实现面向切面编程的功能。在Spring框架中，将AOP联盟的接口以内嵌的形式放到了spring-aop包中，同时也引入了spring...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值