1. Spring AOP介紹

AOP(Aspect-Oriented Programming)，面向切面的編程哼拔，是OOP（面向?qū)ο蟮木幊蹋┑闹匾a充倦逐，所謂AOP宫补，就是在執(zhí)行Java類中的方法前或后加入自定義方法粉怕。Spring AOP是Spring的一個重要組成部分贫贝，和IoC并稱為Spring的兩大基礎組件凤优。關于Spring Ioc可以訪問http://www.reibang.com/p/6178ba063553。

spring-aop.png

1.1 小明搬磚的故事

小明每天都要上班栖袋、搬磚电媳、下班。現(xiàn)在珍促，小明的老婆每天在他上班搬磚之前犬第，檢查他是否帶了公交卡；小明的兒子每天在搬磚下班之后討要零花錢橙垢。小明只管搬磚掙錢即可剂癌，老婆檢查公交卡和兒子討要零花錢對搬磚掙錢這個事不會產(chǎn)生任何影響琳要，該掙多少錢還掙多少錢课幕；只是搬磚回來后，兒子會討要零花錢，減少小明掙到的工資。

接下來我們使用OOP和AOP的思想來考慮小明搬磚的故事励翼。根據(jù)OOP的思想，小明就是一個對象，他具有上班、搬磚驼卖、下班等三個行為桥胞。根據(jù)AOP的思想伊群，小明老婆在小明執(zhí)行搬磚掙錢前做出門檢查，小明兒子在小明執(zhí)行搬磚掙錢后討要零花錢及老，這兩者都不會改變小明調(diào)用搬磚掙錢的方法，但可能會影響其結果偶惠。

1.2 AOP使用的場景

AOP用來封裝橫切關注點厘线，具體可以在下面的場景中使用。

• Authentication 權限
• Caching 緩存
• Context passing 內(nèi)容傳遞
• Error handling 錯誤處理
• Lazy loading　懶加載
• Debugging　　調(diào)試
• logging析藕，tracing筹煮，profiling and monitoring　記錄跟蹤　優(yōu)化　校準
• Performance optimization　性能優(yōu)化
• Persistence　　持久化
• Resource pooling　資源池
• Synchronization　同步
• Transactions 事務

1.3 AOP的相關概念

1. 切面（Aspect）：切面是通知和切點的結合檬洞。通知和切點共同定義了切面的全部內(nèi)容———他是什么广料，在何時和何處完成其功能性昭。

2. 通知（Advice）：在AOP中，切面的工作被稱為通知。通知定義了切面“是什么”以及“何時”使用元旬。除了描述切面要完成的工作，通知還解決了何時執(zhí)行這個工作的問題穆端。Spring切面可以應用5種類型的通知：

• 前置通知（Before）：在目標方法被調(diào)用之前調(diào)用通知功能
• 后置通知（After）：在目標方法完成之后調(diào)用通知，此時不會關心方法的輸出是什么
• 返回通知（After-returning）：在目標方法成功執(zhí)行之后調(diào)用通知
• 異常通知（After-throwing）：在目標方法拋出異常后調(diào)用通知
• 環(huán)繞通知（Around）：通知包裹了被通知的方法，在被通知的方法調(diào)用之前和調(diào)用之后執(zhí)行自定義的行為

3. 切點（Pointcut）：如果說通知定義了切面“是什么”和“何時”的話，那么切點就定義了“何處”仅偎。比如我想把日志引入到某個具體的方法中，這個方法就是所謂的切點威恼。

4. 連接點（Join Point）：程序執(zhí)行過程中明確的點，如方法的調(diào)用或特定的異常被拋出走越。在Spring AOP中低淡，一個連接點總是表示一個方法的執(zhí)行。

5. 引入（Introduction）：添加方法或字段到被通知的類芦倒。 Spring允許引入新的接口到任何被通知的對象傲霸。例如播歼，你可以使用一個引入使任何對象實現(xiàn) IsModified接口，來簡化緩存刊橘。Spring中要使用Introduction, 可有通過DelegatingIntroductionInterceptor來實現(xiàn)通知稳懒，通過DefaultIntroductionAdvisor來配置Advice和代理類要實現(xiàn)的接口。

6. 織入（Weaving）：把切面應用到目標對象來創(chuàng)建新的代理對象的過程添加方法或字段到被通知的類。這可以在編譯時完成（例如使用AspectJ編譯器）藕施，也可以在運行時完成找田。Spring AOP，在運行時完成織入捶码。

7. 目標對象（Target Object）: 包含連接點的對象粒没。也被稱作被通知或被代理對象。

