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

<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>