建造者模式 定义 将一个复杂对象的构建与它的表示分离，使得同样的构建过程可以创建不同的表示。
首先这是一个复杂的对象，也就是说对象的创建过程比较复杂，可能需要N多个组件来完成整个对象的创建，这个时候为了符合“单一职责”，我们将对象的构建过程分离出来，通过建造者来完成对象组件的创建，再通过一个指挥者类完成组装生成一个完整的产品。
UML图
四要素 根据UML图可知道，建造者模式有4个非常重要的角色
Builder:一个抽象接口，用于规范子类建造者的创建产品对象的各个组件。
ConcreteBuilder: 实现抽象类的所有未实现的方法，不同的建造者有不同的构建产品组件的方法。
Director:指挥者类，复杂完成整个产品的组装，不同的建造者创建一个产品不同的组件，通过指挥者类将整个产品组装完成。
Product:产品类，一般是一个比较复杂的对象，也就是说这个产品的创建过程比较复杂。
下面还是通过一个实例来认识一下建造者模式
实例
一软件公司欲开发一个音乐播放软件，为了给用户使用提供方便，该播放软件提供多种界面显示模式，如完整模式、精简模式、记忆模式、网络模式等。在不同的显示模式下主界面的组成元素有所差异，如在完整模式下将显示菜单、播放列表、主窗口、控制条等，在精简模式下只显示主窗口和控制条，而在记忆模式下将显示主窗口、控制条、收藏列表等。
UML图 根据需求我们可以设计UML图如下
代码 MusicPlayer类
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 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 抽象接口
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 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; } }
根据需求建立三个不同的建造者
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 // 完整模式 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("收藏列表"); } }
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 //精简模式 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); } }
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 //记忆模式 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类，也就是指挥者类
1 2 3 4 5 6 7 8 9 10 11 12 public class PlayerController { public MusicPlayer construct(PlayerBuilder pb) { pb.buildType(); pb.buildMenu(); pb.buildPlayerList(); pb.buildMainWindows(); pb.buildControlStrip(); pb.buildCollectionList(); return pb.createPlayer(); } }
客户端测试
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 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 2 3 4 5 这是一个 精简模式 音乐播放器 播放器拥有： 主界面 控制条
选择不同的建造者即可以生产出不同模式的音乐播放器，建造者完成了创建播放器组件的过程，而指挥者类完成最后的组装。对于客户端来说不需要了解具体的创建步骤，只需要选择对应的建造者即可。
变种1:省略Director Director类在建造者模式中扮演十分重要的作用，它按一定的顺序调用Builder的buildPartX()方法，像客户端返回一个完整的产品。
但是在有些情况下，为了简化系统，我们可以将Director和抽象建造者Builder进行合并，例如下面的代码
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 public class Product { private String name; private String price; @Override public String toString() { return "Product{" + "name='" + name + '\'' + ", price='" + price + '\'' + '}'; } ... }
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 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"); } }
客户端调用
1 2 3 4 5 6 7 8 9 10 11 12 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 先给大家看一段代码
1 2 3 4 5 6 7 8 9 10 11 12 13 14 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的代码
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 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的源码看看，受益良多。
建造者模式与抽象工厂模式 有些同学可能会发现，建造者模式完成的事，我们都可以通过抽象工厂模式完成，那么他们有什么区别呢？
与建造者模式相比，抽象工厂模式返回的是一系列相关的产品，这些产品位于不同的产品等级结构，构成产品族，而建造者模式返回的是一个组装好的完整产品。抽象工厂模式更像一个汽车零件生产商，生产不同品牌汽车的各种零件。而建造者模式更像一个汽车装配厂，通过一系列零件的组装，最终生产出的是一个完整的汽车。
抽象工厂模式中，客户端需实例化工厂类，然后通过工厂类获取所需的产品对象。而建造者模式更侧重于将复杂的构造对象的方法交给建造者去做，而客户端只需要通过指挥者就能创建一个完整的产品实例。
小结 建造者模式将一个复杂对象的构建与它的表示分离，使得客户端通过创建不同的建造者即可创建出不同的对象。且通过分离的方式，将复杂的创建过程分离出来，符合“单一职责”规范。新的不同对象可以通过新增建造者类生成，符合“开闭原则”。但建造者类的使用范围也有一定的限制，建造者模式创建的产品都有一定的相似性，如果所创建的产品差异性很大，则不适合建造者模式。
源码：https://github.com/lichenming0516/DesignPattern
