溫馨提示×
您好，登錄后才能下訂單哦！
點擊 登錄注冊 即表示同意《億速云用戶服務條款》
您好，登錄后才能下訂單哦！
簡介
Java編程的目標是實現現實不能完成的，優化現實能夠完成的，是一種虛擬技術。生活中的方方面面都可以虛擬到代碼中。代理模式所講的就是現實生活中的這么一個概念：中介。
代理模式的定義：給某一個對象提供一個代理，并由代理對象控制對原對象的引用。
代理模式包含如下角色：
ISubject：抽象主題角色，是一個接口。該接口是對象和它的代理共用的接口。
RealSubject：真實主題角色，是實現抽象主題接口的類。
Proxy：代理角色，內部含有對真實對象RealSubject的引用，從而可以操作真實對象。代理對象提供與真實對象相同的接口，以便在任何時刻都能代替真實對象。同時，代理對象可以在執行真實對象操作時，附加其他的操作，相當于對真實對象進行封裝。
實現動態代理的關鍵技術是反射。
靜態代理
代理模式有幾種，虛擬代理，計數代理，遠程代理，動態代理。主要分為兩類，靜態代理和動態代理。靜態代理比較簡單，是由程序員編寫的代理類，并在程序運行前就編譯好的，而不是由程序動態產生代理類，這就是所謂的靜態。
考慮這樣的場景，管理員在網站上執行操作，在生成操作結果的同時需要記錄操作日志，這是很常見的。此時就可以使用代理模式，代理模式可以通過聚合和繼承兩種方式實現：
/**方式一：聚合式靜態代理
* @author Goser (mailto:goskalrie@163.com)
* @Since 2016年9月7日
*/
//1.抽象主題接口
public interface Manager {
void doSomething();
}
//2.真實主題類
public class Admin implements Manager {
public void doSomething() {
System.out.println("Admin do something.");
}
}
//3.以聚合方式實現的代理主題
public class AdminPoly implements Manager{
private Admin admin;
public AdminPoly(Admin admin) {
super();
this.admin = admin;
}
public void doSomething() {
System.out.println("Log:admin操作開始");
admin.doSomething();
System.out.println("Log:admin操作結束");
}
}
//4.測試代碼
Admin admin = new Admin();
Manager m = new AdminPoly(admin);
m.doSomething();
//方式二：繼承式靜態代理
//與上面的方式僅代理類和測試代碼不同
//1.代理類
public class AdminProxy extends Admin {
@Override
public void doSomething() {
System.out.println("Log:admin操作開始");
super.doSomething();
System.out.println("Log:admin操作開始");
}
}
//2.測試代碼
AdminProxy proxy = new AdminProxy();
proxy.doSomething();
聚合實現方式中代理類聚合了被代理類，且代理類及被代理類都實現了同一個接口，可實現靈活多變。繼承式的實現方式則不夠靈活。
比如，在管理員操作的同時需要進行權限的處理，操作內容的日志記錄，操作后數據的變化三個功能。三個功能的排列組合有6種，也就是說使用繼承要編寫6個繼承了Admin的代理類，而使用聚合，僅需要針對權限的處理、日志記錄和數據變化三個功能編寫代理類，在業務邏輯中根據具體需求改變代碼順序即可。
動態代理
一般來說，對代理模式而言，一個主題類與一個代理類一一對應，這也是靜態代理模式的特點。
但是，也存在這樣的情況，有n各主題類，但是代理類中的“前處理、后處理”都是一樣的，僅調用主題不同。也就是說，多個主題類對應一個代理類，共享“前處理，后處理”功能，動態調用所需主題，大大減小了程序規模，這就是動態代理模式的特點。
JDK動態代理
實現
//1. 抽象主題
public interface Moveable {
void move() throws Exception;
}
//2. 真實主題
public class Car implements Moveable {
public void move() throws Exception {
Thread.sleep(new Random().nextInt(1000));
System.out.println("汽車行駛中…");
}
}
//3.事務處理器
public class TimeHandler implements InvocationHandler {
private Object target;
public TimeHandler(Object target) {
super();
this.target = target;
}
/**
* 參數：
*proxy 被代理的對象
*method 被代理對象的方法
*args 方法的參數
* 返回：
*Object 方法返回值
*/
public Object invoke(Object proxy, Method method, Object[] args)
throws Throwable {
long startTime = System.currentTimeMillis();
System.out.println("汽車開始行駛…");
method.invoke(target, args);
long stopTime = System.currentTimeMillis();
System.out.println("汽車結束行駛…汽車行駛時間：" + (stopTime - startTime) + "毫秒！");
return null;
}
}
//測試類
public class Test {
public static void main(String[] args) throws Exception{
Car car = new Car();
InvocationHandler h = new TimeHandler(car);
Class<!--?--> cls = car.getClass();
/**
*loader 類加載器
*interfaces 實現接口
*h InvocationHandler
*/
Moveable m = (Moveable) Proxy.newProxyInstance(cls.getClassLoader(),cls.getInterfaces(), h);
m.move();
}
}
代碼講解：
在測試代碼中，Proxy.newProxyInstance()方法需要3個參數：類加載器（要進行代理的類）、被代理類實現的接口，事務處理器。所以先實例化Car，實例化InvocationHandler的子類TimeHandler，將各參數傳入Proxy的靜態方法newProxyInstance()即可獲得Car的代理類，前面的靜態代理，代理類是我們編寫好的，而動態代理則不需要我們去編寫代理類，是在程序中動態生成的。
JDK動態代理步驟
1.創建一個實現InvocationHandler接口的類，它必須實現invoke()方法
2.創建被代理的類及接口
3.調用Proxy的靜態方法，創建一個代理類
4.通過代理調用方法
而為什么要進行如此操作，可以從Proxy和InvocationHandler的源碼中找打答案。對源碼不感興趣的可以將下面的源碼部分小節略過。
JDK動態代理原理與源碼
newProxyInstance()方法的源碼：
public static Object newProxyInstance(ClassLoader loader,
Class<!--?-->[] interfaces,
InvocationHandler h)
throws IllegalArgumentException{
if (h == null) {
throw new NullPointerException();
}
final Class<!--?-->[] intfs = interfaces.clone();
final SecurityManager sm = System.getSecurityManager();
if (sm != null) {
checkProxyAccess(Reflection.getCallerClass(), loader, intfs);
}
/*查找或生成指定的代理類*/
Class<!--?--> cl = getProxyClass0(loader, intfs);
/*用指定的調用處理程序調用它的構造函數.*/
try {
//獲得類的構造函數
final Constructor<!--?--> cons =cl.getConstructor(constructorParams);
final InvocationHandler ih = h;
if (sm != null && ProxyAccessHelper.needsNewInstanceCheck(cl)) {
//當需要代理的類實現了一個非public的接口時，因為這樣的接口需要特殊的權限，因此調用doPrivilege（native 修飾的方法）創建代理實例。
return AccessController.doPrivileged(newPrivilegedAction<object>() {
public Object run() {
return newInstance(cons,ih);
}
});
} else {
return newInstance(cons,ih);
}
} catch (NoSuchMethodException e) {
throw new InternalError(e.toString());
}
}
可以看到，獲得代理類的代碼是
Classcl = getProxyClass0(loader,intfs);
并由此獲得代理類的構造函數，生成代理類的實例返回給該方法的調用者。
繼續跟進getProxyClass0()方法：
/** 生成代理類。調用該方法前必須使用checkproxyaccess方法執行權限檢查。*/
private static Class<!--?--> getProxyClass0(ClassLoader loader,
Class<!--?-->... interfaces) {
//檢查實現的接口數，65535這個數字好特殊，端口數好像也是這個，這個數字是由虛擬機所決定的，2^16-1個
if (interfaces.length > 65535) {
throw new IllegalArgumentException("interface limit exceeded");
}
// 如果代理類已經通過實現給定接口的類加載器創建了，則返回緩存中的該類的副本；否則將通過ProxyClassFactory創建代理類
return proxyClassCache.get(loader, interfaces);
}
還是沒有看到代理類是怎么生成的，只知道代理類是從proxyClassCache中取得的，這個變量是與緩存相關的一個對象，查看該變量的聲明與初始化：
private static final WeakCache<classloader,>[], Class<!--?-->>
proxyClassCache = new WeakCache<>(new KeyFactory(), new ProxyClassFactory());</classloader,>
可以發現proxyClassCache是個用來緩存代理類的類變量，大家知道類變量的特點是與類一一對應，在一個虛擬機中類只有一個，對應著在一個虛擬機中類變量也只有一個，且在此處，在Proxy類被加載的時候就賦值了。在賦值操作的參數中有ProxyClassFactory()這么一個構造函數，這個是動態代理中的關鍵：生成代理類的類文件字節碼。繼續跟進去，找到代理類的生成之處了：
/** 根據給定的類加載器和接口數組生成代理類的工廠類*/
private static final class ProxyClassFactory
implements BiFunction<classloader,class<?>[], Class<!--?-->>
{
// 所有代理類名稱的前綴
private static final String proxyClassNamePrefix = "$Proxy";
//用于生成唯一代理類名稱的下一個序號
private static final AtomicLong nextUniqueNumber = new AtomicLong();
@Override
public Class<!--?--> apply(ClassLoader loader,Class<!--?-->[] interfaces) {
Map<class<?>, Boolean>interfaceSet = new IdentityHashMap<>(interfaces.length);
for (Class<!--?--> intf : interfaces) {
/* 驗證類加載器將此接口的名稱解析為實際對象的名稱。*/
Class<!--?--> interfaceClass =null;
try {
interfaceClass = Class.forName(intf.getName(),false, loader);
} catch (ClassNotFoundException e) {
}
if (interfaceClass != intf) {
throw new IllegalArgumentException(
intf + " is not visible from classloader");
}
/* 驗證類對象確實是一個接口。*/
if (!interfaceClass.isInterface()) {
throw new IllegalArgumentException(
interfaceClass.getName() + " is not an interface");
}
/*確保接口唯一*/
if (interfaceSet.put(interfaceClass, Boolean.TRUE) != null) {
throw new IllegalArgumentException(
"repeated interface: " + interfaceClass.getName());
}
}
String proxyPkg = null; // 代理類的包名
/*記錄非公開代理接口的包，以便將代理類定義在同一個包中。確認所有非公共代理接口都在同一個包中。*/
for (Class<!--?--> intf : interfaces) {
int flags = intf.getModifiers();
if (!Modifier.isPublic(flags)) {
String name =intf.getName();
int n = name.lastIndexOf('.');
String pkg = ((n == -1) ? "" : name.substring(0, n + 1));
if (proxyPkg == null) {
proxyPkg = pkg;
} else if (!pkg.equals(proxyPkg)) {
throw new IllegalArgumentException(
"non-public interfaces fromdifferent packages");
}
}
}
if (proxyPkg == null) {
// 如果沒有非公開的代理接口，使用com.sun.proxy作為包名
proxyPkg = ReflectUtil.PROXY_PACKAGE + ".";
}
/* 生成代理類名的序號*/
long num = nextUniqueNumber.getAndIncrement();
//生成全類名
String proxyName = proxyPkg + proxyClassNamePrefix + num;
/*生成代理類字節碼 */
byte[] proxyClassFile = ProxyGenerator.generateProxyClass(proxyName,interfaces);
try {
return defineClass0(loader, proxyName,proxyClassFile, 0, proxyClassFile.length);
} catch (ClassFormatError e) {
throw new IllegalArgumentException(e.toString());
}
}
}
在ProxyClassFactory中，可以看到產生代理類的具體邏輯，大致上是，根據傳遞的被代理類及其實現的接口生成代理類的字節碼加載到緩存中，但是加載到緩存中只是一個.java文件也不能用，所以底層還有編譯等操作。到這里，可以大致的看清JDK中動態代理的面孔了，實現的步驟為：
1.創建代理類的源碼；
2.對源碼進行編譯成字節碼；
3.將字節碼加載到內存；
4.實例化代理類對象并返回給調用者；
底層的代碼我們看不到，但是我們可以查看其生成的字節碼：
//獲得字節碼的測試方法
byte[] classFile = ProxyGenerator.generateProxyClass("$Proxy1", Car.class.getInterfaces());
FileOutputStream out = null;
try {
out = new FileOutputStream(System.getProperty("user.dir") + "\\$Proxy1.class");
out.write(classFile);
out.flush();
} catch (Exception e) {
e.printStackTrace();
} finally {
try {
out.close();
} catch (IOException e) {
e.printStackTrace();
}
}
//生成的字節碼：
importcn.com.goser.proxy.imooc.staticproxy.Moveable;
importjava.lang.reflect.InvocationHandler;
importjava.lang.reflect.Method;
importjava.lang.reflect.Proxy;
import java.lang.reflect.UndeclaredThrowableException;
public final class $Proxy1 extends Proxy
implements Moveable
{
private static Method m1;
private static Method m3;
private static Method m0;
private static Method m2;
public $Proxy1(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 (RuntimeException localRuntimeException)
{
throw localRuntimeException;
}
catch (Throwable localThrowable)
{
}
throw new UndeclaredThrowableException(localThrowable);
}
public final void move()
throws Exception
{
try
{
this.h.invoke(this, m3, null);
return;
}
catch (Exception localException)
{
throw localException;
}
catch (Throwable localThrowable)
{
}
throw new UndeclaredThrowableException(localThrowable);
}
public final int hashCode()
throws
{
try
{
return ((Integer)this.h.invoke(this, m0, null)).intValue();
}
catch (RuntimeException localRuntimeException)
{
throw localRuntimeException;
}
catch (Throwable localThrowable)
{
}
throw new UndeclaredThrowableException(localThrowable);
}
public final String toString()
throws
{
try
{
return (String)this.h.invoke(this, m2, null);
}
catch (RuntimeException localRuntimeException)
{
throw localRuntimeException;
}
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("cn.com.goser.proxy.imooc.staticproxy.Moveable").getMethod("move", 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 (NoSuchMethodExceptionlocalNoSuchMethodException)
{
throw new NoSuchMethodError(localNoSuchMethodException.getMessage());
}
catch (ClassNotFoundExceptionlocalClassNotFoundException)
{
}
throw new NoClassDefFoundError(localClassNotFoundException.getMessage());
}
}
生成的字節碼比較長，但是在字節碼中最關鍵的信息是代理類的聲明：
public final class $Proxy1 extends Proxy
可以看到生成的代理類是繼承了Proxy類的，這就是說明了為什么使用JDK動態代理不能實現繼承式動態代理，原因是Java不允許多繼承，而生成的代理類本身就已經繼承了Proxy類。
至此，JDK的動態代理的使用及底層原理分析完畢，揭下動態代理的神秘面紗，果然是枚美女。
至于最底層的native方法是怎么動態生成代理類的字節碼我們也可以簡單的模擬一下，先分析下模擬的步驟：首先要生成一段代理類的源碼，然后將源碼編譯后生成代理類的實例返回給調用者。依據此步驟開始編寫我們的模擬代碼：
/**
* JDK java.lang.reflect.Proxy的模擬
* @author Goser (mailto:goskalrie@163.com)
* @Since 2016年9月7日
*/
public class Proxy {
private static final String RT = "\r\n";
public static Object newProxyInstance() throws Exception{
//聲明一段源碼
String sourceCode =
"packagecn.com.goser.proxy.jdk.simulate;"+ RT +
"importcn.com.goser.proxy.imooc.staticproxy.Admin;" + RT +
"importcn.com.goser.proxy.imooc.staticproxy.Manager;" + RT +
"http://以聚合方式實現的代理主題" + RT +
"public class $Proxy0 implementsManager{" + RT +
" privateAdmin admin;" + RT +
" public$Proxy0(Admin admin) {" + RT +
" super();" + RT +
" this.admin= admin;" + RT +
" }" + RT +
" publicvoid doSomething() {" + RT +
" System.out.println(\"Log:admin操作開始\");" + RT +
" admin.doSomething();" + RT +
" System.out.println(\"Log:admin操作結束\");" + RT +
" }" + RT +
"}";
String filename = System.getProperty("user.dir") + "/src/main/java/cn/com/goser/proxy/jdk/simulate/$Proxy0.java";
File file = new File(filename);
//使用org.apache.commons.io.FileUtils.writeStringToFile()將源碼寫入磁盤
//編寫到處，可以運行一下程序，可以在當前目錄中看到生成的.java文件
FileUtils.writeStringToFile(file,sourceCode);
//獲得當前系統中的編譯器
JavaCompiler complier = ToolProvider.getSystemJavaCompiler();
//獲得文件管理者
StandardJavaFileManager fileMgr =complier.getStandardFileManager(null, null, null);
Iterable its =fileMgr.getJavaFileObjects(filename);
//編譯任務
CompilationTask task = complier.getTask(null, fileMgr, null, null, null, its);
//開始編譯，執行完可在當前目錄下看到.class文件
task.call();
fileMgr.close();
//load到內存
ClassLoader loader = ClassLoader.getSystemClassLoader();
Class cls = loader.loadClass("cn.com.goser.proxy.jdk.simulate.$Proxy0");
//生成代理類對象
Constructor ct = cls.getConstructor(Admin.class);
return ct.newInstance(new Admin());
}
}
class test{
public static void main(String[] args) throws Exception {
Manager m = (Manager)Proxy.newProxyInstance();
m.doSomething();
}
}
運行測試代碼，結果和手工編寫的結果一致，完成了JDK中動態代理的實現模擬。
cglib動態代理
前面分析到，因為Java只允許單繼承，而JDK生成的代理類本身就繼承了Proxy類，因此，使用JDK實現的動態代理不能完成繼承式的動態代理，但是我們可以使用cglib來實現繼承式的動態代理。
大名鼎鼎的Spring中就含有cglib動態代理，在此也以Spring中自帶的cglib完成動態代理的實現：
//1.具體主題
public class Train{
public void move(){
System.out.println("火車行駛中…");
}
}
//2.生成代理
public class CGLibProxy implements MethodInterceptor {
private Enhancer enhancer = new Enhancer();
public Object getProxy(Class<!--?--> clazz){
enhancer.setSuperclass(clazz);
enhancer.setCallback(this);
return enhancer.create();
}
/**
* 攔截所有目標類方法的調用
* 參數：
* obj目標實例對象
*method 目標方法的反射對象
* args方法的參數
* proxy代理類的實例
*/
public Object intercept(Object obj, Method method, Object[] args,
MethodProxy proxy) throws Throwable {
//代理類調用父類的方法
System.out.println("日志開始");
proxy.invokeSuper(obj, args);
System.out.println("日志結束");
return null;
}
}
//3.測試
public class Test {
public static void main(String[] args) {
CGLibProxy proxy = new CGLibProxy();
Train t = (Train) proxy.getProxy(Train.class);
t.move();
}
}
小結
動態代理與靜態代理相比較，最大的好處是接口中聲明的所有方法都被轉移到調用處理器一個集中的方法中處理。在接口方法數量比較多的時候，我們可以進行靈活處理，而不需要像靜態代理那樣對每一個方法或方法組合進行處理。Proxy 很美很強大，但是僅支持 interface 代理。Java 的單繼承機制注定了這些動態代理類們無法實現對 class 的動態代理。好在有cglib為Proxy提供了彌補。class與interface的區別本來就模糊，在java8中更是增加了一些新特性，使得interface越來越接近class，當有一日，java突破了單繼承的限制，動態代理將會更加強大。
以上就是本文關于Java設計模式之代理模式原理及實現代碼分享的全部內容，希望對大家有所幫助。感興趣的朋友可以繼續參閱本站：快速理解Java設計模式中的組合模式、Java設計者模式簡單工廠模式解析、Java設計模式之訪問者模式使用場景及代碼示例等，有什么問題可以隨時留言，小編會及時回復大家的。感謝朋友們對本站的支持！
免責聲明：本站發布的內容（圖片、視頻和文字）以原創、轉載和分享為主，文章觀點不代表本網站立場，如果涉及侵權請聯系站長郵箱：is@yisu.com進行舉報，并提供相關證據，一經查實，將立刻刪除涉嫌侵權內容。
