Spring AOP实现机制（二）--ProxyFactoryBean---将Spring AOP和Spring IoC容器相结合

最新推荐文章于 2022-07-21 00:16:47 发布
最新推荐文章于 2022-07-21 00:16:47 发布
阅读量993 收藏
点赞数
分类专栏： Spring 文章标签： Spring AOP ProxyFactoryBean
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/cwzhsi/article/details/41221819
版权 
<span style="font-size:18px;">Spring AOP的织入，在Spring AOP 中，使用类org.springframework.aop.framework.ProxyFactory作为织入器
  为ProxyFactory提供必要的“生产原材料后”，ProxyFactory会返回那个织入完成的代理对象,使用ProxyFactory只需要制定如下两个最基本的东西
  第一个是要对其进行织入的目标对象，可以通过ProxyFactory的构造方法直接传入,也可以在ProxyFactory构造完成之后，通过相应的setter方法进行设置
  第二个是将要应用到目标对象的Aspect。在spring里面叫做Advisor，除了指定相应的Advisor之外，还可以直接指定各种类型的Advice()   weaver.addAdvice(...);
  
  下面是我自己写的一个小例子
  public interface ISomeBean {
	public void doSth();
  }
  
  public class ISomeBeanImpl implements ISomeBean{
	@Override
	public void doSth() {
		System.out.println("do something");
	}
 }
 
 有了要拦截的目标类，还得有织入到Joinpoint处的横切逻辑，也就是要用到某个Advice实现
  public class PerformanceMethodInterceptor implements MethodInterceptor{
	@Override
	public Object invoke(MethodInvocation invocation) throws Throwable {
		// TODO Auto-generated method stub
		System.out.println("you must overcome the obstacle hiding in yor heart");
		return invocation.proceed();
	}
 }
 
  有了这些，我们来看一下使用ProxyFactory对实现了ISomeBean接口的目标类，以及没有实现任何接口的目标类如何进行处理
  (1)基于借口的代理
   ISomeBeanImpl somebean=new ISomeBeanImpl();
	ProxyFactory proxy=new ProxyFactory(somebean);
	proxy.setProxyTargetClass(true);//强制ProxyFactory采用基于类的代理
	proxy.setInterfaces(new Class[]{ISomeBean.class});//告诉ProxyFactory要对ISomeBean接口进行代理
	NameMatchMethodPointcutAdvisor advisor=new NameMatchMethodPointcutAdvisor();
	advisor.setMappedName("doSth");
	advisor.setAdvice(new PerformanceMethodInterceptor());
	proxy.addAdvisor(advisor);
	ISomeBean proxyObject=(ISomeBean) proxy.getProxy();
	proxyObject.doSth();
	System.out.println(proxyObject.getClass());
	
	(2)基于类的代理
	如果目标类没有实现任何接口,默认情况下，ProxyFactory会对目标类进行基于类的代理，即使用CGLIB,
	假设我们现在有如下的类:
	public class Executable {
	public void execute(){
		System.out.println("Executable without any Interfaces");
	}
  }
  
  /**
	 * 如果使用Executable作为目标对象，那么ProxyFactory就会对其进行基于类的代理，下面的代码演示了使用ProxyFactory对Executable进行织入的过程.
	 */
	ProxyFactory proxy1=new ProxyFactory(new Executable());
	NameMatchMethodPointcutAdvisor advisor1=new NameMatchMethodPointcutAdvisor();
	advisor1.setMappedName("execute");
	advisor1.setAdvice(new PerformanceMethodInterceptor());
	proxy1.addAdvisor(advisor1);
	Executable proxyObject1=(Executable) proxy1.getProxy();
	proxyObject1.execute();
	System.out.println(proxyObject1.getClass());
	
	输出结果如下：
	Executable without any Interfaces
    class aop.spring.advice.Executable$$EnhancerByCGLIB$$decfdbd3
	
	可以看出最终的代理对象是基于CGLIB的
	
	即使目标对象至少实现了一个接口，我们也可以通过proxyTargetClass属性强制ProxyFactory采用基于类的代理
	总的来说，如果满足下列三种情况中的任何一种，ProxyFactory将对目标对象进行基于类的代理
	如果目标对象没有实现任何接口，不管proxyTargetClass的值是什么，都会采用基于类代理
	如果ProxyFactory的proxyTargetClass属性值被设置为true，ProxyFactory会采用基于类的代理
	如果ProxyFactory的optimize属性值被设置为true，ProxyFactory会采用基于类的代理
 
  
  容器中的织入器----ProxyFactoryBean
  虽然使用ProxyFactory，可以让我们能够独立于Spring的IoC容器之外来使用Spring的AOP支持,但是，将Spring AOP和Spring的IoC容器
  支持相结合，才是发挥Spring AOP更大作用的最佳途径。通过Spring的IOC容器，我们可以在容器中对Pointcut和Advice等进行管理，即
  使他们依赖于其他业务对象，也可以很容易注入其中
  
  
  ProxyFactoryBean的本质是一个用来生产Proxy的FactoryBean.IoC容器中的FactoryBean，如果容器中的某个对象持有某个FactoryBean的
  引用，它取得的不是FactoryBean本身，而是FactoryBean.getObject()方法所返回的对象
  
  下面是我写的一个小程序
  public interface ISomeBean {
	public void doSth();
  } 
  public class ISomeBeanImpl implements ISomeBean{
	@Override
	public void doSth() {
		System.out.println("do something");
	}
 } 
 
 public interface IOtherBean {
	public void doOther();
}

