设计模式笔记—建造者模式

建造者模式

      概念：将一个复杂对象的构建与它的表示分离，使得同样的构建过程可以创建不同的表示。在建造者模式中，通常有4个角色:Product产品类，Builde抽象建造者，ConcreteBuilder具体建造者，Director导演类。

          使用场景：(1)相同的方法，不同的执行顺序，产生不同的事件效应。(2)多个部件或零件，可以装配到一个对象中，但是产生的运行结果又不同时。(3)产品类非常复杂，或者产品类的调用顺序不同产生了不同的效能。(4)在对象创建过程中会使用到系统中的一些其他对象，这些对象在产品对象的创建过程中不易得到时，也可以采用建造者模式封装该对象的创建过程。

         案例：生产电脑

//计算机抽象类，即Product角色，通常是实现了模板方法模式
public abstract class Computer {
	protected String mBoard;
	protected String mDisplay;
	protected String mOS;
	public Computer() {
		super();
	}
	//设置CPU核心数
	public void setBoard(String board){
		mBoard=board;
	}
	//设置内存
	public void setDisplay(String display){
		mDisplay=display;
	}
	//设置操作系统
	public abstract void setOS();
	@Override
	public String toString() {
		return "Computer [mBoard= " + mBoard + ", mDisplay= " + mDisplay + ", mOS= " + mOS + "]";
	}
}

//具体的Computer类，Macbook
public class Macbook extends Computer {
	protected Macbook(){
	}
	@Override
	public void setOS() {
		mOS="Mac OS X 10.10";
	}
}

//抽象Builder类，规范产品的组建，一般由子类来实现
public abstract class Builder {
	//设置主机
	public abstract void buildBoard(String board);
	//设置显示器
	public abstract void buildDisplay(String display);
	//设置操作系统
	public abstract void buildOS();
	//创建Computer
	public abstract Computer create();
}

//具体的Builder类，MacbookBuilder
public class MacbookBuilder extends Builder{
	private Computer mComputer=new Macbook();
	@Override
	public void buildBoard(String board) {
		mComputer.setBoard(board);
	}
	@Override
	public void buildDisplay(String display) {
		mComputer.setDisplay(display);
	}
	@Override
	public void buildOS() {
		mComputer.setOS();
	}
	@Override
	public Computer create() {
		return mComputer;
	}
}

//Director类，负责构造Computer，及安排已有模块的顺序
public class Director {
	Builder mBuilder=null;
	//构造函数传递依赖对象
	public Director(Builder mBuilder) {
		super();
		this.mBuilder = mBuilder;
	}
	//构建对象
	public void construct(String board,String display){
		mBuilder.buildBoard(board);
		mBuilder.buildDisplay(display);
		mBuilder.buildOS();
	}
}

测试类

public class Test {
	public static void main(String[] args) {
		//构建器
		Builder builder=new MacbookBuilder();
		//Director
		Director pcDirector = new Director(builder);
		//封装构建过程，4核，内存2GB,Mac系统
		pcDirector.construct("Intel主板","Retina显示器");
		//构建计算机，输出相关信息
		System.out.println("Computer Info:"+builder.create().toString());
	}
}

运行结果:

Computer Info:Computer [mBoard= Intel主板, mDisplay= Retina显示器, mOS= Mac OS X 10.10]

        分析：通过具体的MacbookBuilder来构建Macbook对象，而Director封装了构建复杂产品对象的过程，对外隐藏构建细节。Builder与Director一起将一个复杂对象的构建与它的表示分离，使得同样的构建过程可以创建不同的对象。需要注意的是，在实际开发中，Director角色经常会被省略。而直接使用一个Builder来进行对象的组装，这个Builder通常为链式调用，它的关键点是每个setter方法都返回自身，也就是return this,这样就使得setter方法可以链式调用。如下：

new TestBuilder().setA("A").setB("B").create();

       通过这种形式不仅去除了Director角色，整个结构也更加简单，也能对Product对象的组装过程有更精细的控制。

      建造者模式优点 ：(1)封装性，使客户端不必知道产品内部组成的细节(2)建造者独立，容易扩展(3)便于控制细节风险，由于具体的建造者是独立的，因此可以对建造者过程逐步细化，而不对其他的模块产生任何影响。

Android中的应用

      在Android中常见到Builder模式是对话框的创建，使用Builder来构建复杂的AlertDialog对象，如下：

private void showDialog(Context context){
        AlertDialog.Builder builder=new AlertDialog.Builder(this);
        //构建AlertDialog
        AlertDialog dialog=builder.setTitle("标题")
                .setIcon(android.R.drawable.ic_dialog_alert)
                .setView(R.layout.activity_main)
                .setPositiveButton("确定", new DialogInterface.OnClickListener() {
                    @Override
                    public void onClick(DialogInterface dialog, int which) {
                    }
                })
                .setNegativeButton("取消", new DialogInterface.OnClickListener() {
                    @Override
                    public void onClick(DialogInterface dialog, int which) {
                    }
                })
                .create();
        // 显示AlertDialog
        dialog.show();
    }
}

      分析：通过Builder对象来组装Dialog的各个部分，如title,buttons,Message，icon等，将Dialog的构造和表示进行分离。
       Builder模式在框架中的应用：

Picasso.with(getApplicationContext()).load(urlPic).into(ivPica);
public class Picasso {
...
public static Picasso with(Context context) {
    if (singleton == null) {
      synchronized (Picasso.class) {
        if (singleton == null) {
          singleton = new Builder(context).build();
        }
      }
    }
    return singleton;
  }
 public static class Builder {
    private final Context context;
    private Downloader downloader;
    private ExecutorService service;
    private Cache cache;
	 public Builder(Context context) {
      if (context == null) {
        throw new IllegalArgumentException("Context must not be null.");
      }
      this.context = context.getApplicationContext();
    }
	 /** Create the {@link Picasso} instance. */
    public Picasso build() {
      Context context = this.context;
      if (downloader == null) {
        downloader = Utils.createDefaultDownloader(context);
      }
      if (cache == null) {
        cache = new LruCache(context);
      }
      if (service == null) {
        service = new PicassoExecutorService();
      }
      return new Picasso(context, dispatcher, cache, listener, transformer, requestHandlers, stats,
          defaultBitmapConfig, indicatorsEnabled, loggingEnabled);
    }
	}
...
}

      Builder模式在Java中的应用：

        StringBuilder builder = new StringBuilder();
	builder.append("str1").append("str2").append("str3");