建造者模式

Posted 2021-11-26 peter-hao

 

　　建造者模式也是一种对象创建型模式。相较于工厂模式、单例模式等创建简单类型对象的创建型模式，这种模式适合创建复杂类型的对象。比如我们要组装一辆汽车，包括许多组件，发动机、轮胎、车架等。每一个组件可以看做是一个简单类型的对象，那么整个汽车就相当于一个复杂类型的对象。

　　那么我们如何将这些组件构建和组合设计，建造者模式为我们提供了解决方案，我们将组件的构建和设计分离，抽象成一个构建器和一个设计器。构建器负责生产各种汽车组件，设计器负责将这些组件设计组合。下面我们开始构建和设计一辆宝马汽车。

1.建造者模式设计整体示意图

2.汽车组件类

　　首先我们要创建一个汽车的组件类，声明各种汽车的组件。汽车的各个组件定义成了一个个类，通过在组件类中声明有参构造器来注入汽车各种组件的商标，也可以通过set方法注入，这里使用构造器注入。同时通过get方法获取宝马汽车的各种组件的商标。

//汽车组件类，声明汽车各种组件
public class Car {
    private Engine engine;//引擎
    private Tyre tyre;//轮胎
    private Frame frame;//车架

    public Engine getEngine() {
        return engine;
    }
    public void setEngine(Engine engine) {
        this.engine = engine;
    }
    public Tyre getTyre() {
        return tyre;
    }
    public void setTyre(Tyre tyre) {
        this.tyre = tyre;
    }
    public Frame getFrame() {
        return frame;
    }
    public void setFrame(Frame frame) {
        this.frame = frame;
    }
}
//引擎类
class Engine {
    private String name;
    public Engine(String name) {
        this.name = name;
    }
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
}
//轮胎类
class Tyre {
    private String name;
    public Tyre(String name) {
        this.name = name;
    }
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
}
//车架类
class Frame {
    private String name;
    public Frame(String name) {
        this.name = name;
    }
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
}

3.创建构建器接口

/**
 *  汽车构建器接口
 */
public interface CarBuilder {
    //构建汽车引擎
    public Engine builderEngine();
    //构建汽车轮胎
    public Tyre builderTyre();
    //构建汽车车架
    public Frame builderFrame();
}

4.宝马汽车构建器

　　这里构建的汽车各种组件对象也可以结合工厂模式、单例模式或者其他创建简单类型对象的模式进行创建。

public class BwmBuilder implements CarBuilder {

    @Override
    public Engine builderEngine() {
        //也可通过工厂模式,单例模式等创建
        return new Engine("宝马发动机！");
    }
    @Override
    public Tyre builderTyre() {
        return new Tyre("宝马轮胎");
    }
    @Override
    public Frame builderFrame() {
        return new Frame("宝马车架");
    }    
}

5.设计器接口

/**
 *  汽车设计器接口
 */
public interface CarDirector {
    //组装设计汽车
    public Car directorCar();
}

6.宝马汽车设计器

　　这里通过有参构造器将宝马汽车构造器注入进来，在directorCar()内进行汽车组件的获取和组装等操作，最后返回一个组装设计完好的宝马汽车。

public class BwmDirector implements CarDirector{
    private CarBuilder builder;
    public BwmDirector(CarBuilder builder) {
        this.builder  = builder;
    }
    
    @Override
    public Car directorCar() {
        //获取组件
        Engine engine = builder.builderEngine();
        Tyre tyre = builder.builderTyre();
        Frame frame = builder.builderFrame();
        //组装构建bwm汽车
        Car bwmCar = new Car();
        bwmCar.setEngine(engine);
        bwmCar.setTyre(tyre);
        bwmCar.setFrame(frame);
        
        return bwmCar;
        
    }
}

7.Client类来制造宝马汽车

public class Client {
    public static void main(String[] args) {
        //获取宝马汽车设计器
        BwmDirector carDirector = new BwmDirector(new BwmBuilder());
        //设计组装
        Car car = carDirector.directorCar();
        //查看汽车各种组件商标
        System.out.println("汽车引擎："+car.getEngine().getName());
        System.out.println("汽车轮胎："+car.getTyre().getName());
        System.out.println("汽车车架："+car.getFrame().getName());
    }
}

8.结果

9.总结

　　模式源于生活。建造者模式，能够创建更加复杂类型的对象。这种模式将组件的构建和组件的设计组合分离出来，实现了构建和设计组合的解耦，使得在创建一个复杂对象的时候变得更加清晰。因为实现了这种解耦，在相同的构建器和不同的设计器下，可以在相同组件中设计出不同的对象来，例如搭积木，相同的积木块，搭建的顺序不同，效果也不同。相反，不同的构建器和相同的设计器下，也可以设计出不同的对象来，例如汽车的组装，汽车的组件不同，生产出来的汽车也不一样。