public class SomeBeanIntroductionInterceptor implements IOtherBean,IntroductionInterceptor{
	/**
	 * 判断调用的方法是否为指定类中的方法
	 * 如果Method代表了一个方法 那么调用它的invoke就相当于执行了它代表的这个方法
	 */
	@Override
	public Object invoke(MethodInvocation invocation) throws Throwable {
		if(implementsInterface(invocation.getMethod().getDeclaringClass())){
			System.out.println("zhangsi");
			return invocation.getMethod().invoke(this, invocation.getArguments());
		}
		return invocation.proceed();
	}
	/**
	 * 判断clazz是否为给定接口IOtherBean的实现
	 */
	@Override
	public boolean implementsInterface(Class clazz) {
		return clazz.isAssignableFrom(IOtherBean.class);
	}
	@Override
	public void doOther() {
		System.out.println("do other thing");
	}
}

配置文件如下，<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
	xmlns:context="http://www.springframework.org/schema/context" xmlns:tx="http://www.springframework.org/schema/tx"
	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
        http://www.springframework.org/schema/context
        http://www.springframework.org/schema/context/spring-context-2.5.xsd
        http://www.springframework.org/schema/tx
         http://www.springframework.org/schema/tx/spring-tx-2.5.xsd">
	<!-- 目标对象 -->
	<bean id="someBeanTarget" class="com.spring.targetImpl.ISomeBeanImpl" />

	<!-- 通知 -->
	<bean id="someBeanAdvice" class="aop.spring.advice.SomeBeanIntroductionInterceptor"></bean>

	<!-- 通知者，只能以构造器方法注入 -->
	<!-- DefaultIntroductionAdvisor(Advice advice, IntroductionInfo introductionInfo) -->
	<!-- introductionInfo - the IntroductionInfo that describes the interface 
		to introduce (may be null) -->
	<bean id="introductionAdvisor"
		class="org.springframework.aop.support.DefaultIntroductionAdvisor">
		<constructor-arg ref="someBeanAdvice" />
		<constructor-arg value="aop.spring.target.IOtherBean" />
	</bean>

	<!-- 代理，将我们的切面织入到目标对象 -->
	<bean id="someBeanProxy" class="org.springframework.aop.framework.ProxyFactoryBean">

		<!-- 若目标对象实现了代理接口，则可以提供代理接口的配置 -->
		<property name="proxyInterfaces" value="aop.spring.target.ISomeBean" />

		<!-- 配置目标对象 -->
		<property name="target" ref="someBeanTarget" />

		<!-- 配置切面 -->
		<property name="interceptorNames">
			<list>
				<value>introductionAdvisor</value>
			</list>
		</property>
	</bean>
