一天一个设计模式---生成器模式

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

场景：我们在创建对象时可能会碰到过一个问题，比如，如果需要赋值的属性过多，构造函数会很多，而且有的会很长。通过JavaBean的方式可能不需要担心构造函数，但是，我们的set部分又会很长很难看，这里推荐大家试试builder模式

一、角色及作用

角色	作用
产品(Product）	目标创建的复杂对象
抽象生成器(Builder)	提供创建一个Product对象的各个组件的方法及返回Product对象的方法
具体生成器(ConcreteBuilder)	实现Buidler接口的类。
管理者(Director)	用于管理builder对象的工作

二、场景

玩过《我的世界》这类沙盒游戏的玩家，很多都是冲着其开放式的制作功能去的。比如，我们要建造一个房子就需要以下：墙，屋顶，门，床。但是这些东西的制作也十分麻烦。如果每次都让客户端来创建会需要很多代码

内部组件

// 床
public class Bed {
    public Bed(String s) {
        System.out.println(s);
    }
}

// 门
public class Door {
    public Door(String s) {
        System.out.println(s);
    }
}

// 屋顶
public class Roof {
    public Roof(String s) {
        System.out.println(s);
    }
}

// 墙
public class Wall {
    public Wall(String s) {
        System.out.println(s);
    }
}

1.使用构造函数的方式

public class House {
    public Bed bed;
    public Door door;
    public Roof roof;
    public Wall wall;

    public House(Bed bed){
        this.bed = bed;
    }

    public House(Bed bed,Door door){
        this.bed = bed;
        this.door = door;
    }

    // ......省略各种组合的构造函数

}

可见，这种方式会使此类中存在很多构造方法，而且不能满足所有的组合，客户端在制作房屋的时候，比较不适用。

2.使用setter方式

public class House {
    public Bed bed;
    public Door door;
    public Roof roof;
    public Wall wall;

    // setter and getter
}

典型的java bean 的形式，解决上面构造函数的不足，但是让我们来看看使用。

House house = new House();
house.setBed(1);
// ......省略其它set方法

如果我们的私有属性增加到二十，那么我们每次创建的时候就需要写二十行setter代码，累不累？

总结：
上面这两种方法，在每次创建房屋的时候，客户端还需要每次去创建各种类型的对象，会产生很多重复代码。

三、使用builder模式

产品-房子

public class House {
    public Bed bed;
    public Door door;
    public Roof roof;
    public Wall wall;
}

抽象生成器

public interface Builder {

    public void bed();

    public void door();

    public void roof();

    public void wall();

    public House getProduct();
}

生成器的具体实现:木屋

public class WoodHouseBuilder implements Builder {

    private House house = new House();

    @Override
    public void bed() {
        house.bed=new Bed("木床");
    }

    @Override
    public void door() {
        house.door = new Door("木门");
    }

    @Override
    public void roof() {
        house.roof = new Roof("木头屋顶");
    }

    @Override
    public void wall() {
        house.wall = new Wall("木墙");
    }

    @Override
    public House getProduct() {
        return house;
    }

}

生成器的具体实现:别墅

public class VillaHouseBuilder implements Builder {

    private House house = new House();

    @Override
    public void bed() {
        house.bed = new Bed("木床");
    }

    @Override
    public void door() {
        house.door = new Door("铁门");
    }

    @Override
    public void roof() {
        house.roof = new Roof("欧式带天窗屋顶");
    }

    @Override
    public void wall() {
        house.wall = new Wall("石墙");
    }

    @Override
    public House getProduct() {
        return house;
    }

}

build管理者

public class Director {
    private Builder builder;

    public Director(Builder builder) {
        this.builder = builder;
    }

    public void construct() {
        builder.wall();
        builder.roof();
        builder.door();
        builder.bed();
    }
}

开始制作房子

public static void main(String[] args) {
    System.out.println("开始做木屋=======");
    Builder builder = new WoodHouseBuilder();
    Director director = new Director(builder);
    director.construct();
    System.out.println("开始做别墅=======");
    Builder builder2 = new VillaHouseBuilder();
    director = new Director(builder2);
    director.construct();
}

输出

开始做木屋=======
木墙
木头屋顶
木门
木床
开始做别墅=======
石墙
欧式带天窗屋顶
铁门
木床

这样，我们可以明显感觉到在创建对象时候代码量少了很多。而且，对于不同款式的房子，我们只需要不同的Director，对象的属性和创建分离。

优点：
- 生产过程交给Director，客户端不必知道产品的内部结构
- 可以有多个生成器，方便扩展

四、《Effective Java》中的Builder模式

在《Effective Java》中也有对Builder模式的使用，但是感觉在实现上和上面还是有点区别。参考：《Effective Java》 第二章，第2条：遇到多个构造器参数时要考虑用构造器

public class NutFacts {
    private final int serSize;
    private final int fat;
    private final int car;
    private final int so;

    public static class Builder {

        // 必填字段
        private final int serSize;

        // 非必填字段
        private int fat = 0;
        private int car = 0;
        private int so = 0;

        public Builder(int serSize) {
            this.serSize = serSize;
        }

        public Builder fat(int val) {
            fat = val;
            return this;
        }

        public Builder car(int val) {
            car = val;
            return this;
        }

        public Builder so(int val) {
            so = val;
            return this;
        }

        public NutFacts build() {
            return new NutFacts(this);
        }
    }

    private NutFacts(Builder builder) {
        serSize = builder.serSize;
        fat = builder.fat;
        car = builder.car;
        so = builder.so;
    }
}

创建对象的方法：

NutFacts no = new NutFacts.Builder(1).car(2).so(1).build();

比较：

这个创建对象的方法就像Python中的具名的可选参数。

builder可以对参数加强约束条件，build方法可以用于检验这些约束。

与构造器相比，builder的优势在于可以有多个可变参数，builder参数可以在创建对象期间调整。

和setter相比，属性可以不可变，如上面NutFacts，属性都是不可变得final。但是通过构造器对Builer对象修改，又可以修改属性。

---

更多模式： 一天一个设计模式—分类与六大原则

更多源码： https://github.com/oDevilo/Java-Base