Spring AOP 原理剖析，这一篇就够

最新推荐文章于 2023-07-28 13:40:45 发布
最新推荐文章于 2023-07-28 13:40:45 发布
阅读量1k 收藏 17
点赞数 5
分类专栏： Spring原理 文章标签： java spring aop
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/fh667788123/article/details/104862343
版权

Spring AOP 学习记录

AOP（面向切面编程）方面的知识又是看了忘忘了看，今天有空记录下AOP的知识点。主要分为以下几方面：

​ 1、AOP相关术语

​ 2、基础知识及示例

​ 3、增强分类

1、AOP相关术语

连接点（Joinpoint） 一个类拥有一些边界性质的特定点，如一个类的各个方法就可称为连接点。
切点（Pointcut） 切点就是在众多连接点中选择自己感兴趣的连接点，如果将连接点比作一个数据库中的所有记录，那么切点就是一个查询语句的查询条件。
增强（Advice） 增强是置入目标连接点的一段代码，增强本身携带方位信息，如方法调用前、调用后、调用前后、异常抛出使等。
切面（Aspect） 切面由切点和增强组成，既包含增强逻辑和方位信息，也包含连接点信息。
目标对象（Target） 增强逻辑织入的目标类。
引介（Introduction） 引介是一种特殊的增强，它为类提供一些属性和方法。这样，即是一个业务类原本没实现某个接口，通过AOP的引介功能也可以动态的为该类添加接口实现逻辑，让该类成为接口的实现类。
织入（Weaving） 织入就是讲增强添加到目标类的具体方法上的过程。AOP有三种织入方式①编译期织入、②类装载期织入、③动态代理织入（Spring一般采用的方式）
代理（Proxy） 一个类被AOP织入增强后，就产生了一个代理结果类。它融合了增强逻辑，根据代理方式不同，代理类既可能是和原类具有相同接口的类或者是原类的子类。

通过以上概念我们可以想到通过定义切点、给切点织入增强逻辑等步骤，最后就可以完成切面编程。

2、基础知识及示例
2.1 JDK动态代理

​ Java JDK提供的动态代理技术允许开发者在运行期创建接口的代理类，JDK动态代理主要涉及java.lang.reflect包中的两个类：Proxy和InvocationHandler。

​ 其中，InvocationHandler是一个接口，可以通过实现该接口实现增强逻辑，并通过反射机制调用目标类代码，动态的将增强逻辑和业务逻辑编制在一起。Proxy利用InvocationHandler动态创建一个符合某一接口的示例，生成目标类的代理类。下面我使用代码演示。

// 下面假设我们有以下代码
public interface GreetService {
	void serviceTo(String name);
}

public class Waiter implements GreetService{

	@Override
	public void serviceTo(String name) {
         // 假设下面为代码时间性能监测代码
		// Long beginTime = System.currentTimeMillis();
		try {
			// 模拟程序在工作
			System.out.println("service to :"+name);
			Thread.sleep(10000L);
		} catch (InterruptedException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
		// System.out.println("consume time:"+(System.currentTimeMillis()-beginTime));
	}
}


// 我们将上面代码的性能监控代码使用JDK动态代理织入
// 首先编写InvocationHandler实现类
public class WaiterHandler implements InvocationHandler{
	// 目标类
	private Object target;
	public WaiterHandler(Object target) {
		this.target = target;
	}
	// 代理调用方法
	@Override
	public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
		Long beginTime = System.currentTimeMillis();
		// 调用target的相应方法，并传入参数
		method.invoke(target,args);
		
		System.out.println("consume time : "+(System.currentTimeMillis()-beginTime));
		return null;
	}
}
public class MainTest {

	public static void main(String[] args) {
		// 创建GreetService实例，也就是希望被代理的业务类
		GreetService waiter = new Waiter();
		// 创建InvocationHandler实现类，为业务类织入增强逻辑
		WaiterHandler waiterHandler = new WaiterHandler(waiter);
		// 使用Proxy生成GreetService代理实例
		GreetService waiterProxy = (GreetService)Proxy.newProxyInstance(waiter.getClass().getClassLoader(), Waiter.class.getInterfaces(),waiterHandler);
		// 调用代理实例方法
		waiterProxy.serviceTo("fuhang");
	}
}
// output:
//  service to :fuhang
//  consume time : 10002

