Android源碼設計模式解析與實戰（三）

1. Builder模式介紹

Builder模式是一步一步建立一個複雜對象的建立型模式，它容許用戶在不知道內部構建細節的狀況下，能夠更精細地控制對象的構造流程。該模式是爲了將構建複雜對象的過程和它的部件解耦，使得構建過程和部件的表示隔離開來。

Builder一般爲鏈式調用，關鍵點是每一個settter方法都返回自身，也就是return this，這樣就使得setter方法能夠鏈式調用。

2. Android源碼中的Builder模式實現

最經常使用的就是AlertDialog.Builder，用來建立AlertDialog對象。

private void showAlertDialog(Context mContext) {
    AlertDialog.Builder builder = new AlertDialog.Builder(mContext);
    builder.setTitle("title");
    builder.setMessage("message");
    ........
    builder.create().show();
}

3. Builder模式實戰

圖片加載工具，須要添加些參數，好比線程數量、網絡下載時的默認圖片placeholder等。

你們通常想到的就是直接在ImageLoader中增長setter方法

package com.outman.myimageloader;

import android.graphics.Bitmap;
import android.graphics.BitmapFactory;
import android.widget.ImageView;

import java.io.IOException;
import java.net.HttpURLConnection;
import java.net.URL;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

public class ImageLoader {

    // 封裝的緩存類
    private ImageCache mImageCache = new MemoryCache();
    // 線程池，線程數量爲CPU的數量
    private ExecutorService mExecutorService;

    private int mPlaceHolder;

    private static ImageLoader mInstance;
    private ImageLoader() {
        mExecutorService = Executors.newFixedThreadPool(Runtime.getRuntime().availableProcessors());
    }
    public static ImageLoader getInstance() {
        .............
    }

    public void setImageCache(ImageCache cache) {
        this.mImageCache = cache;
    }

    public void setThreadCount(int count) {
        mExecutorService.shutdown();
        mExecutorService = null;
        mExecutorService = Executors.newFixedThreadPool(count);
    }

    public void setPlaceHolder(int resId) {
        this.mPlaceHolder = resId;
    }

    ...............
}

上面的代碼存在一個問題就是，設置緩存、線程數等，這些都應該在初始化ImageLoader時設置好，後面不容許再修改，這種能夠使用Builder模式來避免。

public class ImageConfig {
    // 封裝的緩存類
    private ImageCache mImageCache = new MemoryCache();
    // 線程個數
    private int mThreadCount = Runtime.getRuntime().availableProcessors();
    // 默認圖片
    private int mPlaceHolder;

    public ImageCache getCache() {
        return mImageCache;
    }
    public int getThreadCount() {
        return mThreadCount;
    }
    public int getPlaceHolder() {
        return mPlaceHolder;
    }
    /**
     * 配置類的Builder
     */
    public static class Builder {

        private ImageConfig mConfig;
        public Builder() {
            mConfig = new ImageConfig();
        }

        public Builder setImageCache(ImageCache cache) {
            mConfig.mImageCache = cache;
            return this;
        }
        public Builder setThreadCount(int count) {
            mConfig.mThreadCount = count;
            return this;
        }
        public Builder setPlaceHolder(int resId) {
            mConfig.mPlaceHolder = resId;
            return this;
        }
        public ImageConfig create() {
            return mConfig;
        }
    }
}

public class ImageLoader {

    private ImageConfig mConfig;

    // 線程池，線程數量爲CPU的數量
    private ExecutorService mExecutorService;

    private static ImageLoader mInstance;
    private ImageLoader() {
    }
    public static ImageLoader getInstance() {
        .............
    }

    public void init(ImageConfig config) {
        this.mConfig = config;
        checkConfig();
        mExecutorService = Executors.newFixedThreadPool(this.mConfig.getThreadCount());
    }

    /**
     * 加載圖片
     * @param url
     * @param imageView
     */
    public void displayImage(final String url, final ImageView imageView) {
        checkConfig();
        ............
    }

    ...............

    private void checkConfig() {

    }
}

我的理解：「Builder模式的好處是，能夠封閉一些沒必要要的暴露，即setXXX方法，在某些場景下只須要初始化時設置一次，後面不容許再修改。使用Builder模式將這些方法封裝，利用鏈式調用，使配置的構建簡單化，避免過多的setXXX方法在目標類中」