spring---aop（9）---Spring AOP中引入增强

写在前面

　　Spring将introduction通知看作一种特殊类型的拦截通知。用Spring的行话来讲，对方法的增强叫做Wearing（织入），而对类的增强叫introduction（引入）。Introduction Advice（引入增强）就是对类的功能增强，它也是Spring AOP 提供的一种特殊增强。

一个简单的例子（以CGLIB的代理实现）

　　定义一个接口（这个例子演示了一个mixin。我们想要能够 将被通知对象类型转换为Lockable，不管它们的类型，并且调用lock和unlock方法。如果我们调用 lock()方法，我们希望所有setter方法抛出LockedException异常。 这样我们能添加一个方面使的对象不可变，而它们不需要知道这一点：这是一个很好的AOP例 子。）

public interface Lockable {
    void lock();
    void unlock();
    boolean locked();
}

　　首先，我们需要一个做大量转化的IntroductionInterceptor。 在这里，我们继承 org.springframework.aop.support.DelegatingIntroductionInterceptor 实用类。我们可以直接实现IntroductionInterceptor接口，但是大多数情况下 DelegatingIntroductionInterceptor是最合适的。

　　这样，LockMixin继承DelegatingIntroductionInterceptor 并自己实现Lockable。父类自动选择支持导入的Lockable，所以我们不需要指定它。 用这种方法我们可以导入任意数量的接口。

public class LockMixin extends DelegatingIntroductionInterceptor 
    implements Lockable {
    private boolean locked;
    public void lock() {
        this.locked = true;
    }
    public void unlock() {
        this.locked = false;
    }
    public boolean locked() {
        return this.locked;
    }
    public Object invoke(MethodInvocation invocation) throws Throwable {
        if (locked() && invocation.getMethod().getName().indexOf("set") == 0)
            throw new LockedException();
        return super.invoke(invocation);
    }
}

　　通常不要需要改写invoke()方法：实现 DelegatingIntroductionInterceptor就足够了，如果是导入的方法， DelegatingIntroductionInterceptor实现会调用委托方法， 否则继续沿着连接点处理。在现在的情况下，我们需要添加一个检查：在上锁 状态下不能调用setter方法。

　　在spring中的配置如下

    <bean id="aServiceImpl" class="com.xxx.plus.aop.demo.AServiceImpl" />  
    <bean id="lockAdvice" class="com.xxx.plus.aop.demo.LockMixin" />
    <bean id="aServiceImplProxy" class="org.springframework.aop.framework.ProxyFactoryBean">  
        <property name="interfaces" value="com.xxx.plus.aop.demo.Lockable" />  
        <property name="target" ref="aServiceImpl" />  
        <property name="proxyTargetClass" value="true"></property>
        <property name="interceptorNames">  
            <list>  
                <value>lockAdvice</value>  
            </list>  
        </property>  
    </bean>  

客户的代码代用如下

ApplicationContext context =new FileSystemXmlApplicationContext( "beans-config.xml");
        AService aServiceProxy =(AService) context.getBean("proxyFactoryBean");
        // 物件没有被锁定，可以呼叫 set 方法 some.setSome("justin"); System.out.println(some.getSome());
        try {
            // （重点一）
            ((LockAble) aServiceProxy).lock();
            // 无法呼叫 set 方法，丢出例外
            aServiceProxy.setSome("momor");
            // 由于会丢出例外，所以下面的这行程式无法被执行
            System.out.println(aServiceProxy.getSome());
        }
        catch(Throwable e) {
            e.printStackTrace();
        }
        some.setSome("momor");
　　　　　System.out.println(aServiceProxy.getSome());

　　重点一：这里的lock()方法可以直接被aServiceProxy调用，这里将aServiceProxy由AService强转为LockAble 没有报错。原理是在生产代理的时候，代理对象动态的实现了LockAble 接口。

    public Object getProxy(ClassLoader classLoader) {
        ......
            Enhancer enhancer = createEnhancer();
            if (classLoader != null) {
                enhancer.setClassLoader(classLoader);
                if (classLoader instanceof SmartClassLoader &&
                        ((SmartClassLoader) classLoader).isClassReloadable(proxySuperClass)) {
                    enhancer.setUseCache(false);
                }
            }
            enhancer.setSuperclass(proxySuperClass);
　　　　　　　//重点1.1(将advised 的接口也给了代理对象，获得完整的代理接口)
　　　　　　　enhancer.setInterfaces(AopProxyUtils.completeProxiedInterfaces(this.advised));
            enhancer.setNamingPolicy(SpringNamingPolicy.INSTANCE);
            enhancer.setStrategy(new UndeclaredThrowableStrategy(UndeclaredThrowableException.class));

            Callback[] callbacks = getCallbacks(rootClass);
            Class<?>[] types = new Class<?>[callbacks.length];
　　　　　　.......
    }

