设计模式读书笔记二 Builder模式

1、Builder模式介绍
Builder是一步步创建一个复杂的对象的模式，它允许用户在不知道内部构建细节的情况下，可以更加精细的控制对象的构造流程。该模式是为了构建复杂对象的过程和它的部件解耦，使得构建过程和部件的表示隔离开来。因为一个复杂的对象有很多大量的组成部分，如汽车，有轮胎、方向盘、发动机还有各种小零件等，如何将这些部件配装乘一辆汽车，这个过程很漫长也很复杂，对于这种情况，为了在构建过程中对外部隐藏细节，就可以使用Builder模式将部件和组装过程分离，使得构建过程和部件都可以自由的扩展，两者之间的耦合也降到最低。

2、Builder模式的定义
将一个复杂的构建对象与它的表示分离，使得同样的构建过程可以创建不同的表示。

3、使用场景
Builder模式的使用场景，主要有以下几种。
（1）相同的方法，不同的执行顺序，产生不同的事件结果。
（2）多个部件或零件，都可以装配到一个对象中，但是产生的运行结果又不相同时。
（3）产品类十分复杂，或者产品类中的调用顺序不同产生了不同的结果，这个时候使用Builder十分合适。
（4）当初始化一个对象特别复杂，如参数多，且很多参数都具有默认值时。

4、UML图
略

5、Builder模式的简单实现
举个例子：将计算机简化为主机、操作系统、显示器
(1)Computer.java

package com.lc.example.builder;

/**
 * 电脑的抽象类
 *
 * @author HP
 *
 */
public abstract class Computer {
       protected String mBroad ;// 主板
       protected String mDisplay ;// 显示器
       protected String mOS ;// 操作系统

       protected Computer() {
      }

       /**
       * 设置主板信息
       *
       * @param broad
       */
       public void setBroad(String broad) {
             mBroad =broad;
      }

       /**
       * 设置显示器
       *
       * @param display
       */
       public void setDisplay(String display) {
             mDisplay =display;
      }

       /**
       * 设置操作系统
       *
       * @param os
       */
       public abstract void setOs();

       @Override
       public String toString() {
             // TODO Auto-generated method stub
             return "Computer [mBroad=" +mBroad +", mDiaplay=" +mDisplay +", mOS=" + mOS+ "]";
      }
}

（2）Builder.java

package com.lc.example.builder;

/**
 * 抽象的Builder类
 *
 * @author HP
 *
 */
public abstract class Builder {
       /**
       * 设置主板
       *
       * @param broad
       */
       public abstract void setBroad(String broad);

       /**
       * 设置显示器
       *
       * @param display
       */
       public abstract void setDisplay(String display);

       /**
       * 设置操作系统
       */
       public abstract void setOs();

       /**
       * 构建Computer
       *
       * @return
       */
       public abstract Computer create();
}

（3）MacBulider .java

package com.lc.example.builder;

/**
 * 抽象Builder的具体实现
 *
 * @author HP
 *
 */
public class MacBulider extends Builder {

       // 创建Computer对象,具体实现时MacBook
      Computer mComputer = new MacBook();

       @Override
       public void setBroad(String broad) {
             // TODO Auto-generated method stub
             mComputer .setBroad(broad);
      }

       @Override
       public void setDisplay(String display) {
             // TODO Auto-generated method stub
             mComputer .setDisplay(display);
      }

       @Override
       public void setOs() {
             // TODO Auto-generated method stub
             mComputer .setOs();
      }

       @Override
       public Computer create() {
             // TODO Auto-generated method stub
             return mComputer ;
      }

}

(4) MacBook.java

package com.lc.example.builder;

public class MacBook extends Computer {

       protected MacBook()
      {

      }

       @Override
       public void setOs() {
             // TODO Auto-generated method stub
             mOS ="Mac OS X 10.10" ;
      }

}

(5) Director.java

package com.lc.example.builder;
/**
 * 负责构造Computer类
 * @author HP
 *
 */
public class Director {

      Builder bulider =null ;

       public Director(Builder builder) {
             // TODO Auto-generated constructor stub
             this .bulider =builder;
      }

       public void construct(String broad,String display)
      {
             bulider .setBroad(broad);
             bulider .setDisplay(display);
             bulider .setOs();
      }
}

(6)Main.java

package com.lc.example.builder;

public class Main {

