[轉載]Spring AOP的實現機制

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更快一些，然後測試結果並非如此，還需要高手指教。

JDK
Method: sayHi, execution time: 32 milliseconds.
CGLib
Method: sayHi, execution time: 53 milliseconds.