AOP生成代码三种方式

AOP生成代码有三种可能方式：
（1）静态编译时期，源代码生成。为每个符合条件的类方法产生对应的Proxy对象。AspectJ以前就是这种方式。
（2）静态编译时期，处理编译后的字节码。Java、Python之类的虚拟机语言都有一种中间代码（Java的中间代码叫做字节码），AOP处理程序可以分析字节码，并直接产生字节码形式的Proxy。这种方式也叫做静态字节码增强。AspectJ也支持这种方式。Java有一些开源项目，比如 ASM、Cglib等，可以分析并生成Java字节码。这些开源项目不仅可以静态分析增强字节码，还可以在程序运行期动态分析增强字节码。很多AOP项目,比如Spring AOP，都采用ASM/Cglib处理字节码。
（3）动态运行时期，即时处理装载到虚拟机内部的类结构字节码。这也叫做动态增强。比如，Spring AOP。如前所述，Spring AOP使用ASM/Cglib之类的处理字节码的开源项目。Java运行库本身也提供了类似于ASM/Cglib的简单的动态处理字节码的API，叫做 Dynamic Proxy。

以上就是AOP的实现原理：Proxy Pattern + Method Reflection + Aspect DSL + 自动代码生成。

 

spring中AOP实现：

<bean id="bean" class="org.springframework.aop.framework.ProxyFactoryBean">

<property name="proxyInterfaces">

    <value>com.ascenttech.springaop.test.Bean</value>

   </property>

   <property name="target">

    <ref local="beanTarget"/>

   </property>

   <property name="interceptorNames">

    <list>

     <value>theAdvisor</value>

    </list>

   </property>

</bean>

 

bean，它可以通过一个工厂来创建。bean是ProxyFactoryBean的一个实现，它是Spring framework的一部分。这个bean的行为通过以下的3个属性来定义。

— 属性proxyInterface定义了接口类。

— 属性target指向本地配置的一个bean，这个bean返回一个接口的实现。

— 属性interceptorNames是惟一允许定义一个值列表的属性，这个列表包含所有需要在beanTarget上执行的advisor。注意，advisor列表的次序是非常重要的。

 

 

动态代理，Dynamic Proxy
      Java动态代理类位于Java.lang.reflect包下，一般主要涉及到以下两个类：

(1). Interface InvocationHandler：该接口中仅定义了一个方法Object：invoke(Object obj,Method method,Object[]。在实际使用时，第一个参数obj一般是指代理类，method是被代理的方法，如上例中的request()，args为该方法的参数数组。这个抽象方法在代理类中动态实现。 args)

(2).Proxy：该类即为动态代理类，作用类似于上例中的ProxySubject，其中主要包含以下内容：

Protected Proxy(InvocationHandler h)：构造函数，估计用于给内部的h赋值。

Static Class getProxyClass (ClassLoader loader, Class[] interfaces)：获得一个代理类，其中loader是类装载器，interfaces是真实类所拥有的全部接口的数组。

Static Object newProxyInstance(ClassLoader loader, Class[] interfaces, InvocationHandler h)：返回代理类的一个实例，返回后的代理类可以当作被代理类使用(可使用被代理类的在Subject接口中声明过的方法)。

       所谓Dynamic Proxy是这样一种class：它是在运行时生成的class，在生成它时你必须提供一组interface给它，然后该class就宣称它实现了这些 interface。你当然可以把该class的实例当作这些interface中的任何一个来用。当然啦，这个Dynamic Proxy其实就是一个Proxy，它不会替你作实质性的工作，在生成它的实例时你必须提供一个handler，由它接管实际的工作。

 

       spring实现AOP可以利用两种技术——JDK的动态代理和CGLIB。首先要讲一下动态代理的概念。所谓动态指的是代理类是由JDK帮我们生成的，我们不需要写代理类的代码。那何谓代理呢？先看一下下面这张类图：

Target是需要被代理的类。Proxy就是代理类。他们必须实现相同的接口。并且代理类中包含被代理的实例。工作时，客户端获得的是代理类的实例。调用接口中定义的方法时会去调用Proxy的具体方法。Proxy再通过自己内部的Target实例调用被代理类的方法。也就是说实际工作的还是Target类的实例。当然在Target实例方法调用的前后可以加一些用户定制的行为（例如可以输出一下日志）。这就是简单的AOP了。

对上面的代码进行重构:

用工厂类创建实例:

package cm.longtop.zhmh.dynamicproxy;

import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Proxy;
//工厂类负责创建实例
public class ProxyFactory {
     public static Subject createInstant(String className){
    Object obj;
    InvocationHandler ih;
    Subject sub=null;
    try {
     obj= Class.forName(className).newInstance();
     ih=new SubjectDynamicProxy(obj);
       sub=(Subject)Proxy.newProxyInstance(Subject.class.getClassLoader(), new Class[]{Subject.class}, ih);
    } catch (InstantiationException e) {
     // TODO Auto-generated catch block
     e.printStackTrace();
    } catch (IllegalAccessException e) {
     // TODO Auto-generated catch block
     e.printStackTrace();
    } catch (ClassNotFoundException e) {
     // TODO Auto-generated catch block
     e.printStackTrace();
    } 
    return sub;
     }
     
}

 

测试类改成:

public class Test {
   public static void main(String[] args) throws Throwable{
    InvocationHandler ih =null;
    Subject sub=null;

    sub=ProxyFactory.createInstant("cm.longtop.zhmh.dynamicproxy.RealSuject1");
    sub.doAction();
    sub=ProxyFactory.createInstant("cm.longtop.zhmh.dynamicproxy.RealSuject2");
    sub.doAction();

}