【Spring 学习笔记】9 从动态代理到SpringAOP

最新推荐文章于 2024-11-06 09:59:41 发布
最新推荐文章于 2024-11-06 09:59:41 发布
阅读量63 收藏
点赞数
文章标签： spring
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_38491553/article/details/131895360
版权
本文详细介绍了AOP（面向切面编程）的概念，特别是SpringAOP中的动态代理机制，涉及Cglib和JDK动态代理，以及如何通过Advisor、Pointcut、Advice和MethodInterceptor实现类方法的切面编程。文章还展示了如何在Spring中使用ProxyFactory和各种类型的Advice进行目标类的增强。
摘要由CSDN通过智能技术生成

AOP

AOP（Aspect Oriented Programming）是一种编程思想， 面向切面编程，而Spring AOP只是对它的一种实现，常用的实现框架还有AspectJ。
面向切面编程就要求我们要对目标类方法进行切入，可以在目标类方法前后执行一些的逻辑，这不可避免的就要用到动态代理去实现，接下来我们从动态代理开始逐步认识Spring AOP是怎么实现的。

动态代理

动态代理的基础知识可以参这篇文章–动态代理基础知识，文章中描写了Cglib的动态代理和JDK的动态代理的应用。

Spring中的动态代理

  • PoxyFactory

    上面两种动态代理技术在Spring中进行了封装，通过ProxyFactory，可以不再关心到底是用cglib还是jdk动态代理了，ProxyFactory会去判断，如果目标类实现了接口，那么ProxyFactory底层就会用jdk动态代理，如果没有实现接口，就会用cglib技术。

  • Advice

    MethodBeforeAdvice：定义目标方法执行前的逻辑
    AfterReturningAdvice： 定义目标方法执行后的逻辑
    org.aopalliance.intercept.MethodInterceptor：定义目标方法执行前后的逻辑
    ** **：定义目标方法抛出异常的逻辑
    // MethodBeforeAdvice
public class BeforeAdvice1 implements MethodBeforeAdvice {
	@Override
	public void before(Method method, Object[] args, Object target) throws Throwable {
		System.out.println("BeforeAdvice1");
	}
}	

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

    // MethodInterceptor
public class AroundAdvice1 implements MethodInterceptor {
	@Nullable
	@Override
	public Object invoke(@NotNull MethodInvocation invocation) throws Throwable {
		System.out.println("方法执行Around前");
		Object proceed = invocation.proceed();
		System.out.println("方法执行Around后");
		return proceed;
	}
}

    // ThrowsAdvice
public class ThrowsAdvice1 implements ThrowsAdvice {
	// method参数:调用到的方法
	// args参数:调用到方法传入的参数
	// target参数:目标对象
	// e参数:将来调用方法所抛出的异常
	// 这个方法要么如上介绍的四个参数，要么只有一个Exception参数
	public void afterThrowing(Method method, Object[] args, Object target, Exception e) {
		System.out.println("ThrowAdvice:" + e.getMessage());
	}
}	

    // 测试用例
public class ProxyFactoryTest {

	public static void main(String[] args) throws Exception {

		TargetService target = new TargetService();

		ProxyFactory proxyFactory = new ProxyFactory();
		proxyFactory.setTarget(target);

		proxyFactory.addAdvice(new AfterAdvice1());
		proxyFactory.addAdvice(new BeforeAdvice1());
		proxyFactory.addAdvice(new AroundAdvice1());
		//proxyFactory.addAdvice(new ThrowsAdvice1());

		TargetService proxy = (TargetService) proxyFactory.getProxy();
		proxy.test();
	}
}

  • Advisor

    advisor是有一个Pointcut和一个Advice组成的，通过Pointcut可以指定要需要被代理的逻辑，可以通过Advisor，来控制到具体代理哪一个方法
    // PointcutAdvisor
public class NingPointcutAdvisor implements PointcutAdvisor  {
	@Override
	// 得到一个Advice
	public Advice getAdvice() {
		return new MethodInterceptor() {
			@Nullable
			@Override
			public Object invoke(@NotNull MethodInvocation invocation) throws Throwable {
				System.out.println("before method");
				Object proceed = invocation.proceed();
				System.out.println("after method");
				return proceed;
			}
		};
	}
	