8. AOP代理（AOP Proxy）: AOP框架創(chuàng)建的對象举畸，包含通知。 在Spring中动漾，AOP代理可以是JDK動態(tài)代理或者CGLIB代理，本文會在下文講述這兩種動態(tài)創(chuàng)建代理的方式雪位。

2. 基于@Aspect的AOP編程實踐

本節(jié)通過一個簡單的例子，說明如何實現(xiàn)基于@Aspect的AOP編程實踐覆醇。我們將在Controller執(zhí)行方法的前后落午，輸出一些日志。

2.1 pom.xml中引入AOP

    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-aop</artifactId>
    </dependency>

2.2 HelloController

這個Controller就是我們選定的目標對象（Target Object）齐帚，它的hello()方法就是連接點（Join Point）敢朱。

@RestController
public class HelloController {

  @RequestMapping(value = "/hello")
  public String hello(@RequestParam(value = "name", required = true) String name) {
    String result = "hello  " + name;
    System.out.println(result);
    return result;
  }

}

2.3 ApiAspect切面

@Component // 注冊到Spring容器
@Aspect // 該注解標示該類為切面類，切面是由通知和切點組成的。
public class ApiAspect {
  
  //雙引號中間的內(nèi)容是PointCut（切點）表達式鬓长。@Before是前屬通知
  @Before("execution(* com.example.controller.HelloController.*(..))")  
  public void before(){
    System.out.println("方法執(zhí)行前執(zhí)行.....before");  
  }

  //@Around是環(huán)繞通知易遣，下面的通知看注解即可彼妻，不再寫注釋。
  @Around("execution(* com.example.controller.HelloController.*(..))")  
  public String around(ProceedingJoinPoint pjp) {
    System.out.println("方法環(huán)繞start....around.");
    String result = null;
    try {
      result = (String) pjp.proceed();
    } catch (Throwable e) {
      e.printStackTrace();
    }
    System.out.println("方法環(huán)繞end.....around");  
    return result;
  }
  
  @After("within(com.example.controller.*Controller)")
  public void after(){
    System.out.println("方法之后執(zhí)行....after.");
  }
  
  @AfterReturning("within(com.example.controller.*Controller)")
  public void afterReturning(){
    System.out.println("方法執(zhí)行完執(zhí)行.....afterReturning");  
  }
  
  @AfterThrowing("within(com.example.controller.*Controller)")
  public void afterThrowing(){
    System.out.println("異常出現(xiàn)之后.....afterThrowing");  
  }

}

啟動Spring Boot工程，訪問http://localhost:8080/hello?name=world 拳话，控制臺輸出以下結果形耗。

方法環(huán)繞start....around.
方法執(zhí)行前執(zhí)行.....before
hello  world
方法環(huán)繞end.....around
方法之后執(zhí)行....after.
方法執(zhí)行完執(zhí)行.....afterReturning

本節(jié)通過一個例子，說明了如果基于@Aspect實現(xiàn)AOP編程园爷，并在過程中體現(xiàn)了AOP概念中切面、切點十艾、通知劈榨、連接點和目標對象踪古。AOP的動態(tài)織入和AOP的代理將通過下文的兩節(jié)描述偷厦。分別是Java動態(tài)代理和cglib動態(tài)代理，前者是基于接口動態(tài)生成代理類，后者是通過子類生成動態(tài)代理類役纹。

3. Java動態(tài)代理

代理模式是一種常用的Java設計模式汁胆，它的特征是代理類和委托類實現(xiàn)了同樣的接口烘挫，代理類負責預處理消息厂抖、過濾消息、把消息轉發(fā)給委托類豌鹤，以及事后處理消息等园骆。代理類并不實現(xiàn)真正的服務，而是調(diào)用委托類的方法來提供特定的服務斋枢。

所謂動態(tài)代理怯邪，就是在程序運行時东羹，運用反射機制動態(tài)創(chuàng)建代理類。其實現(xiàn)主要通過java.lang.reflect.Proxy類和java.lang.reflect.InvocationHandler接口症革。其中筐咧，Proxy類主要用來獲取動態(tài)代理對象；InvocationHandler接口用來約束調(diào)用者實現(xiàn)噪矛。

要想使用Java動態(tài)代理量蕊，委托類、或者說是被代理的對象（target）艇挨，必須是一個接口的實現(xiàn)類残炮。

3.1 Java動態(tài)代理的使用

下面是Java動態(tài)代理的一個示例，說明見代碼中的注釋內(nèi)容缩滨。

import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;

public class Main {