​ 上面为大家演示了一个使用JDK动态代理将性能监控代码从业务逻辑抽出然后动态织入的示例代码。

​ 从上面的示例代码中大家可能发现了几个问题：

​ 1、Waiter必须实现一个接口

​ 2、newProxyInstance(waiter.getClass().getClassLoader(), Waiter.class.getInterfaces(),waiterHandler);第二个参数必须传入Waiter实现的接口列表

由以上可以知道JDK创建代理有一个限制，它只能为接口创建代理实例，难道我们写一个业务类必须为其定义一个接口吗？对于没有通过接口定义业务方法的类，如何实现为其动态创建代理实例呢？下面我们看看下一个动态代理技术CGLib。

2.2CGLib动态代理

​ CGLib底层使用了动态字节码技术，可以为一个类创建子类，在子类中采用方法拦截技术拦截所有父类方法调用，并顺势织入增强逻辑。下面我们使用CGLib实现上面性能监控织入的逻辑。

// 首先我们创建类CglibProxy实现MethodInterceptor
public class CglibProxy implements MethodInterceptor{

	@Override
	public Object intercept(Object obj, Method arg1, Object[] arg2, MethodProxy methodProxy) throws Throwable {
		Long beginTime = System.currentTimeMillis();
		// 实际方法调用的地方
		methodProxy.invokeSuper(obj, arg2);
		
		System.out.println("consume time : "+(System.currentTimeMillis()-beginTime));
		return null;
	}
}

// 测试类
public class MainTest {

	public static void main(String[] args) {
		// 创建EnHancer对象
		Enhancer enhancer = new Enhancer();
        // 创建我们的CglibProxy代理对象
		CglibProxy cglibProxy = new CglibProxy();
		// 设置父类为Waiter
		enhancer.setSuperclass(Waiter.class);
        // 设置回调函数为CglibProxy
		enhancer.setCallback(cglibProxy);
		// 使用enhancer动态字节码技术创建Waiter的代理类
		Waiter waiter = (Waiter) enhancer.create();
		waiter.serviceTo("fuhang");
	}
}
// output:
//    service to :fuhang
//    consume time : 10044

​ 上面就是通过Cglib动态字节码技术为业务类生成子类的方式生成代理类，由此牵扯到Java知识点回顾，final和private修饰符修饰的类不能使用Cglib动态代理技术。

小结 ：

​ SpringAOP技术底层就是使用动态代理技术为目标bean织入增强逻辑的，但是从以上两类型代理技术的示例代码中可以发现以下几个问题：

​ （1）、目标类被代理后，所有方法都加入了增强逻辑，有些时候这并不是我们想要的。

​ （2）、 通过手动编码方式指定了增强逻辑

​ （3）、 手工编写代理实例创建过程，为不同类创建代理时候需要手工编写相应的代理实例创建过程代码。

​ 所以Spring AOP的主要工作就是解决以上三个问题：Spring AOP 通过切点（Pointcut）指定在哪些类的哪些方法上织入增强逻辑，通过增强（Advice）描述具体的织入点（方法调用前、调用后、调用前后），Spring通过Advisor（切面）将切面和增强组织起来，下面Spring就可以利用动态代理技术采用统一的方式为目标bean织入增强了。

3、增强类型

​ Spring使用增强（Advice）定义增强逻辑，增强不仅包括增强逻辑，还包括方位信息（即方法调用前、调用后、调用前后）

​ Spring支持五种增强类型，解释如下：

在这里插入图片描述

  • 前置增强 ：org.springframework.aop.BeforeAdvice 代表前置增强，Spring只支持方法级的增强，所以目前MethodBeforeAdvice是Spring中可用的前置增强，BeforeAdvice接口是为了将来扩展定义的。
  • 后置增强 ：org.springframework.aop.AfterReturningAdvice，表示在目标方法执行后进行增强。
  • 环绕增强 ：org.aopalliance.intercept.MethodInterceptor代表环绕增强，表示在目标方法执行前后实施增强。
  • 异常抛出增强 ： org.springframework.aop.ThrowsAdvice代表抛出异常增强，表示在目标方法抛出异常后实施增强。
  • 引介增强 ： org.springframework.aop.IntroductionInterceptor代表引介增强，表示在目标类中添加一些新的方法和属性。
