代理設計模式

1. Java常用的幾種設計模式

下面給你介紹5種設計模式：

1.單例設計模式

所謂單例設計模式簡單說就是無論程序如何運行，採用單例設計模式的類（Singleton類）永遠只會有一個實例化對象產生。具體實現步驟如下：

(1) 將採用單例設計模式的類的構造方法私有化（採用private修飾）。

(2) 在其內部產生該類的實例化對象，並將其封裝成private static類型。

(3) 定義一個靜態方法返回該類的實例。

2.工廠設計模式

程序在介面和子類之間加入了一個過渡端，通過此過渡端可以動態取得實現了共同介面的子類實例化對象。

3.代理設計模式

指由一個代理主題來操作真實主題，真實主題執行具體的業務操作，而代理主題負責其他相關業務的處理。比如生活中的通過代理訪問網路，客戶通過網路代理連接網路（具體業務），由代理伺服器完成用戶許可權和訪問限制等與上網相關的其他操作（相關業務）。

4.觀察者設計模式

所謂觀察者模式，舉個例子現在許多購房者都密切觀察者房價的變化，當房價變化時，所有購房者都能觀察到，以上的購房者屬於觀察者，這便是觀察者模式。

java中可以藉助Observable類和Observer介面輕松實現以上功能。當然此種模式的實現也不僅僅局限於採用這兩個類。

5.適配器模式

如果一個類要實現一個具有很多抽象方法的介面，但是本身只需要實現介面中的部分方法便可以達成目的，所以此時就需要一個中間的過渡類，但此過渡類又不希望直接使用，所以將此類定義為抽象類最為合適，再讓以後的子類直接繼承該抽象類便可選擇性的覆寫所需要的方法，而此抽象類便是適配器類。

2. 如何理解iOS開發中的代理設計模式

Delegate ，又稱為 委託或代理， 它是一種設計模式。 學習iOS開發，需要深入理解 Delegate的用法。 Apple 對Delegate 有明確的說明。但理解起來還是有些抽象。 Delegate的用途： 用於改變或控制其他對象 。 Delegate 的定義： （1）Delegate 是一個對象， 其類型為 id (anonymous type: 匿名類型)； （2） Delegate 的引用通常是一個實例變數 （instance variable）， 命名為 delegate； （3）Delegate 內所用的方法是 訪問模式 （Accessors pattern） Delegate Message 的命名： 發給Delegate的消息 通常帶有(should, will, did) 之一。 should：期待delegate返回一個值； will：表示變化發生之前 要做的事情； did ： 表示變化發生之後 要做的事情。 Cocoa Touh 的很多類都不同程度地用到Delgete。 比如： NSTextField， NSTableView。 其中 NSTableView 還用到了 Data Source。 其實，Data Source 也是一種委託。 Data Source 減少了 View 與 Model 之間的耦合性。 其中 ， NSAppplication 實現了幾十個委託方法。 Delegate 使用的注意事項： Delegate 是一個 ID 類型的對象， 同樣存在創建和釋放問題。 對於Data Source ， 只有Data Source的使用者 （比如Table View）釋放後， Data Souce 才能被釋放。 否則， 就會出現crash。 因為在table view 獲取數據時， 數據已經不見了。 Delegate 可用在多個場景下，比如對象間的數據交互， 不同視圖之間的行為交互。 若僅僅是數據交互， 可實現的方法還有很多。Delegate 尤其適用於視圖之間的行為交互。

3. 設計模式：適配器模式和代理模式的區別

這是之前我的博客總結的：

Proxy，代理模式：為其他對象提供一種代理以控制對這個對象的訪問。
例如：經典的體現在Spring AOP切面中，Spring中利用了倆種代理類型。
其實，代理也分為靜態和動態，但是我們一般常用動態，因為靜態代理秀不起來

Adapter,適配器模式：將一類的介面轉換成客戶希望的另外一個介面，Adapter模式使得原本由於介面不兼容而不能一起工作那些類可以一起工作。
其中對象的適配器模式是各種結構型模式的起源，分為三種：類，對象，介面的適配器模式。

結一下三種適配器模式的應用場景：
類的適配器模式：當希望將一個類轉換成滿足另一個新介面的類時，可以使用類的適配器模式，創建一個新類，繼承原有的類，實現新的介面即可。
對象的適配器模式：當希望將一個對象轉換成滿足另一個新介面的對象時，可以創建一個Wrapper類，持有原類的一個實例，在Wrapper類的方法中，調用實例的方法就行。
介面的適配器模式：當不希望實現一個介面中所有的方法時，可以創建一個抽象類Wrapper，實現所有方法，我們寫別的類的時候，繼承抽象類即可。

