Java設計模式之代理模式原理及實現(xiàn)代碼分享
簡介
Java編程的目標是實現(xiàn)現(xiàn)實不能完成的，優(yōu)化現(xiàn)實能夠完成的，是一種虛擬技術。生活中的方方面面都可以虛擬到代碼中。代理模式所講的就是現(xiàn)實生活中的這么一個概念：中介。
代理模式的定義：給某一個對象提供一個代理，并由代理對象控制對原對象的引用。
代理模式包含如下角色：
ISubject：抽象主題角色，是一個接口。該接口是對象和它的代理共用的接口。
RealSubject：真實主題角色，是實現(xiàn)抽象主題接口的類。
Proxy：代理角色，內(nèi)部含有對真實對象RealSubject的引用，從而可以操作真實對象。代理對象提供與真實對象相同的接口，以便在任何時刻都能代替真實對象。同時，代理對象可以在執(zhí)行真實對象操作時，附加其他的操作，相當于對真實對象進行封裝。
實現(xiàn)動態(tài)代理的關鍵技術是反射。
靜態(tài)代理
代理模式有幾種，虛擬代理，計數(shù)代理，遠程代理，動態(tài)代理。主要分為兩類，靜態(tài)代理和動態(tài)代理。靜態(tài)代理比較簡單，是由程序員編寫的代理類，并在程序運行前就編譯好的，而不是由程序動態(tài)產(chǎn)生代理類，這就是所謂的靜態(tài)。
考慮這樣的場景，管理員在網(wǎng)站上執(zhí)行操作，在生成操作結果的同時需要記錄操作日志，這是很常見的。此時就可以使用代理模式，代理模式可以通過聚合和繼承兩種方式實現(xiàn)：
/**方式一：聚合式靜態(tài)代理
* @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.以聚合方式實現(xiàn)的代理主題
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();
//方式二：繼承式靜態(tài)代理
//與上面的方式僅代理類和測試代碼不同
//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();
聚合實現(xiàn)方式中代理類聚合了被代理類，且代理類及被代理類都實現(xiàn)了同一個接口，可實現(xiàn)靈活多變。繼承式的實現(xiàn)方式則不夠靈活。
比如，在管理員操作的同時需要進行權限的處理，操作內(nèi)容的日志記錄，操作后數(shù)據(jù)的變化三個功能。三個功能的排列組合有6種，也就是說使用繼承要編寫6個繼承了Admin的代理類，而使用聚合，僅需要針對權限的處理、日志記錄和數(shù)據(jù)變化三個功能編寫代理類，在業(yè)務邏輯中根據(jù)具體需求改變代碼順序即可。
動態(tài)代理
一般來說，對代理模式而言，一個主題類與一個代理類一一對應，這也是靜態(tài)代理模式的特點。
但是，也存在這樣的情況，有n各主題類，但是代理類中的“前處理、后處理”都是一樣的，僅調(diào)用主題不同。也就是說，多個主題類對應一個代理類，共享“前處理，后處理”功能，動態(tài)調(diào)用所需主題，大大減小了程序規(guī)模，這就是動態(tài)代理模式的特點。
JDK動態(tài)代理
實現(xiàn)
//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;
}
/**
* 參數(shù)：
*proxy 被代理的對象
*method 被代理對象的方法
*args 方法的參數(shù)
* 返回：
*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 實現(xiàn)接口
*h InvocationHandler
*/
Moveable m = (Moveable) Proxy.newProxyInstance(cls.getClassLoader(),cls.getInterfaces(), h);
m.move();
}
}
代碼講解：
在測試代碼中，Proxy.newProxyInstance()方法需要3個參數(shù)：類加載器（要進行代理的類）、被代理類實現(xiàn)的接口，事務處理器。所以先實例化Car，實例化InvocationHandler的子類TimeHandler，將各參數(shù)傳入Proxy的靜態(tài)方法newProxyInstance()即可獲得Car的代理類，前面的靜態(tài)代理，代理類是我們編寫好的，而動態(tài)代理則不需要我們?nèi)ゾ帉懘眍?，是在程序中動態(tài)生成的。
JDK動態(tài)代理步驟
1.創(chuàng)建一個實現(xiàn)InvocationHandler接口的類，它必須實現(xiàn)invoke()方法
2.創(chuàng)建被代理的類及接口
3.調(diào)用Proxy的靜態(tài)方法，創(chuàng)建一個代理類
4.通過代理調(diào)用方法
而為什么要進行如此操作，可以從Proxy和InvocationHandler的源碼中找打答案。對源碼不感興趣的可以將下面的源碼部分小節(jié)略過。
JDK動態(tài)代理原理與源碼
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);
/*用指定的調(diào)用處理程序調(diào)用它的構造函數(shù).*/
try {
//獲得類的構造函數(shù)
final Constructor<!--?--> cons =cl.getConstructor(constructorParams);
final InvocationHandler ih = h;
if (sm != null && ProxyAccessHelper.needsNewInstanceCheck(cl)) {
//當需要代理的類實現(xiàn)了一個非public的接口時，因為這樣的接口需要特殊的權限，因此調(diào)用doPrivilege（native 修飾的方法）創(chuàng)建代理實例。
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);
并由此獲得代理類的構造函數(shù)，生成代理類的實例返回給該方法的調(diào)用者。
繼續(xù)跟進getProxyClass0()方法：
/** 生成代理類。調(diào)用該方法前必須使用checkproxyaccess方法執(zhí)行權限檢查。*/
private static Class<!--?--> getProxyClass0(ClassLoader loader,
Class<!--?-->... interfaces) {
//檢查實現(xiàn)的接口數(shù)，65535這個數(shù)字好特殊，端口數(shù)好像也是這個，這個數(shù)字是由虛擬機所決定的，2^16-1個
if (interfaces.length > 65535) {
throw new IllegalArgumentException("interface limit exceeded");
}
// 如果代理類已經(jīng)通過實現(xiàn)給定接口的類加載器創(chuàng)建了，則返回緩存中的該類的副本；否則將通過ProxyClassFactory創(chuàng)建代理類
return proxyClassCache.get(loader, interfaces);
}
還是沒有看到代理類是怎么生成的，只知道代理類是從proxyClassCache中取得的，這個變量是與緩存相關的一個對象，查看該變量的聲明與初始化：
private static final WeakCache<classloader,>[], Class<!--?-->>
proxyClassCache = new WeakCache<>(new KeyFactory(), new ProxyClassFactory());</classloader,>
可以發(fā)現(xiàn)proxyClassCache是個用來緩存代理類的類變量，大家知道類變量的特點是與類一一對應，在一個虛擬機中類只有一個，對應著在一個虛擬機中類變量也只有一個，且在此處，在Proxy類被加載的時候就賦值了。在賦值操作的參數(shù)中有ProxyClassFactory()這么一個構造函數(shù)，這個是動態(tài)代理中的關鍵：生成代理類的類文件字節(jié)碼。繼續(xù)跟進去，找到代理類的生成之處了：
/** 根據(jù)給定的類加載器和接口數(shù)組生成代理類的工廠類*/
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;
/*生成代理類字節(jié)碼 */
byte[] proxyClassFile = ProxyGenerator.generateProxyClass(proxyName,interfaces);
try {
return defineClass0(loader, proxyName,proxyClassFile, 0, proxyClassFile.length);
} catch (ClassFormatError e) {
throw new IllegalArgumentException(e.toString());
}
}
}
在ProxyClassFactory中，可以看到產(chǎn)生代理類的具體邏輯，大致上是，根據(jù)傳遞的被代理類及其實現(xiàn)的接口生成代理類的字節(jié)碼加載到緩存中，但是加載到緩存中只是一個.java文件也不能用，所以底層還有編譯等操作。到這里，可以大致的看清JDK中動態(tài)代理的面孔了，實現(xiàn)的步驟為：
1.創(chuàng)建代理類的源碼；
2.對源碼進行編譯成字節(jié)碼；
3.將字節(jié)碼加載到內(nèi)存；
4.實例化代理類對象并返回給調(diào)用者；
底層的代碼我們看不到，但是我們可以查看其生成的字節(jié)碼：
//獲得字節(jié)碼的測試方法
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();
}
}
//生成的字節(jié)碼：
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());
}
}
生成的字節(jié)碼比較長，但是在字節(jié)碼中最關鍵的信息是代理類的聲明：
public final class $Proxy1 extends Proxy
可以看到生成的代理類是繼承了Proxy類的，這就是說明了為什么使用JDK動態(tài)代理不能實現(xiàn)繼承式動態(tài)代理，原因是Java不允許多繼承，而生成的代理類本身就已經(jīng)繼承了Proxy類。
至此，JDK的動態(tài)代理的使用及底層原理分析完畢，揭下動態(tài)代理的神秘面紗，果然是枚美女。
至于最底層的native方法是怎么動態(tài)生成代理類的字節(jié)碼我們也可以簡單的模擬一下，先分析下模擬的步驟：首先要生成一段代理類的源碼，然后將源碼編譯后生成代理類的實例返回給調(diào)用者。依據(jù)此步驟開始編寫我們的模擬代碼：
/**
* 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://以聚合方式實現(xiàn)的代理主題" + 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);
//獲得當前系統(tǒng)中的編譯器
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);
//開始編譯，執(zhí)行完可在當前目錄下看到.class文件
task.call();
fileMgr.close();
//load到內(nèi)存
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中動態(tài)代理的實現(xiàn)模擬。
cglib動態(tài)代理
前面分析到，因為Java只允許單繼承，而JDK生成的代理類本身就繼承了Proxy類，因此，使用JDK實現(xiàn)的動態(tài)代理不能完成繼承式的動態(tài)代理，但是我們可以使用cglib來實現(xiàn)繼承式的動態(tài)代理。
大名鼎鼎的Spring中就含有cglib動態(tài)代理，在此也以Spring中自帶的cglib完成動態(tài)代理的實現(xiàn)：
//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();
}
/**
* 攔截所有目標類方法的調(diào)用
* 參數(shù)：
* obj目標實例對象
*method 目標方法的反射對象
* args方法的參數(shù)
* proxy代理類的實例
*/
public Object intercept(Object obj, Method method, Object[] args,
MethodProxy proxy) throws Throwable {
//代理類調(diào)用父類的方法
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();
}
}
小結
動態(tài)代理與靜態(tài)代理相比較，最大的好處是接口中聲明的所有方法都被轉移到調(diào)用處理器一個集中的方法中處理。在接口方法數(shù)量比較多的時候，我們可以進行靈活處理，而不需要像靜態(tài)代理那樣對每一個方法或方法組合進行處理。Proxy 很美很強大，但是僅支持 interface 代理。Java 的單繼承機制注定了這些動態(tài)代理類們無法實現(xiàn)對 class 的動態(tài)代理。好在有cglib為Proxy提供了彌補。class與interface的區(qū)別本來就模糊，在java8中更是增加了一些新特性，使得interface越來越接近class，當有一日，java突破了單繼承的限制，動態(tài)代理將會更加強大。
以上就是本文關于Java設計模式之代理模式原理及實現(xiàn)代碼分享的全部內(nèi)容，希望對大家有所幫助。感興趣的朋友可以繼續(xù)參閱本站：快速理解Java設計模式中的組合模式、Java設計者模式簡單工廠模式解析、Java設計模式之訪問者模式使用場景及代碼示例等，有什么問題可以隨時留言，小編會及時回復大家的。感謝朋友們對本站的支持！
相關文章
下面小編就為大家?guī)硪黄钊肜斫釰ava 對象和類。小編覺得挺不錯的，現(xiàn)在分享給大家，也給大家做個參考。一起跟隨小編過來看看吧，希望能給你帶來幫助2021-07-07
在Java開發(fā)中,我們經(jīng)常會遇到各種性能問題、內(nèi)存泄漏、線程阻塞等問題,這些問題往往難以通過常規(guī)的日志和監(jiān)控工具來定位和解決,Arthas作為一款開源的Java診斷工具,提供了強大的實時監(jiān)控和診斷功能,本文將詳細介紹Arthas的安裝、基本使用以及一些常用命令2025-02-02
MybatisPlus關聯(lián)查詢的完美實現(xiàn)方案
我們在項目開發(fā)的時候,難免會遇到連表查詢的操作,所以下面這篇文章主要給大家介紹了關于MybatisPlus關聯(lián)查詢的相關資料,文中通過實例代碼介紹的非常詳細,需要的朋友可以參考下2021-12-12
Springboot接收?Form?表單數(shù)據(jù)的示例詳解
這篇文章主要介紹了Springboot接收?Form?表單數(shù)據(jù)的實例代碼，本文通過圖文實例代碼相結合給大家介紹的非常詳細，對大家的學習或工作具有一定的參考借鑒價值,需要的朋友可以參考下2022-08-08
這篇文章主要介紹了SpringBoot生成二維碼的實現(xiàn)，文中通過示例代碼介紹的非常詳細，對大家的學習或者工作具有一定的參考學習價值，需要的朋友們下面隨著小編來一起學習學習吧2020-12-12
這篇文章主要為大家詳細介紹了java的正則表達式，使用表格進行介紹，文中示例代碼介紹的非常詳細，具有一定的參考價值，感興趣的小伙伴們可以參考一下，希望能夠給你帶來幫助2022-02-02
SpringCloud之Admin服務監(jiān)控實現(xiàn)流程示例詳解
這篇文章主要為大家介紹了SpringCloud之Admin服務監(jiān)控流程示例詳解,有需要的朋友可以借鑒參考下,希望能夠有所幫助,祝大家多多進步,早日升職加薪2023-09-09
spring boot 實現(xiàn)配置多個DispatcherServlet最簡單方式
這篇文章主要介紹了spring boot 實現(xiàn)配置多個DispatcherServlet最簡單方式，具有很好的參考價值，希望對大家有所幫助。一起跟隨小編過來看看吧2021-01-01
在本篇文章里小編給大家整理的是關于SpringBoot配置https實操方法以及相關知識點，需要的朋友們參考下。2019-11-11
這篇文章主要介紹了分享一個簡單的java爬蟲框架，具有一定參考價值，需要的朋友可以了解下。2017-11-11