</beans>

 测试代码：
    AbstractApplicationContext ctx=new ClassPathXmlApplicationContext("/beans.xml");
	/**
	 * 将代理对象强制转换为目标对象的具体类型
	 */
	ISomeBean weaver=(ISomeBean) ctx.getBean("someBeanProxy");
	weaver.doSth();
	System.out.println("=====");
	((IOtherBean)weaver).doOther(); 
	

   ProxyFactoryBean的改进-----加快织入的自动化进程
   在IoC容器中使用ProxyFactoryBean进行横切逻辑织入固然不错，但是，我们都是针对每个目标对象，然后给出它们对应的ProxyFactoryBean的配置。如果
   目标对象就那么几个，还应付的过来，但是系统中那么多的业务对象都可能是目标对象，这样实现起来就是有问难的。
    Spring AOP中给出了自动代理机制，用以帮助我们解决使用ProxyFactoryBean配置工作量比较大的问题

    比如常用的一个AutoProxyCreator类DefaultAdvisorAutoProxyCreator
    DefaultAdvisorAutoProxyCreator注册到容器后，它会自动搜寻容器内的所有的Advisor,然后根据各个Advisor所提供动的拦截信息，
	为符合条件的容器中的目标对象生成相应的代理对象。注意，DefaultAdvisorAutoProxyCreator只对Advisor有效，因为只有Advisor才既有Pointcut信息以捕捉
	符合条件的目标对象，又有相应的Advice。使用DefaultAdvisorAutoProxyCreator对容器内所有的bean定义对应的对象进行自动代理后，我们从容器中取得的实例
	就都是已经包含了织入横切逻辑的代理对象。
	 
	一个实现的小程序如下：
	public interface ICounter {
	void resetCounter();
	int getCounter();
   }
   
   public class CounterImpl1 implements ICounter {
	private int counter;
	@Override
	public void resetCounter() {
		// TODO Auto-generated method stub
		counter = 0;
	}
	@Override
	public int getCounter() {
		// TODO Auto-generated method stub
		counter++;
		return counter;
	}
  } 
  
  public class CounterImpl2 implements ICounter{
	private int counter;
	@Override
	public void resetCounter() {
		// TODO Auto-generated method stub
		counter=10;
	}
	@Override
	public int getCounter() {
		// TODO Auto-generated method stub
		counter--;
		return counter;
	}
  }
  
  public interface ITask {
	void execute();
 }
 public class FakeTask implements ITask{
	@Override
	public void execute() {
		// TODO Auto-generated method stub
		System.out.println(" facktask executed");
	}
 }
 
 public class MockTask implements ITask{
	@Override
	public void execute() {
		// TODO Auto-generated method stub
		System.out.println("task executed");
	}
 }
 
 配置文件如下：
 <?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
	xmlns:context="http://www.springframework.org/schema/context" xmlns:tx="http://www.springframework.org/schema/tx"
	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
        http://www.springframework.org/schema/context
        http://www.springframework.org/schema/context/spring-context-2.5.xsd
        http://www.springframework.org/schema/tx
         http://www.springframework.org/schema/tx/spring-tx-2.5.xsd">

	<bean
		class="org.springframework.aop.framework.autoproxy.DefaultAdvisorAutoProxyCreator"></bean>
	<bean id="counterImpl1" class="aop.spring.deleIntroduction.CounterImpl1"></bean>
	<bean id="counterImpl2" class="aop.spring.deleIntroduction.CounterImpl2"></bean>

	<bean id="mockTask" class="aop.spring.deleIntroduction.MockTask"></bean>
	<bean id="fakeTask" class="aop.spring.deleIntroduction.FakeTask"></bean>


	<bean name="pointcut"
		class="org.springframework.aop.support.NameMatchMethodPointcut">
		<property name="mappedName" value="execute"></property>
	</bean>
	<!-- 有多个方法时 -->
	<bean name="pointcut2" class="org.springframework.aop.support.NameMatchMethodPointcut">
		<property name="mappedNames">
		<list>
		<value>resetCounter</value>
		<value>getCounter</value>
		</list>
		</property>
	</bean>

	<bean id="logAdvisor1" class="org.springframework.aop.support.DefaultPointcutAdvisor">
		<property name="pointcut" ref="pointcut"></property>
		<property name="advice">
			<bean id="performaceInterceptor1"
				class="aop.spring.deleIntroduction.PerformanceMethodInterceptor">
			</bean>
		</property>
	</bean>


	<bean id="logAdvisor2" class="org.springframework.aop.support.DefaultPointcutAdvisor">
		<property name="pointcut" ref="pointcut2"></property>
		<property name="advice">
			<bean id="performaceInterceptor2" class="aop.spring.deleIntroduction.PerformanceMethodInterceptor"></bean>
		</property>
	</bean>
