Java 動態(tài)代理與CGLIB詳細介紹

更新時間：2017年02月20日 09:48:51 投稿：lqh

這篇文章主要介紹了 Java 動態(tài)代理與CGLIB詳細介紹的相關(guān)資料,需要的朋友可以參考下

靜態(tài)代理模式

因為需要對一些函數(shù)進行二次處理，或是某些函數(shù)不讓外界知道時，可以使用代理模式，通過訪問第三方，間接訪問原函數(shù)的方式，達到以上目的。

interface Hosee{
  String sayhi();
}

class Hoseeimpl implements Hosee{

  @Override
  public String sayhi()
  {
    return "Welcome oschina hosee's blog";
  }

}

class HoseeProxy implements Hosee{

  Hosee h;

  public HoseeProxy(Hosee h)
  {
    this.h = h;
  }

  @Override
  public String sayhi()
  {
    System.out.println("I'm proxy!");
    return h.sayhi();
  }

}


public class StaticProxy
{

  public static void main(String[] args)
  {
    Hoseeimpl h = new Hoseeimpl();
    HoseeProxy hp = new HoseeProxy(h);
    System.out.println(hp.sayhi());
  }

}

1.1 靜態(tài)代理的弊端

如果要想為多個類進行代理，則需要建立多個代理類，維護難度加大。

仔細想想，為什么靜態(tài)代理會有這些問題，是因為代理在編譯期就已經(jīng)決定，如果代理哪個發(fā)生在運行期，這些問題解決起來就比較簡單，所以動態(tài)代理的存在就很有必要了。

2.動態(tài)代理

import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;

interface HoseeDynamic
{
  String sayhi();
}

class HoseeDynamicimpl implements HoseeDynamic
{
  @Override
  public String sayhi()
  {
    return "Welcome oschina hosee's blog";
  }
}

class MyProxy implements InvocationHandler
{
  Object obj;
  public Object bind(Object obj)
  {
    this.obj = obj;
    return Proxy.newProxyInstance(obj.getClass().getClassLoader(), obj
        .getClass().getInterfaces(), this);
  }
  @Override
  public Object invoke(Object proxy, Method method, Object[] args)
      throws Throwable
  {
    System.out.println("I'm proxy!");
    Object res = method.invoke(obj, args);
    return res;
  }
}

public class DynamicProxy
{
  public static void main(String[] args)
  {
    MyProxy myproxy = new MyProxy();
    HoseeDynamicimpl dynamicimpl = new HoseeDynamicimpl();
    HoseeDynamic proxy = (HoseeDynamic)myproxy.bind(dynamicimpl);
    System.out.println(proxy.sayhi());
  }
}

類比靜態(tài)代理，可以發(fā)現(xiàn)，代理類不需要實現(xiàn)原接口了，而是實現(xiàn)InvocationHandler。通過

Proxy.newProxyInstance(obj.getClass().getClassLoader(), obj
        .getClass().getInterfaces(), this);

來動態(tài)生成一個代理類，該類的類加載器與被代理類相同，實現(xiàn)的接口與被代理類相同。

通過上述方法生成的代理類相當于靜態(tài)代理中的代理類。

這樣就實現(xiàn)了在運行期才決定代理對象是怎么樣的，解決了靜態(tài)代理的弊端。

當動態(tài)生成的代理類調(diào)用方法時，會觸發(fā)invoke方法，在invoke方法中可以對被代理類的方法進行增強。

通過動態(tài)代理可以很明顯的看到它的好處，在使用靜態(tài)代理時，如果不同接口的某些類想使用代理模式來實現(xiàn)相同的功能，將要實現(xiàn)多個代理類，但在動態(tài)代理中，只需要一個代理類就好了。

除了省去了編寫代理類的工作量，動態(tài)代理實現(xiàn)了可以在原始類和接口還未知的時候，就確定代理類的代理行為，當代理類與原始類脫離直接聯(lián)系后，就可以很靈活地重用于不同的應(yīng)用場景中。

2.1 動態(tài)代理的弊端

代理類和委托類需要都實現(xiàn)同一個接口。也就是說只有實現(xiàn)了某個接口的類可以使用Java動態(tài)代理機制。但是，事實上使用中并不是遇到的所有類都會給你實現(xiàn)一個接口。因此，對于沒有實現(xiàn)接口的類，就不能使用該機制。

而CGLIB則可以實現(xiàn)對類的動態(tài)代理

2.2 回調(diào)函數(shù)原理

上文說了，當動態(tài)生成的代理類調(diào)用方法時，會觸發(fā)invoke方法。

很顯然invoke方法并不是顯示調(diào)用的，它是一個回調(diào)函數(shù)，那么回調(diào)函數(shù)是怎么被調(diào)用的呢？

上述動態(tài)代理的代碼中，唯一不清晰的地方只有

Proxy.newProxyInstance(obj.getClass().getClassLoader(), obj
        .getClass().getInterfaces(), this);

跟蹤這個方法的源碼，可以看到程序進行了驗證、優(yōu)化、緩存、同步、生成字節(jié)碼、顯示類加載等操作，前面的步驟并不是我們關(guān)注的重點，而最后它調(diào)用了

byte[] proxyClassFile = ProxyGenerator.generateProxyClass(
        proxyName, interfaces);

該方法用來完成生成字節(jié)碼的動作，這個方法可以在運行時產(chǎn)生一個描述代理類的字節(jié)碼byte[]數(shù)組。

在main函數(shù)中加入

System.getProperties().put("sun.misc.ProxyGenerator.saveGeneratedFiles","true");

