對于開發(fā)人員來說眼刃，設(shè)計模式有時候就是一道坎摄狱，但是設(shè)計模式又非常有用脓诡，過了這道坎，它可以讓你水平提高一個檔次媒役。而在android開發(fā)中誉券，必要的了解一些設(shè)計模式又是非常有必要的。對于想系統(tǒng)的學(xué)習(xí)設(shè)計模式的同學(xué)刊愚，這里推薦2本書踊跟。一本是Head First系列的Head Hirst Design Pattern，英文好的可以看英文鸥诽，可以多讀幾遍商玫。另外一本是大話設(shè)計模式。
單例模式
首先了解一些單例模式的概念牡借。
確保某一個類只有一個實例拳昌，而且自行實例化并向整個系統(tǒng)提供這個實例。
這樣做有以下幾個優(yōu)點
對于那些比較耗內(nèi)存的類钠龙，只實例化一次可以大大提高性能炬藤，尤其是在移動開發(fā)中御铃。
保持程序運行的時候該中始終只有一個實例存在內(nèi)存中
其實單例有很多種實現(xiàn)方式，但是個人比較傾向于其中1種沈矿∩险妫可以見單例模式
代碼如下
1
2
3
4
5
6
7
publicclassSingleton {
privatestaticvolatile Singleton instance =null;
privateSingleton(){
}
publicstatic SingletongetInstance() {
if (instance ==null) {
synchronized (Singleton.class) {
if (instance ==null) {
instance =new Singleton();
}
}
}
return instance;
}
}
要保證單例，需要做一下幾步
必須防止外部可以調(diào)用構(gòu)造函數(shù)進(jìn)行實例化羹膳，因此構(gòu)造函數(shù)必須私有化睡互。
必須定義一個靜態(tài)函數(shù)獲得該單例
單例使用volatile修飾
使用synchronized 進(jìn)行同步處理，并且雙重判斷是否為null陵像，我們看到synchronized (Singleton.class)里面又進(jìn)行了是否為null的判斷就珠，這是因為一個線程進(jìn)入了該代碼，如果另一個線程在等待醒颖，這時候前一個線程創(chuàng)建了一個實例出來完畢后妻怎，另一個線程獲得鎖進(jìn)入該同步代碼，實例已經(jīng)存在泞歉，沒必要再次創(chuàng)建蹂季，因此這個判斷是否是null還是必須的。
至于單例的并發(fā)測試疏日，可以使用CountDownLatch，使用await()等待鎖釋放撒汉，使用countDown()釋放鎖從而達(dá)到并發(fā)的效果沟优。可以見下面的代碼
1
2
3
4
5
6
7
8
publicstaticvoidmain(String[] args) {
final CountDownLatch latch =new CountDownLatch(1);
int threadCount =1000;
for (int i =0; i < threadCount; i++) {
new Thread() {
@Override
publicvoidrun() {
try {
latch.await();
}catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println(Singleton.getInstance().hashCode());
}
}.start();
}
latch.countDown();
}
看看打印出來的hashCode會不會出現(xiàn)不一樣即可睬辐，理論上是全部都一樣的挠阁。
而在Android中，很多地方用到了單例溯饵。
比如Android-Universal-Image-Loader中的單例
1
2
3
privatevolatilestatic ImageLoader instance;
/** Returns singleton class instance */
publicstatic ImageLoadergetInstance() {
if (instance ==null) {
synchronized (ImageLoader.class) {
if (instance ==null) {
instance =new ImageLoader();
}
}
}
return instance;
}
比如EventBus中的單例
1
2
3
privatestaticvolatile EventBus defaultInstance;
publicstatic EventBusgetDefault() {
if (defaultInstance ==null) {
synchronized (EventBus.class) {
if (defaultInstance ==null) {
defaultInstance =new EventBus();
}
}
}
return defaultInstance;
}
上面的單例都是比較規(guī)規(guī)矩矩的侵俗，當(dāng)然實際上有很多單例都是變了一個樣子，單本質(zhì)還是單例丰刊。
如InputMethodManager 中的單例
1
2
3
static InputMethodManager sInstance;
publicstatic InputMethodManagergetInstance() {
synchronized (InputMethodManager.class) {
if (sInstance ==null) {
IBinder b = ServiceManager.getService(Context.INPUT_METHOD_SERVICE);
IInputMethodManager service = IInputMethodManager.Stub.asInterface(b);
sInstance =new InputMethodManager(service, Looper.getMainLooper());
}
return sInstance;
}
}
AccessibilityManager 中的單例隘谣，看代碼這么長，其實就是進(jìn)行了一些判斷啄巧，還是一個單例
1
2
3
privatestatic AccessibilityManager sInstance;
publicstatic AccessibilityManagergetInstance(Context context) {
synchronized (sInstanceSync) {
if (sInstance ==null) {
finalint userId;
if (Binder.getCallingUid() == Process.SYSTEM_UID
|| context.checkCallingOrSelfPermission(
Manifest.permission.INTERACT_ACROSS_USERS)
== PackageManager.PERMISSION_GRANTED
|| context.checkCallingOrSelfPermission(
Manifest.permission.INTERACT_ACROSS_USERS_FULL)
== PackageManager.PERMISSION_GRANTED) {
userId = UserHandle.USER_CURRENT;
}else {
userId = UserHandle.myUserId();
}
IBinder iBinder = ServiceManager.getService(Context.ACCESSIBILITY_SERVICE);
IAccessibilityManager service = IAccessibilityManager.Stub.asInterface(iBinder);
sInstance =new AccessibilityManager(context, service, userId);
}
}
return sInstance;
}
當(dāng)然單例還有很多種寫法寻歧，比如惡漢式，有興趣的自己去了解就好了秩仆。
最后码泛，我們應(yīng)用一下單例模式。典型的一個應(yīng)用就是管理我們的Activity澄耍，下面這個可以作為一個工具類噪珊，代碼也很簡單晌缘，也不做什么解釋了。
1
2
3
publicclassActivityManager {
privatestaticvolatile ActivityManager instance;
private Stack mActivityStack =new Stack();
privateActivityManager(){
}
publicstatic ActivityManagergetInstance(){
if (instance ==null) {
synchronized (ActivityManager.class) {
if (instance ==null) {
instance =new ActivityManager();
}
}
return instance;
}
publicvoidaddActicity(Activity act){
mActivityStack.push(act);
}
publicvoidremoveActivity(Activity act){
mActivityStack.remove(act);
}
publicvoidkillMyProcess(){
int nCount = mActivityStack.size();
for (int i = nCount -1; i >=0; i--) {
Activity activity = mActivityStack.get(i);
activity.finish();
}
mActivityStack.clear();
android.os.Process.killProcess(android.os.Process.myPid());
}
}
這個類可以在開源中國的幾個客戶端中找到類似的源碼
以上兩個類是一樣的痢站，沒區(qū)別磷箕。
Build模式
了解了單例模式，接下來介紹另一個常見的模式——Builder模式瑟押。
那么什么是Builder模式呢搀捷。你通過搜索，會發(fā)現(xiàn)大部分網(wǎng)上的定義都是
將一個復(fù)雜對象的構(gòu)建與它的表示分離多望，使得同樣的構(gòu)建過程可以創(chuàng)建不同的表示
但是看完這個定義嫩舟，并沒有什么卵用，你依然不知道什么是Builder設(shè)計模式怀偷。在此個人的態(tài)度是學(xué)習(xí)設(shè)計模式這種東西家厌，不要過度在意其定義，定義往往是比較抽象的椎工，學(xué)習(xí)它最好的例子就是通過樣例代碼饭于。
我們通過一個例子來引出Builder模式。假設(shè)有一個Person類维蒙，我們通過該Person類來構(gòu)建一大批人掰吕，這個Person類里有很多屬性，最常見的比如name颅痊，age殖熟，weight，height等等斑响，并且我們允許這些值不被設(shè)置菱属，也就是允許為null，該類的定義如下舰罚。
1
2
3
publicclassPerson {
private String name;
privateint age;
privatedouble height;
privatedouble weight;
public StringgetName() {
return name;
}
publicvoidsetName(String name) {
this.name = name;
}
publicintgetAge() {
return age;
}
publicvoidsetAge(int age) {
this.age = age;
}
publicdoublegetHeight() {
return height;
}
publicvoidsetHeight(double height) {
this.height = height;
}
publicdoublegetWeight() {
return weight;
}
publicvoidsetWeight(double weight) {
this.weight = weight;
}
}
然后我們?yōu)榱朔奖憧赡軙x一個構(gòu)造方法纽门。
1
2
3
4
5
6
publicPerson(String name,int age,double height,double weight) {
this.name = name;
this.age = age;
this.height = height;
this.weight = weight;
}
或許為了方便new對象，你還會定義一個空的構(gòu)造方法
1
2
publicPerson() {
}
甚至有時候你很懶营罢，只想傳部分參數(shù)赏陵，你還會定義如下類似的構(gòu)造方法。
1
2
3
publicPerson(String name) {
this.name = name;
}
publicPerson(String name,int age) {
this.name = name;
this.age = age;
}
publicPerson(String name,int age,double height) {
this.name = name;
this.age = age;
this.height = height;
}
于是你就可以這樣創(chuàng)建各個需要的對象
1
2
3
4
5
Person p1=new Person();
Person p2=new Person("張三");
Person p3=new Person("李四",18);
Person p4=new Person("王五",21,180);
Person p5=new Person("趙六",17,170,65.4);
可以想象一下這樣創(chuàng)建的壞處饲漾，最直觀的就是四個參數(shù)的構(gòu)造函數(shù)的最后面的兩個參數(shù)到底是什么意思瘟滨，可讀性不怎么好，如果不點擊看源碼能颁，鬼知道哪個是weight哪個是height杂瘸。還有一個問題就是當(dāng)有很多參數(shù)時，編寫這個構(gòu)造函數(shù)就會顯得異常麻煩伙菊，這時候如果換一個角度败玉，試試Builder模式敌土，你會發(fā)現(xiàn)代碼的可讀性一下子就上去了。
我們給Person增加一個靜態(tài)內(nèi)部類Builder類运翼，并修改Person類的構(gòu)造函數(shù)返干，代碼如下。
1
2
3
publicclassPerson {
private String name;
privateint age;
privatedouble height;
privatedouble weight;
privatePerson(Builder builder) {
this.name=builder.name;
this.age=builder.age;
this.height=builder.height;
this.weight=builder.weight;
}
public StringgetName() {
return name;
}
publicvoidsetName(String name) {
this.name = name;
}
publicintgetAge() {
return age;
}
publicvoidsetAge(int age) {
this.age = age;
}
publicdoublegetHeight() {
return height;
}
publicvoidsetHeight(double height) {
this.height = height;
}
publicdoublegetWeight() {
return weight;
}
publicvoidsetWeight(double weight) {
this.weight = weight;
}
staticclassBuilder{
private String name;
privateint age;
privatedouble height;
privatedouble weight;
public Buildername(String name){
this.name=name;
returnthis;
}
public Builderage(int age){
this.age=age;
returnthis;
}
public Builderheight(double height){
this.height=height;
returnthis;
}
public Builderweight(double weight){
this.weight=weight;
returnthis;
}
public Personbuild(){
returnnew Person(this);
}
}
}
從上面的代碼中我們可以看到血淌，我們在Builder類里定義了一份與Person類一模一樣的變量矩欠，通過一系列的成員函數(shù)進(jìn)行設(shè)置屬性值，但是返回值都是this悠夯，也就是都是Builder對象癌淮，最后提供了一個build函數(shù)用于創(chuàng)建Person對象，返回的是Person對象沦补，對應(yīng)的構(gòu)造函數(shù)在Person類中進(jìn)行定義乳蓄，也就是構(gòu)造函數(shù)的入?yún)⑹荁uilder對象，然后依次對自己的成員變量進(jìn)行賦值夕膀，對應(yīng)的值都是Builder對象中的值虚倒。此外Builder類中的成員函數(shù)返回Builder對象自身的另一個作用就是讓它支持鏈?zhǔn)秸{(diào)用，使代碼可讀性大大增強产舞。
于是我們就可以這樣創(chuàng)建Person類魂奥。
1
2
3
4
5
6
7
Person.Builder builder=new Person.Builder();
Person person=builder
.name("張三")
.age(18)
.height(178.5)
.weight(67.4)
.build();
有沒有覺得創(chuàng)建過程一下子就變得那么清晰了。對應(yīng)的值是什么屬性一目了然易猫，可讀性大大增強耻煤。
其實在Android中， Builder模式也是被大量的運用擦囊。比如常見的對話框的創(chuàng)建
1
2
3
AlertDialog.Builder builder=new AlertDialog.Builder(this);
AlertDialog dialog=builder.setTitle("標(biāo)題")
.setIcon(android.R.drawable.ic_dialog_alert)
.setView(R.layout.myview)
.setPositiveButton(R.string.positive,new DialogInterface.OnClickListener() {
@Override
publicvoidonClick(DialogInterface dialog,int which) {
}
})
.setNegativeButton(R.string.negative,new DialogInterface.OnClickListener() {
@Override
publicvoidonClick(DialogInterface dialog,int which) {
}
})
.create();
dialog.show();
其實在java中有兩個常見的類也是Builder模式，那就是StringBuilder和StringBuffer嘴办，只不過其實現(xiàn)過程簡化了一點罷了瞬场。
我們再找找Builder模式在各個框架中的應(yīng)用。
如Gson中的GsonBuilder涧郊，代碼太長了贯被，就不貼了，有興趣自己去看源碼妆艘，這里只貼出其Builder的使用方法彤灶。
1
2
3
GsonBuilder builder=new GsonBuilder();
Gson gson=builder.setPrettyPrinting()
.disableHtmlEscaping()
.generateNonExecutableJson()
.serializeNulls()
.create();
還有EventBus中也有一個Builder，只不過這個Builder外部訪問不到而已批旺，因為它的構(gòu)造函數(shù)不是public的幌陕，但是你可以在EventBus這個類中看到他的應(yīng)用。
1
2
3
publicstatic EventBusBuilderbuilder() {
returnnew EventBusBuilder();
}
publicEventBus() {
this(DEFAULT_BUILDER);
}
EventBus(EventBusBuilder builder) {
subscriptionsByEventType =new HashMap, CopyOnWriteArrayList>();
typesBySubscriber =new HashMap>>();
stickyEvents =new ConcurrentHashMap, Object>();
mainThreadPoster =new HandlerPoster(this, Looper.getMainLooper(),10);
backgroundPoster =new BackgroundPoster(this);
asyncPoster =new AsyncPoster(this);
subscriberMethodFinder =new SubscriberMethodFinder(builder.skipMethodVerificationForClasses);
logSubscriberExceptions = builder.logSubscriberExceptions;
logNoSubscriberMessages = builder.logNoSubscriberMessages;
sendSubscriberExceptionEvent = builder.sendSubscriberExceptionEvent;
sendNoSubscriberEvent = builder.sendNoSubscriberEvent;
throwSubscriberException = builder.throwSubscriberException;
eventInheritance = builder.eventInheritance;
executorService = builder.executorService;
}
再看看著名的網(wǎng)絡(luò)請求框架OkHttp
1
2
3
Request.Builder builder=new Request.Builder();
Request request=builder.addHeader("","")
.url("")
.post(body)
.build();
除了Request外汽煮，Response也是通過Builder模式創(chuàng)建的搏熄。貼一下Response的構(gòu)造函數(shù)
1
2
3
privateResponse(Builder builder) {
this.request = builder.request;
this.protocol = builder.protocol;
this.code = builder.code;
this.message = builder.message;
this.handshake = builder.handshake;
this.headers = builder.headers.build();
this.body = builder.body;
this.networkResponse = builder.networkResponse;
this.cacheResponse = builder.cacheResponse;
this.priorResponse = builder.priorResponse;
}
可見各大框架中大量的運用了Builder模式棚唆。最后總結(jié)一下
定義一個靜態(tài)內(nèi)部類Builder，內(nèi)部的成員變量和外部類一樣
Builder類通過一系列的方法用于成員變量的賦值心例，并返回當(dāng)前對象本身（this）
Builder類提供一個build方法或者create方法用于創(chuàng)建對應(yīng)的外部類宵凌，該方法內(nèi)部調(diào)用了外部類的一個私有構(gòu)造函數(shù)，該構(gòu)造函數(shù)的參數(shù)就是內(nèi)部類Builder
外部類提供一個私有構(gòu)造函數(shù)供內(nèi)部類調(diào)用止后，在該構(gòu)造函數(shù)中完成成員變量的賦值瞎惫，取值為Builder對象中對應(yīng)的值
觀察者模式
前面介紹了單例模式和Builder模式，這部分著重介紹一下觀察者模式译株。先看下這個模式的定義瓜喇。
定義對象間的一種一對多的依賴關(guān)系，當(dāng)一個對象的狀態(tài)發(fā)送改變時古戴，所有依賴于它的對象都能得到通知并被自動更新
還是那句話欠橘，定義往往是抽象的，要深刻的理解定義现恼，你需要自己動手實踐一下肃续。
先來講幾個情景。
情景1
有一種短信服務(wù)叉袍，比如天氣預(yù)報服務(wù)始锚，一旦你訂閱該服務(wù)，你只需按月付費喳逛，付完費后瞧捌，每天一旦有天氣信息更新，它就會及時向你發(fā)送最新的天氣信息润文。
情景2
雜志的訂閱姐呐，你只需向郵局訂閱雜志，繳納一定的費用典蝌，當(dāng)有新的雜志時曙砂，郵局會自動將雜志送至你預(yù)留的地址。
觀察上面兩個情景骏掀，有一個共同點鸠澈，就是我們無需每時每刻關(guān)注我們感興趣的東西，我們只需做的就是訂閱感興趣的事物截驮，比如天氣預(yù)報服務(wù)笑陈，雜志等，一旦我們訂閱的事物發(fā)生變化葵袭，比如有新的天氣預(yù)報信息涵妥，新的雜志等，被訂閱的事物就會即時通知到訂閱者，即我們异逐。而這些被訂閱的事物可以擁有多個訂閱者该溯，也就是一對多的關(guān)系或听。當(dāng)然藐俺，嚴(yán)格意義上講硫戈，這個一對多可以包含一對一倍谜，因為一對一是一對多的特例瓢省，沒有特殊說明窟坐，本文的一對多包含了一對一海渊。
現(xiàn)在你反過頭來看看觀察者模式的定義，你是不是豁然開朗了哲鸳。
然后我們看一下觀察者模式的幾個重要組成臣疑。
觀察者，我們稱它為Observer徙菠，有時候我們也稱它為訂閱者讯沈，即Subscriber
被觀察者，我們稱它為Observable婿奔，即可以被觀察的東西缺狠，有時候還會稱之為主題，即Subject
至于觀察者模式的具體實現(xiàn)萍摊，這里帶帶大家實現(xiàn)一下場景一挤茄，其實java中提供了Observable類和Observer接口供我們快速的實現(xiàn)該模式，但是為了加深印象冰木，我們不使用這兩個類穷劈。
場景1中我們感興趣的事情是天氣預(yù)報，于是踊沸，我們應(yīng)該定義一個Weather實體類歇终。
1
2
3
publicclassWeather {
private String description;
publicWeather(String description) {
this.description = description;
}
public StringgetDescription() {
return description;
}
publicvoidsetDescription(String description) {
this.description = description;
}
@Override
public StringtoString() {
return"Weather{" +
"description='" + description +'\'' +
'}';
}
}
然后定義我們的被觀察者，我們想要這個被觀察者能夠通用逼龟，將其定義成泛型评凝。內(nèi)部應(yīng)該暴露register和unregister方法供觀察者訂閱和取消訂閱，至于觀察者的保存审轮，直接用ArrayList即可肥哎，此外辽俗，當(dāng)有主題內(nèi)容發(fā)送改變時疾渣，會即時通知觀察者做出反應(yīng)，因此應(yīng)該暴露一個notifyObservers方法崖飘，以上方法的具體實現(xiàn)見如下代碼榴捡。
1
2
3
publicclassObservable {
List> mObservers =new ArrayList>();
publicvoidregister(Observer observer) {
if (observer ==null) {
thrownew NullPointerException("observer == null");
}
synchronized (this) {
if (!mObservers.contains(observer))
mObservers.add(observer);
}
}
publicsynchronizedvoidunregister(Observer observer) {
mObservers.remove(observer);
}
publicvoidnotifyObservers(T data) {
for (Observer observer : mObservers) {
observer.onUpdate(this, data);
}
}
}
而我們的觀察者，只需要實現(xiàn)一個觀察者的接口Observer朱浴，該接口也是泛型的吊圾。其定義如下达椰。
1
2
3
publicinterfaceObserver {
voidonUpdate(Observable observable,T data);
}
一旦訂閱的主題發(fā)送變換就會回調(diào)該接口。
我們來使用一下项乒，我們定義了一個天氣變換的主題啰劲，也就是被觀察者，還有兩個觀察者觀察天氣變換檀何，一旦變換了蝇裤，就打印出天氣信息，注意一定要調(diào)用被觀察者的register進(jìn)行注冊频鉴，否則會收不到變換信息栓辜。而一旦不敢興趣了，直接調(diào)用unregister方法進(jìn)行取消注冊即可
1
2
3
publicclassMain {
publicstaticvoidmain(String [] args){
Observable observable=new Observable();
Observer observer1=new Observer() {
@Override
publicvoidonUpdate(Observable observable, Weather data) {
System.out.println("觀察者1："+data.toString());
}
};
Observer observer2=new Observer() {
@Override
publicvoidonUpdate(Observable observable, Weather data) {
System.out.println("觀察者2："+data.toString());
}
};
observable.register(observer1);
observable.register(observer2);
Weather weather=new Weather("晴轉(zhuǎn)多云");
observable.notifyObservers(weather);
Weather weather1=new Weather("多云轉(zhuǎn)陰");
observable.notifyObservers(weather1);
observable.unregister(observer1);
Weather weather2=new Weather("臺風(fēng)");
observable.notifyObservers(weather2);
}
}
最后的輸出結(jié)果也是沒有什么問題的垛孔，如下
觀察者1：Weather{description=’晴轉(zhuǎn)多云’}
觀察者2：Weather{description=’晴轉(zhuǎn)多云’}
觀察者1：Weather{description=’多云轉(zhuǎn)陰’}
觀察者2：Weather{description=’多云轉(zhuǎn)陰’}
觀察者2：Weather{description=’臺風(fēng)’}
接下來我們看看觀察者模式在android中的應(yīng)用藕甩。我們從最簡單的開始。還記得我們?yōu)橐粋€Button設(shè)置點擊事件的代碼嗎周荐。
1
2
3
Button btn=new Button(this);
btn.setOnClickListener(new View.OnClickListener() {
@Override
publicvoidonClick(View v) {
Log.e("TAG","click");
}
});
其實嚴(yán)格意義上講狭莱，這個最多算是回調(diào)，但是我們可以將其看成是一對一的觀察者模式羡藐，即只有一個觀察者贩毕。
其實只要是set系列的設(shè)置監(jiān)聽器的方法最多都只能算回調(diào)，但是有一些監(jiān)聽器式add進(jìn)去的仆嗦，這種就是觀察者模式了辉阶，比如RecyclerView中的addOnScrollListener方法
1
2
3
private List mScrollListeners;
publicvoidaddOnScrollListener(OnScrollListener listener) {
if (mScrollListeners ==null) {
mScrollListeners =new ArrayList();
}
mScrollListeners.add(listener);
}
publicvoidremoveOnScrollListener(OnScrollListener listener) {
if (mScrollListeners !=null) {
mScrollListeners.remove(listener);
}
}
publicvoidclearOnScrollListeners() {
if (mScrollListeners !=null) {
mScrollListeners.clear();
}
}
然后有滾動事件時便會觸發(fā)觀察者進(jìn)行方法回調(diào)
1
2
3
publicabstractstaticclassOnScrollListener {
publicvoidonScrollStateChanged(RecyclerView recyclerView,int newState){}
publicvoidonScrolled(RecyclerView recyclerView,int dx,int dy){}
}
voiddispatchOnScrolled(int hresult,int vresult) {
//...
if (mScrollListeners !=null) {
for (int i = mScrollListeners.size() -1; i >=0; i--) {
mScrollListeners.get(i).onScrolled(this, hresult, vresult);
}
}
}
voiddispatchOnScrollStateChanged(int state) {
//...
if (mScrollListeners !=null) {
for (int i = mScrollListeners.size() -1; i >=0; i--) {
mScrollListeners.get(i).onScrollStateChanged(this, state);
}
}
}
類似的方法很多很多，都是add監(jiān)聽器系列的方法瘩扼，這里也不再舉例谆甜。
還有一個地方就是Android的廣播機制，其本質(zhì)也是觀察者模式集绰，這里為了簡單方便规辱，直接拿本地廣播的代碼說明，即LocalBroadcastManager栽燕。
我們平時使用本地廣播主要就是下面四個方法
1
2
3
4
LocalBroadcastManager localBroadcastManager=LocalBroadcastManager.getInstance(this);
localBroadcastManager.registerReceiver(BroadcastReceiver receiver, IntentFilter filter);
localBroadcastManager.unregisterReceiver(BroadcastReceiver receiver);
localBroadcastManager.sendBroadcast(Intent intent)
調(diào)用registerReceiver方法注冊廣播罕袋，調(diào)用unregisterReceiver方法取消注冊，之后直接使用sendBroadcast發(fā)送廣播碍岔，發(fā)送廣播之后浴讯，注冊的廣播會收到對應(yīng)的廣播信息，這就是典型的觀察者模式蔼啦。具體的源代碼這里也不貼榆纽。
android系統(tǒng)中的觀察者模式還有很多很多，有興趣的自己去挖掘，接下來我們看一下一些開源框架中的觀察者模式奈籽。一說到開源框架饥侵，你首先想到的應(yīng)該是EventBus。沒錯衣屏，EventBus也是基于觀察者模式的躏升。
觀察者模式的三個典型方法它都具有，即注冊狼忱，取消注冊煮甥，發(fā)送事件
1
2
3
4
EventBus.getDefault().register(Object subscriber);
EventBus.getDefault().unregister(Object subscriber);
EventBus.getDefault().post(Object event);
內(nèi)部源碼也不展開了。接下來看一下重量級的庫藕赞，它就是RxJava成肘，由于學(xué)習(xí)曲線的陡峭，這個庫讓很多人望而止步斧蜕。
創(chuàng)建一個被觀察者
1
2
3
4
5
6
7
8
9
Observable myObservable = Observable.create(
new Observable.OnSubscribe() {
@Override
publicvoidcall(Subscriber sub) {
sub.onNext("Hello, world!");
sub.onCompleted();
}
}
);
創(chuàng)建一個觀察者双霍，也就是訂閱者
1
2
3
Subscriber mySubscriber =new Subscriber() {
@Override
publicvoidonNext(String s) { System.out.println(s); }
@Override
publicvoidonCompleted() { }
@Override
publicvoidonError(Throwable e) { }
};
觀察者進(jìn)行事件的訂閱
1
myObservable.subscribe(mySubscriber);
具體源碼也不展開，不過RxJava這個開源庫的源碼個人還是建議很值得去看一看的批销。
總之洒闸，在Android中觀察者模式還是被用得很頻繁的。
原型模式
這部分介紹的模式其實很簡單均芽，即原型模式丘逸，按照慣例，先看定義掀宋。
用原型實例指定創(chuàng)建對象的種類深纲，并通過拷貝這些原型創(chuàng)建新的對象。
這是什么鬼哦劲妙，本寶寶看不懂湃鹊！不必過度在意這些定義，自己心里明白就ok了镣奋。沒代碼你說個jb币呵。
首先我們定義一個Person類
1
2
3
publicclassPerson{
private String name;
privateint age;
privatedouble height;
privatedouble weight;
publicPerson(){
}
public StringgetName() {
return name;
}
publicvoidsetName(String name) {
this.name = name;
}
publicintgetAge() {
return age;
}
publicvoidsetAge(int age) {
this.age = age;
}
publicdoublegetHeight() {
return height;
}
publicvoidsetHeight(double height) {
this.height = height;
}
publicdoublegetWeight() {
return weight;
}
publicvoidsetWeight(double weight) {
this.weight = weight;
}
@Override
public StringtoString() {
return"Person{" +
"name='" + name +'\'' +
", age=" + age +
", height=" + height +
", weight=" + weight +
'}';
}
}
要實現(xiàn)原型模式，只需要按照下面的幾個步驟去實現(xiàn)即可侨颈。
實現(xiàn)Cloneable接口
1
2
3
publicclassPersonimplementsCloneable{
}
重寫Object的clone方法
1
2
3
4
@Override
public Objectclone(){
returnnull;
}
實現(xiàn)clone方法中的拷貝邏輯
1
2
3
@Override
public Objectclone(){
Person person=null;
try {
person=(Person)super.clone();
person.name=this.name;
person.weight=this.weight;
person.height=this.height;
person.age=this.age;
}catch (CloneNotSupportedException e) {
e.printStackTrace();
}
return person;
}
測試一下
1
2
3
publicclassMain {
publicstaticvoidmain(String [] args){
Person p=new Person();
p.setAge(18);
p.setName("張三");
p.setHeight(178);
p.setWeight(65);
System.out.println(p);
Person p1= (Person) p.clone();
System.out.println(p1);
p1.setName("李四");
System.out.println(p);
System.out.println(p1);
}
}
輸出結(jié)果如下
Person{name=’張三’, age=18, height=178.0, weight=65.0}
Person{name=’張三’, age=18, height=178.0, weight=65.0}
Person{name=’張三’, age=18, height=178.0, weight=65.0}
Person{name=’李四’, age=18, height=178.0, weight=65.0}
試想一下余赢，兩個不同的人，除了姓名不一樣哈垢，其他三個屬性都一樣妻柒，用原型模式進(jìn)行拷貝就會顯得異常簡單，這也是原型模式的應(yīng)用場景之一温赔。
一個對象需要提供給其他對象訪問蛤奢，而且各個調(diào)用者可能都需要修改其值時，可以考慮使用原型模式拷貝多個對象供調(diào)用者使用陶贼，即保護(hù)性拷貝啤贩。
但是假設(shè)Person類里還有一個屬性叫興趣愛好，是一個List集合拜秧，就像這樣子
1
2
3
private ArrayList hobbies=new ArrayList();
public ArrayListgetHobbies() {
return hobbies;
}
publicvoidsetHobbies(ArrayList hobbies) {
this.hobbies = hobbies;
}
在進(jìn)行拷貝的時候要格外注意痹屹，如果你直接按之前的代碼那樣拷貝
1
2
3
@Override
public Objectclone(){
Person person=null;
try {
person=(Person)super.clone();
person.name=this.name;
person.weight=this.weight;
person.height=this.height;
person.age=this.age;
person.hobbies=this.hobbies;
}catch (CloneNotSupportedException e) {
e.printStackTrace();
}
return person;
}
會帶來一個問題
使用測試代碼進(jìn)行測試
1
2
3
publicclassMain {
publicstaticvoidmain(String [] args){
Person p=new Person();
p.setAge(18);
p.setName("張三");
p.setHeight(178);
p.setWeight(65);
ArrayList hobbies=new ArrayList();
hobbies.add("籃球");
hobbies.add("編程");
hobbies.add("長跑");
p.setHobbies(hobbies);
System.out.println(p);
Person p1= (Person) p.clone();
System.out.println(p1);
p1.setName("李四");
p1.getHobbies().add("游泳");
System.out.println(p);
System.out.println(p1);
}
}
我們拷貝了一個對象，并添加了一個興趣愛好進(jìn)去枉氮，看下打印結(jié)果
Person{name=’張三’, age=18, height=178.0, weight=65.0, hobbies=[籃球, 編程, 長跑]}
Person{name=’張三’, age=18, height=178.0, weight=65.0, hobbies=[籃球, 編程, 長跑]}
Person{name=’張三’, age=18, height=178.0, weight=65.0, hobbies=[籃球, 編程, 長跑, 游泳]}
Person{name=’李四’, age=18, height=178.0, weight=65.0, hobbies=[籃球, 編程, 長跑, 游泳]}
你會發(fā)現(xiàn)原來的對象的hobby也發(fā)生了變換志衍。
其實導(dǎo)致這個問題的本質(zhì)原因是我們只進(jìn)行了淺拷貝，也就是只拷貝了引用聊替，最終兩個對象指向的引用是同一個楼肪，一個發(fā)生變化另一個也會發(fā)生變換，顯然解決方法就是使用深拷貝惹悄。
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
@Override
public Objectclone(){
Person person=null;
try {
person=(Person)super.clone();
person.name=this.name;
person.weight=this.weight;
person.height=this.height;
person.age=this.age;
person.hobbies=(ArrayList)this.hobbies.clone();
}catch (CloneNotSupportedException e) {
e.printStackTrace();
}
return person;
}
注意person.hobbies=(ArrayList)this.hobbies.clone();，不再是直接引用而是進(jìn)行了一份拷貝泣港。再運行一下暂殖，就會發(fā)現(xiàn)原來的對象不會再發(fā)生變化了。
Person{name=’張三’, age=18, height=178.0, weight=65.0, hobbies=[籃球, 編程, 長跑]}
Person{name=’張三’, age=18, height=178.0, weight=65.0, hobbies=[籃球, 編程, 長跑]}
Person{name=’張三’, age=18, height=178.0, weight=65.0, hobbies=[籃球, 編程, 長跑]}
Person{name=’李四’, age=18, height=178.0, weight=65.0, hobbies=[籃球, 編程, 長跑, 游泳]}
其實有時候我們會更多的看到原型模式的另一種寫法当纱。
在clone函數(shù)里調(diào)用構(gòu)造函數(shù)呛每，構(gòu)造函數(shù)的入?yún)⑹窃擃悓ο蟆?/p>
1
2
3
4
@Override
public Objectclone(){
returnnew Person(this);
}
在構(gòu)造函數(shù)中完成拷貝邏輯
1
2
3
4
5
6
7
publicPerson(Person person){
this.name=person.name;
this.weight=person.weight;
this.height=person.height;
this.age=person.age;
this.hobbies=new ArrayList(hobbies);
}
其實都差不多，只是寫法不一樣坡氯。
現(xiàn)在來挖挖android中的原型模式晨横。
先看Bundle類，該類實現(xiàn)了Cloneable接口
1
2
3
4
5
6
7
8
9
public Objectclone() {
returnnew Bundle(this);
}
publicBundle(Bundle b) {
super(b);
mHasFds = b.mHasFds;
mFdsKnown = b.mFdsKnown;
}
然后是Intent類箫柳，該類也實現(xiàn)了Cloneable接口
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
@Override
public Objectclone() {
returnnew Intent(this);
}
publicIntent(Intent o) {
this.mAction = o.mAction;
this.mData = o.mData;
this.mType = o.mType;
this.mPackage = o.mPackage;
this.mComponent = o.mComponent;
this.mFlags = o.mFlags;
this.mContentUserHint = o.mContentUserHint;
if (o.mCategories !=null) {
this.mCategories =new ArraySet(o.mCategories);
}
if (o.mExtras !=null) {
this.mExtras =new Bundle(o.mExtras);
}
if (o.mSourceBounds !=null) {
this.mSourceBounds =new Rect(o.mSourceBounds);
}
if (o.mSelector !=null) {
this.mSelector =new Intent(o.mSelector);
}
if (o.mClipData !=null) {
this.mClipData =new ClipData(o.mClipData);
}
}
用法也顯得十分簡單颓遏，一旦我們要用的Intent與現(xiàn)有的一個Intent很多東西都是一樣的，那我們就可以直接拷貝現(xiàn)有的Intent滞时，再修改不同的地方叁幢，便可以直接使用。
1
2
3
4
5
6
Uri uri = Uri.parse("smsto:10086");
Intent shareIntent =new Intent(Intent.ACTION_SENDTO, uri);
shareIntent.putExtra("sms_body","hello");
Intent intent = (Intent)shareIntent.clone() ;
startActivity(intent);
網(wǎng)絡(luò)請求中一個最常見的開源庫OkHttp中坪稽，也應(yīng)用了原型模式曼玩。它就在OkHttpClient這個類中，它實現(xiàn)了Cloneable接口
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
/** Returns a shallow copy of this OkHttpClient. */
@Override
public OkHttpClientclone() {
returnnew OkHttpClient(this);
}
privateOkHttpClient(OkHttpClient okHttpClient) {
this.routeDatabase = okHttpClient.routeDatabase;
this.dispatcher = okHttpClient.dispatcher;
this.proxy = okHttpClient.proxy;
this.protocols = okHttpClient.protocols;
this.connectionSpecs = okHttpClient.connectionSpecs;
this.interceptors.addAll(okHttpClient.interceptors);
this.networkInterceptors.addAll(okHttpClient.networkInterceptors);
this.proxySelector = okHttpClient.proxySelector;
this.cookieHandler = okHttpClient.cookieHandler;
this.cache = okHttpClient.cache;
this.internalCache = cache !=null ? cache.internalCache : okHttpClient.internalCache;
this.socketFactory = okHttpClient.socketFactory;
this.sslSocketFactory = okHttpClient.sslSocketFactory;
this.hostnameVerifier = okHttpClient.hostnameVerifier;
this.certificatePinner = okHttpClient.certificatePinner;
this.authenticator = okHttpClient.authenticator;
this.connectionPool = okHttpClient.connectionPool;
this.network = okHttpClient.network;
this.followSslRedirects = okHttpClient.followSslRedirects;
this.followRedirects = okHttpClient.followRedirects;
this.retryOnConnectionFailure = okHttpClient.retryOnConnectionFailure;
this.connectTimeout = okHttpClient.connectTimeout;
this.readTimeout = okHttpClient.readTimeout;
this.writeTimeout = okHttpClient.writeTimeout;
}
正如開頭的注釋Returns a shallow copy of this OkHttpClient窒百，該clone方法返回了一個當(dāng)前對象的淺拷貝對象黍判。
至于其他框架中的原型模式，請讀者自行發(fā)現(xiàn)篙梢。
策略模式
看下策略模式的定義
策略模式定義了一些列的算法顷帖，并將每一個算法封裝起來，而且使它們還可以相互替換。策略模式讓算法獨立于使用它的客戶而獨立變換贬墩。
乍一看榴嗅，也沒看出個所以然來。舉個栗子吧陶舞。
假設(shè)我們要出去旅游嗽测，而去旅游出行的方式有很多，有步行肿孵，有坐火車唠粥，有坐飛機等等。而如果不使用任何模式停做，我們的代碼可能就是這樣子的晤愧。
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
publicclassTravelStrategy {
enum Strategy{
WALK,PLANE,SUBWAY
}
private Strategy strategy;
publicTravelStrategy(Strategy strategy){
this.strategy=strategy;
}
publicvoidtravel(){
if(strategy==Strategy.WALK){
print("walk");
}elseif(strategy==Strategy.PLANE){
print("plane");
}elseif(strategy==Strategy.SUBWAY){
print("subway");
}
}
publicvoidprint(String str){
System.out.println("出行旅游的方式為："+str);
}
publicstaticvoidmain(String[] args) {
TravelStrategy walk=new TravelStrategy(Strategy.WALK);
walk.travel();
TravelStrategy plane=new TravelStrategy(Strategy.PLANE);
plane.travel();
TravelStrategy subway=new TravelStrategy(Strategy.SUBWAY);
subway.travel();
}
}
這樣做有一個致命的缺點，一旦出行的方式要增加蛉腌，我們就不得不增加新的else if語句养涮，而這違反了面向?qū)ο蟮脑瓌t之一，對修改封閉眉抬。而這時候贯吓，策略模式則可以完美的解決這一切。
首先蜀变，需要定義一個策略接口悄谐。
1
2
3
4
publicinterfaceStrategy {
voidtravel();
}
然后根據(jù)不同的出行方式實行對應(yīng)的接口
1
2
3
4
5
6
7
8
publicclassWalkStrategyimplementsStrategy{
@Override
publicvoidtravel() {
System.out.println("walk");
}
}
1
2
3
4
5
6
7
8
publicclassPlaneStrategyimplementsStrategy{
@Override
publicvoidtravel() {
System.out.println("plane");
}
}
1
2
3
4
5
6
7
8
publicclassSubwayStrategyimplementsStrategy{
@Override
publicvoidtravel() {
System.out.println("subway");
}
}
此外還需要一個包裝策略的類，并調(diào)用策略接口中的方法
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
publicclassTravelContext {
Strategy strategy;
public StrategygetStrategy() {
return strategy;
}
publicvoidsetStrategy(Strategy strategy) {
this.strategy = strategy;
}
publicvoidtravel() {
if (strategy !=null) {
strategy.travel();
}
}
}
測試一下代碼
1
2
3
4
5
6
7
8
9
10
11
publicclassMain {
publicstaticvoidmain(String[] args) {
TravelContext travelContext=new TravelContext();
travelContext.setStrategy(new PlaneStrategy());
travelContext.travel();
travelContext.setStrategy(new WalkStrategy());
travelContext.travel();
travelContext.setStrategy(new SubwayStrategy());
travelContext.travel();
}
}
輸出結(jié)果如下
plane
walk
subway
可以看到库北，應(yīng)用了策略模式后爬舰，如果我們想增加新的出行方式，完全不必要修改現(xiàn)有的類寒瓦，我們只需要實現(xiàn)策略接口即可情屹，這就是面向?qū)ο笾械膶U(kuò)展開放準(zhǔn)則。假設(shè)現(xiàn)在我們增加了一種自行車出行的方式杂腰。只需新增一個類即可垃你。
1
2
3
4
5
6
7
8
publicclassBikeStrategyimplementsStrategy{
@Override
publicvoidtravel() {
System.out.println("bike");
}
}
之后設(shè)置策略即可
1
2
3
4
5
6
7
publicclassMain {
publicstaticvoidmain(String[] args) {
TravelContext travelContext=new TravelContext();
travelContext.setStrategy(new BikeStrategy());
travelContext.travel();
}
}
而在Android的系統(tǒng)源碼中,策略模式也是應(yīng)用的相當(dāng)廣泛的.最典型的就是屬性動畫中的應(yīng)用.
我們知道,在屬性動畫中,有一個東西叫做插值器,它的作用就是根據(jù)時間流逝的百分比來來計算出當(dāng)前屬性值改變的百分比.
我們使用屬性動畫的時候,可以通過set方法對插值器進(jìn)行設(shè)置.可以看到內(nèi)部維持了一個時間插值器的引用，并設(shè)置了getter和setter方法喂很，默認(rèn)情況下是先加速后減速的插值器惜颇，set方法如果傳入的是null，則是線性插值器少辣。而時間插值器TimeInterpolator是個接口凌摄，有一個接口繼承了該接口，就是Interpolator這個接口漓帅，其作用是為了保持兼容
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
privatestaticfinal TimeInterpolator sDefaultInterpolator =
new AccelerateDecelerateInterpolator();
private TimeInterpolator mInterpolator = sDefaultInterpolator;
@Override
publicvoidsetInterpolator(TimeInterpolator value) {
if (value !=null) {
mInterpolator = value;
}else {
mInterpolator =new LinearInterpolator();
}
}
@Override
public TimeInterpolatorgetInterpolator() {
return mInterpolator;
}
1
2
3
4
5
6
publicinterfaceInterpolatorextendsTimeInterpolator {
// A new interface, TimeInterpolator, was introduced for the new android.animation
// package. This older Interpolator interface extends TimeInterpolator so that users of
// the new Animator-based animations can use either the old Interpolator implementations or
// new classes that implement TimeInterpolator directly.
}
此外還有一個BaseInterpolator插值器實現(xiàn)了Interpolator接口锨亏，并且是一個抽象類
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
abstractpublicclassBaseInterpolatorimplementsInterpolator {
privateint mChangingConfiguration;
/**
*@hide
*/
publicintgetChangingConfiguration() {
return mChangingConfiguration;
}
/**
*@hide
*/
voidsetChangingConfiguration(int changingConfiguration) {
mChangingConfiguration = changingConfiguration;
}
}
平時我們使用的時候痴怨，通過設(shè)置不同的插值器，實現(xiàn)不同的動畫速率變換效果器予，比如線性變換浪藻，回彈，自由落體等等劣摇。這些都是插值器接口的具體實現(xiàn)，也就是具體的插值器策略弓乙。我們略微來看幾個策略末融。
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
publicclassLinearInterpolatorextendsBaseInterpolatorimplementsNativeInterpolatorFactory {
publicLinearInterpolator() {
}
publicLinearInterpolator(Context context, AttributeSet attrs) {
}
publicfloatgetInterpolation(float input) {
return input;
}
/**@hide */
@Override
publiclongcreateNativeInterpolator() {
return NativeInterpolatorFactoryHelper.createLinearInterpolator();
}
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
publicclassAccelerateDecelerateInterpolatorextendsBaseInterpolator
implementsNativeInterpolatorFactory {
publicAccelerateDecelerateInterpolator() {
}
@SuppressWarnings({"UnusedDeclaration"})
publicAccelerateDecelerateInterpolator(Context context, AttributeSet attrs) {
}
publicfloatgetInterpolation(float input) {
return (float)(Math.cos((input +1) * Math.PI) /2.0f) +0.5f;
}
/**@hide */
@Override
publiclongcreateNativeInterpolator() {
return NativeInterpolatorFactoryHelper.createAccelerateDecelerateInterpolator();
}
}
內(nèi)部使用的時候直接調(diào)用getInterpolation方法就可以返回對應(yīng)的值了，也就是屬性值改變的百分比暇韧。
屬性動畫中另外一個應(yīng)用策略模式的地方就是估值器勾习，它的作用是根據(jù)當(dāng)前屬性改變的百分比來計算改變后的屬性值。該屬性和插值器是類似的懈玻，有幾個默認(rèn)的實現(xiàn)巧婶。其中TypeEvaluator是一個接口。
1
2
3
4
5
publicinterfaceTypeEvaluator {
public Tevaluate(float fraction, T startValue, T endValue);
}
1
2
3
4
5
6
7
publicclassIntEvaluatorimplementsTypeEvaluator {
public Integerevaluate(float fraction, Integer startValue, Integer endValue) {
int startInt = startValue;
return (int)(startInt + fraction * (endValue - startInt));
}
}
1
2
3
4
5
6
7
publicclassFloatEvaluatorimplementsTypeEvaluator {
public Floatevaluate(float fraction, Number startValue, Number endValue) {
float startFloat = startValue.floatValue();
return startFloat + fraction * (endValue.floatValue() - startFloat);
}
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
publicclassPointFEvaluatorimplementsTypeEvaluator {
private PointF mPoint;
publicPointFEvaluator() {
}
publicPointFEvaluator(PointF reuse) {
mPoint = reuse;
}
@Override
public PointFevaluate(float fraction, PointF startValue, PointF endValue) {
float x = startValue.x + (fraction * (endValue.x - startValue.x));
float y = startValue.y + (fraction * (endValue.y - startValue.y));
if (mPoint !=null) {
mPoint.set(x, y);
return mPoint;
}else {
returnnew PointF(x, y);
}
}
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
publicclassArgbEvaluatorimplementsTypeEvaluator {
privatestaticfinal ArgbEvaluator sInstance =new ArgbEvaluator();
publicstatic ArgbEvaluatorgetInstance() {
return sInstance;
}
public Objectevaluate(float fraction, Object startValue, Object endValue) {
int startInt = (Integer) startValue;
int startA = (startInt >>24) &0xff;
int startR = (startInt >>16) &0xff;
int startG = (startInt >>8) &0xff;
int startB = startInt &0xff;
int endInt = (Integer) endValue;
int endA = (endInt >>24) &0xff;
int endR = (endInt >>16) &0xff;
int endG = (endInt >>8) &0xff;
int endB = endInt &0xff;
return (int)((startA + (int)(fraction * (endA - startA))) <<24) |
(int)((startR + (int)(fraction * (endR - startR))) <<16) |
(int)((startG + (int)(fraction * (endG - startG))) <<8) |
(int)((startB + (int)(fraction * (endB - startB))));
}
}
上面的都是一些系統(tǒng)實現(xiàn)好的估值策略涂乌，在內(nèi)部調(diào)用估值器的evaluate方法即可返回改變后的值了艺栈。我們也可以自定義估值策略。這里就不展開了湾盒。
當(dāng)然湿右，在開源框架中，策略模式也是無處不在的罚勾。
首先在Volley中毅人，策略模式就能看到。
有一個重試策略接口
1
2
3
4
5
6
7
8
9
10
11
publicinterfaceRetryPolicy {
publicintgetCurrentTimeout();//獲取當(dāng)前請求用時（用于 Log）
publicintgetCurrentRetryCount();//獲取已經(jīng)重試的次數(shù)（用于 Log）
publicvoidretry(VolleyError error)throws VolleyError;//確定是否重試尖殃，參數(shù)為這次異常的具體信息丈莺。在請求異常時此接口會被調(diào)用，可在此函數(shù)實現(xiàn)中拋出傳入的異常表示停止重試送丰。
}
在Volley中缔俄，該接口有一個默認(rèn)的實現(xiàn)DefaultRetryPolicy，Volley 默認(rèn)的重試策略實現(xiàn)類器躏。主要通過在 retry(…) 函數(shù)中判斷重試次數(shù)是否達(dá)到上限確定是否繼續(xù)重試牵现。
1
2
3
publicclassDefaultRetryPolicyimplementsRetryPolicy {
...
}
而策略的設(shè)置是在Request類中
1
2
3
4
5
6
7
8
9
10
11
publicabstractclassRequestimplementsComparable> {
private RetryPolicy mRetryPolicy;
public Request setRetryPolicy(RetryPolicy retryPolicy) {
mRetryPolicy = retryPolicy;
returnthis;
}
public RetryPolicygetRetryPolicy() {
return mRetryPolicy;
}
}
此外，各大網(wǎng)絡(luò)請求框架邀桑，或多或少都會使用到緩存瞎疼，緩存一般會定義一個Cache接口，然后實現(xiàn)不同的緩存策略壁畸，如內(nèi)存緩存贼急，磁盤緩存等等茅茂，這個緩存的實現(xiàn)，其實也可以使用策略模式太抓。直接看Volley空闲，里面也有緩存。
定義了一個緩存接口
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
/**
* An interface for a cache keyed by a String with a byte array as data.
*/
publicinterfaceCache {
/**
* Retrieves an entry from the cache.
*@param key Cache key
*@return An {@link Entry} or null in the event of a cache miss
*/
public Entryget(String key);
/**
* Adds or replaces an entry to the cache.
*@param key Cache key
*@param entry Data to store and metadata for cache coherency, TTL, etc.
*/
publicvoidput(String key, Entry entry);
/**
* Performs any potentially long-running actions needed to initialize the cache;
* will be called from a worker thread.
*/
publicvoidinitialize();
/**
* Invalidates an entry in the cache.
*@param key Cache key
*@param fullExpire True to fully expire the entry, false to soft expire
*/
publicvoidinvalidate(String key,boolean fullExpire);
/**
* Removes an entry from the cache.
*@param key Cache key
*/
publicvoidremove(String key);
/**
* Empties the cache.
*/
publicvoidclear();
/**
* Data and metadata for an entry returned by the cache.
*/
publicstaticclassEntry {
/** The data returned from cache. */
publicbyte[] data;
/** ETag for cache coherency. */
public String etag;
/** Date of this response as reported by the server. */
publiclong serverDate;
/** The last modified date for the requested object. */
publiclong lastModified;
/** TTL for this record. */
publiclong ttl;
/** Soft TTL for this record. */
publiclong softTtl;
/** Immutable response headers as received from server; must be non-null. */
public Map responseHeaders = Collections.emptyMap();
/** True if the entry is expired. */
publicbooleanisExpired() {
returnthis.ttl < System.currentTimeMillis();
}
/** True if a refresh is needed from the original data source. */
publicbooleanrefreshNeeded() {
returnthis.softTtl < System.currentTimeMillis();
}
}
}
它有兩個實現(xiàn)類NoCache和DiskBasedCache走敌，使用的時候設(shè)置對應(yīng)的緩存策略即可碴倾。
在android開發(fā)中，ViewPager是一個使用非常常見的控件掉丽，它的使用往往需要伴隨一個Indicator指示器跌榔。如果讓你重新實現(xiàn)一個ViewPager，并且?guī)в蠭ndicator捶障，這時候僧须，你會不會想到用策略模式呢？在你自己寫的ViewPager中（不是系統(tǒng)的项炼，當(dāng)然你也可以繼承系統(tǒng)的）持有一個策略接口Indicator的變量担平，通過set方法設(shè)置策略，然后ViewPager滑動的時候調(diào)用策略接口的對應(yīng)方法改變指示器锭部。默認(rèn)提供幾個Indicator接口的實現(xiàn)類暂论，比如圓形指示器CircleIndicator、線性指示器LineIndicator拌禾、Tab指示器TabIndicator空另、圖標(biāo)指示器IconIndicator 等等等等。有興趣的話自己去實現(xiàn)一個吧蹋砚。
失敗是什么扼菠？沒有什么，只是更走近成功一步坝咐；成功是什么循榆？就是走過了所有通向失敗的路，只剩下一條路墨坚，那就是成功的路秧饮。
分類:?android進(jìn)階