區別：很明顯，適配器模式是因為新舊介面不一致導致出現了客戶端無法得到滿足的問題，但是，由於舊的介面是不能被完全重構掉的，因為我們還想使用實現了這個介面的一些服務。那麼為了使用以前實現舊介面的服務，我們就應該把新的介面轉換成舊介面。相比於適配器的應用場景，代理就不一樣了，雖然代理也同樣是增加了一層，但是，代理提供的介面和原本的介面是一樣的，代理模式的作用是不把實現直接暴露給client，而是通過代理這個層，代理能夠做一些處理。

4. java設計模式之代理模式：

很簡單：對外部提供統一的介面方法，而代理類在介面中實現對真實類的附加操作行為，從而可以在不影響外部調用情況下，進行系統擴展。也就是說，我要修改真實角色的操作的時候，盡量不要修改他，而是在外部在「包」一層進行附加行為，即代理類。

例如：介面A有一個介面方法operator()，真是角色：RealA實現介面A，則必須實現介面方法operator()。客戶端Client調用介面A的介面方法operator()。
現在新需求來了，需要修改RealA中的operator()的操作行為。怎麼辦呢？如果修改RealA就會影響原有系統的穩定性，還要重新測試。這是就需要代理類實現附加行為操作。創建代理ProxyA實現介面A，並將真實對象RealA注入進來。ProxyA實現介面方法operator()，可以增加附加行為，然後調用真實對象的operator()。從而達到了「對修改關閉，對擴展開放」，保證了系統的穩定性。我們看客戶端Client調用仍是介面A的介面方法operator()，只不過實例變為了ProxyA類了而已。
建議看看《軟體秘笈：設計模式那點事》，當中講解的很詳細，例子也很生動，讀了收獲很大！希望以上內容對你有幫助！

5. 繼續設計模式，代理模式有什麼好理解的實用的例子

代理模式就是抽象出一個調用方與被調方的中間層

達到一定程度的解耦與封裝內

設計模容式只是一種思想

打個比方說, 使用代理模式， 被調方的對象在調用方就不能直接操作， 可以在代理類中調用被調方的方法前後再加上一些操作， 又或者再隱藏一些被調方的操作

當然， 我舉的例子可能有一些是其他設計模式的思想， 但是我覺得沒有必要死扣概念， 設計出符合當前需求、易於維護、擴展的框架才是設計模式的最終體現

6. 這個是設計模式中代理模式的結構圖，我沒看懂構建流程，哪位大神幫助再描述下構建順序

abstract public class Subject
{
abstract public void request();

}

public class RealSubject extends Subject
{
public RealSubject() { }

public void request()
{
System.out.println( " From real subject. " );
}
}

public class ProxySubject extends Subject
{
private RealSubject realSubject; // 以真實角色作為代理角色的屬性

public ProxySubject() { }

public void request()
{ // 該方法封裝了真實對象的request方法
preRequest();

if ( realSubject == null )
{

realSubject = new RealSubject();
}

realSubject.request(); // 此處執行真實對象的request方法

postRequest();
}
}

//調用
Subject sub = new ProxySubject();
Sub.request();

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

8. 我覺得大話設計模式中對於代理模式，用GG追MM的例子的解釋是完全錯誤的！

仔細抄看了一下，是有問題的

A 要訪問 C， 無法直接訪問，必須通過B，則

B（參數）
{
C(參數）
}

A 提供的參數就是 flower，通過B，則
B（flower)
{
C （flower）
}

這里實際作用的是C，B和C應該是同一個介面，A是客戶端，大話設計模式里將A與B作為實現一個介面，是不對的

9. 設計模式都有哪些

總體來說設計模式分為三大類：

一、創建型模式，共五種：工廠方法模式、抽象工廠模式、單例模式、建造者模式、原型模式。

二、結構型模式，共七種：適配器模式、裝飾器模式、代理模式、外觀模式、橋接模式、組合模式、享元模式。

三、行為型模式，共十一種：策略模式、模板方法模式、觀察者模式、迭代子模式、責任鏈模式、命令模式、備忘錄模式、狀態模式、訪問者模式、中介者模式、解釋器模式。

1、工廠方法模式：

定義一個用於創建對象的介面，讓子類決定實例化哪一個類。Factory Method 使一個類的實例化延遲到其子類。

工廠模式有一個問題就是，類的創建依賴工廠類，也就是說，如果想要拓展程序，必須對工廠類進行修改，這違背了閉包原則，所以，從設計角度考慮，有一定的問題，這就用到工廠方法模式。

創建一個工廠介面和創建多個工廠實現類，這樣一旦需要增加新的功能，直接增加新的工廠類就可以了，不需要修改之前的代碼。