	@Override
	// 只有匹配成功的Target Class才可以执行上述Advice方法逻辑，这个方法就是定义匹配逻辑的
	public Pointcut getPointcut() {
		return new StaticMethodMatcherPointcut() {
			@Override
			public boolean matches(Method method, Class<?> targetClass) {
				return targetClass.equals(TargetService.class);
			}
		};
	}
	
	// 暂时先不关注此方法
	@Override
	public boolean isPerInstance() {
		return false;
	}
}

  • ProxyFactoryBean

    我们希望ProxyFactory所产生的代理对象能直接就是Bean，能直接从Spring容器中得到目标类的代理对象，我们可以通过ProxyFactoryBean把某一个目标类直接注册为Spring Bean, 也就只能针对一个Bean
    //ProxyFactoryBean， 可以在AppConfig中做如下配置
@Bean
public ProxyFactoryBean userServiceProxy(){
	TargetService targetService = new TargetService();

	ProxyFactoryBean proxyFactoryBean = new ProxyFactoryBean();
	proxyFactoryBean.setTarget(targetService);
	proxyFactoryBean.addAdvice(new MethodInterceptor() {
		@Override
		public Object invoke(MethodInvocation invocation) throws Throwable {
			System.out.println("before...");
			Object result = invocation.proceed();
			System.out.println("after...");
			return result;
		}
	});
	return proxyFactoryBean;
}

  • BeanNameAutoProxyCreator

    ProxyFactoryBean得自己指定被代理的对象，那么我们可以通过BeanNameAutoProxyCreator来通过指定某个bean的名字，来对该bean进行代理
    //BeanNameAutoProxyCreator， 可以在AppConfig中做如下配置
@Bean
public BeanNameAutoProxyCreator beanNameAutoProxyCreator() {
	BeanNameAutoProxyCreator beanNameAutoProxyCreator = new BeanNameAutoProxyCreator();
	 // 可以用*做模糊匹配，如这所示会匹配到所有以‘target’开头的Bean
	beanNameAutoProxyCreator.setBeanNames("target*");
	// 根据beanName去Spring容器中找到这个Advice
	beanNameAutoProxyCreator.setInterceptorNames("aroundAdvice1");
	beanNameAutoProxyCreator.setProxyTargetClass(true);

    return beanNameAutoProxyCreator;
}

  • DefaultAdvisorAutoProxyCreator

    通过DefaultAdvisorAutoProxyCreator会直接去找所有Advisor类型的Bean，根据Advisor中的PointCut和Advice信息，确定要代理的Bean以及代理逻辑。
    // DefaultAdvisorAutoProxyCreator,可以在AppConfig中做如下配置
@Bean
public DefaultPointcutAdvisor defaultPointcutAdvisor(){
	NameMatchMethodPointcut pointcut = new NameMatchMethodPointcut();
	pointcut.addMethodName("test");
	DefaultPointcutAdvisor defaultPointcutAdvisor = new DefaultPointcutAdvisor();
	defaultPointcutAdvisor.setPointcut(pointcut);
	defaultPointcutAdvisor.setAdvice(new AfterAdvice1());

	return defaultPointcutAdvisor;
}

@Bean
public DefaultAdvisorAutoProxyCreator defaultAdvisorAutoProxyCreator() {
	return new DefaultAdvisorAutoProxyCreator();
}

总结，通过上述Spring中代理的一些认识，可以了解到可以利用代理来对Bean进行在类外部进行类的曾强，其实Spring AOP也运用了这些来实现的

Spring AOP 基础概念

  • Aspect：表示切面，比如被@Aspect注解的类就是切面，可以在切面中去定义Pointcut、Advice等
  • Join point：表示连接点，表示一个程序在执行过程中的一个点，比如一个方法的执行，比如一个异常的处理，在Spring AOP中，一个连接点通常表示一个方法的执行。
  • Advice：表示通知，表示在一个特定连接点上所采取的动作，在很多AOP框架中，包括Spring，会用Interceptor拦截器来实现Advice，
  • Pointcut：表示切点，用来匹配一个或多个连接点。
  • Introduction：可以使用@DeclareParents来给所匹配的类添加一个接口，并指定一个默认实现
  • Target object：目标对象，被代理对象

