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方法在目标类中”