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对象，消耗内存资源。
