设计模式：建造者模式

建造者模式

类型：创建型

参考
23 种设计模式详解（全23种）
设计模式：建造者模式（Builder）

简单来说，就是有一个管事的和一堆各司其职（制造产品）的工人，这个管事的人可以每次吩咐一个人去完成他的任务，需要完成任务A就找到工人A，需要完成任务B就找到工人B。管事的只负责找到相应的工人，工人只负责完成自己的任务。

包结构

需要被建造的bean

package 建造者模式.bean;

public class Animal {
    private String head;
    private String body;
    private String feet;
    private String tail;

    public String getHead() {
        return head;
    }

    public void setHead(String head) {
        this.head = head;
    }

    public String getBody() {
        return body;
    }

    public void setBody(String body) {
        this.body = body;
    }

    public String getFeet() {
        return feet;
    }

    public void setFeet(String feet) {
        this.feet = feet;
    }

    public String getTail() {
        return tail;
    }

    public void setTail(String tail) {
        this.tail = tail;
    }

    @Override
    public String toString() {
        return "Animal{" +
                "head='" + head + '\'' +
                ", body='" + body + '\'' +
                ", feet='" + feet + '\'' +
                ", tail='" + tail + '\'' +
                '}';
    }
}

建造者基类

package 建造者模式.builder;

import 建造者模式.bean.Animal;

public abstract class AnimalBuilder {
    protected Animal animal;

    public Animal getAnimal(){
        return animal;
    }

    public void createAnimal(){
        animal = new Animal();
    }

    public abstract void buildHead();
    public abstract void buildBody();
    public abstract void buildFeet();
    public abstract void buildTail();
}

具体的建造者

造猫工人

package 建造者模式.builder;

import 建造者模式.bean.Animal;

public class CatBuilder extends AnimalBuilder {
    @Override
    public void buildHead() {
        super.animal.setHead("猫的头");
    }

    @Override
    public void buildBody() {
        super.animal.setBody("猫的身子");
    }

    @Override
    public void buildFeet() {
        super.animal.setFeet("猫的脚");
    }

    @Override
    public void buildTail() {
        super.animal.setTail("猫的尾巴");
    }
}

造狗工人

package 建造者模式.builder;

public class DogBuilder extends AnimalBuilder{
    @Override
    public void buildHead() { super.animal.setHead("狗的头"); }

    @Override
    public void buildBody() { super.animal.setBody("狗的身子"); }

    @Override
    public void buildFeet() {
        super.animal.setFeet("狗的脚");
    }

    @Override
    public void buildTail() {
        super.animal.setTail("狗的尾巴");
    }
}

负责管事的director

package 建造者模式.director;

import 建造者模式.bean.Animal;
import 建造者模式.builder.AnimalBuilder;

public class Director {
    private AnimalBuilder animalBuilder;

    public void setAnimalBuilder(AnimalBuilder animalBuilder) {
        this.animalBuilder = animalBuilder;
    }

    public void createAnimal(){
    	//这里就可以控制赋值的顺序
        animalBuilder.createAnimal();
        animalBuilder.buildHead();
        animalBuilder.buildBody();
        animalBuilder.buildFeet();
        animalBuilder.buildTail();
    }

    public Animal getAnimal() {
        return animalBuilder.getAnimal();
    }
}

客户端

package 建造者模式.client;

import 建造者模式.bean.Animal;
import 建造者模式.builder.CatBuilder;
import 建造者模式.builder.DogBuilder;
import 建造者模式.director.Director;

public class Client {
    public static void main(String[] args) {
        //先new出director对象
        Director director = new Director();
        System.out.println("============创造猫咪============");
        director.setAnimalBuilder(new CatBuilder());
        director.createAnimal();
        Animal cat = director.getAnimal();
        System.out.println(cat);
        System.out.println("============创造炫狗============");
        director.setAnimalBuilder(new DogBuilder());
        director.createAnimal();
        Animal dog = director.getAnimal();
        System.out.println(dog);
    }
}

效果

============创造猫咪============
Animal{head='猫的头', body='猫的身子', feet='猫的脚', tail='猫的尾巴'}
============创造炫狗============
Animal{head='狗的头', body='狗的身子', feet='狗的脚', tail='狗的尾巴'}

Process finished with exit code 0

优点

• 使用建造者模式可以使客户端不必知道产品内部的组成细节。（封装性）
• 具体的建造者之间是相互独立的，对系统的扩展非常有利。（扩展性）
• 由于具体的建造者是独立的，因此可以对建造过程逐步细化，而不对其他模块产生任何影响。

缺点

对不同类型的对象需要实现不同的具体构造器的类，这可能会大大增加类的数量

与工厂模式的区别

建造者模式构建对象的时候，通常构建对象的过程需要多个步骤，而且是将这些复杂的构建过程封装起来。
工厂模式构建对象通常只有一个步骤，调用一个工厂方法就可以生成一个对象。

建造者模式关注的是零件类型和装配工艺（顺序），而工厂模式是创建一个对象，这是最大不同的地方。

建造者模式的使用场景

1）相同的方法，不同的执行顺序，产生不同的事件结果时，可以使用建造者模式。
2）多个部件或零件，都可以装配到一个对象中，但是产生的运行结果又不想同时，可以使用建造者模式。
3）产品类非常复杂，或者产品类中的调用顺序不同产生了不同的效能，这时候可以使用建造者模式。