建造者模式
定义
将一个复杂对象的构建与它的表示分离，使得同样的构建过程可以创建不同的表示。
首先这是一个复杂的对象，也就是说对象的创建过程比较复杂，可能需要N多个组件来完成整个对象的创建，这个时候为了符合“单一职责”，我们将对象的构建过程分离出来，通过建造者来完成对象组件的创建，再通过一个指挥者类完成组装生成一个完整的产品。
UML图
四要素
根据UML图可知道，建造者模式有4个非常重要的角色
- Builder:一个抽象接口，用于规范子类建造者的创建产品对象的各个组件。
- ConcreteBuilder: 实现抽象类的所有未实现的方法，不同的建造者有不同的构建产品组件的方法。
- Director:指挥者类，负责完成整个产品的组装，不同的建造者创建一个产品不同的组件，通过指挥者类将整个产品组装完成。
- Product:产品类，一般是一个比较复杂的对象，也就是说这个产品的创建过程比较复杂。
下面还是通过一个实例来认识一下建造者模式
实例
一软件公司欲开发一个音乐播放软件，为了给用户使用提供方便，该播放软件提供多种界面显示模式，如完整模式、精简模式、记忆模式、网络模式等。在不同的显示模式下主界面的组成元素有所差异，如在完整模式下将显示菜单、播放列表、主窗口、控制条等，在精简模式下只显示主窗口和控制条，而在记忆模式下将显示主窗口、控制条、收藏列表等。
UML图
根据需求我们可以设计UML图如下
代码
MusicPlayer类
public class MusicPlayer {
private String type;
private String menu;
private String playerList;
private String mainWindows;
private String controlStrip;
private String collectionList;
@Override
public String toString() {
StringBuilder sb = new StringBuilder();
sb.append("这是一个 ").append(type).append(" 音乐播放器\n\n");
sb.append("播放器拥有：\n");
if (menu != null) sb.append(menu).append("\n");
if (playerList != null) sb.append(playerList).append("\n");
if (mainWindows != null) sb.append(mainWindows).append("\n");
if (controlStrip != null) sb.append(controlStrip).append("\n");
if (collectionList != null) sb.append(collectionList).append("\n");
return sb.toString();
}
//get set方法
...
}
PlayerBuilder 抽象接口
public abstract class PlayerBuilder {
protected MusicPlayer player = new MusicPlayer();
public abstract void buildType();
public abstract void buildMenu();
public abstract void buildPlayerList();
public abstract void buildMainWindows();
public abstract void buildControlStrip();
public abstract void buildCollectionList();
public MusicPlayer createPlayer(){
return player;
}
}
根据需求建立三个不同的建造者
// 完整模式
public class FullPlayerBuilder extends PlayerBuilder {
@Override
public void buildType() {
player.setType("完整模式");
}
@Override
public void buildMenu() {
player.setMenu("菜单");
}
@Override
public void buildPlayerList() {
player.setPlayerList("播放列表");
}
@Override
public void buildMainWindows() {
player.setMainWindows("主界面");
}
@Override
public void buildControlStrip() {
player.setControlStrip("控制条");
}
@Override
public void buildCollectionList() {
player.setCollectionList("收藏列表");
}
}
//精简模式
public class SimplePlayerBuilder extends PlayerBuilder {
@Override
public void buildType() {
player.setType("精简模式");
}
@Override
public void buildMenu() {
player.setMenu(null);
}
@Override
public void buildPlayerList() {
player.setPlayerList(null);
}
@Override
public void buildMainWindows() {
player.setMainWindows("主界面");
}
@Override
public void buildControlStrip() {
player.setControlStrip("控制条");
}
@Override
public void buildCollectionList() {
player.setCollectionList(null);
}
}
//记忆模式
public class MemoryPlayerBuilder extends PlayerBuilder {
@Override
public void buildType() {
player.setType("记忆模式");
}
@Override
public void buildMenu() {
player.setMenu(null);
}
@Override
public void buildPlayerList() {
player.setPlayerList(null);
}
@Override
public void buildMainWindows() {
player.setMainWindows("主界面");
}
@Override
public void buildControlStrip() {
player.setControlStrip("控制条");
}
@Override
public void buildCollectionList() {
player.setCollectionList("收藏列表");
}
}
PlayerController类，也就是指挥者类
public class PlayerController {
public MusicPlayer construct(PlayerBuilder pb) {
pb.buildType();
pb.buildMenu();
pb.buildPlayerList();
pb.buildMainWindows();
pb.buildControlStrip();
pb.buildCollectionList();
return pb.createPlayer();
}
}
客户端测试
public class Client {
public static void main(String[] args) {
MusicPlayer player;
PlayerBuilder builder;
PlayerController controller;
builder = new SimplePlayerBuilder();
controller = new PlayerController();
player = controller.construct(builder);
System.out.println(player.toString());
}
}
测试结果如下
这是一个 精简模式 音乐播放器
播放器拥有：
主界面
控制条
选择不同的建造者即可以生产出不同模式的音乐播放器，建造者完成了创建播放器组件的过程，而指挥者类完成最后的组装。对于客户端来说不需要了解具体的创建步骤，只需要选择对应的建造者即可。
变种1:省略Director
Director类在建造者模式中扮演十分重要的作用，它按一定的顺序调用Builder的buildPartX()方法，像客户端返回一个完整的产品。
但是在有些情况下，为了简化系统，我们可以将Director和抽象建造者Builder进行合并，例如下面的代码
public class Product {
private String name;
private String price;
@Override
public String toString() {
return "Product{" +
"name='" + name + '\'' +
", price='" + price + '\'' +
'}';
}
...
}
public abstract class Builder {
protected Product product = new Product();
public abstract void buildName();
public abstract void buildPrice();
public Product createProduct(){
this.buildName();
this.buildPrice();
return product;
}
}
public class Product1Builder extends Builder {
@Override
public void buildName() {
product.setName("product1");
}
@Override
public void buildPrice() {
product.setPrice("1234");
}
}
public class Product2Builder extends Builder {
@Override
public void buildName() {
product.setName("product2");
}
@Override
public void buildPrice() {
product.setPrice("6789");
}
}
客户端调用
public class Client {
public static void main(String[] args) {
Product product;
Builder builder;
builder = new Product1Builder();
product = builder.createProduct();
System.out.println(product.toString());
}
}
变种2:内部Builder
先给大家看一段代码
public class Client {
public static void main(String[] args) {
Person.Builder builder = new Person.Builder();
Person person = builder.setAge(14)
.setCountry("中国")
.setName("张三")
.setSex("男")
.create();
System.out.println(person.toString());
}
}
这熟悉的内部类Builder，这风骚的链式调用，相信作为Android开发程序猿应该非常熟悉吧，不管是Android系统AlertDialog、Notification的创建还是第三方开源库Retrofit、Universal-Image-Loader的配置都是这熟悉的套路，没错这也是建造者模式的一个变种。
先看看上面示例中Person的代码
public class Person {
private String name;
private int age;
private String sex;
private String country;
private Person() {
}
private Person(String name, int age, String sex, String country) {
this.name = name;
this.age = age;
this.sex = sex;
this.country = country;
}
@Override
public String toString() {
return "Person{" +
"name='" + name + '\'' +
", age=" + age +
", sex='" + sex + '\'' +
", country='" + country + '\'' +
'}';
}
public static class Builder {
private String name;
private int age;
private String sex;
private String country;
public Builder setName(String name) {
this.name = name;
return this;
}
public Builder setAge(int age) {
this.age = age;
return this;
}
public Builder setSex(String sex) {
this.sex = sex;
return this;
}
public Builder setCountry(String country) {
this.country = country;
return this;
}
public Person create() {
return new Person(name, age, sex, country);
}
}
}
从代码中我们可以知道，这种模式是对前一个变种的进一步简化，将Builder类置于Product类的内部，通过create()方法完成产品的组装。虽然代码简化只有一个类，但依旧符合建造者模式的思想，依然属于建造者模式的一种。有兴趣的同学可以扒一扒AlertDialog的源码看看，受益良多。
建造者模式与抽象工厂模式
有些同学可能会发现，建造者模式完成的事，我们都可以通过抽象工厂模式完成，那么他们有什么区别呢？
- 与建造者模式相比，抽象工厂模式返回的是一系列相关的产品，这些产品位于不同的产品等级结构，构成产品族，而建造者模式返回的是一个组装好的完整产品。抽象工厂模式更像一个汽车零件生产商，生产不同品牌汽车的各种零件。而建造者模式更像一个汽车装配厂，通过一系列零件的组装，最终生产出的是一个完整的汽车。
- 抽象工厂模式中，客户端需实例化工厂类，然后通过工厂类获取所需的产品对象。而建造者模式更侧重于将复杂的构造对象的方法交给建造者去做，而客户端只需要通过指挥者就能创建一个完整的产品实例。
小结
建造者模式将一个复杂对象的构建与它的表示分离，使得客户端通过创建不同的建造者即可创建出不同的对象。且通过分离的方式，将复杂的创建过程分离出来，符合“单一职责”规范。新的不同对象可以通过新增建造者类生成，符合“开闭原则”。但建造者类的使用范围也有一定的限制，建造者模式创建的产品都有一定的相似性，如果所创建的产品差异性很大，则不适合建造者模式。
