04 设计模式之生成器模式

?

1 背景


我们知道,构建一辆汽车是极其复杂,部件繁多的。假设我们现在需要构建一辆汽车,为方便演示,我们假设构建一辆汽车只需要发动机,车轮,方向盘。那如何去构建一辆汽车呢?假设构建一辆车的顺序为安装发动机,安装车轮,安装方向盘。

首先,需要定义三个部件(发动机,车轮,方向盘),将它们定义为单独的类。

package com.chenpi.builder;

/**
 * @Description 发动机
 * @Author 陈皮
 * @Date 2021/8/8
 * @Version 1.0
 */
public class Engine {

  // 品牌
  private String brand;

  public Engine(String brand) {
    this.brand = brand;
  }

  public String getBrand() {
    return brand;
  }

  public void setBrand(String brand) {
    this.brand = brand;
  }
}
package com.chenpi.builder;

/**
 * @Description 车轮
 * @Author 陈皮
 * @Date 2021/8/8
 * @Version 1.0
 */
public class Wheel {

  // 车轮类型
  private String type;

  public Wheel(String type) {
    this.type = type;
  }

  public String getType() {
    return type;
  }

  public void setType(String type) {
    this.type = type;
  }
}
package com.chenpi.builder;

/**
 * @Description 方向盘
 * @Author 陈皮
 * @Date 2021/8/8
 * @Version 1.0
 */
public class SteeringWheel {

  // 方向盘颜色
  private String color;

  public SteeringWheel(String color) {
    this.color = color;
  }

  public String getColor() {
    return color;
  }

  public void setColor(String color) {
    this.color = color;
  }
}

然后定义汽车类,并且由以上三种部件组成。

package com.chenpi.builder;

/**
 * @Description 汽车
 * @Author 陈皮
 * @Date 2021/8/8
 * @Version 1.0
 */
public class Car {

  // 发动机
  private Engine engine;
  // 方向盘
  private SteeringWheel steeringWheel;
  // 车轮
  private Wheel wheel;

  public Car(Engine engine, SteeringWheel steeringWheel, Wheel wheel) {
    this.engine = engine;
    this.steeringWheel = steeringWheel;
    this.wheel = wheel;
  }

  // 省略 getter / setter 方法
}

最后客户端负责生产各个汽车组件,并组装构建一辆汽车。

package com.chenpi.builder;

/**
 * @Description 客户端
 * @Author 陈皮
 * @Date 2021/8/8
 * @Version 1.0
 */
public class ChenPiClient {

  public static void main(String[] args) {
    Engine engine = new Engine("沃尔沃");
    Wheel wheel = new Wheel("175/70R");
    SteeringWheel steeringWheel = new SteeringWheel("Black");
    Car car = new Car(engine, steeringWheel, wheel);
    System.out.println(car);
  }
}

// 输出结果如下
Car{engine=Engine{brand=‘沃尔沃‘}, steeringWheel=SteeringWheel{color=‘Red‘}, wheel=Wheel{type=‘175/70R‘}}

此时,如果我们需要创建另外一种类型的汽车,那我们就需要重写客户端代码,再进行生产,组装构建一辆新汽车。

Engine engine = new Engine("蔚来");
Wheel wheel = new Wheel("255/55 R19");
SteeringWheel steeringWheel = new SteeringWheel("Black");
Car car = new Car(engine, steeringWheel, wheel);

你会发现客户端不仅要清楚整辆汽车的外观表示,还需要清楚汽车组件的装配细节,然后按顺序组装构建汽车对象,这对客户端的使用是不友好的,使用比较麻烦。而且这演示的只是简单的几个属性的赋值,如果对象属性比较多,构建过程复杂就更不用说了。

对于客户端来说,它不应该知道汽车内部在装配细节,它就只想要一辆完整的汽车来使用。

2 生成器模式(Builder Pattern)


生成器模式(也叫建造者模式)是一种创建型设计模式,它将一个复杂对象的构建与它的表示分离,使得同样的构建过程可以创建不同的表示。

即有些对象的创建流程是一样的,但是创建出来的对象一些自身特性可以是不一样的,所以需要将对象的表示(外观)和对象具体的构建分开来。

生成器模式把对象的构建步骤抽象成生成器(builder),指导类(director)对所有生成步骤的先后顺序进行控制。客户端使用指导类并传入相应的生成器,通过指导类的接口便可以得到相应的对象。

  • Builder:生成器接口,定义了创建一个 Product 对象所需的各个部件的操作,以及获取产品的方法。
  • ConcreteBuilder:生成器接口具体实现类,实现各个部件的创建并负责组装,并返回构建好的产品对象。
  • Director:指导者,使用 Builder 接口,以一个统一的过程来构建所需要的 Product 对象。
  • Product:产品,被生成器构建的复杂对象,包含多个部件。

04 设计模式之生成器模式

现在我们使用生成器模式改写开头的例子,我们首先需要定义一个生成器接口。

package com.chenpi.builder;

/**
 * @Description 汽车生成器接口
 * @Author 陈皮
 * @Date 2021/8/8
 * @Version 1.0
 */
public interface CarBuilder {

  Car builder();

  void buildEngine();

  void buildWheel();

  void buildSteeringWheel();
}

假设我们现在需要沃尔沃的汽车,那么就定义一个沃尔沃的生成器接口实现类。

package com.chenpi.builder;

/**
 * @Description 沃尔沃汽车生成器
 * @Author 陈皮
 * @Date 2021/8/8
 * @Version 1.0
 */
public class VolvoCarBuilder implements CarBuilder {

  private Car car = new Car();

  @Override
  public Car builder() {
    return car;
  }

