spring aop实现

aop中的几个术语：

 切面（Aspect）：一个关注点的模块化，这个关注点可能会横切多个对象。事务管理是J2EE应用中一个关于横切关注点的很好的例子。

• 连接点（Joinpoint）：在程序执行过程中某个特定的点，比如某方法调用的时候或者处理异常的时候。在Spring AOP中，一个连接点总是表示一个方法的执行。

• 通知（Advice）：在切面的某个特定的连接点上执行的动作。其中包括了“around”、“before”和“after”等不同类型的通知（通知的类型将在后面部分进行讨论）。许多AOP框架（包括Spring）都是以拦截器做通知模型，并维护一个以连接点为中心的拦截器链。

• 切入点（Pointcut）：匹配连接点的断言。通知和一个切入点表达式关联，并在满足这个切入点的连接点上运行（例如，当执行某个特定名称的方法时）。切入点表达式如何和连接点匹配是AOP的核心：Spring缺省使用AspectJ切入点语法。

• 引入（Introduction）：用来给一个类型声明额外的方法或属性（也被称为连接类型声明（inter-type declaration））。Spring允许引入新的接口（以及一个对应的实现）到任何被代理的对象。例如，你可以使用引入来使一个bean实现IsModified接口，以便简化缓存机制。

• 目标对象（Target Object）： 被一个或者多个切面所通知的对象。也被称做被通知（advised）对象。 既然Spring AOP是通过运行时代理实现的，这个对象永远是一个被代理（proxied）对象。

• AOP代理（AOP Proxy）：AOP框架创建的对象，用来实现切面契约（例如通知方法执行等等）。在Spring中，AOP代理可以是JDK动态代理或者CGLIB代理。

• 织入（Weaving）：把切面连接到其它的应用程序类型或者对象上，并创建一个被通知的对象。这些可以在编译时（例如使用AspectJ编译器），类加载时和运行时完成。Spring和其他纯Java AOP框架一样，在运行时完成织入。

   

   有些操作横跨多个类，比如操作日志，权限控制，这时就会造成很多代码冗余。这时便可以使用aop功能。

   

• 看通过jdk，proxy和invocationhandle生成的一个代理类

• import java.lang.reflect.InvocationHandler;  
  import java.lang.reflect.Method;  
  import java.lang.reflect.Proxy;  
  import java.lang.reflect.UndeclaredThrowableException;  
    
  //这里很清楚了,代理类继承了Proxy类,并且实现了Proxy.newProxyInstance这个方法中传入的接口  
  public final class $Proxy0 extends Proxy  
    implements Subject  
  {  
      
    //这些方法在下面的static init block中进行初始化  
    private static Method m4;  
    private static Method m1;  
    private static Method m3;  
    private static Method m0;  
    private static Method m2;  
      
    static  
    {  
      try  
      {  
        m4 = Class.forName("ProxyClassName<span style="font-family: Arial, Helvetica, sans-serif;">").getMethod("sub", new Class[] { Class.forName("java.lang.String") });  </span>
        m1 = Class.forName("java.lang.Object").getMethod("equals", new Class[] { Class.forName("java.lang.Object") });  
        m3 = Class.forName("ProxyClassName").getMethod("pub", new Class[] { Class.forName("java.lang.String"), Class.forName("java.lang.String") });  
        m0 = Class.forName("java.lang.Object").getMethod("hashCode", new Class[0]);  
        m2 = Class.forName("java.lang.Object").getMethod("toString", new Class[0]);  
        return;  
      }  
      catch (NoSuchMethodException localNoSuchMethodException)  
      {  
        throw new NoSuchMethodError(localNoSuchMethodException.getMessage());  
      }  
      catch (ClassNotFoundException localClassNotFoundException)  
      {  
        throw new NoClassDefFoundError(localClassNotFoundException.getMessage());  
      }  
    }  
    
    //构造函数,接收一个 InvocationHandler作为参数,这就是为什么Proxy.newProxyInstance方法里可以  
    //通过InvocationHandler实例作为参数来反射获取Constructer实例   
    public $Proxy0 paramInvocationHandler)  
      throws   
    {  
      super(paramInvocationHandler);  
    }  
    
    //下面通过这个来看下代理对象中方法是怎样调用的  
    public final String sub(String paramString)  
      throws   
    {  
      try  
      {  
         //全部是通过调用InvocationHandler的invoke方法,传入对应的方法和参数  
        return (String)this.h.invoke(this, m4, new Object[] { paramString });  
      }  
      catch (Error|RuntimeException localError)  
      {  
        throw localError;  
      }  
      catch (Throwable localThrowable)  
      {  
        throw new UndeclaredThrowableException(localThrowable);  
      }  
    }  
    
    public final boolean equals(Object paramObject)  
      throws   
    {  
      try  
      {  
        return ((Boolean)this.h.invoke(this, m1, new Object[] { paramObject })).booleanValue();  
      }  
      catch (Error|RuntimeException localError)  
      {  
        throw localError;  
      }  
      catch (Throwable localThrowable)  
      {  
        throw new UndeclaredThrowableException(localThrowable);  
      }  
    }  
    
    public final void pub(String paramString1, String paramString2)  
      throws   
    {  
      try  
      {  
        this.h.invoke(this, m3, new Object[] { paramString1, paramString2 });  
        return;  
      }  
      catch (Error|RuntimeException localError)  
      {  
        throw localError;  
      }  
      catch (Throwable localThrowable)  
      {  
        throw new UndeclaredThrowableException(localThrowable);  
      }  
    }  
    
    public final int hashCode()  
      throws   
    {  
      try  
      {  
        return ((Integer)this.h.invoke(this, m0, null)).intValue();  
      }  
      catch (Error|RuntimeException localError)  
      {  
        throw localError;  
      }  
      catch (Throwable localThrowable)  
      {  
        throw new UndeclaredThrowableException(localThrowable);  
      }  
    }  
    
    public final String toString()  
      throws   
    {  
      try  
      {  
        return (String)this.h.invoke(this, m2, null);  
      }  
      catch (Error|RuntimeException localError)  
      {  
        throw localError;  
      }  
      catch (Throwable localThrowable)  
      {  
        throw new UndeclaredThrowableException(localThrowable);  
      }  
    }  
    
  }