</beans>


测试代码如下：
public class AutoProxyCreaterTest {
	@Test
	public void test() {
		ApplicationContext ctx=new ClassPathXmlApplicationContext("/beans1.xml");
		ITask task1=(ITask) ctx.getBean("mockTask");
		task1.execute();
		System.out.println();
		ITask task2=(ITask) ctx.getBean("fakeTask");
		task2.execute();
		System.out.println();
		ICounter counter1=(ICounter) ctx.getBean("counterImpl1");
		System.out.println(counter1.getCounter());
		System.out.println();
		ICounter counter2=(ICounter)ctx.getBean("counterImpl1");
		System.out.println(counter2.getCounter());
		System.out.println();
		ICounter counter3=(ICounter)ctx.getBean("counterImpl2");
		System.out.println(counter3.getCounter());
		System.out.println();
	}
 }
 
 输出结果如下：
 start.....
task executed
stop....

start.....
 facktask executed
stop....

start.....
stop....
1

start.....
stop....
2

start.....
stop....
-1
</span>

上面内容中都要区分Introduction类型的Advice ,我特别对Introduction进行了实现，有专门关于Introduction的博客。接下来时Spring AOP的第三种实现机制。。。。。。

What do you want ?

cwzhsi
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Spring-AOP实现：基于ProxyFactoryBean
qq_43290295的博客
02-26 282
基于代理类的AOP实现 方式：org.springframework.aop.framework.ProxyFactoryBean创建代理 Spring的通知类型： 1.环绕通知 实现org.aopalliance.intercept.MethodInterceptor接口 在目标方法执行前和执行后实施增强。 2.前置通知 实现org.springframework.aop.MethodBefo...
Spring基础-AOP之ProxyFactoryBean及相关内容（五）
飞鸟的轨迹
02-23 295
ProxyFactoryBean 创建Spring AOP代理的基本方法是使用org.springframework.aop.framework.ProxyFactoryBean 这可以完全控制切入点和通知（advice）以及他们的顺序 使用ProxyFactoryBean或者其他IOC相关类来创建AOP代理的最重要好处是通知和切入点也可以由IOC来管理 被代理类没有实现任何接口，使用CGLI...
Spring -- org.springframework.aop.framework.ProxyFactoryBean
GP的空间
06-12 4291
配置<?xml version="1.0" encoding="UTF-8"?> <beans xmlns="http://www.springframework.org/schema/beans" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:aop="http://www.springframework.org/s
Spring系列第33篇：ProxyFactoryBean创建AOP代理
路人甲Java
06-27 2049
Aop相关阅读阅读本文之前，需要先掌握下面3篇文章内容，不然会比较吃力。Spring系列第15篇：代理详解（java动态代理&CGLIB代理)Spring系列第30篇：jdk动态...
Spring AOP自动创建代理 和 ProxyFactoryBean创建代理
想好了就去做吧 即便失败了 至少这条路上留下了你的脚印
07-29 613
Advice 通知类型 AOP按照通知Advice在目标方法的连接点位置，可以分为5种通知类型 前置通知 org.springframework.aop.MethodBeforeAdvice ： 在Joinpoint（连接点 / 目标方法）执行之前进行增强（通知） 后置通知 org.springframework.aop.AfterReturningAdvice ： 在Joinp...
spring-framework-5.3.29.tar.gz
最新发布
08-31
例如，`org.springframework.beans`包主要处理Bean的创建和管理，`org.springframework.context`包实现了IoC容器，而`org.springframework.aop`则包含AOP相关的类和接口。通过对这些源码的阅读和分析，开发者可以更...
spring-framework-5.1.x-源碼解析详细注解
09-22
Spring Framework作为Java开发中的核心框架，其设计理念和实现机制对理解企业级应用的构建至关重要。本资源提供了Spring 5.1.x版本的源码详细注解，旨在帮助开发者深入理解Spring框架的核心功能，包括IOC（Inversion...
spring-framework-5.2.0.RELEASE-master.zip
10-19
在源码中，`org.springframework.aop`和`org.springframework.aop.framework`包下的类，如`AspectJExpressionPointcut`、`AdvisedSupport`和`ProxyFactoryBean`等，是用来实现AOP的关键。 **源码注释**： 这个...
spring-aop源码解读
05-02
ProxyFactoryBean是Spring AOP用于创建代理对象的主要工具，它实现了BeanFactoryAware、BeanClassLoaderAware和FactoryBean接口，使其能够利用IOC容器的功能来查找并应用Advice和目标对象。 配置和使用...
官方源码 spring-framework-5.3.3.zip
01-14
通过研读Spring Framework 5.3.3的源码，开发者可以深入理解IoC和AOP的设计模式，学习如何构建高度模块化和可扩展的系统，同时也能掌握Web开发的最佳实践，提升自身编程和架构设计能力。 总结，Spring Framework ...
做一个合格的程序猿之浅析Spring AOP源码（十四） 分析ProxyFactoryBean
BazingaLyncc
03-24 7559
最基本的实现有三个，AspectJProxyFactory.java ，ProxyFactory.java ProxyFactoryBean这三个，他们的父类ProxyCreatorSupport只是给了他们一些通用的AOP的实现，最为核心的就是怎么生成代理对象就是在该方法中实现的，如图ProxyCreatorSupport.java核心代码：
Spring AOP之ProxyFactoryBean与BeanNameAutoProxyCreator
小9的专栏
09-14 1409
spring AOP的几种模式
spring 直接使用ProxyFactoryBean 实现AOP 流程小结
u011385186的专栏
05-07 1958
<bean id="regexpAdvisor" class="org.springframework.aop.support.RegexpMethodPointcutAdvisor" p:advice-ref="testAOPAdvice"> com\.daodao\.mybatis\..* <bean
浅析代理bean 注入原理
rainful__的博客
03-20 906
大家不知道有没有好奇过各种spring框架中的神奇功能是怎么实现的，例如Feign 的接口，和Jpa 的接口，Spring 是如何驱动实现的呢。下面我来分析一下 在了解FeignClient 注解中发现，FeignClient 注解的接口都是Proxy 类。那到底是如何生成的呢？ spring在注入bean的时候，会根据容器中bean 的类型或者name 来匹配bean 的注入, 但是interf...
将spring ioc和aop结合
01-29 723
通过以下两篇文章，便可以自己做一个aop和ioc的结合，并通过xml文件进行动态的配置 Spring 的aop实现原理：http://blog.csdn.net/lr222584/article/details/54755031 自己写一个简单的Spring IOC容器：http://blog.csdn.net/lr222584/article/details/54744583 包结
《深入浅出Spring》SpringAOP 详解 ProxyFactoryBean
ysj_2021的博客
07-21 448
SpringAOP
死磕Spring AOP系列3：剖析Bean处理器之DefaultAdvisorAutoProxyCreator
weixin_33878457的博客
06-04 210
导航死磕Spring AOP系列1：编程式实现AOP 死磕Spring AOP系列2：剖析Bean处理器之BeanNameAutoProxyCreator这是<死磕Spring AOP系列>的第三篇。经过前面的讲解，已经掌握了以下知识点Spring AOP的底层支持，是基于ProxyFactory+ProxyConfig+Advisor生成的Spring容器的代...
Spring BeanNameAutoProxyCreator 与 ProxyFactoryBean区别
weixin_34278190的博客
03-31 151
一般我们可以使用ProxyBeanFactory，并配置proxyInterfaces,target和interceptorNames实现，但如果需要代理的bean很多，无疑会对spring配置文件的编写带来繁重的工作，这时就该BeanNameAutoProxyCreator出场了。 (一)ProxyFactoryBean属性介绍    target:代理的目标类proxyInterfa...
深入学习Java Spring代理模式AOP-IOC及实现方式
最后，为了帮助读者更好地理解和掌握Spring代理模式AOP-IOC相关知识，可以通过示例代码进行实践，从而更加深入地理解和应用这一重要的设计模式。 综上所述，Spring代理模式是一种非常重要的设计模式，在实际项目中...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值