AOP（Aspect Orient Programming），一般稱為面向切面編程，作為面向對象的一種補充，用于處理系統中分布于各個模塊的橫切關注點，比如事務管理、日志、緩存等等。AOP實現的關鍵在于AOP框架自動創建的AOP代理，AOP代理主要分為靜態代理和動態代理，靜態代理的代表為AspectJ；而動態代理則以Spring AOP為代表。靜態代理是編譯期實現，動態代理是運行期實現，可想而知前者擁有更好的性能。

本文主要介紹Spring AOP的兩種代理實現機制，JDK動態代理和CGLIB動態代理。

靜態代理是編譯階段生成AOP代理類，也就是說生成的字節碼就織入了增強后的AOP對象；動態代理則不會修改字節碼，而是在內存中臨時生成一個AOP對象，這個AOP對象包含了目標對象的全部方法，并且在特定的切點做了增強處理，并回調原對象的方法。

Spring AOP中的動態代理主要有兩種方式，JDK動態代理和CGLIB動態代理。JDK動態代理通過反射來接收被代理的類，并且要求被代理的類必須實現一個接口。JDK動態代理的核心是InvocationHandler接口和Proxy類。

如果目標類沒有實現接口，那么Spring AOP會選擇使用CGLIB來動態代理目標類。CGLIB（Code Generation Library），是一個代碼生成的類庫，可以在運行時動態的生成某個類的子類，注意，CGLIB是通過繼承的方式做的動態代理，因此如果某個類被標記為final，那么它是無法使用CGLIB做動態代理的，諸如private的方法也是不可以作為切面的。

我們分別通過實例來研究AOP的具體實現。

直接使用Spring AOP

首先定義需要切入的接口和實現。為了簡單起見，定義一個Speakable接口和一個具體的實現類，只有兩個方法sayHi()和sayBye()。 

public interface Speakable {  
 void sayHi();  
 void sayBye();  
}  
@Service  
public class PersonSpring implements Speakable {  
 @Override  
 public void sayHi() {  
 try {  
 Thread.currentThread().sleep(30);  
 } catch (Exception e) {  
 throw new RuntimeException(e);  
 }  
 System.out.println("Hi!!");  
 }  
 @Override  
 public void sayBye() {  
 try {  
 Thread.currentThread().sleep(10);  
 } catch (Exception e) {  
 throw new RuntimeException(e);  
 }  
 System.out.println("Bye!!");  
 }  
} 

接下來我們希望實現一個記錄sayHi()和sayBye()執行時間的功能。

定義一個MethodMonitor類用來記錄Method執行時間 

public class MethodMonitor {  
 private long start;  
 private String method;  
 public MethodMonitor(String method) {  
 this.method = method;  
 System.out.println("begin monitor..");  
 this.start = System.currentTimeMillis();  
 }  
 public void log() {  
 long elapsedTime = System.currentTimeMillis() - start;  
 System.out.println("end monitor..");  
 System.out.println("Method: " + method + ", execution time: " + elapsedTime + " milliseconds.");  
 }  
} 

光有這個類還是不夠的，希望有個靜態方法用起來更順手，像這樣 

MonitorSession.begin();  
doWork();  
MonitorSession.end(); 

說干就干，定義一個MonitorSession 

public class MonitorSession {  
 private static ThreadLocal<MethodMonitor> monitorThreadLocal = new ThreadLocal<>();  
 public static void begin(String method) {  
 MethodMonitor logger = new MethodMonitor(method);  
 monitorThreadLocal.set(logger);  
 }  
 public static void end() {  
 MethodMonitor logger = monitorThreadLocal.get();  
 logger.log();  
 }  
} 

萬事具備，接下來只需要我們做好切面的編碼， 

@Aspect  
@Component  
public class MonitorAdvice {  
 @Pointcut("execution (* com.deanwangpro.aop.service.Speakable.*(..))")  
 public void pointcut() {  
 }  
 @Around("pointcut()")  
 public void around(ProceedingJoinPoint pjp) throws Throwable {  
 MonitorSession.begin(pjp.getSignature().getName());  
 pjp.proceed();  
 MonitorSession.end();  
 }  
} 

如何使用？我用了spring boot，寫一個啟動函數吧。 

@SpringBootApplication  
public class Application {  
 @Autowired  
 private Speakable personSpring;  
 public static void main(String[] args) {  
 SpringApplication.run(Application.class, args);  
 }  
 @Bean  
 public CommandLineRunner commandLineRunner(ApplicationContext ctx) {  
 return args -> {  
 // spring aop  
 System.out.println("******** spring aop ******** ");  
 personSpring.sayHi();  
 personSpring.sayBye();  
 System.exit(0);  
 };  
 }  
} 

運行后輸出:   

jdk dynamic proxy begin monitor..Hi!!end monitor..Method: sayHi, execution time: 32 milliseconds.begin monitor..Bye!!end monitor..Method: sayBye, execution time: 22 milliseconds. 

JDK動態代理

剛剛的例子其實內部實現機制就是JDK動態代理，因為Person實現了一個接口。

為了不和***個例子沖突，我們再定義一個Person來實現Speakable, 這個實現是不帶Spring Annotation的，所以他不會被Spring托管。 

