ANDROID 中设计模式的采用--创建型模式

 转http://blog.csdn.net/goohong/article/details/38044229

所谓模式就是在某一情景下解决某个问题的固定解决方案。

        所有的创建型模式都是用作对象的创建或实例化的解决方案。

        1 简单工厂模式

创建对象的最简单方法是使用new来创建一个对象，如果只创建一种固定不变的对象,可以使用new来创建这个对象。

如果要根据不同场景创建不同类型的对象，就可能需要采用不同的方法，就出现了不同的模式的采用和总结。

如ANDROID的媒体框架中为了实现对不同媒体源的播放，就需要实现多种播放器对象，并可能需要根据支持的媒体类型的增加，不断添加播放器对象。

[html]  view plain copy

1.  sp<MediaPlayerBase> p;  
2.     switch (playerType) {  
3.         case SONIVOX_PLAYER:  
4.             ALOGV(" create MidiFile");  
5.             p = new MidiFile();  
6.             break;  
7.         case STAGEFRIGHT_PLAYER:  
8.             ALOGV(" create StagefrightPlayer");  
9.             p = new StagefrightPlayer;  
10.             break;  
11.         case NU_PLAYER:  
12.             ALOGV(" create NuPlayer");  
13.             p = new NuPlayerDriver;  
14.             break;  
15.         case TEST_PLAYER:  
16.             ALOGV("Create Test Player stub");  
17.             p = new TestPlayerStub();  
18.             break;  
19.        case   AAH_RX_PLAYER:  
20.             ALOGV(" create A@H RX Player");  
21.             p = createAAH_RXPlayer();  
22.             break;  
23.         case  AAH_TX_PLAYER:  
24.             ALOGV(" create A@H TX Player");  
25.             p = createAAH_TXPlayer();  
26.             break;  
27. #ifdef BUILD_WITH_MST  
28.         case MST_PLAYER:  
29.             ALOGV(" create MstPlayer");  
30.             p = new MstPlayer;  
31.             break;  
32. #endif  
33.         default:  
34.             ALOGE("Unknown player type: %d", playerType);  
35.             return NULL;  
36.     }  

上面代码可能随着播放支持的媒体类型的添加需要不断修改，因此为了满足“开闭设计原则”（对修改封闭，对扩展开放），就要采用不同的模式实现媒体播放器对象的创建功能。

一种简单的方法是把上面的代码放到一个创建播放器的函数中，这也是ANDROID4.2以前的版本采用的模式，也称为简单工厂之静态工厂模式。就如下面所示：

[html]  view plain copy

