Java動態代理的兩種實現方法

AOP的攔截功能是由java中的動態代理來實現的。說白了，就是在目標類的基礎上增加切面邏輯，生成增強的目標類（該切面邏輯或者在目標類函數執行之前，或者目標類函數執行之后，或者在目標類函數拋出異常時候執行。不同的切入時機對應不同的Interceptor的種類，如BeforeAdviseInterceptor，AfterAdviseInterceptor以及ThrowsAdviseInterceptor等）。

 

那么動態代理是如何實現將切面邏輯（advise）織入到目標類方法中去的呢？下面我們就來詳細介紹並實現AOP中用到的兩種動態代理。

AOP的源碼中用到了兩種動態代理來實現攔截切入功能：jdk動態代理和cglib動態代理。兩種方法同時存在，各有優劣。

jdk動態代理是由java內部的反射機制來實現的，cglib動態代理底層則是借助asm來實現的。

總的來說，反射機制在生成類的過程中比較高效，而asm在生成類之后的相關執行過程中比較高效（可以通過將asm生成的類進行緩存，這樣解決asm生成類過程低效問題）。還有一點必須注意：jdk動態代理的應用前提，必須是目標類基於統一的接口。如果沒有上述前提，jdk動態代理不能應用。由此可以看出，jdk動態代理有一定的局限性，cglib這種第三方類庫實現的動態代理應用更加廣泛，且在效率上更有優勢。。

1、定義接口和實現

    package com.meituan.hyt.test3.service;
     
     
    public interface UserService {
    public String getName(int id);
     
    public Integer getAge(int id);
    }

 

 

    package com.meituan.hyt.test3.service.impl;
     
    import com.meituan.hyt.test3.service.UserService;
     
     
    public class UserServiceImpl implements UserService {
    @Override
    public String getName(int id) {
    System.out.println("------getName------");
    return "Tom";
    }
     
    @Override
    public Integer getAge(int id) {
    System.out.println("------getAge------");
    return 10;
    }
    }

 

 

2、jdk動態代理實現

jdk動態代理是jdk原生就支持的一種代理方式，它的實現原理，就是通過讓target類和代理類實現同一接口，代理類持有target對象，來達到方法攔截的作用，這樣通過接口的方式有兩個弊端，一個是必須保證target類有接口，第二個是如果想要對target類的方法進行代理攔截，那么就要保證這些方法都要在接口中聲明，實現上略微有點限制。

    package com.meituan.hyt.test3.jdk;
     
    import java.lang.reflect.InvocationHandler;
    import java.lang.reflect.Method;
     
     
    public class MyInvocationHandler implements InvocationHandler {
    private Object target;
     
    MyInvocationHandler() {
    super();
    }
     
    MyInvocationHandler(Object target) {
    super();
    this.target = target;
    }
     
    @Override
    public Object invoke(Object o, Method method, Object[] args) throws Throwable {
    if("getName".equals(method.getName())){
    System.out.println("++++++before " + method.getName() + "++++++");
    Object result = method.invoke(target, args);
    System.out.println("++++++after " + method.getName() + "++++++");
    return result;
    }else{
    Object result = method.invoke(target, args);
    return result;
    }
     
    }
    }

 

 

    package com.meituan.hyt.test3.jdk;
     
    import com.meituan.hyt.test3.service.UserService;
    import com.meituan.hyt.test3.service.impl.UserServiceImpl;
     
    import java.lang.reflect.InvocationHandler;
    import java.lang.reflect.Proxy;
     
     
    public class Main1 {
    public static void main(String[] args) {
    UserService userService = new UserServiceImpl();
    InvocationHandler invocationHandler = new MyInvocationHandler(userService);
    UserService userServiceProxy = (UserService)Proxy.newProxyInstance(userService.getClass().getClassLoader(),
    userService.getClass().getInterfaces(), invocationHandler);
    System.out.println(userServiceProxy.getName(1));
    System.out.println(userServiceProxy.getAge(1));
    }
    }

 

運行結果

++++++before getName++++++
------getName------
++++++after getName++++++
Tom
------getAge------
10

3、cglib動態代理實現