  public static void main(String[] args) {
    // 實例化 target
    IHello hello = new Hello();
    // 實例化InvocationHandler
    DynamicProxyHandler handler = new DynamicProxyHandler(hello);
    // 通過Proxy類生成代理對象
    IHello proxy = (IHello) Proxy.newProxyInstance(hello.getClass().getClassLoader(),
        hello.getClass().getInterfaces(), handler);
    // 調(diào)用代理對象的方法
    proxy.sayHello("world");
  }
}


/**
 * JDK動態(tài)代理要實現(xiàn) InvocationHandler 接口势就。
 */
class DynamicProxyHandler implements InvocationHandler {
  // 目標對象
  private Object target;

  /**
   * 構造方法
   * 
   * @param target 目標對象
   */
  public DynamicProxyHandler(Object target) {
    super();
    this.target = target;
  }

  /**
   * 執(zhí)行目標對象target的方法
   */
  @Override
  public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
    Object result = null;
    try {
      System.out.println(method.getName() + " Method start .");
      result = method.invoke(target, args);
      System.out.println(method.getName() + " Method end .");
    } catch (Exception e) {
      e.printStackTrace();
    }
    return result;
  }
  
  /** 
   * 獲取目標對象的代理對象 
   * @return 代理對象 
  public Object getProxy() {  
      return Proxy.newProxyInstance(Thread.currentThread().getContextClassLoader(),   
              target.getClass().getInterfaces(), this);  
  } 
  */  

}

/**
 * target實現(xiàn)的接口泉瞻，用JDK動態(tài)代理生成的對象一定要實現(xiàn)一個接口
 */
interface IHello {
  // target method
  public void sayHello(String name);
}

/**
 * 被代理的target
 */
class Hello implements IHello {
  @Override
  public void sayHello(String name) {
    System.out.println("hello," + name);
  }

}

執(zhí)行結果如下

sayHello Method start .
hello,world
sayHello Method end .

3.2 誰調(diào)用了invoke方法

DynamicProxyHandler中實現(xiàn)了InvocationHandler的invoke方法，表面上看不到是誰調(diào)用了苞冯。事實上袖牙，invok方法最終是由生成的動態(tài)代理類調(diào)用的，下面的代碼使用了sun.misc.ProxyGenerator把生成的動態(tài)代理類的字節(jié)碼寫到了磁盤上抱完。通過反編譯生成的字節(jié)碼贼陶，我們就可以清晰地看到調(diào)用InvocationHandler的invoke方法的過程刃泡。

sun.misc.ProxyGenerator存在于JDK中巧娱，路徑是${JAVA_HOME}/jre/lib/rt.jar中; JRE中沒有這個類。如果你的工程里無法import該類烘贴，請修改JRE System Library到你的JDK目錄禁添。

下面的代碼，把Hello.class的動態(tài)代理字節(jié)碼寫到了d:/logs/HelloProxy.class桨踪。

public class ProxyGeneratorUtils {
  
  public static void main(String[] args) {
    // 把Hello.class的動態(tài)代理類的字節(jié)碼保存到d:/logs/HelloProxy.class
    ProxyGeneratorUtils.writeProxyClassToHardDisk("d:/logs/HelloProxy.class");
  }
  
  
  /**
   * 把代理類的字節(jié)碼寫到磁盤
   * 
   * @param path 保存路徑
   */
  public static void writeProxyClassToHardDisk(String path) {
    // 獲取代理類的字節(jié)碼
    byte[] classFile = ProxyGenerator.generateProxyClass("HelloProxy",
             Hello.class.getInterfaces());
    FileOutputStream out = null;
    try {
      out = new FileOutputStream(path);
      out.write(classFile);
      out.flush();
    } catch (Exception e) {
      e.printStackTrace();
    } finally {
      try {
        out.close();
      } catch (IOException e) {
        e.printStackTrace();
      }
    }
  }
}

下面是HelloProxy.class的主要內(nèi)容老翘，可以看到生成的動態(tài)代理類HelloProxy和Hello一樣實現(xiàn)了IHello接口。HelloProxy繼承了Proxy類锻离，Java不允許類多繼承铺峭，這也是“JDK動態(tài)代理時，委托類必須實現(xiàn)一個接口”的原因汽纠。

public final class HelloProxy extends Proxy implements IHello {

  private static Method m3;

  static {
    // 被調(diào)用的方法
     m3 = Class.forName("aop.IHello").getMethod("sayHello",
      new Class[] {Class.forName("java.lang.String")});
  }
  // 此處為上述實現(xiàn)的DynamicProxyHandler
  public HelloProxy(InvocationHandler paramInvocationHandler) {
    super(paramInvocationHandler);
  }
  //invoke方法就是在這里被調(diào)用的卫键。
  public final void sayHello(String paramString) {
    try {
      this.h.invoke(this, m3, new Object[] {paramString});
      return;
    } catch (Error | RuntimeException localError) {
      throw localError;
    } catch (Throwable localThrowable) {
      throw new UndeclaredThrowableException(localThrowable);
    }
  }
｝

3.3 InvocationHandler接口

InvocationHandler僅有一個方法，即invoke方法虱朵，它接受三個參數(shù)莉炉。proxy是代理類的實例；method是委托類被調(diào)用的方法碴犬；args是傳入method的參數(shù)絮宁。