Spring AOP 关键点解析

@EnableAspectJAutoProxy ，Spring AOP应用的起点。

会在启动类上放入这个注解，它的作用是去注册一个AnnotationAwareAspectJAutoProxyCreator类型的Bean，这个Bean本质上是一个BeanPostProcess, 这样在Bean生命周期的过程中在初始化后去执行wrapIfNecessary(),生成成代理Bean。

AnnotationAwareAspectJAutoProxyCreator类图：
在这里插入图片描述

ProxyFactory 生成代理对象

在上述AnnotationAwareAspectJAutoProxyCreator ->postProcessAfterInitialization() -> wrapIfNecessary() 的方法中会给符合的Bean去生成代理对象，用的就是ProxyFactory。

wrapIfNecessary方法的简单流程图：在这里插入图片描述

在文章最开始的时候就介绍了PoxyFactory可以自动选择是用Cglib还是JDK动态代理去生成代理对象，那么我们从源码来看一下它是怎么做选择的。
如下所示为PoxyFactory核心判断代码


	public AopProxy createAopProxy(AdvisedSupport config) throws AopConfigException {
		// NativeDetector.inNativeImage()是不是在GraalVM虚拟机上运行
		// isOptimize 是个标记字段，如果ProxyFactory的isOptimize为true，Spring认为cglib比jdk动态代理要快，早期的JDK，现在不一定了
		// hasNoUserSuppliedProxyInterfaces 判断被代理对象是否实现接口，
		if (!NativeDetector.inNativeImage() &&
				(config.isOptimize() || config.isProxyTargetClass() || hasNoUserSuppliedProxyInterfaces(config))) {

			Class<?> targetClass = config.getTargetClass();
			if (targetClass == null) {
				throw new AopConfigException("TargetSource cannot determine target class: " +
						"Either an interface or a target is required for proxy creation.");
			}
			if (targetClass.isInterface() || Proxy.isProxyClass(targetClass)) {
				return new JdkDynamicAopProxy(config);
			}
			return new ObjenesisCglibAopProxy(config);
		}
		else {
			return new JdkDynamicAopProxy(config);
		}
	}

//未完待续。。。。。。

在wrapIfNecessary()方法中会从Spring容器查找到所有的advisor，那么这些advisor是什么时候放入到容器中的呢？？？？

Spring AOP中代理对象的执行???

  • @Before：AspectJMethodBeforeAdvice，实际上就是一个MethodBeforeAdvice
  • @AfterReturning：AspectJAfterReturningAdvice，实际上就是一个AfterReturningAdvice
  • @AfterThrowing：AspectJAfterThrowingAdvice，实际上就是一个MethodInterceptor
  • @After：AspectJAfterAdvice，实际上就是一个MethodInterceptor
  • @Around：AspectJAroundAdvice，实际上就是一个MethodInterceptor
代理对象的执行过程
  1. 在使用ProxyFactory创建代理对象之前，需要往ProxyFactory先添加Advisor
  2. 代理对象在执行某个方法时，会把ProxyFactory中的Advisor拿出来和当前正在执行的方法进行匹配筛选
  3. 把和方法所匹配的Advisor适配成MethodInterceptor
  4. 把和当前方法匹配的MethodInterceptor链，以及被代理对象、代理对象、代理类、当前Method对象、方法参数封装为MethodInvocation对象
  5. 调用MethodInvocation的proceed()方法，开始执行各个MethodInterceptor以及被代理对象的对应方法
  6. 按顺序调用每个MethodInterceptor的invoke()方法，并且会把MethodInvocation对象传入invoke()方法
  7. 直到执行完最后一个MethodInterceptor了，就会调用invokeJoinpoint()方法，从而执行被代理对象的当前方法
