重学设计模式--建造者模式

阅读 416
收藏 36
2017-09-01
原文链接:lichenming.com

建造者模式

定义

将一个复杂对象的构建与它的表示分离,使得同样的构建过程可以创建不同的表示。

首先这是一个复杂的对象,也就是说对象的创建过程比较复杂,可能需要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的源码看看,受益良多。

建造者模式与抽象工厂模式

有些同学可能会发现,建造者模式完成的事,我们都可以通过抽象工厂模式完成,那么他们有什么区别呢?

  • 与建造者模式相比,抽象工厂模式返回的是一系列相关的产品,这些产品位于不同的产品等级结构,构成产品族,而建造者模式返回的是一个组装好的完整产品。抽象工厂模式更像一个汽车零件生产商,生产不同品牌汽车的各种零件。而建造者模式更像一个汽车装配厂,通过一系列零件的组装,最终生产出的是一个完整的汽车。
  • 抽象工厂模式中,客户端需实例化工厂类,然后通过工厂类获取所需的产品对象。而建造者模式更侧重于将复杂的构造对象的方法交给建造者去做,而客户端只需要通过指挥者就能创建一个完整的产品实例。

小结

建造者模式将一个复杂对象的构建与它的表示分离,使得客户端通过创建不同的建造者即可创建出不同的对象。且通过分离的方式,将复杂的创建过程分离出来,符合“单一职责”规范。新的不同对象可以通过新增建造者类生成,符合“开闭原则”。但建造者类的使用范围也有一定的限制,建造者模式创建的产品都有一定的相似性,如果所创建的产品差异性很大,则不适合建造者模式。

评论