Java核心庫實現AOP過程

這篇文章是關於Java的一個疑難雜症，經過利用Java核心庫實現簡單的AOP方法，並把實例代碼作了分析對照，如下是所有內容：

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, Method method, 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);
 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);
}
} 
複製代碼

運行結果以下：

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中也是混雜使用了兩種代理模式。