Cglib是一個優秀的動態代理框架，它的底層使用ASM在內存中動態的生成被代理類的子類，使用CGLIB即使代理類沒有實現任何接口也可以實現動態代理功能。CGLIB具有簡單易用，它的運行速度要遠遠快於JDK的Proxy動態代理：

cglib有兩種可選方式，繼承和引用。第一種是基於繼承實現的動態代理，所以可以直接通過super調用target方法，但是這種方式在spring中是不支持的，因為這樣的話，這個target對象就不能被spring所管理，所以cglib還是才用類似jdk的方式，通過持有target對象來達到攔截方法的效果。

CGLIB的核心類：
    net.sf.cglib.proxy.Enhancer – 主要的增強類
    net.sf.cglib.proxy.MethodInterceptor – 主要的方法攔截類，它是Callback接口的子接口，需要用戶實現
    net.sf.cglib.proxy.MethodProxy – JDK的java.lang.reflect.Method類的代理類，可以方便的實現對源對象方法的調用,如使用：
    Object o = methodProxy.invokeSuper(proxy, args);//雖然第一個參數是被代理對象，也不會出現死循環的問題。

net.sf.cglib.proxy.MethodInterceptor接口是最通用的回調（callback）類型，它經常被基於代理的AOP用來實現攔截（intercept）方法的調用。這個接口只定義了一個方法
public Object intercept(Object object, java.lang.reflect.Method method,
Object[] args, MethodProxy proxy) throws Throwable;

第一個參數是代理對像，第二和第三個參數分別是攔截的方法和方法的參數。原來的方法可能通過使用java.lang.reflect.Method對象的一般反射調用，或者使用 net.sf.cglib.proxy.MethodProxy對象調用。net.sf.cglib.proxy.MethodProxy通常被首選使用，因為它更快。

    package com.meituan.hyt.test3.cglib;
     
     
    import net.sf.cglib.proxy.MethodInterceptor;
    import net.sf.cglib.proxy.MethodProxy;
     
    import java.lang.reflect.Method;
     
     
    public class CglibProxy implements MethodInterceptor {
    @Override
    public Object intercept(Object o, Method method, Object[] args, MethodProxy methodProxy) throws Throwable {
    System.out.println("++++++before " + methodProxy.getSuperName() + "++++++");
    System.out.println(method.getName());
    Object o1 = methodProxy.invokeSuper(o, args);
    System.out.println("++++++before " + methodProxy.getSuperName() + "++++++");
    return o1;
    }
    }

 

    package com.meituan.hyt.test3.cglib;
     
    import com.meituan.hyt.test3.service.UserService;
    import com.meituan.hyt.test3.service.impl.UserServiceImpl;
    import net.sf.cglib.proxy.Enhancer;
     
     
     
    public class Main2 {
    public static void main(String[] args) {
    CglibProxy cglibProxy = new CglibProxy();
     
    Enhancer enhancer = new Enhancer();
    enhancer.setSuperclass(UserServiceImpl.class);
    enhancer.setCallback(cglibProxy);
     
    UserService o = (UserService)enhancer.create();
    o.getName(1);
    o.getAge(1);
    }
    }

 

運行結果：

++++++before CGLIB$getName$0++++++
getName
------getName------
++++++before CGLIB$getName$0++++++
++++++before CGLIB$getAge$1++++++
getAge
------getAge------

++++++before CGLIB$getAge$1++++++

 

4、需要注意的問題

需要注意的是，當一個方法沒有被aop事務包裹，在該方法內部去調用另外一個有aop事務包裹的方法時，這個方法的aop事務不會生效。比如：

    public void register() {
    aopRegister();
    }
     
    @Transactional
    public void aopRegister() {
     
    }

 

因為通過上面的分析我們知道，在spring中，無論通過jdk的形式還是cglib的形式，代理類對target對象的方法進行攔截，其實都是通過讓代理類持有target對象的引用，當外部引用aop包圍的方法時，調用的其實是代理類對應的方法，代理類持有target對象，便可以控制target方法執行時的全方位攔截。

 

而如果在target的內部方法register調用一個aop包圍的target方法aopRegister，調用的其實就是target自身的方法，因為這時候的this指針是不可能指向代理類的。所以事務是不能生效的。

 

 

原文連接：

 

 https://blog.csdn.net/heyutao007/article/details/49738887