Java動態代理與CGLIB
1. 靜態代理模式
因為需要對一些函式進行二次處理，或是某些函式不讓外界知道時，可以使用代理模式，通過訪問第三方，間接訪問原函式的方式，達到以上目的，來看一下代理模式的類圖：
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 靜態代理的弊端
如果要想為多個類進行代理，則需要建立多個代理類，維護難度加大。
仔細想想，為什麼靜態代理會有這些問題，是因為代理在編譯期就已經決定，如果代理哪個發生在執行期，這些問題解決起來就比較簡單，所以動態代理的存在就很有必要了。
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);
來動態生成一個代理類，該類的類載入器與被代理類相同，實現的介面與被代理類相同。
通過上述方法生成的代理類相當於靜態代理中的代理類。
這樣就實現了在執行期才決定代理物件是怎麼樣的，解決了靜態代理的弊端。
當動態生成的代理類呼叫方法時，會觸發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 動態代理與靜態代理的區別
-
Proxy類的程式碼被固定下來，不會因為業務的逐漸龐大而龐大；
-
可以實現AOP程式設計，這是靜態代理無法實現的；
-
解耦，如果用在web業務下，可以實現資料層和業務層的分離；
-
動態代理的優勢就是實現無侵入式的程式碼擴充套件。 靜態代理這個模式本身有個大問題，如果類方法數量越來越多的時候，代理類的程式碼量是十分龐大的。所以引入動態代理來解決此類問題。
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動態代理一樣面向介面，因為本質是繼承。