代理模式java
Ⅰ 如何使用Proxy模式及Java內建的動態代理機制
import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;
public class ProxyMain {
public static void main(String[] args) {
Service service = new ServiceImpl();
Service proxy = (Service) Proxy.newProxyInstance(service.getClass().getClassLoader(),
service.getClass().getInterfaces(), new ServiceInvocationHandler(service));
System.out.println(proxy.sayHi("Arvin"));
}
}
class ServiceInvocationHandler implements InvocationHandler {
private final Service target;
public ServiceInvocationHandler(Service target) {
this.target = target;
}
@Override
public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
return method.invoke(target, args);
}
}
interface Service {
String sayHi(String name);
}
class ServiceImpl implements Service {
@Override
public String sayHi(String name) {
return "Hi, " + name;
}
}
Ⅱ java代理模式的應用場景
例如：假設有一組對象都實現同一個介面，實現同樣的方法，但這組對象中有一部分對象需要有單獨的方法，傳統的笨辦法是在每一個應用端都加上這個單獨的方法，但是代碼重用性低，耦合性高。
如果用代理的方法則很好的解決了這個問題。
Ⅲ Java代理的三種模式有什麼
Java的三種代理模式簡述
本文著重講述三種代理模式在java代碼中如何寫出，為保證文章的針對性，暫且不討論底層實現原理，具體的原理將在下一篇文章中講述。
代理模式是什麼
代理模式是一種設計模式，簡單說即是在不改變源碼的情況下，實現對目標對象的功能擴展。
比如有個歌手對象叫Singer，這個對象有一個唱歌方法叫sing()。
假如你希望，通過你的某種方式生產出來的歌手對象，在唱歌前後還要想觀眾問好和答謝，也即對目標對象Singer的sing方法進行功能擴展。
但是往往你又不能直接對源代碼進行修改，可能是你希望原來的對象還保持原來的樣子，又或許你提供的只是一個可插拔的插件，甚至你有可能都不知道你要對哪個目標對象進行擴展。這時就需要用到java的代理模式了。網上好多用生活中的經理人的例子來解釋「代理」，看似通俗易懂，但我覺得不適合程序員去理解。程序員應該從代碼的本質入手。
Ⅳ java中代理模式的問題
兩個new都是實例化一個對象
new ProxySubject() 是代理對象實列，但每個代理都要有一個真實的實列所以需要傳遞一個真實實列給它 。 及new RealSubject()
Ⅳ Java 代理模式和裝飾者模式的區別
代理模式與裝飾者模式看起來很像，都實現基礎對象實現的介面，在其自身專對象中都保存著對被屬代理/被裝飾者的對象引用。
先來看看裝飾者模式的定義：動態的將責任附加到被裝飾者對象上，用於擴展對象的功能。比繼承的靈活性大。典型的如Java IO的設計即是裝飾者模式的典型應用。
代理模式模式的定義：對其他對象進行代理，以控制對被代理對象的訪問。Spring的為業務邏輯層方法生成的代理類，主要進行一些事務控制等。
由定義可以看出裝飾的責任是擴展功能 ，而代理主要控制訪問。
具體例子可參看Java IO裝飾/Spring的動態代理/Hibernate的代理等。
Ⅵ java設計模式之代理模式：
很簡單：對外部提供統一的介面方法，而代理類在介面中實現對真實類的附加操作行為，從而可以在不影響外部調用情況下，進行系統擴展。也就是說，我要修改真實角色的操作的時候，盡量不要修改他，而是在外部在「包」一層進行附加行為，即代理類。
例如：介面A有一個介面方法operator()，真是角色：RealA實現介面A，則必須實現介面方法operator()。客戶端Client調用介面A的介面方法operator()。
現在新需求來了，需要修改RealA中的operator()的操作行為。怎麼辦呢？如果修改RealA就會影響原有系統的穩定性，還要重新測試。這是就需要代理類實現附加行為操作。創建代理ProxyA實現介面A，並將真實對象RealA注入進來。ProxyA實現介面方法operator()，可以增加附加行為，然後調用真實對象的operator()。從而達到了「對修改關閉，對擴展開放」，保證了系統的穩定性。我們看客戶端Client調用仍是介面A的介面方法operator()，只不過實例變為了ProxyA類了而已。
建議看看《軟體秘笈：設計模式那點事》，當中講解的很詳細，例子也很生動，讀了收獲很大！希望以上內容對你有幫助！
Ⅶ java中的代理模式一般和什麼模式相結合
Java編程的目標是實現現實不能完成的，優化現實能夠完成的，是一種虛擬技術。生活中的方方面面都可以虛擬到代碼中。代理模式所講的就是現實生活中的這么一個概念：中介。
代理模式的定義：給某一個對象提供一個代理，並由代理對象控制對原對象的引用。
代理模式包含如下角色：
ISubject：抽象主題角色，是一個介面。該介面是對象和它的代理共用的介面。
RealSubject：真實主題角色，是實現抽象主題介面的類。
Proxy：代理角色，內部含有對真實對象RealSubject的引用，從而可以操作真實對象。代理對象提供與真實對象相同的介面，以便在任何時刻都能代替真實對象。同時，代理對象可以在執行真實對象操作時，附加其他的操作，相當於對真實對象進行封裝。
實現動態代理的關鍵技術是反射。
靜態代理
代理模式有幾種，虛擬代理，計數代理，遠程代理，動態代理。主要分為兩類，靜態代理和動態代理。靜態代理比較簡單，是由程序員編寫的代理類，並在程序運行前就編譯好的，而不是由程序動態產生代理類，這就是所謂的靜態。
考慮這樣的場景，管理員在網站上執行操作，在生成操作結果的同時需要記錄操作日誌，這是很常見的。此時就可以使用代理模式，代理模式可以通過聚合和繼承兩種方式實現：
<pre name="code" class="java">/**方式一：聚合式靜態代理 * @author Goser (mailto:[email protected]) * @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();</pre>
聚合實現方式中代理類聚合了被代理類，且代理類及被代理類都實現了同一個介面，可實現靈活多變。繼承式的實現方式則不夠靈活。
比如，在管理員操作的同時需要進行許可權的處理，操作內容的日誌記錄，操作後數據的變化三個功能。三個功能的排列組合有6種，也就是說使用繼承要編寫6個繼承了Admin的代理類，而使用聚合，僅需要針對許可權的處理、日誌記錄和數據變化三個功能編寫代理類，在業務邏輯中根據具體需求改變代碼順序即可。
動態代理
一般來說，對代理模式而言，一個主題類與一個代理類一一對應，這也是靜態代理模式的特點。
但是，也存在這樣的情況，有n各主題類，但是代理類中的「前處理、後處理」都是一樣的，僅調用主題不同。也就是說，多個主題類對應一個代理類，共享「前處理，後處理」功能，動態調用所需主題，大大減小了程序規模，這就是動態代理模式的特點。
JDK動態代理
實現
<pre name="code" class="java">//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(); } }</pre>
代碼講解：
在測試代碼中，Proxy.newProxyInstance()方法需要3個參數：類載入器（要進行代理的類）、被代理類實現的介面，事務處理器。所以先實例化Car，實例化InvocationHandler的子類TimeHandler，將各參數傳入Proxy的靜態方法newProxyInstance()即可獲得Car的代理類，前面的靜態代理，代理類是我們編寫好的，而動態代理則不需要我們去編寫代理類，是在程序中動態生成的。
JDK動態代理步驟
1. 創建一個實現InvocationHandler介面的類，它必須實現invoke()方法
2. 創建被代理的類及介面
3. 調用Proxy的靜態方法，創建一個代理類
4. 通過代理調用方法
而為什麼要進行如此操作，可以從Proxy和InvocationHandler的源碼中找打答案。對源碼不感興趣的可以將下面的源碼部分小節略過。
JDK動態代理原理與源碼
ewProxyInstance()方法的源碼：
<pre name="code" class="java"> 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()); } }</pre>
可以看到，獲得代理類的代碼是
Class<?>cl = getProxyClass0(loader,intfs)
並由此獲得代理類的構造函數，生成代理類的實例返回給該方法的調用者。
繼續跟進getProxyClass0()方法：
<pre name="code" class="java">/** 生成代理類。調用該方法前必須使用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); }</pre>
還是沒有看到代理類是怎麼生成的，只知道代理類是從
roxyClassCache
中取得的，這個變數是與緩存相關的一個對象，查看該變數的聲明與初始化：
<pre name="code" class="java">private static final WeakCache<ClassLoader, Class<?>[], Class<?>> proxyClassCache = new WeakCache<>(new KeyFactory(), new ProxyClassFactory());</pre>
可以發現
roxyClassCache
是個用來緩存代理類的類變數，大家知道類變數的特點是與類一一對應，在一個虛擬機中類只有一個，對應著在一個虛擬機中類變數也只有一個，且在此處，在Proxy類被載入的時候就賦值了。在賦值操作的參數中有ProxyClassFactory()這么一個構造函數，這個是動態代理中的關鍵：生成代理類的類文件位元組碼。繼續跟進去，找到代理類的生成之處了：
<pre name="code" class="java"> /** 根據給定的類載入器和介面數組生成代理類的工廠類*/ 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()); } } }</pre>
ProxyClassFactory
中，可以看到產生代理類的具體邏輯，大致上是，根據傳遞的被代理類及其實現的介面生成代理類的位元組碼載入到緩存中，但是載入到緩存中只是一個.java文件也不能用，所以底層還有編譯等操作。到這里，可以大致的看清JDK中動態代理的面孔了，實現的步驟為：
1. 創建代理類的源碼；
2. 對源碼進行編譯成位元組碼；
3. 將位元組碼載入到內存；
4. 實例化代理類對象並返回給調用者；
底層的代碼我們看不到，但是我們可以查看其生成的位元組碼：
<pre name="code" class="java">//獲得位元組碼的測試方法 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 () { throw new NoSuchMethodError(localNoSuchMethodException.getMessage()); } catch () { } throw new NoClassDefFoundError(localClassNotFoundException.getMessage()); } }</pre>
生成的位元組碼比較長，但是在位元組碼中最關鍵的信息是代理類的聲明：
ublic final class $Proxy1 extends Proxy
可以看到生成的代理類是繼承了Proxy類的，這就是說明了為什麼使用JDK動態代理不能實現繼承式動態代理，原因是Java不允許多繼承，而生成的代理類本身就已經繼承了Proxy類。
至此，JDK的動態代理的使用及底層原理分析完畢，揭下動態代理的神秘面紗，果然是枚美女。
至於最底層的native方法是怎麼動態生成代理類的位元組碼我們也可以簡單的模擬一下，先分析下模擬的步驟：首先要生成一段代理類的源碼，然後將源碼編譯後生成代理類的實例返回給調用者。依據此步驟開始編寫我們的模擬代碼：
<pre name="code" class="java">/** * JDK java.lang.reflect.Proxy的模擬 * @author Goser (mailto:[email protected]) * @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 + "//以聚合方式實現的代理主題" + 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(); } }</pre>
運行測試代碼，結果和手工編寫的結果一致，完成了JDK中動態代理的實現模擬。
cglib動態代理
前面分析到，因為Java只允許單繼承，而JDK生成的代理類本身就繼承了Proxy類，因此，使用JDK實現的動態代理不能完成繼承式的動態代理，但是我們可以使用cglib來實現繼承式的動態代理。
大名鼎鼎的Spring中就含有cglib動態代理，在此也以Spring中自帶的cglib完成動態代理的實現：
<pre name="code" class="java">//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(); } }</pre>
Ⅷ JAVA動態代理設計原理及如何實現
Java動態代理機制的出現，使得Java開發人員不用手工編寫代理類，只要簡單地制定一組介面及委託類對象，便能動態地獲得代理類。代理類會負責將所有的方法調用分配到委託對象上反射執行，配置執行過程中，開發人員還可以進行修改
代理設計模式
代理是一種常用的設計模式，其目的就是為其他對象提供一個代理以控制對某個對象的訪問。代理類負責為委託類預處理消息、過濾消息並轉發消息，以及進行消息被委託類執行後的後續處理。
為了保持行為的一致性，代理類和委託類通常會實現相同的介面
2. 引入代理能夠控制對委託對象的直接訪問，可以很好的隱藏和保護委託對象，也更加具有靈活性
代理機制及其特點
首先讓我們來了解一下如何使用 Java 動態代理。具體有如下四步驟：
通過實現 InvocationHandler 介面創建自己的調用處理器；
通過為 Proxy 類指定 ClassLoader 對象和一組 interface 來創建動態代理類；
通過反射機制獲得動態代理類的構造函數，其唯一參數類型是調用處理器介面類型；
通過構造函數創建動態代理類實例，構造時調用處理器對象作為參數被傳入。
代理類實例的一些特點
每個實例都會關聯一個InvocationHandler(調用處理器對象)，在代理類實例上調用其代理介面中聲明的方法時，最終都會由InvocationHandler的invoke方法執行；
java.lang.Object中有三個方法也同樣會被分派到調用處理器的 invoke 方法執行，它們是 hashCode，equals 和 toString；
代碼示例
最後以一個簡單的動態代理例子結束
Ⅸ java-介面的代理設計模式
代理設計模式是有解決特定的問題的先決條件的，即：假定代碼中Network 的實現類 Real 中的代碼作為第三方庫或者其他形式的代碼功能實現【不能被修改或者改變】，此時如果我們想在實際應用Real類中的 browser 方法時，在此方法調用前後添加其他業務邏輯代碼，同時做到不破壞 Real 類的目的，我們需要引入【代理 Proxy】的設計模式來解決此問題（此設計模式被 Spring 中的 AOP 切面編程應用）
//定義業務介面
interfaceNetwork{
voidbrowse();
}
//----------------------------------------//
//Real實現類，此時我們不想修改人家代碼哦！咋整？
//----------------------------------------//
classRealimplementsNetwork{
publicvoidbrowse(){
System.out.println("Realisworkingforbrowsing");
}
}
//----------------------------------------//
//代理設計模式類
//----------------------------------------//
classProxyimplementsNetwork{
//按照介面編程，把Real的父類的類型當做成員變數放進來，只要有人實現了
//Network類，都能在本類實例化的時候傳進來，對不？
privateNetworknetwork;
//此時實現了Network的類型就被扔進來了
publicProxy(Networknetwork){
this.network=network;
}
publicvoidbrowse(){
//其他的業務邏輯Blahblah~~~
this.network.browse();
//其他的業務邏輯Blahblah~~~
}
}
//此時這個類也屬於了Network的實現類，但是我們的browse()方法中，業務代碼更
//豐富了，更厲害了，對不？^_^
publicstaticvoidmain(String[]args){
Networknet=newProxy(newReal())
//此時我們的browse方法，既沒有改Real人家的代碼，又比人家
//代碼更厲害了，Real現在只是Proxy類的一個內部小變數了.
net.browse();
}
Ⅹ java的代理模式和工廠模式有什麼區別
工廠模式
簡單工程模式：定義介面（規則），定義的多個實現類（實現給定的規則），當不同的數據時，返回不同類型的實現
代理模式
需要1、代理類和被代理對象；2、被代理對象不想去執行的方法；3、代理