2、抽象工廠模式：

提供一個創建一系列相關或相互依賴對象的介面，而無需指定它們具體的類。抽象工廠需要創建一些列產品，著重點在於"創建哪些"產品上，也就是說，如果你開發，你的主要任務是劃分不同差異的產品線，並且盡量保持每條產品線介面一致，從而可以從同一個抽象工廠繼承。

3、單例模式：

單例對象（Singleton）是一種常用的設計模式。在Java應用中，單例對象能保證在一個JVM中，該對象只有一個實例存在。這樣的模式有幾個好處：

（1）某些類創建比較頻繁，對於一些大型的對象，這是一筆很大的系統開銷。

（2）省去了new操作符，降低了系統內存的使用頻率，減輕GC壓力。

（3）有些類如交易所的核心交易引擎，控制著交易流程，如果該類可以創建多個的話，系統完全亂了。（比如一個軍隊出現了多個司令員同時指揮，肯定會亂成一團），所以只有使用單例模式，才能保證核心交易伺服器獨立控制整個流程。

4、建造者模式：

將一個復雜對象的構建與它的表示分離，使得同樣的構建過程可以創建不同的表示。

5、原型模式：

原型模式雖然是創建型的模式，但是與工程模式沒有關系，從名字即可看出，該模式的思想就是將一個對象作為原型，對其進行復制、克隆，產生一個和原對象類似的新對象。本小結會通過對象的復制，進行講解。在Java中，復制對象是通過clone()實現的，先創建一個原型類。

6、適配器模式：

適配器模式將某個類的介面轉換成客戶端期望的另一個介面表示，目的是消除由於介面不匹配所造成的類的兼容性問題。主要分為三類：類的適配器模式、對象的適配器模式、介面的適配器模式。

7、裝飾器模式：

顧名思義，裝飾模式就是給一個對象增加一些新的功能，而且是動態的，要求裝飾對象和被裝飾對象實現同一個介面，裝飾對象持有被裝飾對象的實例。

8、代理模式：

代理模式就是多一個代理類出來，替原對象進行一些操作，比如我們在租房子的時候回去找中介，為什麼呢？因為你對該地區房屋的信息掌握的不夠全面，希望找一個更熟悉的人去幫你做，此處的代理就是這個意思。

9、外觀模式：

外觀模式是為了解決類與類之家的依賴關系的，像spring一樣，可以將類和類之間的關系配置到配置文件中，而外觀模式就是將他們的關系放在一個Facade類中，降低了類類之間的耦合度，該模式中沒有涉及到介面。

10、橋接模式：

橋接模式就是把事物和其具體實現分開，使他們可以各自獨立的變化。橋接的用意是：將抽象化與實現化解耦，使得二者可以獨立變化，像我們常用的JDBC橋DriverManager一樣。

JDBC進行連接資料庫的時候，在各個資料庫之間進行切換，基本不需要動太多的代碼，甚至絲毫不用動，原因就是JDBC提供統一介面，每個資料庫提供各自的實現，用一個叫做資料庫驅動的程序來橋接就行了。

11、組合模式：

組合模式有時又叫部分-整體模式在處理類似樹形結構的問題時比較方便。使用場景：將多個對象組合在一起進行操作，常用於表示樹形結構中，例如二叉樹，數等。

12、享元模式：

享元模式的主要目的是實現對象的共享，即共享池，當系統中對象多的時候可以減少內存的開銷，通常與工廠模式一起使用。

13、策略模式：

策略模式定義了一系列演算法，並將每個演算法封裝起來，使其可以相互替換，且演算法的變化不會影響到使用演算法的客戶。需要設計一個介面，為一系列實現類提供統一的方法，多個實現類實現該介面，設計一個抽象類（可有可無，屬於輔助類），提供輔助函數。

14、模板方法模式：

一個抽象類中，有一個主方法，再定義1...n個方法，可以是抽象的，也可以是實際的方法，定義一個類，繼承該抽象類，重寫抽象方法，通過調用抽象類，實現對子類的調用。

15、觀察者模式：

觀察者模式很好理解，類似於郵件訂閱和RSS訂閱，當我們瀏覽一些博客或wiki時，經常會看到RSS圖標，就這的意思是，當你訂閱了該文章，如果後續有更新，會及時通知你。

其實，簡單來講就一句話：當一個對象變化時，其它依賴該對象的對象都會收到通知，並且隨著變化！對象之間是一種一對多的關系。

16、迭代子模式：

顧名思義，迭代器模式就是順序訪問聚集中的對象，一般來說，集合中非常常見，如果對集合類比較熟悉的話，理解本模式會十分輕松。這句話包含兩層意思：一是需要遍歷的對象，即聚集對象，二是迭代器對象，用於對聚集對象進行遍歷訪問。

