构造者模式多种实现方式

构造者模式

​ 构造者模式建议将对象构造代码从产品类中抽取出来， 并将其放在一个名为构造者的独立对象中

​ 构建者模式也是用来创建对象，但是相对于工厂模式来说，建造者模式适用于构建复杂对象，而工厂模式适用于创建对象的封装和管理，也就是说，构建者模式可以根据个人需求创建对象，根据个人需求决定对对象的某个属性是否进行赋值，以及对对象的某个属性进行不同的赋值，这是和工厂的主要区别

​ 构建者主要分为以下几个对象：

• 抽象构造者（Builder）

package com.lhl.build;

/**
 * 抽象构造者
 * @author Liu Hanlin
 * @create 2024-09-22 23:47
 */
public abstract class Builder {

    // 创建产品
    protected Product product = new Product();

    /**
     * 构建相同部分
     */
    public void buildCommon(){
        this.product.setCommon("构造器设置公共部分");
    }

    /** 可变构造部分 */
    public abstract void buildA();
    public abstract void buildB();

    // 返回对象实例
    public Product getInstance(){
        return this.product;
    }

}

• 具体构造者（ConcreteBuilder）

  • 带指挥者的具体构造者

  package com.lhl.build;
  
  /**
   * 具体构造者
   * @author Liu Hanlin
   * @create 2024-09-22 23:49
   */
  public class ConcreteBuilder extends Builder{
      @Override
      public void buildA() {
          this.product.setPartA("构造器设置部分A");
      }
  
      @Override
      public void buildB() {
          this.product.setPartB("构造器设置部分B");
      }
  }
  

  • 不带指挥者的具体构造者，设置完产品的属性后，继续返回此构造者

  package com.lhl.chainbuild.build;
  
  /**
   * 具体构造者
   * @author 刘翰林
   * @create 2024-09-22 23:49
   */
  public class ChainBuilder extends Builder {
      @Override
      public Builder buildA() {
          this.product.setPartA("构造器设置部分A");
          return this;
      }
  
      @Override
      public Builder buildB() {
          this.product.setPartB("构造器设置部分B");
          return this;
      }
  }
  
  

• 产品（Product）

package com.lhl.build;

/**
 * 产品
 * @author Liu Hanlin
 * @create 2024-09-22 23:47
 */
public class Product {

    /** 产品公共部分 */
    private String common;

    /** 产品部分A */
    private String partA;

    /** 产品部分B */
    private String partB;

    @Override
    public String toString() {
        return "Product{" +
                "common='" + common + '\'' +
                ", partA='" + partA + '\'' +
                ", partB='" + partB + '\'' +
                '}';
    }

    public String getPartA() {
        return partA;
    }

    public void setPartA(String partA) {
        this.partA = partA;
    }

    public String getCommon() {
        return common;
    }

    public void setCommon(String common) {
        this.common = common;
    }

    public String getPartB() {
        return partB;
    }

    public void setPartB(String partB) {
        this.partB = partB;
    }
}

• 指挥者（Director）【可有可无】

package com.lhl.build;

/**
 * 指挥者【不是必须的，可以由我们自己来充当指挥者】
 * @author Liu Hanlin
 * @create 2024-09-22 23:47
 */
public class Director {
    private Builder builder;

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

    public Director(){
    }

    public void setBuilder(Builder builder){
        this.builder = builder;
    }

    /**
     * 组装产品返回
     * @return
     */
    public Product Construct(){
        this.builder.buildCommon();
        this.builder.buildA();
        this.builder.buildB();

        return this.builder.getInstance();
    }
}

​ 如上，我们就完成了构造者模式的带指挥者和不带指挥者的两种类型，我们现在可以进行测试一下

package com.lhl;

import com.lhl.build.ConcreteBuilder;
import com.lhl.build.Director;
import com.lhl.build.Product;
import com.lhl.chainbuild.build.Builder;
import com.lhl.chainbuild.build.ChainBuilder;

/**
 * 构建者模式
 * @author 刘翰林
 * @create 2024-09-20 0:46
 */
public class Main {
    public static void main(String[] args) {

        System.out.println("有指挥者：");
        buildDemo();
        System.out.println("*******************************");
        System.out.println("无指挥者：");
        chainBuildDemo();
    }

    /**
     * 构造者模式链式调用【无指挥者，指挥权交给客户端】构建示例
     */
    public static void chainBuildDemo(){
        Builder builder = new ChainBuilder();
        com.lhl.chainbuild.build.Product instance = builder.buildCommon()
                .buildA()
                .buildB()
                .getInstance();

        System.out.println(instance);
    }

    /**
     * 有指挥者对象的构造器模式示例
     */
    public static void buildDemo(){
        Director director = new Director(new ConcreteBuilder());
        Product construct = director.Construct();

        System.out.println(construct);
    }
}

输出结果如下：可以看到都是可以正常使用的

此外，值得注意的是，我们在导入了Lombok依赖后，可以直接使用@Builder注解帮助我们创建此类的构造者

具体示例如下：

• 导入Lombok依赖

<!-- Lombok -->
    <dependency>
      <groupId>org.projectlombok</groupId>
      <artifactId>lombok</artifactId>
      <version>1.18.24</version> <!-- Use the latest version available -->
    </dependency>

• 定义产品类，给产品类添加build注解

package com.lhl.lombokbuild;

import lombok.Builder;
import lombok.Data;

/**
 * 产品
 * @author Liu Hanlin
 * @create 2024-09-22 23:47
 */
@Data
@Builder
public class Product {

    /** 产品公共部分 */
    private String common;

    /** 产品部分A */
    private String partA;

    /** 产品部分B */
    private String partB;

}

• 添加测试方法，

public static void lombokBuildDemo(){

        ProductBuilder builder = com.lhl.lombokbuild.Product.builder();

        builder.partA("lombokA");
        builder.partB("lombokB");
        builder.common("lombokCommon");
        com.lhl.lombokbuild.Product product = builder.build();

        System.out.println(product);
    }

生成对象正常输出：