SpringAOP学习笔记
01-27
全称:面向切面编程(AspectOrientedProgramming),通过预编译方式和运行期动态代理实现程序功能的统一维护的一种技术。AOP是OOP的延续，是软件开发中的一个热点，也是Spring框架中的一个重要内容，是函数式编程的一种...
spring aop 学习笔记
05-27
本学习笔记将深入探讨Spring AOP的核心概念、工作原理以及实际应用。 1. **核心概念** - **切面（Aspect）**：切面是关注点的模块化，包含业务逻辑之外的横切关注点，如日志、事务管理。 - **连接点（Join Point...
SpringAop学习笔记
2301_77207909的博客
10-19 1227
SpringAop学习笔记,包括代理模式，静态和动态代理，aop的概念详解，执行流程，使用情况，使用方法
【Spring】Spring AOP底层原理：JDK动态代理和CGLIB动态代理
m0_65277261的博客
05-27 1995
Spring AOP 的实现原理是基于动态代理和字节码操作的。而动态代理是基于反射机制的。 在编译时， Spring 会使用 AspectJ 编译器将切面代码编译成字节码文件。在运行时， Spring 会使用 Java 动态代理或 CGLIB 代理生成代理类，这些代理类会在目标对象方法执行前后插入切面代码，从而实现AOP的功能。
Spring AOP学习笔记
小吴
08-05 723
AOP的全称是Aspect Oriented Programming，即面向切面编程。和OOP不同，AOP主张将程序中相同的业务逻辑进行横向隔离，并将重复的业务逻辑抽取到一个独立的模块中，以达到提高程序可重用性和开发效率的目的。在传统的业务处理代码中，通常都会进行事务处理、日志记录等操作。虽然使用OOP可以通过组合或者继承的方式来达到代码的重用，但如果要实现某个功能（如日志记录），同样的代码仍然会分散到各个方法中。未使用AOP的面向切面编程案例。
学习笔记——Spring(二)AOP和动态代理
qq_46107726的博客
12-18 960
文章目录AOP什么是AOP动态代理引入1.对实现类进行修改添加功能需要修改大量源码,不利已开发例子和源码分析底层的个人理解：反射的理解：底层原理AOP术语AOP操作基础AspectJ基于AspectJ实现AOP操作切入点表达式AOP注解操作AOP 操作（AspectJ 配置文件) AOP 什么是AOP (1)面向切面编程，通过预编译方式和运行期动态代理实现程序功能的统一维护的一种技术。AOP是OOP的延续，是软件开发中的一个热点，也是Spring框架中的一个重要内容，是函数式编程的一种衍生范型。利用AOP可
Spring Aop学习笔记
weixin_42082191的博客
05-03 575
在学习AOP之前我们先提出几个问题？ AOP是什么？ AOP优点是什么？ AOP组成结构？ AOP实现原理？ AOP是什么 在软件业，AOP为Aspect Oriented Programming的缩写，意为：面向切面编程，可以通过预编译方式和运行其动态代理实现在不修改源代码的情况下给程序动态统一添加某种特定功能的一种技术。在springAop表现中就是对某一类型的方法进行拦截处理。 AOP优点是什么？ 使用面向对象编程（OOP）有一些弊端，当需要为多个不具有继承关系的对象引入同一个公共行为时，例如日志
Spring API 接口和自定义类来实现AOP（Spring学习笔记十）
weixin_59096327的博客
03-30 542
全称是 Aspect Oriented Programming 即：面向切面编程。是OOP（面向对象编程）的延续，也是Spring框架中的一个重要内容，是函数式编程的一种衍生泛型。简单的说他就是把我们程序重复的代码抽取出来，在需要执行的时候使用动态代理技术在不修改源码的基础上，对我们的已有方法进行增强。AOC在Spring中的作用创建自定义类和方法System.out.println("====切面之前执行====");System.out.println("====切面之后执行====");
【学习笔记】Spring中的动态代理
zuzhiang的博客
09-13 1672
本文参考了文章Spring AOP动态代理的实现方式和文章Spring中的动态代理。 1. 动态代理的两种实现方式 (1) 两种动态代理 Spring中的AOP（面向切面编程）是基于动态代理技术实现的，而动态代理是基于反射设计的。动态代理的实现方式有2种：JDK动态代理和CGLIB动态代理。 JDK动态代理：通过反射来接收被代理的类，并且要求被代理的类必须实现一个接口，核心是InvocationHandler接口和Proxy类 CGLIB（Code Generation Library）动态代理：CGLI
Spring学习笔记——AOP篇
qq_53149124的博客
08-12 1087
除了spring的几个基础包外还需要导入aspectjweaver，下面是maven导入的配置信息 常用名词 名词 解释 连接点 可以被增强的方法 切入点 实际被增强的方法。切入点就是被增强的连接点 通知 增强的逻辑实现 切面 通知和切入点的组合 常用的通知类型 类型 解释 前置通知 在被增强方法之前执行的逻辑部分 后置通知 在被增强方法之后执行的逻辑部分，如果被增强方法出现异常就不会执行了 环绕通知 在被增强方法之前和之后执行的逻辑部分 异常通知
15. Spring AOP 的实现原理 & 代理模式
qq_58969626的博客
07-31 1234
代理模式分为静态代理和动态代理。Spring AOP 支持 JDK Proxy 和 CGLIB 方式实现动态代理。默认情况下，实现了接口的类，使用 AOP 会基于 JDK 生成代理类；没有实现接口的类，会基于 CGLIB 生成代理类。
Spring学习笔记：AOP
qq_49019244的博客
02-20 992
学习内容：AOP 一、什么是AOP 当我们操作某些数据的时候，一般检验用户的权限，并且操作完数据后记录日志，按照正常的逻辑，我们可以这么做： 但是对数据的每一个操作都得检验权限和记录日志，不仅代码重复，而且也是非常的麻烦。我们可以把这些公共部分写入一个方法，每次操作数据需要检验和记录日志的时候，调用这个方法就行了： 虽然代码重复的问题解决了，但是，每个用户操作数据总得要调用这个方法吧。于是就有了切面的概念，我将方法注入到调用的某个地方（切点）。 二、AOP中的相关概念 术语 概念 A
Spring Aop 学习笔记
03-25
Spring Aop 学习笔记
SpringAop学习笔记以及实现Demo
06-17
**Spring AOP 学习笔记及实现Demo** Spring AOP（Aspect Oriented Programming，面向切面编程）是Spring框架中的一个重要组成部分，它提供了一种在不修改源代码的情况下，对程序进行功能增强的技术。AOP的主要目的...
SpEL（Spring Expression Language）入门指南
kersixy的博客
11-05 666
SpEL（Spring Expression Language）是 Spring 框架提供的一个强大的表达式语言，用于在运行时查询和操作对象图。它类似于 JSP EL（JavaServer Pages Expression Language）和 OGNL（Object-Graph Navigation Language），但在功能上更为丰富和强大。
SpringMVC入门详解
ning的博客
11-02 791
SpringMVC是一个基于Java的实现了MVC设计模式的Web框架，它通过将Web层进行模块化，使得Web应用程序的开发变得更加灵活和可维护。简化开发：通过注解的方式简化了配置，减少了代码量。强大的集成能力：可以很容易地与其他Spring模块集成。灵活的配置：支持零配置启动，也支持通过XML或Java配置进行详细配置。可重用性高：可以轻松地将一个项目中的代码重用到另一个项目中。
后端SpringBoot及vue proxyTable解决跨域
最新发布
qq_42059717的博客
11-06 192
昨天上线项目遇到了一个奇怪的问题，本来服务实在腾讯云的轻量应用服务器的，但是迁移到一个香港的服务器之后就出现了各种各样的问题。Nginx 开启Https Springboot开启Https，先后出现了噔噔蹬蹬但是我其实已经部署了一个项目了的，那个用的proxyTable,新部署的这个用的是里边的env控制的。后来改成proxyTable就好了。
Spring中@Autowired@Resource和@Inject注解区别
2401_87333857的博客
11-06 365
同时，它默认是采用byType装配，当指定了1SR-330规范中的@Named注解之后，变成byName装配。它也可以出现在方法上，构造函数上和字段上但是需要注意的是:因为IRE无法决定构造方法注入的优先级，所以规范中规定类中只能有一个构造方法带@Inject注解。@Autowired:来源于spring框架自身默认是byType自动装配，当配合了@Qualifier注解之后，在没有指定name属性时是byType自动装配，当指定了name属性之后，采用byName方式自动装配。
Spring学习笔记：从基础到AOP的全面整理
"这是一份关于Spring框架的学习笔记，涵盖了Spring的核心概念和主要特性，包括模块切换、属性注入、自定义属性编辑器、初始化和销毁方法、自动装配、动态代理以及面向切面编程（AOP）等内容。笔记分为13个章节，详细...
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值