3.1前置增强

​ 我们还用我们之前的GreetService和Waiter做示例代码，之前我们的代码中Waiter.serviceTo(name)方法只是输出"service to xxx"，现在我们想实现Waiter.serviceTo(name)在输出之前想客户打招呼，那么按照前面的理解，我们需要为其定义一个前置增强，下面我们着手改造吧。

// 我们定义一个打招呼前置类，实现MethodBeforeAdvice
public class GreetBeforeAdvice implements MethodBeforeAdvice{
	@Override
	public void before(Method arg0, Object[] arg1, Object arg2) throws Throwable {
         // 输出招呼用语
		System.out.print("hello "+ arg1[0]);
	}
}
public class MainTest {
	public static void main(String[] args) {
		// 创建Waiter和前置增强类
		Waiter waiter = new Waiter();
		GreetBeforeAdvice greetBeforeAdvice = new GreetBeforeAdvice();
		// 创建代理工厂，随后解释这个工厂
		ProxyFactory proxyFactory = new ProxyFactory();
		// 设置被代理的目标和要织入的增强
		proxyFactory.setTarget(waiter);
		proxyFactory.addAdvice(greetBeforeAdvice);
		// 通过代理工厂创建代理类
		Waiter myWaiter = (Waiter) proxyFactory.getProxy();
		// 调用方法
		myWaiter.serviceTo("fuhang");	
	}
}
// output：
// 		hello fuhang service to :fuhang

​ 上面就是前置增强的示例，下面讲解下ProxyFactory的细节，先来回一下前面的基础知识章节的内容，说了两个动态代理技术，ProxyFactory实际就是用到了JDK或者Cglib动态代理技术。

​ Spring定义了org.springframework.aop.framework.AopProxy接口，最终提供了两个final实现类，如下图所示。

在这里插入图片描述

​ 上图中Cglib2Proxy使用的是Cglib动态代理技术，JdkDynamicAopProxy使用的是JDK动态代理技术，如果通过ProxyFactory的setInterfaces(Class [] interfaces)方法指定目标类的接口信息，那么ProxyFactory底层将使用Jdk动态代理技术，否则不设置就使用Cglib动态代理技术。由此可知我们的示例代码中用到了Cglib动态代理技术。

3.2后置增强

​ 比如每次服务过后服务员需要询问顾客"还有什么需要吗？"这句话，那么可以通过一个后置增强来实施这一个要求。示例如下。

// 声明一个后置增强类并实现AfterReturningAdvice
public class GreetAfterAdvice implements AfterReturningAdvice{

	@Override
	public void afterReturning(Object arg0, Method arg1, Object[] arg2, Object arg3) throws Throwable {
		System.out.println("还有什么需要吗？");
	}
}

// 测试类
public class MainTest {

	public static void main(String[] args) {
		// 创建Waiter及前置增强、后置增强
		Waiter waiter = new Waiter();
		GreetBeforeAdvice greetBeforeAdvice = new GreetBeforeAdvice();
		GreetAfterAdvice greetAfterAdvice = new GreetAfterAdvice();
		// 代理工厂
		ProxyFactory proxyFactory = new ProxyFactory();
		// 设置目标代理类及前置增强、后置增强
		proxyFactory.setTarget(waiter);
		proxyFactory.addAdvice(greetAfterAdvice);
		proxyFactory.addAdvice(greetBeforeAdvice);
		// 创建代理Waiter
		Waiter myWaiter = (Waiter) proxyFactory.getProxy();
		// 调用方法
		myWaiter.serviceTo("fuhang");
	}
}
// output:
//     hello fuhang service to :fuhang
//     还有什么需要吗？
3.3 环绕增强

​ 使用环绕增强实现上面前置后置增强综合体，示例代码如下。

// 声明环绕增强类并实现MethodInterceptor(aopalliance的包)
public class SurrondAdvice implements MethodInterceptor{

	@Override
	public Object invoke(MethodInvocation arg0) throws Throwable {
         // 获取目标类参数
		Object [] args = arg0.getArguments();
		System.out.println("hello :"+args[0]);
         // 执行目标类方法
		arg0.proceed();
		System.out.println(" 请问还有什么需要吗？");
		return null;
	}
}

