Spring是一個十分火熱開源框架，而AOP（面向切面程式設計）則是Spring最重要的概念之一，為了更好的理解和學習AOP的思想，使用核心庫來實現一次不失為一個好方法。

　　首先介紹一下AOP的概念，AOP（Aspect Oriented Programming），即面向切面程式設計，所謂的面向切面程式設計，就是從一個橫切面的角度去設計程式碼的思想，傳統的OOP思想是用封裝繼承和多型構造一種縱向的層次關係，但不適合定義橫向的關係，而AOP思想則對此進行了很好的補充。

　　例如日誌管理程式碼往往橫向的散佈在很多物件層次中，但跟它對應的物件的核心功能可以說是毫無關係，還有很多類似的程式碼，如許可權驗證，除錯輸出，事務處理等，也都是如此，這樣的話就不利於程式碼的複用和管理了。

　　這時候AOP技術就應運而生了，它利用“橫切”技術，深入封裝物件的內部，並將那些影響了多個類的公共行為封裝到一個可重用模組，並將其命名為"Aspect"，即切面。所謂"切面"，簡單說就是那些與業務無關，卻為業務模組所共同呼叫的邏輯或責任封裝起來，便於減少系統的重複程式碼，降低模組之間的耦合度，並有利於後續的可操作性和可維護性。

　　那麼AOP又是如何實現的呢？

　　答案是動態代理（關於代理會有另外篇章做詳細介紹，這裡就不贅述了）。實現動態代理有兩種方式，一種是JDK動態代理，一種是CGLib動態代理。

　　那麼分別使用兩種方式來做一個簡單的栗子。

　　先設計一個場景，假設我們有一個計算介面ICalculator和實現了該介面的計算器類CalculatorImpl。

public interface ICalculator {
  //加法運算
  public int add(int a,int b);
  //減法
  public int subtract(int a,int b);
  //乘法
  public int multiply(int a,int b);
  //除法
  public int devide(int a,int b);
}

public class CalculatorImpl implements ICalculator{
  @Override
  public int add(int a,int b) {
    return a + b;
  }

  @Override
  public int subtract(int a,int b) {
    return a - b;
  }

  @Override
  public int multiply(int a,int b) {
    return a * b;
  }

  @Override
  public int devide(int a,int b) {
    return a / b;
  }
}

　　如何在不改動原來計算器類內部程式碼的情況下記錄計算器各個方法使用的總次數呢？

　　有了動態代理後，其實就很簡單了，先建立一個類並實現InvocationHandler介面，覆蓋invoke方法，

public class TestHandler implements InvocationHandler {

  private Object targetObject;
  private int useTimes;

  //繫結委託物件，並返回代理類
  public Object bind(Object targetObject){
    this.targetObject = targetObject;
    return Proxy.newProxyInstance(targetObject.getClass().getClassLoader(),targetObject.getClass().getInterfaces(),this);
  }

  @Override
  public Object invoke(Object proxy,Method method,Object[] args) throws Throwable {
    //do something
    before();
    Object result = method.invoke(targetObject,args);
    after();
    return result;
  }
  private void before(){
    System.out.println("we can do something before calculate.");
  }

  private void after(){
    useTimes++;
    System.out.println("已使用："+useTimes+"次");
  }
}

　　別看程式碼好像有點多，其實主要的方法就是invoke方法，裡面的Object result = method.invoke(targetObject,args);相當於繼續用原來的引數執行原來方法。這裡的before和after為自定義的函式，可以在目的碼執行前後做一些我們想要做的事情，比如這裡的使用次數統計。

　　在bind方法裡，傳入目標代理物件，並返回一個代理類例項。接下來我們看看如何使用：

public class TestProxy {
  public static void main(String[] args) {
    TestHandler proxy = new TestHandler();
    ICalculator calculator = (ICalculator)proxy.bind(new CalculatorImpl());
    int result = calculator.add(1,2);
    System.out.println("result is:"+result);
    result = calculator.subtract(3,2);
    System.out.println("result is:"+result);
    result = calculator.multiply(4,6);
    System.out.println("result is:"+result);
    result = calculator.devide(6,2);
    System.out.println("result is:"+result);
  }
}

　　我們先定義一個TestHandler，然後通過bind方法來獲得一個代理例項，之後我們就可以直接使用這個例項了。執行結果如下：

we can do something before calculate.
已使用：1次
result is:3
we can do something before calculate.
已使用：2次
result is:1
we can do something before calculate.
已使用：3次
result is:24
we can do something before calculate.
已使用：4次
result is:3

　　這樣我們就實現了不修改CalculatorImpl內部程式碼的情況下對程式碼進行擴充套件。

　　接下來用CGLib的方式來實現一次。

　　先建立一個類來實現MethodInterceptor介面，並覆蓋intercept方法。其他程式碼跟使用JDK代理大同小異，僅僅是獲取代理物件的過程有所差異。

public class CGLibProxy implements MethodInterceptor {
  private int useTimes;
  private Object target;

  public Object getInstance(Object target){
    this.target=target;
    Enhancer enhancer =new Enhancer();
    enhancer.setSuperclass(this.target.getClass());
    enhancer.setCallback(this);
    return enhancer.create();
  }

  @Override
  public Object intercept(Object o,Object[] objects,MethodProxy methodProxy) throws Throwable {
    before();
    Object result = methodProxy.invokeSuper(o,objects);
    after();
    return result;
  }

  private void before(){
    System.out.println("we can do something before calculate.");
  }

  private void after(){
    useTimes++;
    System.out.println("已使用："+useTimes+"次");
  }
}

　　測試一下：

public class TestCGLibProxy {
  public static void main(String[] args) {
    CGLibProxy cgLibProxy = new CGLibProxy();
    ICalculator calculator = (ICalculator) cgLibProxy.getInstance(new CalculatorImpl());
    int result = calculator.add(1,2);
    System.out.println("result is:"+result);
  }
}

　　執行結果如下：

we can do something before calculate.
已使用：1次
result is:3
we can do something before calculate.
已使用：2次
result is:1
we can do something before calculate.
已使用：3次
result is:24
we can do something before calculate.
已使用：4次
result is:3

　　現在我們得到了同樣的結果。（需要匯入兩個包，cglib-2.2.2.jar asm-3.3.jar）

　　兩種方法各有所長，JDK代理需要先設定一個介面，然後才能實現代理，這是它的缺點，也是它的優點，缺點是這樣會麻煩一點，而且無法對那些已經封裝好的，沒有實現介面的類進行代理，而CGLib代理的方式不需要使用介面。但也正是因為如此，JDK代理的方式僅僅攔截類中覆蓋介面的方法，而CGLib則會攔截類的所有方法呼叫。兩者各有利弊，所以需要具體情況具體分析。在Spring中也是混雜使用了兩種代理模式。

以上就是Java核心庫實現簡單的AOP的詳細內容，更多關於Java 實現aop的資料請關注我們其它相關文章！