17、責任鏈模式：

責任鏈模式，有多個對象，每個對象持有對下一個對象的引用，這樣就會形成一條鏈，請求在這條鏈上傳遞，直到某一對象決定處理該請求。但是發出者並不清楚到底最終那個對象會處理該請求，所以，責任鏈模式可以實現，在隱瞞客戶端的情況下，對系統進行動態的調整。

18、命令模式：

命令模式的目的就是達到命令的發出者和執行者之間解耦，實現請求和執行分開。

19、備忘錄模式：

主要目的是保存一個對象的某個狀態，以便在適當的時候恢復對象，個人覺得叫備份模式更形象些，通俗的講下：假設有原始類A，A中有各種屬性，A可以決定需要備份的屬性，備忘錄類B是用來存儲A的一些內部狀態，類C呢，就是一個用來存儲備忘錄的，且只能存儲，不能修改等操作。

20、狀態模式：

狀態模式在日常開發中用的挺多的，尤其是做網站的時候，我們有時希望根據對象的某一屬性，區別開他們的一些功能，比如說簡單的許可權控制等。

21、訪問者模式：

訪問者模式把數據結構和作用於結構上的操作解耦合，使得操作集合可相對自由地演化。訪問者模式適用於數據結構相對穩定演算法又易變化的系統。因為訪問者模式使得演算法操作增加變得容易。

若系統數據結構對象易於變化，經常有新的數據對象增加進來，則不適合使用訪問者模式。訪問者模式的優點是增加操作很容易，因為增加操作意味著增加新的訪問者。訪問者模式將有關行為集中到一個訪問者對象中，其改變不影響系統數據結構。其缺點就是增加新的數據結構很困難。

22、中介者模式：

中介者模式也是用來降低類類之間的耦合的，因為如果類類之間有依賴關系的話，不利於功能的拓展和維護，因為只要修改一個對象，其它關聯的對象都得進行修改。

如果使用中介者模式，只需關心和Mediator類的關系，具體類類之間的關系及調度交給Mediator就行，這有點像spring容器的作用。

23、解釋器模式：

解釋器模式一般主要應用在OOP開發中的編譯器的開發中，所以適用面比較窄。

(9)代理設計模式擴展閱讀：

介紹三本關於設計模式的書：

1、《設計模式：可復用面向對象軟體的基礎》

作者：[美] Erich Gamma, Richard Helm, Ralph Johnson, John Vlissides

出版社： 機械工業出版社

2、《軟體秘笈：設計模式那點事》

作者：鄭阿奇

出版社：電子工業出版社

3、《設計模式：基於C#的工程化實現及擴展》

作者：王翔

出版社：電子工業出版社

10. 求教java高手：什麼是DAO設計模式，聽老師說DAO設計模式通常會和工廠設計模式、代理設計模式一起使用，

class User {
private String name;
private int age;
public void setName(String name){
this.name=name;
}
public void setAge(int age){
this.age=age;
}
public String getName(){
return this.name;
}
public int getAge(){
return this.age;
}
}
interface UserDAO {
public boolean doCreate(User user)throws Exception;
}
class UserDAOImpl implements UserDAO {
private String str=null;
public UserDAOImpl(String str){
this.str=str;
}
public boolean doCreate(User user)throws Exception{
boolean flag=false;
try{
System.out.println("真實主題類的資料庫增加操作");
}catch(Exception e){
e.printStackTrace();
}finally{

}
return flag;
}
}
class UserDAOProxy implements UserDAO {
private UserDAOImpl =null;
private String str=null; //此處其實應該傳入一個資料庫的連接到真實主題類的，不過這里只是個演示，所有以字元串的形式傳了進去
public UserDAOProxy(){
this.str=new String();
this.=new UserDAOImpl(this.str);
}
public boolean doCreate(User user)throws Exception{
boolean flag=true;
System.out.println("代理類的操作，打開資料庫，同時取得真實主題類的實例去調用真實的數據層操作");
try{
this..doCreate(user);
}catch(Exception e){
e.printStackTrace();
}finally{
System.out.println("代理類的操作，調用完真實主題類的操作，同時關閉資料庫");
}
return flag;
}
}
class UserDAOFactory {
public static UserDAO getUserDAONewInstance(){
System.out.println("通過工廠類取得代理類的實例去調用代理類的操作。");
return new UserDAOProxy();
}
}
public class FactoryDemo {
public static void main(String args[])throws Exception{
User user=new User();
user.setName("jhjjs");
user.setAge(20);
UserDAOFactory.getUserDAONewInstance().doCreate(user);
}
}
lz看下吧，剛做的