// 下面代码不在啰嗦，直接看输出
public class MainTest {

	public static void main(String[] args) {
		
		Waiter waiter = new Waiter();
		SurrondAdvice surrondAdvice = new SurrondAdvice();
		
		ProxyFactory proxyFactory = new ProxyFactory();
		
		proxyFactory.setTarget(waiter);
		proxyFactory.addAdvice(surrondAdvice);

		
		Waiter myWaiter = (Waiter) proxyFactory.getProxy();
		
		myWaiter.serviceTo("fuhang");
		
	}
}
// output:
//  	hello :fuhang
//   	service to :fuhang
//		请问还有什么需要吗？
3.4 异常抛出增强

​ 异常抛出增强适合的应用场景是事务管理，当参与事务管理的某个Dao抛出异常时候回滚事务。示例如下。

public class Waiter{

	@Override
	public void serviceTo(String name) {
		throw new RuntimeException("Dao异常");
	}
}

// 异常抛出增强类，在异常抛出之前会调用
public class ExceptionAdvice implements ThrowsAdvice{
	
	public void afterThrowing(Method method,Object [] args,Object target,Exception exception){
		System.out.println("事务回滚");
	}
}

// 测试类
public class MainTest {

	public static void main(String[] args) {
		
		Waiter waiter = new Waiter();
		ExceptionAdvice exceptionAdvice = new ExceptionAdvice();
		
		ProxyFactory proxyFactory = new ProxyFactory();
		
		proxyFactory.setTarget(waiter);
		proxyFactory.addAdvice(exceptionAdvice);

		
		Waiter myWaiter = (Waiter) proxyFactory.getProxy();
		
		myWaiter.serviceTo("fuhang");
		
	}
}
// output:
// 		事务回滚
//		Exception in thread "main" java.lang.RuntimeException: Dao异常

​ ThrowingAdvice是一个标签接口，其中没有声明任何方法，在运行期Spring通过反射机制自动判断增强方法，增强方法签名必须是以下格式：

​ void afterThrowing([Method method,Object [] args,Object obj],Throwable)

方法前三个参数可选，要么全部传入，要么全部不传。最后一个必须传入。最后一个参数是Throwable的子类就行。

3.5 引介增强

​ 引介增强比较特殊，他不是在方法周围增加增强逻辑，而是为目标类动态添加新的方法和属性。所以引介增强的连接点定位是类而不是方法上。下面我们通过引介增强为目标类添加一个接口实现，完成监控开关功能。

// 声明一个附加接口
public interface Monitor {
	void setMonitorActive(boolean active);
}

// 目标类
public class Waiter{
	public void serviceTo(String name) {
		System.out.println("hello :"+name);
	}
}

// 创建一个类继承DelegatingIntroductionInterceptor并实现将来要附加到目标类的接口
public class PerformanceMonitor extends DelegatingIntroductionInterceptor implements Monitor{
	// 相当于最终给类添加的属性
	ThreadLocal<Boolean> isOpen = new ThreadLocal<>();

	@Override
	public void setMonitorActive(boolean active) {
		isOpen.set(active);
	}

	@Override
	public Object invoke(MethodInvocation arg0) throws Throwable {
		if(isOpen.get()!=null && isOpen.get() ){
			Long beginTime = System.currentTimeMillis();
			super.invoke(arg0);
			System.out.println("consume time :"+(System.currentTimeMillis()-beginTime));
		}else{
			super.invoke(arg0);
		}
		return null;
	}

}

// 测试类
public class MainTest {

	public static void main(String[] args) {
		
		Waiter waiter = new Waiter();
		PerformanceMonitor performanceMonitor = new PerformanceMonitor();
		
		ProxyFactory proxyFactory = new ProxyFactory();
		// 下面必须设置setOptimize(true)，开启Cglib代理
		proxyFactory.setInterfaces(Monitor.class);
		proxyFactory.setTarget(waiter);
		proxyFactory.addAdvice(performanceMonitor);
		proxyFactory.setOptimize(true);

		// 第一次调用方法
		Waiter myWaiter = (Waiter) proxyFactory.getProxy();
		myWaiter.serviceTo("fuhang");
		
        // 转为Monitor后设置监控开关后再次调用方法
		Monitor monitor = (Monitor)myWaiter;
		monitor.setMonitorActive(true);
		
		myWaiter.serviceTo("zhangsan");
		
	}
}
// output：
// 		hello :fuhang
//		hello :zhangsan
//		consume time :0