public class PersonImpl implements Speakable {  
 @Override  
 public void sayHi() {  
 try {  
 Thread.currentThread().sleep(30);  
 } catch (Exception e) {  
 throw new RuntimeException(e);  
 }  
 System.out.println("Hi!!");  
 }  
 @Override  
 public void sayBye() {  
 try {  
 Thread.currentThread().sleep(10);  
 } catch (Exception e) {  
 throw new RuntimeException(e);  
 }  
 System.out.println("Bye!!");  
 }  
} 

重頭戲來了，我們需要利用InvocationHandler實現一個代理，讓它去包含Person這個對象。那么再運行期實際上是執行這個代理的方法，然后代理再去執行真正的方法。所以我們得以在執行真正方法的前后做一些手腳。JDK動態代理是利用反射實現，直接看代碼。 

public class DynamicProxy implements InvocationHandler {  
 private Object target;  
 public DynamicProxy(Object object) {  
 this.target = object;  
 }  
 @Override  
 public Object invoke(Object arg0, Method arg1, Object[] arg2)  
 throws Throwable {  
 MonitorSession.begin(arg1.getName());  
 Object obj = arg1.invoke(target, arg2);  
 MonitorSession.end();  
 return obj;  
 }  
 @SuppressWarnings("unchecked")  
 public <T> T getProxy() {  
 return (T) Proxy.newProxyInstance(  
 target.getClass().getClassLoader(),  
 target.getClass().getInterfaces(),  
 this  
 );  
 }  
} 

通過getProxy可以得到這個代理對象，invoke就是具體的執行方法，可以看到我們在執行每個真正的方法前后都加了Monitor。

我實現了一個工廠類來獲取Person代理對象 

public class PersonProxyFactory {  
 public static Speakable newJdkProxy() {  
 // 代理PersonImpl  
 DynamicProxy dynamicProxy = new DynamicProxy(new PersonImpl());  
 Speakable proxy = dynamicProxy.getProxy();  
 return proxy;  
 }  
} 

具體使用 

// jdk dynamic proxy  
System.out.println("******** jdk dynamic proxy ******** ");  
Speakable jdkProxy = PersonProxyFactory.newJdkProxy();  
jdkProxy.sayHi();  
jdkProxy.sayBye(); 

輸出結果: 

******** jdk dynamic proxy ********   
begin monitor..  
Hi!!  
end monitor..  
Method: sayHi, execution time: 32 milliseconds.  
begin monitor..  
Bye!!  
end monitor..  
Method: sayBye, execution time: 22 milliseconds. 

CGLib動態代理

我們再新建一個Person來，這次不實現任何接口。 

public class Person {  
 public void sayHi() {  
 try {  
 Thread.currentThread().sleep(30);  
 } catch (Exception e) {  
 throw new RuntimeException(e);  
 }  
 System.out.println("Hi!!");  
 }  
 public void sayBye() {  
 try {  
 Thread.currentThread().sleep(10);  
 } catch (Exception e) {  
 throw new RuntimeException(e);  
 }  
 System.out.println("Bye!!");  
 }  
} 

如果Spring識別到所代理的類沒有實現Interface，那么就會使用CGLib來創建動態代理，原理實際上成為所代理類的子類。 

public class CGLibProxy implements MethodInterceptor {  
 private static CGLibProxy instance = new CGLibProxy();  
 private CGLibProxy() {  
 }  
 public static CGLibProxy getInstance() {  
 return instance;  
 }  
 private Enhancer enhancer = new Enhancer();  
 @SuppressWarnings("unchecked")  
 public <T> T getProxy(Class<T> clazz) {  
 enhancer.setSuperclass(clazz);  
 enhancer.setCallback(this);  
 return (T) enhancer.create();  
 }  
 @Override  
 public Object intercept(Object arg0, Method arg1, Object[] arg2,  
 MethodProxy arg3) throws Throwable {  
 MonitorSession.begin(arg1.getName());  
 Object obj = arg3.invokeSuper(arg0, arg2);  
 MonitorSession.end();  
 return obj;  
 }  
} 

類似的通過getProxy可以得到這個代理對象，intercept就是具體的執行方法，可以看到我們在執行每個真正的方法前后都加了Monitor。

在工廠類中增加獲得Person代理類的方法, 

public static Person newCglibProxy() {  
 CGLibProxy cglibProxy = CGLibProxy.getInstance();  
 Person proxy = cglibProxy.getProxy(Person.class);  
 return proxy;  
} 

具體使用 

// cglib dynamic proxy  
System.out.println("******** cglib proxy ******** ");  
Person cglibProxy = PersonProxyFactory.newCglibProxy();  
cglibProxy.sayHi();  
cglibProxy.sayBye(); 

輸出結果： 

begin monitor..Hi!!end monitor..Method: sayHi, execution time: 53 milliseconds.begin monitor..Bye!!end monitor..Method: sayBye, execution time: 14 milliseconds. 

小結

對比JDK動態代理和CGLib代理，在實際使用中發現CGLib在創建代理對象時所花費的時間卻比JDK動態代理要長，實測數據 

Method: newJdkProxy, execution time: 5 milliseconds.  
Method: newCglibProxy, execution time: 18 milliseconds. 

所以CGLib更適合代理不需要頻繁實例化的類。

在具體方法執行效率方面，理應是不通過反射的CGlib更快一些，然后測試結果并非如此，還需要高手指教。   

JDKMethod: sayHi, execution time: 32 milliseconds.CGLibMethod: sayHi, execution time: 53 milliseconds.