　　　　重点1.1（所以上面的强转是不会报错的）

    public static Class<?>[] completeProxiedInterfaces(AdvisedSupport advised) {
　　　　　//获取所有的代理接口
        Class<?>[] specifiedInterfaces = advised.getProxiedInterfaces();
        if (specifiedInterfaces.length == 0) {
            // No user-specified interfaces: check whether target class is an interface.
            Class<?> targetClass = advised.getTargetClass();
            if (targetClass != null) {
                if (targetClass.isInterface()) {
                    advised.setInterfaces(targetClass);
                }
                else if (Proxy.isProxyClass(targetClass)) {
                    advised.setInterfaces(targetClass.getInterfaces());
                }
                specifiedInterfaces = advised.getProxiedInterfaces();
            }
        }
        boolean addSpringProxy = !advised.isInterfaceProxied(SpringProxy.class);
        boolean addAdvised = !advised.isOpaque() && !advised.isInterfaceProxied(Advised.class);
        int nonUserIfcCount = 0;
        if (addSpringProxy) {
            nonUserIfcCount++;
        }
        if (addAdvised) {
            nonUserIfcCount++;
        }
        Class<?>[] proxiedInterfaces = new Class<?>[specifiedInterfaces.length + nonUserIfcCount];
        System.arraycopy(specifiedInterfaces, 0, proxiedInterfaces, 0, specifiedInterfaces.length);
        if (addSpringProxy) {
            proxiedInterfaces[specifiedInterfaces.length] = SpringProxy.class;
        }
        if (addAdvised) {
            proxiedInterfaces[proxiedInterfaces.length - 1] = Advised.class;
        }
        return proxiedInterfaces;
    }

　　客户的的代码

　　   aService.barA();
　　　　//h会发现这里的强制转换时成功的
   　　Lockable ku = ((Lockable) aService);
　　   ku.lock();

　　输出结果：

AServiceImpl.barA()
is lock

引入增强（JDK 代理实现）

接口与实现类，引入增强类

public interface ISome {
    public void doSome();
}

public class Some implements ISome {
    public void doSome() {
        System.out.println("原来物件的职责。。。");
    }
}

public class OtherIntroduction extends DelegatingIntroductionInterceptor implements IOther {
    @Override
    public Object invoke(MethodInvocation methodInvocation) throws Throwable {
        return super.invoke(methodInvocation);
    }
    public void doOther() {
        System.out.println("增加的职责。。。");
    }
}

 　　配置文件

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE beans PUBLIC "-//SPRING/DTD BEAN/EN" "http://www.springframework.org/dtd/spring-beans.dtd">
<beans>
    <bean id="some" class="com.xxx.Some"/>
    <bean id="otherIntroduction" class="com.xxx.OtherIntroduction"/>
    <bean id="otherAdvisor" class="org.springframework.aop.support.DefaultIntroductionAdvisor">
        <constructor-arg index="0">
            <ref bean="otherIntroduction"/>
        </constructor-arg>
        <constructor-arg index="1">
            <value>onlyfun.caterpillar.IOther</value>
        </constructor-arg>
    </bean>
    <bean id="proxyFactoryBean" class="org.springframework.aop.framework.ProxyFactoryBean">
        <property name="proxyInterfaces">
            <value>com.xxx.ISome</value>
        </property>
        <property name="target">
            <ref bean="some"/>
        </property>
        <property name="interceptorNames">
            <list>
                <value>otherAdvisor</value>
            </list>
        </property>
    </bean>
</beans>

 测试代码

    public static void main(String[] args) {
        ApplicationContext context = new FileSystemXmlApplicationContext("classpath:beans-config.xml");
        ISome some = (ISome) context.getBean("proxyFactoryBean");
        some.doSome();
        // 看来好像 some 物件动态增加了职责
        ((IOther) some).doOther();
    }

运行结果

原来物件的职责。。。
增加的职责。。。

分析：JDK 在代理接口的时候动态的代理了增强类实现的接口

    @Override
    public Object getProxy(ClassLoader classLoader) {
  　　　　//重点1 这里获取的所有完整的代理接口
        Class<?>[] proxiedInterfaces = AopProxyUtils.completeProxiedInterfaces(this.advised);
        findDefinedEqualsAndHashCodeMethods(proxiedInterfaces);
        return Proxy.newProxyInstance(classLoader, proxiedInterfaces, this);
    }    

 这里其实和CGLIB 代理是一样的。获取所有的需要代理的接口

    public static Class<?>[] completeProxiedInterfaces(AdvisedSupport advised) {
        Class<?>[] specifiedInterfaces = advised.getProxiedInterfaces();
        if (specifiedInterfaces.length == 0) {
            // No user-specified interfaces: check whether target class is an interface.
            Class<?> targetClass = advised.getTargetClass();
            if (targetClass != null) {
                if (targetClass.isInterface()) {
                    advised.setInterfaces(targetClass);
                }
                else if (Proxy.isProxyClass(targetClass)) {
                    advised.setInterfaces(targetClass.getInterfaces());
                }
                specifiedInterfaces = advised.getProxiedInterfaces();
            }
        }
        boolean addSpringProxy = !advised.isInterfaceProxied(SpringProxy.class);
        boolean addAdvised = !advised.isOpaque() && !advised.isInterfaceProxied(Advised.class);
        int nonUserIfcCount = 0;
        if (addSpringProxy) {
            nonUserIfcCount++;
        }
        if (addAdvised) {
            nonUserIfcCount++;
        }
        Class<?>[] proxiedInterfaces = new Class<?>[specifiedInterfaces.length + nonUserIfcCount];
        System.arraycopy(specifiedInterfaces, 0, proxiedInterfaces, 0, specifiedInterfaces.length);
        if (addSpringProxy) {
            proxiedInterfaces[specifiedInterfaces.length] = SpringProxy.class;
        }
        if (addAdvised) {
            proxiedInterfaces[proxiedInterfaces.length - 1] = Advised.class;
        }
        return proxiedInterfaces;
    }

 然后动态的实现接口，这样就可以实现强转了