总结

​ 以上就是本次学习的主要内容，后面如何将上面手动创建的方法转换为Spring xml配置在本篇不做记录（因为不难，也没啥技术含量）。希望通过本次记录能学到Spring Aop核心知识。

参考资料
《精通Spring4.x企业应用开发实战》

DoubleCherish
关注
  • 5
    点赞
  • 踩
  • 17
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
图文详解Spring AOP，你学会了吗？
qq_39652397的博客
04-28 2932
如果说 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具体在什么时候被调用总还是需要你来规定的，虽然是基于约定的声明这种简单的规定，这就是切点。
SpringAOP学习--SpringAOP简介及原理
drhrht的博客
08-02 3837
为了标准化AOP，Spring引入了一套AOP顶级API--AOP联盟，用来定义和使用AOP。底层根据配置生成JDK或CGLIB动态代理对象。SpringAOP不是一种新的AOP实现，使用JDK动态代理和CGLIB动态代理实现SpringAOP配置方式核心是Advisor，可以自定义Advisor，也可以通过AspectJ间接定义AdvisorSpringAOP的实现遵循了AOP联盟规范，AOP联盟顶级API接口贯穿了整个AOP过程httpshttpshttpshttpshttps。...
AOP 的详细说明以及基本的使用
热门推荐
cyt
07-19 3万+
AOP（Aspect-OrientedProgramming，面向切面编程），可以说是OOP（Object-OrientedPrograming，面向对象编程）的补充和完善。​OOP引入封装、继承和多态性等概念来建立一种对象层次结构，用以模拟公共行为的一个集合。当我们需要为分散的对象引入公共行为的时候，OOP则显得无能为力。也就是说，OOP允许你定义从上到下的关系，但并不适合定义从左到右的关系。例如日志功能。...
Spring AOP功能实现
weixin_44697633的博客
04-15 738
一、AOP的基本概念： 1、什么是aop：AOP（Aspect Oriented Programming）称为面向切面编程，在程序开发中主要用来解决一些系统层面上的问题，比如日志，事务，权限等待，Struts2的拦截器设计就是基于AOP的思想，是个比较经典的例子。在不改变原有的逻辑的基础上，增加一些额外的功能。代理也是这个功能，读写分离也能用aop来做。AOP可以说是OOP（Object Oriented Programming，面向对象编程）的补充和完善。OOP引入封装、继承、多态等概念来建立一种对象层.
使用Spring AOP实现MySQL数据库读写分离案例分析（附demo）
08-31
分布式环境下数据库的读写分离策略是解决数据库读写性能瓶颈的一个关键解决方案，这篇文章主要介绍了使用Spring AOP实现MySQL数据库读写分离案例分析（附demo），有兴趣的可以了解一下。
Spring原理篇.xmind
06-09
包括内容：Spring体系结构、Spring重要接口讲解（BeanFactory继承体系、BeanDefinition继承体系、ApplicationContext继承体系）、IOC/DI（容器初始化流源码分析）、AOP原理（解析流程，代理流程，执行流程）、事务...
Spring学习day03（Spring中的AOP）
12-22
一、AOP的相关概念 1、AOP概述 （1）什么是AOP AOP：全称是Aspect Oriented Programming，即：面向切面编程。...分析 上篇文章（Spring学习day02（基于注解的IOC配置、Spring整合Junit））点击访问 中的案例（这
Spring.3.x企业应用开发实战（完整版）.part2
05-31
Spring3.0是Spring在积蓄了3年之久后，隆重推出的一个重大升级版本，进一步加强了Spring作为Java领域第一开源平台的翘楚地位。 　Spring3.0引入了众多Java开发者翘首以盼的新功能和新特性，如OXM、校验及格式化框架...
AOP是什么？如何使用AOP？
weixin_64572002的博客
06-13 3万+
AOP就是面向切面编程，或者叫面向方面编程，或者开玩笑的说叫面向方便面编程在软件业，AOP为Aspect Oriented Programming的缩写，意为：面向切面编程，通过预编译方式和运行期间动态代理实现程序功能的统一维护的一种技术。AOP是OOP的延续，是软件开发中的一个热点，也是Spring框架中的一个重要内容，是函数式编程的一种衍生范型。利用AOP可以对业务逻辑的各个部分进行隔离，从而使得业务逻辑各部分之间的耦合度降低，提高程序的可重用性，同时提高了开发的效率。用我的话讲，比如一个方法，他只能计
AOP介绍和使用
最新发布
薛定谔的猫的博客
07-28 4110
⽽ AOP 是⼀种思想，⽽ Spring AOP 是⼀个框架，提供了⼀种对 AOP 思想的实现，它们的关系和 IoC 与 DI 类似。@Slf4j@Component@Aspect//定义切点//定义通知//这里注意，环绕式通知必须自己写返回结果log.info("之前");try{//调用目标方法log.info("之后");return oj;@Aspect是aop框架中提供的，表示是一个切面。
Spring AOP 详解
yyhgo_的博客
01-23 6034
Spring AOP 详解
图文详解 Spring AOP，看完必懂！
良月柒
03-18 2141
程序员的成长之路互联网/程序员/技术/资料共享关注阅读本文大概需要 4 分钟。来自：blog.csdn.net/duxd185120/article/details/109210224学...
一文弄懂AOP各种概念
wh柒八九的博客
08-28 4693
本文来说下Redis常见使用场景 文章目录概述 概述
Spring——AOP原理及流程详解
共勉
11-28 6437
基于5.3.9 版本的Spring源码，对AOP原理及流程详解，AOP是在Bean生成流程中什么位置介入处理的？各个通知方法又是怎么组装的？AOP真的只是动态代理这么简单吗？
AOP原理
qq_42477665的博客
07-25 4461
AOP原理 什么是Aop AOP（Aspect Orient Programming）也就是面向切面编程，作为面向对象编程的一种补充，已经成为一种比较成熟的编程方式。其实AOP问世的时间并不太长，AOP和OOP互为补充，面向切面编程将程序运行过程分解成各个切面 AOP的作用 作用：在不修改源代码的情况下，可以实现功能的增强。 AOP的基本概念 切面（Aspect）: 切面用于组织多个Advice，Advice放在切面中定义。 连接点（Joinpoint）: 程序执行过程中明确的点，如方法的调用，或
细说Spring——AOP详解（AOP概览）
Cx330_0217的博客
06-23 4319
一、对AOP的初印象 首先先给出一段比较专业的术语（来自百度）：在软件业，AOP为Aspect Oriented Programming的缩写，意为：面向切面编程，通过预编译方 式和运行期动态代理实现程序功能的统一维护的一种技术。AOP是OOP的延续，是软件开发中的一个 热点，也是Spring框架中的一个重要内容，是函数式编程的一种衍生范型。利用AOP可以对业务逻辑 的各个部分进行隔离，从而使得业务逻辑各部分之间的耦合度降低，提高程序的可重用性，同时提高 了开发的效率。 然后我们举一个比较容易理解的例子（
spring aop原理
06-07
Spring AOP（Aspect Oriented Programming）是 Spring 框架提供的一种面向切面编程的实现方式，它基于动态代理技术实现了在运行时动态地将代码织入到现有的代码中。 Spring AOP 的原理可以概括为以下几个步骤： 1. 定义切点：切点是指一个或一组方法，它们将被增强或拦截，Spring AOP 通过表达式或注解定义切点。 2. 定义增强逻辑：增强逻辑是指在切点方法被调用时需要执行的代码，这些代码可以是前置、后置、环绕等类型的通知。 3. 生成代理对象：Spring AOP 通过 JDK 动态代理或 CGLIB 字节码生成技术在运行时生成代理对象，代理对象包装了原始的目标对象，并负责将增强逻辑织入到目标对象的方法中。 4. 执行增强逻辑：当调用代理对象的方法时，代理对象会在执行目标方法前后执行增强逻辑。 通过以上步骤，Spring AOP 实现了将增强逻辑织入到目标对象的方法中，从而实现了切面编程的功能。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值