  @Override
  public void buildEngine() {
    car.setEngine(new Engine("沃尔沃"));
  }

  @Override
  public void buildWheel() {
    car.setWheel(new Wheel("175/70R"));
  }

  @Override
  public void buildSteeringWheel() {
    car.setSteeringWheel(new SteeringWheel("Black"));
  }
}

再定义汽车指导者,负责指导汽车产品的构建。

package com.chenpi.builder;

/**
 * @Description 汽车指导者
 * @Author 陈皮
 * @Date 2021/8/8
 * @Version 1.0
 */
public class CarDirector {

  private CarBuilder builder;

  public CarDirector(CarBuilder builder) {
    this.builder = builder;
  }

  public void buildCar() {
    builder.buildEngine();
    builder.buildWheel();
    builder.buildSteeringWheel();
  }

  public Car getCar() {
    return builder.builder();
  }
}

最后,客户端就选择特定的生成器实现类对象,传递给指导类对象,让它生产我们需要的产品对象即可。

package com.chenpi.builder;

/**
 * @Description 客户端
 * @Author 陈皮
 * @Date 2021/8/8
 * @Version 1.0
 */
public class ChenPiClient {

  public static void main(String[] args) {
    CarDirector director = new CarDirector(new VolvoCarBuilder());
    director.buildCar();
    Car car = director.getCar();
    System.out.println(car);
  }
}

// 输出结果如下
Car{engine=Engine{brand=‘沃尔沃‘}, steeringWheel=SteeringWheel{color=‘Black‘}, wheel=Wheel{type=‘175/70R‘}}

3 生成器模式简化版


生成器模式的主要功能是构建复杂的产品,而且是细化的、分步骤的构建产品,也就是生成器模式重在一步一步解决构造复杂对象的问题。

你是否发现上述的生成器模式会比较复杂,定义太多的接口和类等。其实实际使用中会根据情况进行调整。例如上述的生成器对象和被构建的对象是分开的,那其实客户端可以直接使用 new 被构建对象的方式来创建产品对象,这样就导致生成器模式荒废了,所以我们可以将生成器对象合并到被构建的对象中去,称为它的一个内部类。

而且我们也可以不再需要指导类,直接让客户端使用生成器对象进行构建最终产品。

假设我们现在需要一个 Mongo 客户端参数选项对象,来进行 Mongo 客户端的配置,那我们就可以定义一个客户端参选选项类,存放各种参数,并且将生成器定义为它的内部类,用来构建 Mongo 客户端参数选项对象。

实际开发中,Mongo 客户端配置参数是很多的,可达十几二十多个,为方便演示,我们只定义几个。这些参数值通过生成器来进行配置构建,并对参数合理值进行校验。

而且我们将 MongoClientOptions 类的构造方法定义为私有的,所以外部只能通过生成器来构建 MongoClientOptions 对象。

package com.chenpi.builder.mongo;

/**
 * @Description mongo客户端参数选项
 * @Author 陈皮
 * @Date 2021/8/8
 * @Version 1.0
 */
public class MongoClientOptions {

  private final int maxWaitTime;
  private final int maxConnectionIdleTime;
  private final int maxConnectionLifeTime;
  private final int connectTimeout;
  private final int socketTimeout;

  private MongoClientOptions(final Builder builder) {
    maxWaitTime = builder.maxWaitTime;
    maxConnectionIdleTime = builder.maxConnectionIdleTime;
    maxConnectionLifeTime = builder.maxConnectionLifeTime;
    connectTimeout = builder.connectTimeout;
    socketTimeout = builder.socketTimeout;
  }

  // 创建一个生成器对象
  public static Builder builder() {
    return new Builder();
  }


  public static class Builder {

    private int maxWaitTime = 1000 * 60 * 2;
    private int maxConnectionIdleTime = 0;
    private int maxConnectionLifeTime = 0;
    private int connectTimeout = 1000 * 10;
    private int socketTimeout = 0;

    public Builder maxWaitTime(final int maxWaitTime) {
      this.maxWaitTime = maxWaitTime;
      return this;
    }

    public Builder maxConnectionIdleTime(final int maxConnectionIdleTime) {
      this.maxConnectionIdleTime = maxConnectionIdleTime;
      return this;
    }

    public Builder maxConnectionLifeTime(final int maxConnectionLifeTime) {
      this.maxConnectionLifeTime = maxConnectionLifeTime;
      return this;
    }

    public Builder connectTimeout(final int connectTimeout) {
      if (connectTimeout < 0) {
        throw new RuntimeException("connectTimeout must be >= 0");
      }
      this.connectTimeout = connectTimeout;
      return this;
    }

    public Builder socketTimeout(final int socketTimeout) {
      this.socketTimeout = socketTimeout;
      return this;
    }

    // 构建一个最终的mongo客户端选项对象
    public MongoClientOptions build() {
      return new MongoClientOptions(this);
    }
  }
}

接下来,我们演示如何使用生成器来构建一个 MongoClientOptions 对象。使用链式编程的方式,很简单轻松的就构建出我们需要的对象了。

package com.chenpi.builder.mongo;

/**
 * @Description
 * @Author 陈皮
 * @Date 2021/8/8
 * @Version 1.0
 */
public class ChenPiClient {

  public static void main(String[] args) {
    MongoClientOptions mongoClientOptions = MongoClientOptions.builder().connectTimeout(1000)
        .maxConnectionIdleTime(60000)
        .maxConnectionLifeTime(600000).maxWaitTime(1000).socketTimeout(5000).build();
  }
}

本次分享到此结束啦~~?

上一篇:find、filter、map的区别


下一篇:CTF中的命令执行绕过