Java動態代理與CGLIB

時間  2019-11-12
標籤 java 動態 代理 cglib 欄目 Java 简体版
原文   原文鏈接

1. 靜態代理模式

由於須要對一些函數進行二次處理，或是某些函數不讓外界知道時，可使用代理模式，經過訪問第三方，間接訪問原函數的方式，達到以上目的，來看一下代理模式的類圖：html

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 靜態代理的弊端

    若是要想爲多個類進行代理，則須要創建多個代理類，維護難度加大。java

    仔細想一想，爲何靜態代理會有這些問題，是由於代理在編譯期就已經決定，若是代理哪一個發生在運行期，這些問題解決起來就比較簡單，因此動態代理的存在就頗有必要了。web

2. 動態代理

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());
	}
}

類比靜態代理，能夠發現，代理類不須要實現原接口了，而是實現InvocationHandler。經過編程

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

來動態生成一個代理類，該類的類加載器與被代理類相同，實現的接口與被代理類相同。數組

經過上述方法生成的代理類至關於靜態代理中的代理類。緩存

這樣就實現了在運行期才決定代理對象是怎麼樣的，解決了靜態代理的弊端。ide

當動態生成的代理類調用方法時，會觸發invoke方法，在invoke方法中能夠對被代理類的方法進行加強。函數

經過動態代理能夠很明顯的看到它的好處，在使用靜態代理時，若是不一樣接口的某些類想使用代理模式來實現相同的功能，將要實現多個代理類，但在動態代理中，只須要一個代理類就行了。工具

除了省去了編寫代理類的工做量，動態代理實現了能夠在原始類和接口還未知的時候，就肯定代理類的代理行爲，當代理類與原始類脫離直接聯繫後，就能夠很靈活地重用於不一樣的應用場景中。優化

2.1 動態代理的弊端

代理類和委託類須要都實現同一個接口。也就是說只有實現了某個接口的類可使用Java動態代理機制。可是，事實上使用中並非遇到的全部類都會給你實現一個接口。所以，對於沒有實現接口的類，就不能使用該機制。

而CGLIB則能夠實現對類的動態代理

2.2 回調函數原理

上文說了，當動態生成的代理類調用方法時，會觸發invoke方法。

很顯然invoke方法並非顯示調用的，它是一個回調函數，那麼回調函數是怎麼被調用的呢？

上述動態代理的代碼中，惟一不清晰的地方只有

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

跟蹤這個方法的源碼，能夠看到程序進行了驗證、優化、緩存、同步、生成字節碼、顯示類加載等操做，前面的步驟並非咱們關注的重點，而最後它調用了

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

該方法用來完成生成字節碼的動做，這個方法能夠在運行時產生一個描述代理類的字節碼byte[]數組。

在main函數中加入

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

加入這句代碼後再次運行程序，磁盤中將會產生一個名爲"$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());
    }
  }
}

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

能夠在上述代碼中看到，不管調用哪一個方法，都會調用到InvocationHandler的invoke方法，只是參數不一樣。

2.3 動態代理與靜態代理的區別

  1. Proxy類的代碼被固定下來，不會由於業務的逐漸龐大而龐大；
  2. 能夠實現AOP編程，這是靜態代理沒法實現的；
  3. 解耦，若是用在web業務下，能夠實現數據層和業務層的分離。
  4. 動態代理的優點就是實現無侵入式的代碼擴展。 靜態代理這個模式自己有個大問題，若是類方法數量愈來愈多的時候，代理類的代碼量是十分龐大的。因此引入動態代理來解決此類問題

3. CGLIB

cglib是針對類來實現代理的，他的原理是對指定的目標類生成一個子類，並覆蓋其中方法實現加強，但由於採用的是繼承，因此不能對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須要指定父類和回調方法。固然cglib也能夠與Java動態代理同樣面向接口，由於本質是繼承。

Reference：

1. http://blog.csdn.net/lidatgb/article/details/8941711

2. http://shensy.iteye.com/blog/1698197

3. http://www.cnblogs.com/jqyp/archive/2010/08/20/1805041.html

4. http://www.shangxueba.com/jingyan/1853835.html

5. 《深刻理解Java虛擬機》

6. http://paddy-w.iteye.com/blog/841798

相關文章
相關標籤/搜索
每日一句
    每一个你不满意的现在，都有一个你没有努力的曾经。
本站公眾號
   歡迎關注本站公眾號,獲取更多信息
聯繫我們 最近搜索 最新文章 沪ICP备13005482号-10 MyBatis教程 SQL 教程 MySQL教程 Java 教程 Thymeleaf 教程 Hibernate教程 Spring教程 Redis教程