加快织入的自动化进程---DefaultAdvisorAutoProxyCreator

秒速五厘米 2022-08-14 00:46 183阅读 0赞

<span style="font-size:18px;">加快织入的自动化进程
      在IoC容器中使用ProxyFactoryBean进行横切逻辑的织入固然不错，但是我们都是针对每个目标对象，然后给出它们各自所对应ProxyFactoryBean配置。
      如果目标对象就那几个，那还应付的过来。但系统中那么多的业务对象可能都是目标对象，如果还用ProxyFactoryBean一个个的进行配置，估计会很累
      所以得寻求更加快捷的方式.SpringAOP给出了自动代理（AutoProxy）机制，用以帮助我们解决ProxyFactoryBean的配置工作量较大的问题。
      Spring AOP的自动代理的实现建立在IOC容器的BeanPostProcessor概念之上，通过BeanPostProcessor，可以在遍历容器中所有bean的基础上，对遍历到
      的bean进行一些操作。根据这个BeanPostProcessor内部实现逻辑，即当对象实例化的时候不，为其生成代理对象并返回，从而达到代理对象自动生成目的。
      
      可用的AutoProxyCreator
      Spring AOP 在org.springframework.aop.framework.autoproxy包中提供了两个常用的AutoProxyCreator，即BeanNameAutoProxyCreator 和  DefaultAdvisorAutoProxyCreator
      
      这里主要来介绍下DefaultAdvisorAutoProxyCreator。
      DefaultAdvisorAutoProxy可以算是全自动的，我们只需要在ApplicationContext的配置文件中注册一个DefaultAdvisorAutoProxy的bean定义就可以了，剩下的事情由
      DefaultAdvisorAutoProxy全部搞定。下面来展示一个具体的实现例子
      
      ICounter接口定义及相关具体实现类
      public interface ICounter {
    
    	void resetCounter();
    	int getCounter();
     }
     
     ICounter有两个实现类ICounterImpl1和ICounterImpl2
     
     public class CounterImpl 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;
    	}
    }
    
    ITask接口定义及相关实现类
    public interface ITask {
    	void execute();
    }
    
    ITask也有两个实现类 MockTask 和 FakeTask
    
    public class MockTask implements ITask{
    	@Override
    	public void execute() {
    		// TODO Auto-generated method stub
    		System.out.println("taskmock executed");
    	}
    }
    
    public class FakeTask implements ITask{
    	@Override
    	public void execute() {
    		// TODO Auto-generated method stub
    		System.out.println(" facktask executed");
    	}
    }
    
    我还自定义了一个简单的拦截类PerformanceMethodInterceptor，可以应用到具体的类或其方法中
    
    public class PerformanceMethodInterceptor implements MethodInterceptor{
    	@Override
    	public Object invoke(MethodInvocation invocation) throws Throwable {
    		System.out.println("start.....");//相当于beforeAvice
    		Object returnVal=invocation.proceed();
    		System.out.println("stop....");//相当于AfterAdvice
    		return returnVal;
    	}
    }
    
    DefaultAdvisorAutoProxyCreator的使用配置示例
    <?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>
    
    
      将DefaultAdvisorAutoProxyCreator注册到容器后，它就会自动搜寻容器类所有Advisor，然后根据各个Advisor所提供的拦截信息,
      为符合条件的容器中的目标对象生成相应的代理对象。注意DefaultAdvisorAutoProxyCreator只对Advisor有效，因为只有Advisor
      才既有Pointcut信息以捕捉符合条件的目标对象,又有相应的Advice。
      使用DefaultAdvisorAutoProxyCreator对容器内所有bean定义对应的对象进行自动代理之后,我们从容器中取得对象实例，就都是代理
      后已经包含了织入的横切逻辑的代理对象了，除非该对象不符合Pointcut规定的拦截条件。
      
      建立一个测试类如下
      
      public class AutoProxyCreaterTest {
    	@Test
    	public void test() {
    		ApplicationContext ctx=new ClassPathXmlApplicationContext("/beans1.xml");
    		ITask task1=(ITask) ctx.getBean("mockTask");
    		task1.execute();
    		ITask task2=(ITask) ctx.getBean("fakeTask");
    		task2.execute();
    		ICounter counter1=(ICounter) ctx.getBean("counterImpl1");
    		System.out.println(counter1.getCounter());
    		ICounter counter2=(ICounter)ctx.getBean("counterImpl1");
    		System.out.println(counter2.getCounter());
    		ICounter counter3=(ICounter)ctx.getBean("counterImpl2");
    		System.out.println(counter3.getCounter());
    	}
    }
    
    输出的结果如下：
    start.....
    task executed
    stop....
    
    start.....
     facktask executed
    stop....
    
    start.....
    stop....
    1
    
    start.....
    stop....
    2
    
    start.....
    stop....
    -1
    
    从结果可以看出每个对象都被加上了横切逻辑
    所以这里  ITask task1=(ITask) ctx.getBean("mockTask");这些返回的都不是目标对象本身而是被织入了横切逻辑的对象。
    通过自己动手实践，我基本上就了解了DefaultAdvisorAutoProxy的用法了。
    真的是动手实践很重要很重要.
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    </span>