       /**
       * @param args
       */
       public static void main(String[] args) {
             // TODO Auto-generated method stub

             /**
             * 第一种表现形式，使用Director类构件好对象
             */
            Builder builder = new MacBulider();
            Director mDirector = new Director(builder);
            mDirector.construct( "英特尔主板" , "Retina显示器" );
            System. out .print("Computer Info:" + builder.create().toString());
            System. out .println();
            System. out .println("-------------------------" );
      }

}

输出结果：

Computer Info:Computer [mBroad=英特尔主板, mDiaplay=Retina显示器, mOS=Mac OS X 10.10]
-------------------------

在上述代码中，Computer是一个抽象的类MacBook继承了Computer。MacBook对象通过MacbookBuilder来构建对象，而Director类封装了构建复杂产品的对象过程，对外隐藏细节。这是builder模式的一种写法，在实际的开发过程中，Director经常会被省略掉，而直接使用Builder来构建对象，这个Builder常是用链式调用。但是要实现链式调用的关键是每一个setter方法都返回this，这样就可以实现链式调用。为此，我们新建Builder1.java、ThinkPadBuilder.java 、ThinkPad.java,来实现链式调用

Builder1.java

package com.lc.example.builder;

public abstract class Builder1 {
       /**
       * 设置主板
       *
       * @param broad
       */
       public abstract Builder1 setBroad(String broad);

       /**
       * 设置显示器
       *
       * @param display
       */
       public abstract Builder1 setDisplay(String display);

       /**
       * 设置操作系统
       */
       public abstract Builder1 setOs();

       /**
       * 构建Computer
       *
       * @return
       */
       public abstract Computer create();
}

ThinkPadBuilder.java

package com.lc.example.builder;

public class ThinkPadBuilder extends Builder1{

      ThinkPad thinkPad =new ThinkPad();
       @Override
       public ThinkPadBuilder setBroad(String broad) {
             // TODO Auto-generated method stub
             thinkPad .setBroad(broad);
             return this ;
      }

       @Override
       public ThinkPadBuilder setDisplay(String display) {
             // TODO Auto-generated method stub
             thinkPad .setDisplay(display);
             return this ;
      }

       @Override
       public ThinkPadBuilder setOs() {
             // TODO Auto-generated method stub
             thinkPad .setOs();
             return this ;
      }

       @Override
       public Computer create() {
             // TODO Auto-generated method stub
             return thinkPad ;
      }

}

ThinkPad.java

package com.lc.example.builder;

public class ThinkPad extends Computer {

       protected ThinkPad() {

      }

       @Override
       public void setOs() {
             // TODO Auto-generated method stub
             mOS = "Win 8" ;
      }

}

修改mian.java如下：

package com.lc.example.builder;

public class Main {

       /**
       * @param args
       */
       public static void main(String[] args) {
             // TODO Auto-generated method stub

             /**
             * 第一种表现形式，使用Director类构件好对象
             */
            Builder builder = new MacBulider();
            Director mDirector = new Director(builder);
            mDirector.construct( "英特尔主板" , "Retina显示器" );
            System. out .print("Computer Info:" + builder.create().toString());
            System. out .println();
            System. out .println("-------------------------" );
             /**
             * 第二种表现形式，省去Director类并且使用链式调用。这种方式在ImageLoader可以看见
             */
            Builder1 builderWin = new ThinkPadBuilder();
            builderWin.setBroad( "主板think" ).setDisplay("显示器think" ).setOs();
            System. out .print("Computer Info:" + builderWin.create().toString());
            System. out .println();
            System. out .println("-------------------------" );
      }

}

输出结果：

Computer Info:Computer [mBroad=英特尔主板, mDiaplay=Retina显示器, mOS=Mac OS X 10.10]
-------------------------
Computer Info:Computer [mBroad=主板think, mDiaplay=显示器think, mOS=Win 8]
-------------------------

这种链式的Builder模式是在实际开发中比较常见的，例如ImageLoader、Glide等都是使用的这种方式。

6、总结
Builder模式在Android中是比较常见的，通常作为配置类的构建器将配置的构建和表示分离开来，同时也是将配置从目标类中隔离出来，避免过多的setter方法。Builder模式比较常见的实现方式是通过链式调用来实现的，这样使得代码更简洁易懂，如上文所述ImageLoader就是通过这种方式实现的。

Builder模式的优点：
（1）良好的封装性，使用Builder模式可以使客户端不必知道产品内部结构。
（2）Builder模式容易扩展
缺点：
会产生多余的Builder对象以及Director对象，消耗内存资源。