1. static sp<MediaPlayerBase> createPlayer(player_type playerType, void* cookie,  
2.         notify_callback_f notifyFunc)  
3. {  
4.   sp<MediaPlayerBase> p;  
5.     switch (playerType) {  
6.         case SONIVOX_PLAYER:  
7.             ALOGV(" create MidiFile");  
8.             p = new MidiFile();  
9.             break;  
10.         case STAGEFRIGHT_PLAYER:  
11.             ALOGV(" create StagefrightPlayer");  
12.             p = new StagefrightPlayer;  
13.             break;  
14.         case NU_PLAYER:  
15.             ALOGV(" create NuPlayer");  
16.             p = new NuPlayerDriver;  
17.             break;  
18.         case TEST_PLAYER:  
19.             ALOGV("Create Test Player stub");  
20.             p = new TestPlayerStub();  
21.             break;  
22.        case   AAH_RX_PLAYER:  
23.             ALOGV(" create A@H RX Player");  
24.             p = createAAH_RXPlayer();  
25.             break;  
26.         case  AAH_TX_PLAYER:  
27.             ALOGV(" create A@H TX Player");  
28.             p = createAAH_TXPlayer();  
29.             break;  
30. #ifdef BUILD_WITH_MST  
31.         case MST_PLAYER:  
32.             ALOGV(" create MstPlayer");  
33.             p = new MstPlayer;  
34.             break;  
35. #endif  
36.         default:  
37.             ALOGE("Unknown player type: %d", playerType);  
38.             return NULL;  
39.     }  
40.   sp<MediaPlayerBase> p;  
41.     switch (playerType) {  
42.         case SONIVOX_PLAYER:  
43.             ALOGV(" create MidiFile");  
44.             p = new MidiFile();  
45.             break;  
46.         case STAGEFRIGHT_PLAYER:  
47.             ALOGV(" create StagefrightPlayer");  
48.             p = new StagefrightPlayer;  
49.             break;  
50.         case NU_PLAYER:  
51.             ALOGV(" create NuPlayer");  
52.             p = new NuPlayerDriver;  
53.             break;  
54.         case TEST_PLAYER:  
55.             ALOGV("Create Test Player stub");  
56.             p = new TestPlayerStub();  
57.             break;  
58.        case   AAH_RX_PLAYER:  
59.             ALOGV(" create A@H RX Player");  
60.             p = createAAH_RXPlayer();  
61.             break;  
62.         case  AAH_TX_PLAYER:  
63.             ALOGV(" create A@H TX Player");  
64.             p = createAAH_TXPlayer();  
65.             break;  
66. #ifdef BUILD_WITH_MST  
67.         case MST_PLAYER:  
68.             ALOGV(" create MstPlayer");  
69.             p = new MstPlayer;  
70.             break;  
71. #endif  
72.         default:  
73.             ALOGE("Unknown player type: %d", playerType);  
74.             return NULL;  
75.     }  

 当然也可以把上面的创建播放器对象的代码放到一个工厂类中。

ANDROID系统中的PhoneFactory类就是一个简单工厂类的采用，该类提供了makeDefaultPhones、getGsmPhone、getCdmaPhone、getDefaultPhone、makeSipPhone等工厂函数来创建和获得不同类型的Phone对象。

以上的简单工厂模式虽然可以在一处修改代码，但还是不满足“开闭设计原则”，也不满足针对接口编程的设计原则，因此在功能扩展时还是需要修改相关代码。

PhoneFactory工厂类还存在一个问题: 为了创建不同类型的Phone对象需要调用PhoneFactory工厂类的不同的工厂函数，虽然它们创建的Phone对象都是Phone的子类。

为了解决上面的简单工厂模式的问题，就需要采用另外的两个工厂模式：工厂方法和抽象工厂,一个采用了类继承的方式,一个采用了对象组合的方式。

2 工厂模式之工厂方法

工厂方法模式通过在要创建对象的共同父类中定义一个公共抽象接口来返回具体类创建的对象，该接口返回的具体对象实际在具体类的实现公共抽象接口的创建函数中创建。

 意图：在抽象类定义一个用于创建对象的接口，让具体类创建具体的对象。

工厂方法的UML结构类图为：

在ANDROID系统的媒体路由框架中的MediaRouteProvider类就是工厂方法模式的采用。

抽象类MediaRouteProvider中提供了一个创建RouteController对象的公共接口onCreateRouteController，用来返回一个MediaRouteProvider.RouteController对象，MediaRouteProvider.RouteController的具体对象实际由MediaRouteProvider的具体派生类在其onCreateRouteController函数中负责创建，如MediaRouteProvider的派生类RegisteredMediaRouteProvider在其onCreateRouteController函数中创建了一个具体类型为RegisteredMediaRouteProvider.Controller的MediaRouteProvider.RouteController对象，MediaRouteProvider的间接派生类SystemMediaRouteProvider.LegacyImpl和SystemMediaRouteProvider.JellybeanImpl在各自的onCreateRouteController函数中分别创建了派生于MediaRouteProvider.RouteController的两个具体对象：SystemMediaRouteProvider.DefaultRouteController和SystemMediaRouteProvider.SystemRouteController。

3工厂模式之抽象工厂

抽象工厂模式是通过实现一个派生于抽象工厂的具体工厂来负责创建具体的产品或产品系列。抽象工厂模式可以通过实现不同的具体工厂来创建不同的产品或系列，也可以通过具体工厂的不同方法来创建不同的产品。而用户只与抽象工厂打交道，而不关心哪个工厂创建了具体产品。

抽象工厂模式的意图是提供一个创建一系列相关或依赖的对象的接口，用户可以通过该接口创建一系列相关的对象。

在最新版本的ANDROID系统中的媒体框架中上面的媒体播放器的创建就采用了抽象工厂模式。类图如下：

其中MediaPlayerFactory为MediaPlayerFactory:IFactory的客户，MediaPlayerFactory通过其包含的抽象工厂MediaPlayerFactory:IFactory的抽象接口createPlayer来创建不同的播放器，每种具体的播放器由每一个具体的工厂来负责创建，如StagefrightPlayer播放器由StagefrightPlayerFactory工厂创建，NuPlayerFactory工厂创建NuPlayerDriver播放器，SonivoxPlayerFactory工厂创建MidiFile播放器，TestPlayerFactory工厂创建用于测试的播放器TestPlayerStub。在MediaPlayerFactory类中每种具体的播放器工厂需要采用MediaPlayerFactory的registerFactory_l或registerFactory函数登记到MediaPlayerFactory类中，以便MediaPlayerFactory类在其工厂方法中能够根据不同的播放类型获得具体的播放工厂来创建具体类型的播放器。

抽象工厂与工厂方法模式的关键区别是：抽象工厂需要创建派生自抽象工厂的具体的工厂，通过具体工厂对象的实例方法来创建具体的产品,工厂对象的责任就是创建具体的产品；而工厂方法模式是提供一个框架，产品的创建是通过要创建产品的子类中的一个工厂方法来完成,创建产品只是子类的诸多责任中的一项任务。

4 生成器

有时对象的创建需要采用分步骤来完成，这时就可以采用生成器模式，UML类图如下：

在ANDROID系统中也存在大量的生成器模式的采用。如AlertDialog、Uri、Notification等对象的创建。如下是AlertDialog对象的创建例子。

[html]  view plain copy

1. AlertDialog dialog = new AlertDialog.Builder(mContext)  
2.           .setTitle(r.getString(R.string.wifi_p2p_invitation_sent_title))  
3.           .setView(textEntryView)  
4.           .setPositiveButton(r.getString(R.string.ok), null)  
5.           .create();  

5、原形

如果需要通过克隆已有的对象来创建新的对象，就要采用原形模式。UML类图如下：

在android系统中所有实现Cloneable接口的类都支持采用原形模式创建其对象，如Intent、Animation、Bundle、ComponentName、Event等对象。

如下例子为Intent对象采用原形模式创建其对象的代码片断：

[html]  view plain copy

1. /**  
2.     * Copy constructor.  
3.     */  
4.    public Intent(Intent o) {  
5.        this.mAction = o.mAction;  
6.        this.mData = o.mData;  
7.        this.mType = o.mType;  
8.        this.mPackage = o.mPackage;  
9.        this.mComponent = o.mComponent;  
10.        this.mFlags = o.mFlags;  
11.        if (o.mCategories != null) {  
12.            this.mCategories = new ArraySet<String>(o.mCategories);  
13.        }  
14.        if (o.mExtras != null) {  
15.            this.mExtras = new Bundle(o.mExtras);  
16.        }  
17.        if (o.mSourceBounds != null) {  
18.            this.mSourceBounds = new Rect(o.mSourceBounds);  
19.        }  
20.        if (o.mSelector != null) {  
21.            this.mSelector = new Intent(o.mSelector);  
22.        }  
23.        if (o.mClipData != null) {  
24.            this.mClipData = new ClipData(o.mClipData);  
25.        }  
26.    }  
27.   
28.    @Override  
29.    public Object clone() {  
30.        return new Intent(this);  
31.    }  

6 单件模式

如果在一个进程中某个类只需要创建一个实例，就需要采用单件模式，类图如下：

在android系统中，单件模式也普遍采用，以便维持一个进程内的某个类的唯一实例。

如许多硬件相关的系统服务管理类和服务：ServiceManager、SensorManager、WindowManagerGlobal、WallpaperManager、AccessibilityManager、UserManagerService、DownloadManager、BatteryService、ConnectivityManager等。

如下代码采用单件模式获得ServiceManager类的单件实例。

[html]  view plain copy

1. private static IServiceManager sServiceManager;  
2. private static IServiceManager getIServiceManager() {  
3.         if (sServiceManager != null) {  
4.             return sServiceManager;  
5.         }  
6.   
7.         // Find the service manager  
8.         sServiceManager = ServiceManagerNative.asInterface(BinderInternal.getContextObject());  
9.         return sServiceManager;  
10.     }