第一篇：深入淺出基于Java的代理設計模式

深入淺出基于Java的代理設計模式

一、引子

我們去科技市場為自己的機器添加點奢侈的配件，很多DIYer都喜歡去找代理商，因為在代理商那里拿到的東西不僅質量有保證，而且價格和售后服務上都會好很多。客戶通過代理商得到了自己想要的東西，而且還享受到了代理商額外的服務；而生產廠商通過代理商將自己的產品推廣出去，而且可以將一些銷售服務的任務交給代理商來完成（當然代理商要和廠商來共同分擔風險，分配利潤），這樣自己就可以花更多的心思在產品的設計和生產上了。

在美國，任何企業的產品要想拿到市場上去賣就必須經過代理商這一個環節，否則就是非法的。看來代理商在商業運作中起著很關鍵的作用。不小心把話題扯遠了，回過頭來，那么在我們的面向對象的程序設計中，會不會有代理商這樣的角色呢？來看這篇文章的人肯定不會說：沒有！

那么就跟著這篇文章來看看代理模式的奇妙吧。

二、定義和分類

代理模式在設計模式中的定義就是：為其他對象提供一種代理以控制對這個對象的訪問。說白了就是，在一些情況下客戶不想或者不能直接引用一個對象，而代理對象可以在客戶和目標對象之間起到中介作用，去掉客戶不能看到的內容和服務或者增添客戶需要的額外服務。

那么什么時候要使用代理模式呢？在對已有的方法進行使用的時候出現需要對原有方法進行改進或者修改，這時候有兩種改進選擇：修改原有方法來適應現在的使用方式，或者使用一個“第三者”方法來調用原有的方法并且對方法產生的結果進行一定的控制。第一種方法是明顯違背了“對擴展開放、對修改關閉”（開閉原則），而且在原來方法中作修改可能使得原來類的功能變得模糊和多元化（就像現在企業多元化一樣），而使用第二種方式可以將功能劃分的更加清晰，有助于后面的維護。所以在一定程度上第二種方式是一個比較好的選擇！

當然，話又說回來了，如果是一個很小的系統，功能也不是很繁雜，那么使用代理模式可能就顯得臃腫，不如第一種方式來的快捷。這就像一個三口之家，家務活全由家庭主婦或者一個保姆來完成是比較合理的，根本不需要雇上好幾個保姆層層代理:)

根據《Java與模式》書中對代理模式的分類，代理模式分為8種，這里將幾種常見的、重要的列舉如下：

1.遠程（Remote）代理：為一個位于不同的地址空間的對象提供一個局域代表對象。比如：你可以將一個在世界某個角落一臺機器通過代理假象成你局域網中的一部分。

2.虛擬（Virtual）代理：根據需要將一個資源消耗很大或者比較復雜的對象延遲的真正需要時才創建。比如：如果一個很大的圖片，需要花費很長時間才能顯示出來，那么當這個圖片包含在文檔中時，使用編輯器或瀏覽器打開這個文檔，這個大圖片可能就影響了文檔的閱讀，這時需要做個圖片Proxy來代替真正的圖片。

3.保護（ProtectorAccess）代理：控制對一個對象的訪問權限。比如：在論壇中，不同的身份登陸，擁有的權限是不同的，使用代理模式可以控制權限（當然，使用別的方式也可以實現）。

4.智能引用（SmartReference）代理：提供比對目標對象額外的服務。比如：紀錄訪問的流量（這是個再簡單不過的例子），提供一些友情提示等等。

代理模式是一種比較有用的模式，從幾個類的“小結構”到龐大系統的“大結構”都可以看到它的影子。

三、結構

代理模式中的“代理商”要想實現代理任務，就必須和被代理的“廠商”使用共同的接口（你可以想象為產品）。所以自然而然你會想到在java中使用一個抽象類或者接口（推薦）來實現這個共同的接口。于是代理模式就有三個角色組成了：

1．抽象主題角色：聲明了真實主題和代理主題的共同接口。

2．代理主題角色：內部包含對真實主題的引用，并且提供和真實主題角色相同的接口。3．真實主題角色：定義真實的對象。

使用類圖來表示下三者間的關系如下：

當然，圖上所示的是代理模式中的一個具體情況。而代理模式可以非常靈活的使用其他方式來實現，這樣就與圖上所示有很大的區別。

也許，現在你已經對代理模式已經有了一個宏觀的認識了，下面我們來看看怎么實際的使用代理模式。

四、舉例

以論壇中已注冊用戶和游客的權限不同來作為第一個例子：已注冊的用戶擁有發帖，修改自己的注冊信息，修改自己的帖子等功能；而游客只能看到別人發的帖子，沒有其他權限。為了簡化代碼，更好的顯示出代理模式的骨架，我們這里只實現發帖權限的控制。首先我們先實現一個抽象主題角色MyForum，里面定義了真實主題和代理主題的共同接口——發帖功能。

代碼如下：

publicinterfaceMyForum

{

publicvoidAddFile();

}

這樣，真實主題角色和代理主題角色都要實現這個接口。其中真實的主題角色基本就是將這個接口的方法內容填充進來。所以在這里就不再贅述它的實現。我們把主要的精力放到關鍵的代理主題角色上。代理主題角色代碼大體如下：

publicclassMyForumProxyimplementsMyForum

{

privateRealMyForumforum;

privateintpermission;//權限值

publicMyForumProxy(intpermission)

{

forum=newRealMyForum()

this.permission=permission;

}

//實現的接口

publicvoidAddFile()

{

//滿足權限設置的時候才能夠執行操作

//Constants是一個常量類

if(Constants.ASSOCIATOR==permission)

{

forum.AddFile();

}

else

System.out.println(“YouarenotaassociatorofMyForum,pleaseregiste!”);

}

}

這樣就實現了代理模式的功能。當然你也可以在這個代理類上添加自己的方法來實現額外的服務，比如統計帖子的瀏覽次數，記錄用戶的登錄情況等等。

還有一個很常見的代理模式的使用例子就是對大幅圖片瀏覽的控制。在我們常見的網站上面瀏覽圖文的信息時，不知道你有沒有注意到，圖片位置放置的是經過縮小的，當有人要仔細的查看這個圖片時，可以通過點擊圖片來激活一個鏈接，在一個新的網頁打開要看的圖片。這樣對于提高瀏覽速度是很有好處的，因為不是每個人都要去看仔細圖上的信息。這種情況就可以使用代理模式來全面實現。這里我將思路表述出來，至于實現由于工作原因，就不表述了，至于這種方式在B/S模式下的真實可行性，我沒有確認過，只是憑空的想象。如果不是可行的方式，那這個例子可以放到一個C/S下來實現，這個是絕對沒有問題的，而且在很多介紹設計模式的書和文章中使用。兩種方式的實現有興趣的可以來嘗試一下。

我們在瀏覽器中訪問網頁時是調用的不是真實的裝載圖片的方法，而是在代理對象中的方法，在這個對象中，先使用一個線程向瀏覽器裝載了一個縮小版的圖片，而在后臺使用另一個線程來調用真實的裝載大圖片的方法將圖片加載到本地，當你要瀏覽這個圖片的時候，將其在新的網頁中顯示出來。當然如果在你想瀏覽的時候圖片尚未加載成功，可以再啟動一個線程來顯示提示信息，直到加載成功。

這樣代理模式的功能就在上面體現的淋漓盡致——通過代理來將真實圖片的加載放到后臺來操作，使其不影響前臺的瀏覽。

五、總結

代理模式能夠協調調用者和被調用者，能夠在一定程度上降低系統的耦合度。不過一定要記住前面講的使用代理模式的條件，不然的話使用了代理模式不但不會有好的效果，說不定還會出問題的

第二篇：Java設計模式學習心得

Java設計模式學習心得

閱讀次數: 1584次 發布時間: 2010-04-10 14:52:13發布人: 網絡轉載

來源: 網絡轉載

整個設計模式貫穿一個原理:面對介面編程，而不是面對實現，（面向物件編程應該改爲面向介面編程）。目標原則是:降低耦合，增強靈活性。

一、創建模式

1.設計模式之Factory(工廠方法和抽象工廠)

使用工廠模式就象使用new一樣頻繁.2.設計模式之Prototype(原型)

用原型實例指定創建物件的種類，並且通過拷貝這些原型創建新的物件。

3.設計模式之Builder

汽車由車輪 方向盤 發動機很多部件組成，同時，將這些部件組裝成汽車也是一件複雜的工作，Builder模式就是將這兩種情況分開進行。

4.設計模式之Singleton(單態)

保證一個類只有一個實例,並提供一個訪問它的全局訪問點

二、結構模式

1.設計模式之Facade

可擴展的使用JDBC針對不同的資料庫編程,Facade提供了一種靈活的實現。

2.設計模式之Proxy

以Jive爲例,剖析代理模式在用戶級別授權機制上的應用

3.設計模式之Adapter

使用類再生的兩個方式:組合(new)和繼承(extends),這個已經在“thinking in java”中提到過。

4.設計模式之Composite

就是將類用樹形結構組合成一個單位。你向別人介紹你是某單位，你是單位元元中的一個元素，別人和你做買賣，相當於和單位做買賣。文章中還對Jive再進行了剖析。

5.設計模式之Decorator

Decorator是個油漆工,給你的東東的外表刷上美麗的顔色。

6.設計模式之Bridge

將“牛郎織女”分開(本應在一起,分開他們,形成兩個介面),在他們之間搭建一個橋(動態的結合)

7.設計模式之Flyweight

提供Java運行性能,降低小而大量重復的類的開銷。

三、行爲模式

1.設計模式之Template

實際上向你介紹了爲什麼要使用Java 抽象類,該模式原理簡單,使用很普遍。

2.設計模式之Memento

很簡單一個模式,就是在記憶體中保留原來資料的拷貝。

3.設計模式之Observer

介紹如何使用Java API提供的現成Observer

4.設計模式之Chain of Responsibility

各司其職的類串成一串,好象擊鼓傳花,當然如果自己能完成,就不要推委給下一個。

5.設計模式之Command

什麼是將行爲封裝,Command是最好的說明。

6.設計模式之State

狀態是編程中經常碰到的實例,將狀態物件化,設立狀態變換器,便可在狀態中輕鬆切換。

7.設計模式之Strategy

不同演算法各自封裝,用戶端可隨意挑選需要的演算法。

8.設計模式之Mediator

Mediator很象十字路口的紅綠燈,每個車輛只需和紅綠燈交互就可以。

9.設計模式之Interpreter

主要用來對語言的分析,應用機會不多。

10.設計模式之Visitor

訪問者在進行訪問時,完成一系列實質性操作,而且還可以擴展。

11.設計模式之Iterator

這個模式已經被用來遍曆Collection中物件。使用頻率很高。在Java中無需專門闡述,在大多數場合也無需自己制造一個Iterator,只要將物件裝入Collection中，我們就直接可以使用Iterator模式。

第三篇：java設計模式考試題

一選擇題：共10分

1.Open-Close原則的含義是一個軟件實體(a)

A.應當對擴展開放，對修改關閉

2.是10道選擇題第一題考完了

二 簡答題 共10分

1.什么是設計模式？

設計模式是從許多優秀軟件系統中總結出的成功的可復用的設計方案。

2.設計模式的四個基本要素是什么，以及他們是什么含義？

名稱：

問題：

方案：

效果：含義在書上p1

三 畫類圖

14畫出命令模式的類圖，并寫出關鍵的代碼？

見書上17頁

15.畫出迭代器模式的類圖，并寫出關鍵的代碼？、見書上105頁

四寫代碼學一個關于求職中心，通知求職者的問題

這是一個觀察者模式，具體看看書

我的書是第五章的書上例題

2.是一個交通工具營銷問題；

應該是外觀模式；見書上99頁，應該就是個

這是我們學校的考試題，2012年

第四篇：JAVA設計模式之創建模式

設計模式之Builder

Builder模式定義: 將一個復雜對象的構建與它的表示分離,使得同樣的構建過程可以創建不同的表示.Builder模式是一步一步創建一個復雜的對象,它允許用戶可以只通過指定復雜對象的類型和內容就可以構建它們.用戶不知道內部的具體構建細節.Builder模式是非常類似抽象工廠模式,細微的區別大概只有在反復使用中才能體會到.為何使用?

是為了將構建復雜對象的過程和它的部件解耦.注意: 是解耦過程和部件.因為一個復雜的對象,不但有很多大量組成部分,如汽車,有很多部件:車輪 方向盤 發動機還有各種小零件等等,部件很多,但遠不止這些,如何將這些部件裝配成一輛汽車,這個裝配過程也很復雜(需要很好的組裝技術),Builder模式就是為了將部件和組裝過程分開.如何使用?

首先假設一個復雜對象是由多個部件組成的,Builder模式是把復雜對象的創建和部件的創建分別開來,分別用Builder類和Director類來表示.首先,需要一個接口,它定義如何創建復雜對象的各個部件: public interface Builder {

//創建部件A 比如創建汽車車輪

void buildPartA();

//創建部件B 比如創建汽車方向盤

void buildPartB();

//創建部件C 比如創建汽車發動機

void buildPartC();

//返回最后組裝成品結果(返回最后裝配好的汽車)

//成品的組裝過程不在這里進行,而是轉移到下面的Director類中進行.//從而實現了解耦過程和部件

Product getResult();} 用Director構建最后的復雜對象,而在上面Builder接口中封裝的是如何創建一個個部件(復雜對象是由這些部件組成的),也就是說Director的內容是如何將部件最后組裝成成品: public class Director {

private Builder builder;

public Director(Builder builder){

this.builder = builder;} // 將部件partA partB partC最后組成復雜對象 //這里是將車輪 方向盤和發動機組裝成汽車的過程 public void construct(){

builder.buildPartA();

builder.buildPartB();

builder.buildPartC();

} } Builder的具體實現ConcreteBuilder: 通過具體完成接口Builder來構建或裝配產品的部件;定義并明確它所要創建的是什么具體東西;提供一個可以重新獲取產品的接口: public class ConcreteBuilder implements Builder {

Part partA, partB, partC;public void buildPartA(){

//這里是具體如何構建partA的代碼

};public void buildPartB(){

//這里是具體如何構建partB的代碼 };public void buildPartC(){

//這里是具體如何構建partB的代碼 };public Product getResult(){

//返回最后組裝成品結果 };} 復雜對象:產品Product: public interface Product { } 復雜對象的部件: public interface Part { }

我們看看如何調用Builder模式: ConcreteBuilder builder = new ConcreteBuilder();Director director = new Director(builder);

director.construct();Product product = builder.getResult();Builder模式的應用

在Java實際使用中,我們經常用到“池”(Pool)的概念,當資源提供者無法提供足夠的資源,并且這些資源需要被很多用戶反復共享時,就需要使用池.“池”實際是一段內存,當池中有一些復雜的資源的“斷肢”(比如數據庫的連接池,也許有時一個連接會中斷),如果循環再利用這些“斷肢”,將提高內存使用效率,提高池的性能.修改Builder模式中Director類使之能診斷“斷肢”斷在哪個部件上,再修復這個部件.設計模式之Factory

定義:提供創建對象的接口.為何使用?

工廠模式是我們最常用的模式了,著名的Jive論壇 ,就大量使用了工廠模式，工廠模式在Java程序系統可以說是隨處可見。

為什么工廠模式是如此常用？因為工廠模式就相當于創建實例對象的new，我們經常要根據類Class生成實例對象，如A a=new A()工廠模式也是用來創建實例對象的，所以以后new時就要多個心眼，是否可以考慮實用工廠模式，雖然這樣做，可能多做一些工作，但會給你系統帶來更大的可擴展性和盡量少的修改量。我們以類Sample為例，如果我們要創建Sample的實例對象: Sample sample=new Sample();可是，實際情況是，通常我們都要在創建sample實例時做點初始化的工作,比如賦值 查詢數據庫等。

首先，我們想到的是，可以使用Sample的構造函數，這樣生成實例就寫成: Sample sample=new Sample(參數);但是，如果創建sample實例時所做的初始化工作不是象賦值這樣簡單的事，可能是很長一段代碼，如果也寫入構造函數中，那你的代碼很難看了（就需要Refactor重整）。為什么說代碼很難看，初學者可能沒有這種感覺，我們分析如下，初始化工作如果是很長一段代碼，說明要做的工作很多，將很多工作裝入一個方法中，相當于將很多雞蛋放在一個籃子里，是很危險的，這也是有背于Java面向對象的原則，面向對象的封裝(Encapsulation)和分派(Delegation)告訴我們，盡量將長的代碼分派“切割”成每段，將每段再“封裝”起來(減少段和段之間偶合聯系性)，這樣，就會將風險分散，以后如果需要修改，只要更改每段，不會再發生牽一動百的事情。

在本例中，首先，我們需要將創建實例的工作與使用實例的工作分開, 也就是說，讓創建實例所需要的大量初始化工作從Sample的構造函數中分離出去。

這時我們就需要Factory工廠模式來生成對象了，不能再用上面簡單new Sample(參數)。還有,如果Sample有個繼承如MySample, 按照面向接口編程,我們需要將Sample抽象成一個接口.現在Sample是接口,有兩個子類MySample 和HisSample.我們要實例化他們時,如下: Sample mysample=new MySample();Sample hissample=new HisSample();隨著項目的深入,Sample可能還會“生出很多兒子出來”, 那么我們要對這些兒子一個個實例化,更糟糕的是,可能還要對以前的代碼進行修改:加入后來生出兒子的實例.這在傳統程序中是無法避免的.但如果你一開始就有意識使用了工廠模式,這些麻煩就沒有了.工廠方法

你會建立一個專門生產Sample實例的工廠: public class Factory{

public static Sample creator(int which){

//getClass 產生Sample 一般可使用動態類裝載裝入類。if(which==1)

return new SampleA();else if(which==2)

return new SampleB();

} } 那么在你的程序中,如果要實例化Sample時.就使用 Sample sampleA=Factory.creator(1);這樣,在整個就不涉及到Sample的具體子類,達到封裝效果,也就減少錯誤修改的機會,這個原理可以用很通俗的話來比喻:就是具體事情做得越多,越容易范錯誤.這每個做過具體工作的人都深有體會,相反,官做得越高,說出的話越抽象越籠統,范錯誤可能性就越少.好象我們從編程序中也能悟出人生道理?呵呵.使用工廠方法 要注意幾個角色，首先你要定義產品接口，如上面的Sample,產品接口下有Sample接口的實現類,如SampleA,其次要有一個factory類，用來生成產品Sample，如下圖，最右邊是生產的對象Sample：

進一步稍微復雜一點，就是在工廠類上進行拓展，工廠類也有繼承它的實現類concreteFactory了。抽象工廠

工廠模式中有: 工廠方法(Factory Method)抽象工廠(Abstract Factory).這兩個模式區別在于需要創建對象的復雜程度上。如果我們創建對象的方法變得復雜了,如上面工廠方法中是創建一個對象Sample,如果我們還有新的產品接口Sample2.這里假設：Sample有兩個concrete類SampleA和SamleB，而Sample2也有兩個concrete類Sample2A和SampleB2 那么，我們就將上例中Factory變成抽象類,將共同部分封裝在抽象類中,不同部分使用子類實現，下面就是將上例中的Factory拓展成抽象工廠: public abstract class Factory{

public abstract Sample creator();

public abstract Sample2 creator(String name);} public class SimpleFactory extends Factory{

public Sample creator(){

.........return new SampleA } public Sample2 creator(String name){

.........return new Sample2A } } public class BombFactory extends Factory{

public Sample creator(){

......return new SampleB } public Sample2 creator(String name){

......return new Sample2B } }

從上面看到兩個工廠各自生產出一套Sample和Sample2,也許你會疑問，為什么我不可以使用兩個工廠方法來分別生產Sample和Sample2? 抽象工廠還有另外一個關鍵要點，是因為 SimpleFactory內，生產Sample和生產Sample2的方法之間有一定聯系，所以才要將這兩個方法捆綁在一個類中，這個工廠類有其本身特征，也許制造過程是統一的，比如：制造工藝比較簡單，所以名稱叫SimpleFactory。在實際應用中，工廠方法用得比較多一些，而且是和動態類裝入器組合在一起應用，舉例

我們以Jive的ForumFactory為例，這個例子在前面的Singleton模式中我們討論過，現在再討論其工廠模式: public abstract class ForumFactory {

private static Object initLock = new Object();

private static String className = “com.jivesoftware.forum.database.DbForumFactory”;

private static ForumFactory factory = null;

public static ForumFactory getInstance(Authorization authorization){

//If no valid authorization passed in, return null.if(authorization == null){

return null;

}

//以下使用了Singleton 單態模式

if(factory == null){

synchronized(initLock){

if(factory == null){

......}

}

} try {

//動態轉載類

Class c = Class.forName(className);

factory =(ForumFactory)c.newInstance();} catch(Exception e){

return null;}

//Now, 返回 proxy.用來限制授權對forum的訪問

return new ForumFactoryProxy(authorization, factory，factory.getPermissions(authorization));

}

//真正創建forum的方法由繼承forumfactory的子類去完成.public abstract Forum createForum(String name, String description)

throws UnauthorizedException, ForumAlreadyExistsException;

....}

因為現在的Jive是通過數據庫系統存放論壇帖子等內容數據,如果希望更改為通過文件系統實現,這個工廠方法ForumFactory就提供了提供動態接口: private static String className = “com.jivesoftware.forum.database.DbForumFactory”;你可以使用自己開發的創建forum的方法代替com.jivesoftware.forum.database.DbForumFactory就可以.在上面的一段代碼中一共用了三種模式,除了工廠模式外,還有Singleton單態模式,以及proxy模式,proxy模式主要用來授權用戶對forum的訪問,因為訪問forum有兩種人:一個是注冊用戶 一個是游客guest,那么那么相應的權限就不一樣,而且這個權限是貫穿整個系統的,因此建立一個proxy,類似網關的概念,可以很好的達到這個效果.看看Java寵物店中的CatalogDAOFactory: public class CatalogDAOFactory {

/**

* 本方法制定一個特別的子類來實現DAO模式。

* 具體子類定義是在J2EE的部署描述器中。

*/

public static CatalogDAO getDAO()throws CatalogDAOSysException {

CatalogDAO catDao = null;

try {

InitialContext ic = new InitialContext();//動態裝入CATALOG_DAO_CLASS //可以定義自己的CATALOG_DAO_CLASS，從而在無需變更太多代碼 //的前提下，完成系統的巨大變更。

String className =(String)ic.lookup(JNDINames.CATALOG_DAO_CLASS);

catDao =(CatalogDAO)Class.forName(className).newInstance();

} catch(NamingException ne){

throw new CatalogDAOSysException(“

CatalogDAOFactory.getDAO: NamingException while

getting DAO type : n” + ne.getMessage());

} catch(Exception se){

throw new CatalogDAOSysException(“

CatalogDAOFactory.getDAO: Exception while getting

DAO type : n” + se.getMessage());

}

return catDao;

} } CatalogDAOFactory是典型的工廠方法，catDao是通過動態類裝入器className獲得CatalogDAOFactory具體實現子類，這個實現子類在Java寵物店是用來操作catalog數據庫，用戶可以根據數據庫的類型不同，定制自己的具體實現子類，將自己的子類名給與CATALOG_DAO_CLASS變量就可以。

由此可見，工廠方法確實為系統結構提供了非常靈活強大的動態擴展機制，只要我們更換一下具體的工廠方法，系統其他地方無需一點變換，就有可能將系統功能進行改頭換面的變化。

設計模式之Prototype(原型)

定義: 用原型實例指定創建對象的種類,并且通過拷貝這些原型創建新的對象.Prototype模式允許一個對象再創建另外一個可定制的對象，根本無需知道任何如何創建的細節,工作原理是:通過將一個原型對象傳給那個要發動創建的對象，這個要發動創建的對象通過請求原型對象拷貝它們自己來實施創建。如何使用? 因為Java中的提供clone()方法來實現對象的克隆(具體了解clone()按這里),所以Prototype模式實現一下子變得很簡單.以勺子為例：

public abstract class AbstractSpoon implements Cloneable {

String spoonName;

public void setSpoonName(String spoonName){this.spoonName = spoonName;}

public String getSpoonName(){return this.spoonName;}

public Object clone()

{

Object object = null;

try {

object = super.clone();

} catch(CloneNotSupportedException exception){

System.err.println(“AbstractSpoon is not Cloneable”);

}

return object;

} } 有兩個具體實現(ConcretePrototype): public class SoupSpoon extends AbstractSpoon {

public SoupSpoon()

{

setSpoonName(“Soup Spoon”);

} } public class SaladSpoon extends AbstractSpoon {

public SaladSpoon()

{

setSpoonName(“Salad Spoon”);

} } 調用Prototype模式很簡單: AbstractSpoon spoon = new SoupSpoon();AbstractSpoon spoon = new SaladSpoon();當然也可以結合工廠模式來創建AbstractSpoon實例。

在Java中Prototype模式變成clone()方法的使用，由于Java的純潔的面向對象特性，使得在Java中使用設計模式變得很自然，兩者已經幾乎是渾然一體了。這反映在很多模式上，如Interator遍歷模式。

設計模式之Singleton(單態)

定義: Singleton模式主要作用是保證在Java應用程序中，一個類Class只有一個實例存在。在很多操作中，比如建立目錄 數據庫連接都需要這樣的單線程操作。

還有, singleton能夠被狀態化;這樣，多個單態類在一起就可以作為一個狀態倉庫一樣向外提供服務，比如，你要論壇中的帖子計數器，每次瀏覽一次需要計數，單態類能否保持住這個計數，并且能synchronize的安全自動加1，如果你要把這個數字永久保存到數據庫，你可以在不修改單態接口的情況下方便的做到。

另外方面，Singleton也能夠被無狀態化。提供工具性質的功能，Singleton模式就為我們提供了這樣實現的可能。使用Singleton的好處還在于可以節省內存，因為它限制了實例的個數，有利于Java垃圾回收（garbage collection）。

我們常常看到工廠模式中類裝入器(class loader)中也用Singleton模式實現的,因為被裝入的類實際也屬于資源。如何使用?

一般Singleton模式通常有幾種形式: public class Singleton {

private Singleton(){}

//在自己內部定義自己一個實例，是不是很奇怪？

//注意這是private 只供內部調用

private static Singleton instance = new Singleton();

}

第二種形式: public class Singleton {

private static Singleton instance = null;public static synchronized Singleton getInstance(){

//這個方法比上面有所改進，不用每次都進行生成對象，只是第一次

//使用時生成實例，提高了效率！if(instance==null)

instance＝new Singleton();return instance;} //這里提供了一個供外部訪問本class的靜態方法，可以直接訪問

public static Singleton getInstance(){

return instance;

} }

使用Singleton.getInstance()可以訪問單態類。

上面第二中形式是lazy initialization，也就是說第一次調用時初始Singleton，以后就不用再生成了。

注意到lazy initialization形式中的synchronized，這個synchronized很重要，如果沒有synchronized，那么使用getInstance()是有可能得到多個Singleton實例。關于lazy initialization的Singleton有很多涉及double-checked locking(DCL)的討論，有興趣者進一步研究。

一般認為第一種形式要更加安全些。使用Singleton注意事項：

有時在某些情況下，使用Singleton并不能達到Singleton的目的，如有多個Singleton對象同時被不同的類裝入器裝載；在EJB這樣的分布式系統中使用也要注意這種情況，因為EJB是跨服務器，跨JVM的。

我們以SUN公司的寵物店源碼(Pet Store 1.3.1)的ServiceLocator為例稍微分析一下：

在Pet Store中ServiceLocator有兩種，一個是EJB目錄下；一個是WEB目錄下，我們檢查這兩個ServiceLocator會發現內容差不多，都是提供EJB的查詢定位服務，可是為什么要分開呢？仔細研究對這兩種ServiceLocator才發現區別：在WEB中的ServiceLocator的采取Singleton模式，ServiceLocator屬于資源定位，理所當然應該使用Singleton模式。但是在EJB中，Singleton模式已經失去作用，所以ServiceLocator才分成兩種，一種面向WEB服務的，一種是面向EJB服務的。

Singleton模式看起來簡單，使用方法也很方便，但是真正用好，是非常不容易，需要對Java的類 線程 內存等概念有相當的了解。進一步深入可參考：

Double-checked locking and the Singleton pattern When is a singleton not a singleton?

第五篇：JAVA學習書籍- 設計模式

談到設計模式很多人多會推薦GOF 的那本，該書在Amzon上是五星級的推薦書籍。不過對于學習java 沒多久的、特別是java 初學者，我很不推薦這本書。主要是該書的例子基本都是C++的，很多細節沒有講述得足夠清楚。

我給大家推薦的第一本是閻宏博士的《Java 與模式》，它是第一本中國人自己寫的關于設計模式的書籍，寫的比較有趣，融合了很多中

華民族的文化和觀念，例子、類圖都比較多，且相對簡單！非常不錯的入門書籍――又是大塊頭哦！

其次我推薦Wiley 出版社出版的《Pattern In Java》一套三本，我才看了第一本，好像第二本不怎么樣，第三本還不錯！

第三本是中文翻譯版的關于多線程模式的（很難得的中文翻譯版）中國鐵道出版社2003 年出版的《Java 多線程設計模式》，將多線程模

式講得非常淺顯，配有大量的圖例，每章都有習題，最后有答案！我研究多線程模式就是由它開始的！

第四本，今年出版的Head First 系列的《Head First Design Pattern》，秉承Head First 系列圖書的優點，大量的類圖、豐富的實例、有趣的注解，值得購買！

其次在J2EE 方向你可以研究閱讀Addison Wesley 2002 年出版的《Patterns of Enterprise Application Architecture》，眾多大腕的作品，講企業消息集成的！Sun 提供的《J2EE PATTERNS SL500》也很好！晚了推薦那一本Amzon 4 星半的《Holub on patterns》，大師的作品，提供了，很值得研究的例子，不過對上面四本不是很熟悉的讀者，最好不要讀它！可能會讓你比較累！

我學習設計模式經過一段很曲折的路線，前前后后大約看了20 本，閻宏博士的《Java 與模式》我看了4 遍，還排除我第一次基本沒看

懂的看！記得研一時老師給我們講了GOF 的那本，作為選修課，我和它們計算機系的碩士、博士們一起，到最后一個班40－50 個人，不

超過3 個人明白，我也沒有明白任何一點（基礎差吧――主要我對C++語言一點都不了解），憑我不伏輸的性格，我認為我對java 語言理

解還可以，我就借了《Java 與模式》，結果還是基本沒看懂。很有幸的是讀研三時，聽過了上交大饒若楠老師關于Java OOP 語言的講座，我懂了組合書籍模式等三種設計模式后，對其它模式有了強烈的興趣和要征服它的愿望！工作后我買的第一本就是《Java 與模式》，第一遍花了2 個月研究了這個1000 多頁的大塊頭，后來第三遍15 天左右就可以搞定，筆記記了一大本！從此一發不可收拾。

選對書、埋頭研究。相信很快就會入門的！

學習Java 語言8 個簡單的部分，這只是我們研究Java 語言的開始！這些都懂了充其量一個java 程序員而已，后面的路很長很長！我們

可以繼續研究數據庫實現的源代碼、Servlet 服務器的源代碼、RMI、EJB、JNDI、面向方面編程、重構、ANT 工具、Eclipse 工具、Spring

工具、JBoss、JOnAS、Apache Geronimo 等J2EE 服務器！研究了這些你可能會成為一個出色的J2EE Architecture！你可以繼續研究剖

析器、編譯器、JNODE（java 寫的操作系統）