 public Object invoke(Object proxy, Method method, Object[] args)
    throws Throwable;

3.4 Proxy類

Proxy類的使命就是為了獲取代理對象，在上面的例子中服协，我們就是使用它的newProxyInstance方法,獲取到了代理對象绍昂。其主要代碼如下。

/**
 *loader： 類加載器
 *interfaces：target實現(xiàn)的接口
 *h：InvocationHandler的實現(xiàn)類 
 */
public static Object newProxyInstance(ClassLoader loader,Class<?>[] interfaces,
   InvocationHandler h)throws IllegalArgumentException {

    //查找或者生成動態(tài)代理類偿荷。動態(tài)代理類的生成是在ProxyGenerator中實現(xiàn)的治专。
    Class<?> cl = getProxyClass0(loader, intfs);

    // 調(diào)用代理對象的構造方法
    final Constructor<?> cons = cl.getConstructor(constructorParams);
    // 把InvocationHandler實現(xiàn)類的實例傳遞到構造方法中
    final InvocationHandler ih = h;
    if (!Modifier.isPublic(cl.getModifiers())) {
        AccessController.doPrivileged(new PrivilegedAction<Void>() {
            public Void run() {
                cons.setAccessible(true);
                return null;
            }
        });
    }
    // 返回生成的代理類的實例。
    return cons.newInstance(new Object[]{h});
 }

4. cglib動態(tài)代理

JDK動態(tài)代理使用簡單遭顶，但存在著委托類必須實現(xiàn)一個或者多個接口张峰；如果委托類沒有實現(xiàn)接口，而又要代理它棒旗，就可以使用CGLIB包喘批。Spring AOP同時使用JDK動態(tài)代理和cglib撩荣；默認情況下，實現(xiàn)接口的類使用JDK動態(tài)代理饶深；沒有實現(xiàn)接口的類餐曹，使用cglib。

cglib通過使用字節(jié)碼處理框架ASM(Java字節(jié)碼操控框架)敌厘，來轉換字節(jié)碼并生成新的類台猴；其原理是對指定的目標類生成一個子類，并覆蓋其中方法實現(xiàn)增強俱两，但因為采用的是繼承饱狂，所以不能對final修飾的類進行代理。

下面是使用cglib的例子宪彩。

public class CglibMain {
  public static void main(String[] args) {
    // 實例化 target休讳，沒有使用接口
    Hello hello = new Hello();
    // 實例化CglibProxy
    MyCglibProxy cglib = new MyCglibProxy();
    // 通過cglib獲取代理對象
    Hello proxy = (Hello) cglib.getInstance(hello);
    // 調(diào)用代理對象的方法
    proxy.sayHello("world");
  }
}


class MyCglibProxy implements MethodInterceptor {
  // 被代理的對象
  private Object target;

  /**
   * 創(chuàng)建代理對象
   */
  public Object getInstance(Object target) {
    this.target = target;
    Enhancer enhancer = new Enhancer();
    enhancer.setSuperclass(this.target.getClass());
    // 回調(diào)方法
    enhancer.setCallback(this);
    // 創(chuàng)建代理對象
    return enhancer.create();
  }

  @Override
  public Object intercept(Object obj, Method method,
      Object[] args, MethodProxy methodProxy) throws Throwable {
    System.out.println(method.getName() + " before-----------");
    // 生成的代理對象是委托類的子類，因此調(diào)用了super method
    Object result = methodProxy.invokeSuper(obj, args);
    System.out.println(method.getName() + " after-----------");
    return result;
  }

}

結果輸出如下尿孔。

sayHello before-----------
Hello, world
sayHello after-----------

5. 總結

以上是對Spring AOP的總結俊柔，我們記錄AOP的概念、應用場景活合，編寫了一個AOP的小例子雏婶，并分析了動態(tài)代理的生成過程。動態(tài)代理的生成過程對應Spring中源代碼分別是JdkDynamicAopProxy和CglibAopProxy白指，它們的package都是org.springframework.aop.framework留晚，在spring-aop-*.jar中。

http://blog.csdn.net/moreevan/article/details/11977115
http://rejoy.iteye.com/blog/1627405
http://blog.csdn.net/xiaohai0504/article/details/6832990