加入這句代碼后再次運行程序，磁盤中將會產(chǎn)生一個名為”$Proxy().class”的代理類Class文件，反編譯（反編譯工具我使用的是 JD-GUI ）后可以看見如下代碼：

import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;
import java.lang.reflect.UndeclaredThrowableException;

public final class $Proxy0 extends Proxy
 implements HoseeDynamic
{
 private static Method m1;
 private static Method m3;
 private static Method m0;
 private static Method m2;

 public $Proxy0(InvocationHandler paramInvocationHandler)
  throws 
 {
  super(paramInvocationHandler);
 }

 public final boolean equals(Object paramObject)
  throws 
 {
  try
  {
   return ((Boolean)this.h.invoke(this, m1, new Object[] { paramObject })).booleanValue();
  }
  catch (Error|RuntimeException localError)
  {
   throw localError;
  }
  catch (Throwable localThrowable)
  {
   throw new UndeclaredThrowableException(localThrowable);
  }
 }

 public final String sayhi()
  throws 
 {
  try
  {
   return (String)this.h.invoke(this, m3, null);
  }
  catch (Error|RuntimeException localError)
  {
   throw localError;
  }
  catch (Throwable localThrowable)
  {
   throw new UndeclaredThrowableException(localThrowable);
  }
 }

 public final int hashCode()
  throws 
 {
  try
  {
   return ((Integer)this.h.invoke(this, m0, null)).intValue();
  }
  catch (Error|RuntimeException localError)
  {
   throw localError;
  }
  catch (Throwable localThrowable)
  {
   throw new UndeclaredThrowableException(localThrowable);
  }
 }

 public final String toString()
  throws 
 {
  try
  {
   return (String)this.h.invoke(this, m2, null);
  }
  catch (Error|RuntimeException localError)
  {
   throw localError;
  }
  catch (Throwable localThrowable)
  {
   throw new UndeclaredThrowableException(localThrowable);
  }
 }

 static
 {
  try
  {
   m1 = Class.forName("java.lang.Object").getMethod("equals", new Class[] { Class.forName("java.lang.Object") });
   m3 = Class.forName("HoseeDynamic").getMethod("sayhi", new Class[0]);
   m0 = Class.forName("java.lang.Object").getMethod("hashCode", new Class[0]);
   m2 = Class.forName("java.lang.Object").getMethod("toString", new Class[0]);
   return;
  }
  catch (NoSuchMethodException localNoSuchMethodException)
  {
   throw new NoSuchMethodError(localNoSuchMethodException.getMessage());
  }
  catch (ClassNotFoundException localClassNotFoundException)
  {
   throw new NoClassDefFoundError(localClassNotFoundException.getMessage());
  }
 }
}

動態(tài)代理類不僅代理了顯示定義的接口中的方法，而且還代理了java的根類Object中的繼承而來的equals()、hashcode()、toString()這三個方法，并且僅此三個方法。

可以在上述代碼中看到，無論調(diào)用哪個方法，都會調(diào)用到InvocationHandler的invoke方法，只是參數(shù)不同。

2.3 動態(tài)代理與靜態(tài)代理的區(qū)別

Proxy類的代碼被固定下來，不會因為業(yè)務(wù)的逐漸龐大而龐大；

可以實現(xiàn)AOP編程，這是靜態(tài)代理無法實現(xiàn)的；

解耦，如果用在web業(yè)務(wù)下，可以實現(xiàn)數(shù)據(jù)層和業(yè)務(wù)層的分離。

動態(tài)代理的優(yōu)勢就是實現(xiàn)無侵入式的代碼擴展。靜態(tài)代理這個模式本身有個大問題，如果類方法數(shù)量越來越多的時候，代理類的代碼量是十分龐大的。所以引入動態(tài)代理來解決此類問題

3. CGLIB

cglib是針對類來實現(xiàn)代理的，他的原理是對指定的目標類生成一個子類，并覆蓋其中方法實現(xiàn)增強，但因為采用的是繼承，所以不能對final修飾的類進行代理。

import java.lang.reflect.Method;

import net.sf.cglib.proxy.Enhancer;
import net.sf.cglib.proxy.MethodInterceptor;
import net.sf.cglib.proxy.MethodProxy;

class CGlibHosee
{
  public String sayhi()
  {
    return "Welcome oschina hosee's blog";
  }
}

class CGlibHoseeProxy
{
  Object obj;

  public Object bind(final Object target)
  {
    this.obj = target;
    Enhancer enhancer = new Enhancer();
    enhancer.setSuperclass(obj.getClass());
    enhancer.setCallback(new MethodInterceptor()
    {
      @Override
      public Object intercept(Object obj, Method method, Object[] args,
          MethodProxy proxy) throws Throwable
      {
        System.out.println("I'm proxy!");
        Object res = method.invoke(target, args);
        return res;
      }
    });
    return enhancer.create();
  }

}

public class CGlibProxy
{
  public static void main(String[] args)
  {
    CGlibHosee cGlibHosee = new CGlibHosee();
    CGlibHoseeProxy cGlibHoseeProxy = new CGlibHoseeProxy();
    CGlibHosee proxy = (CGlibHosee) cGlibHoseeProxy.bind(cGlibHosee);
    System.out.println(proxy.sayhi());
  }
}

cglib需要指定父類和回調(diào)方法。當然cglib也可以與Java動態(tài)代理一樣面向接口，因為本質(zhì)是繼承。

感謝閱讀，希望能幫助到大家，謝謝大家對本站的支持！

您可能感興趣的文章: