Java Design Parttens - Builder

1、Intent

​ Separate the construction of a complex object from its representation so that the same construction process can create different representations.

​ 通过将对象的构建过程与其表示分离来解决复杂对象的创建问题。它允许你创建具有不同表示形式的对象，而无需更改它们的构建过程。

2、Explanation

2.1 Real-world example

Imagine a character generator for a role-playing game.

想象一下角色扮演游戏的角色生成器。

The easiest option is to let the computer create the character for you.

最简单的方式就是让电脑生成一个角色。

If you want to manually select the character details like profession, gender, hair color, etc. the character generation becomes a step-by-step process that completes when all the selections are ready.

如果想选择角色细节，类似专业，性别等，当配个细节准备好的时候，角色生成器就会一步一步完成角色。

2.2 In plain words

​ Allows you to create different flavors of an object while avoiding constructor pollution. Useful when there could be several flavors of an object. Or when there are a lot of steps involved in creation of an object.

​ 允许创建不同类型的 object，避免污染（过于复杂的过滤器）. 适用于创建不同类型对象或者创建一个对象有很多步。

2.3 Wikipedia says

The builder pattern is an object creation software design pattern with the intentions of finding a solution to the telescoping constructor anti-pattern.

​ “Telescoping constructor anti-pattern” 是指在面向对象编程中，使用过多的构造函数参数来创建一个对象，从而使构造函数参数列表变得过于冗长和难以管理的一种设计反模式。这种情况通常会出现在需要创建多个不同的对象变体，而每个变体需要不同数量或类型的构造函数参数时。

​ Having said that let me add a bit about what telescoping constructor anti-pattern is. At one point or the other, we have all seen a constructor like below :

​ 举个例子

public Hero(Profession profession, String name, HairType hairType, HairColor hairColor, Armor armor, Weapon weapon) {
    
}

​ As you can see the number of constructor parameters can quickly get out of hand, and it may become difficult to understand the arrangement of parameters. Plus this parameter list could keep on growing if you would want to add more options in the future. This is called telescoping constructor anti-pattern.

​ 大概意思就是 参数太多，不容易理解，容易把握不住。

2.4 Programmatic Example

​ 类似下列 Hero 对象创建使用 Builder 模式就是个很好的选择捏

The sane alternative is to use the Builder pattern. First of all, we have our hero that we want to create:

public final class Hero {
    
  private final Profession profession;
  private final String name;
  private final HairType hairType;
  private final HairColor hairColor;
  private final Armor armor;
  private final Weapon weapon;

  private Hero(Builder builder) {
    
    this.profession = builder.profession;
    this.name = builder.name;
    this.hairColor = builder.hairColor;
    this.hairType = builder.hairType;
    this.weapon = builder.weapon;
    this.armor = builder.armor;
  }
}

​ Then we have the builder:

  public static class Builder {
    
    private final Profession profession;
    private final String name;
    private HairType hairType;
    private HairColor hairColor;
    private Armor armor;
    private Weapon weapon;

    public Builder(Profession profession, String name) {
    
      if (profession == null || name == null) {
    
        throw new IllegalArgumentException("profession and name can not be null");
      }
      this.profession = profession;
      this.name = name;
    }

    public Builder withHairType(HairType hairType) {
    
      this.hairType = hairType;
      return this;
    }

    public Builder withHairColor(HairColor hairColor) {
    
      this.hairColor = hairColor;
      return this;
    }

    public Builder withArmor(Armor armor) {
    
      this.armor = armor;
      return this;
    }

    public Builder withWeapon(Weapon weapon) {
    
      this.weapon = weapon;
      return this;
    }

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

​ Then it can be used as:

var mage = new Hero.Builder(Profession.MAGE,"Riobard").withHairColor(HairColor.BLACK).withWeapon(Weapon.DAGGER).build();

3、Class diagram

4、Applicability

​ Use the Builder pattern when

• The algorithm for creating a complex object should be independent of the parts that make up the object and how they’re assembled

​ 将一个复杂对象的构建过程分解成多个简单对象的构建过程，这些简单对象再通过组装起来形成最终的复杂对象

• The construction process must allow different representations for the object that’s constructed

​ 在构建对象的过程中，必须允许为该对象构建不同的表示形式。换句话说，构建过程必须具有足够的灵活性，以便为构建的对象提供多种不同的表现形式，以满足不同的应用场景和需求。

5、自己实现简单的例子

5.1 Object

@Data
public class User {
    
    private String A;
    private String b;
    private String c;
    private String d;
    private String e;

    public User(UserBuilder builder) {
    
        this.A = builder.getA();
        this.b = builder.getB();
        this.c = builder.getC();
        this.d = builder.getD();
        this.e = builder.getE();
    }
}

5.3 builder

@Data
public class UserBuilder {
    

    private String A;
    private String b;
    private String c;
    private String d;
    private String e;

    public UserBuilder buildA(String a) {
    
        A = a;
        return this;
    }

    public UserBuilder buildB(String b) {
    
        this.b = b;
        return this;
    }

    public UserBuilder buildC(String c) {
    
        this.c = c;
        return this;
    }

    public UserBuilder buildD(String d) {
    
        this.d = d;
        return this;
    }

    public UserBuilder buildE(String e) {
    
        this.e = e;
        return this;
    }

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

5.3 test

public class TestUserBuilder {
    

    public static void main(String[] args) {
    
        User user1 = new UserBuilder().buildA("a").buildB("b").buildC("c").build();
        System.out.println(user1);

        User user2 = new UserBuilder().buildC("2 c").buildD("2 d").buildE("2 e").build();
        System.out.println(user2);
    }
}

User(A=a, b=b, c=c, d=null, e=null)
User(A=null, b=null, c=2 c, d=2 d, e=2 e)

6. Spring Security 中的实际应用

​ 在Spring Security 中，有三个 builder 对象 HttpSecurity, WebSecuroty, AuthorizationManager，以下代码所示。他们都继承自 SecurityBuilder<o>。这三个 builder 对象会通过 SecurityConfigurer来对要构建的类进行配置，也就是 buildA("a").buildB("b").buildC("c")这段代码的意思，最后通过 build()方法构建，非常的妙。

public class AuthenticationManagerBuilder
		extends AbstractConfiguredSecurityBuilder<AuthenticationManager, AuthenticationManagerBuilder>
		implements ProviderManagerBuilder<AuthenticationManagerBuilder> {
    

public final class HttpSecurity extends AbstractConfiguredSecurityBuilder<DefaultSecurityFilterChain, HttpSecurity>
		implements SecurityBuilder<DefaultSecurityFilterChain>, HttpSecurityBuilder<HttpSecurity> {
    

public final class WebSecurity extends AbstractConfiguredSecurityBuilder<Filter, WebSecurity>
		implements SecurityBuilder<Filter>, ApplicationContextAware {
    

​ 以下代码大概模拟下

6.1 Builder

​ 顶级接口，只负责构建一个对象， 构建对象类型通过泛型传递。

public interface Builder<O> {
    
    O build();
}

6.2 AbstractBuilder

​ 抽象类，负责实现 Builder 接口，构建出 object对象，并提供对方法，获取构建出的 object对象

​ 具体构建方式由子类实现

public abstract class AbstractBuilder<O> implements Builder<O> {
    

    private O object;

    @Override
    public O build() {
    
        if (null == object) {
    
            return dobuild();
        }
        return object;
    }

    public O getObject() {
    
        return object;
    }

    protected abstract O dobuild();
}

6.3 StepAbstractBuilder

​ AbstractBuilder 的子类，实现了dobuild() 方法，定义出按照步骤去构架对象的具体实现逻辑

​ 自身也是个抽象模板类，先去 config() ，配置所构建对象，当然也可以继续扩充，比如加上 init() 方法，初始化。

​ performBuild() 抽象方法由子类实现，定义做完配置动作之后，如何构建对象。

public abstract class StepAbstractBuilder<O, B extends Builder<O>> extends AbstractBuilder<O> {
    
		
    // 配置对象
    List<Config<O, B>> configs = new ArrayList<>();

    // 模版方法，执行初始化，配置，构建
    @Override
    protected O dobuild() {
    

        // 先配置
        config();
        System.out.println("配置好了" + configs);
				
        O result = performBuild();
        System.out.println("生成了对象" + result.toString());
        return result;
    }
		
    public B addConfig(Config<O, B> config) {
    
        configs.add(config);
        return (B)this;
    }

    private void config() {
    
        for (Config<O, B> config : configs) {
    
            config.config((B)this);
        }
    }

    protected abstract O performBuild();
}

6.4 配置对象

​ 通过 builder 对象实现对被构建对象的配置

​ 泛型 -> <O 被构建对象 , B extends Builder 被构建对象的 builder>

public interface Config<O, B extends Builder<O>> {
    

    // 配置操作
    void config(B builder);
}

6.5 使用方法

6.5.1 构建不同的 House

6.5.1.1 HouseBuilder

​ 继承自 StepAbstractBuilder<House, HouseBuilder>，定义了被构建对象为 House ， 构建逻辑为 HouseBuilder

public class HouseBuilder extends StepAbstractBuilder<House, HouseBuilder> {
    

    // 提供 builder 参数
    private String color;
    private String height;
    private String size;

    @Override
    protected House performBuild() {
    
        return new House(this);
    }

    public HouseBuilder buildColor(String color) {
    
        this.color = color;
        return this;
    }

    public HouseBuilder buildHeight(String height) {
    
        this.height = height;
        return this;
    }

    public HouseBuilder buildSize(String size) {
    
        this.size = size;
        return this;
    }
}

6.5.1.2 HoseConfig

​ HoseConfig 实现 Config 接口，通过 HouseBuilder 来配置 House 对象

public class HoseConfig implements Config<House, HouseBuilder> {
    

    // 提供 builder 参数
    private String color;
    private String height;
    private String size;

    public HoseConfig(String color, String height, String size) {
    
        this.color = color;
        this.height = height;
        this.size = size;
    }

    @Override
    public void config(HouseBuilder builder) {
    
        builder.buildColor(color).buildHeight(height).buildSize(size);
    }
}

6.5.1.3 House

public class House {
    

    public House(HouseBuilder builder) {
    
        this.color = builder.getColor();
        this.height = builder.getHeight();
        this.size = builder.getSize();
    }

    // 提供 builder 参数
    private String color;
    private String height;
    private String size;
}

6.5.1.4 Test

House house1 = new HouseBuilder().addConfig(new HoseConfig("红", "100", "200")).build();
House house2 = new HouseBuilder().addConfig(new HoseConfig("黑", "400", "700")).build();

输出 ->
		配置好了[HoseConfig(color=红, height=100, size=200)]
		生成了对象House(color=红, height=100, size=200)
		配置好了[HoseConfig(color=黑, height=400, size=700)]
		生成了对象House(color=黑, height=400, size=700)
 

6.5.2 构建不同的 Fruit

6.5.2.1 FruitBuilder

@Data
public class FruitBuilder extends StepAbstractBuilder<Fruit, FruitBuilder> {
    

    // 提供 builder 参数
    private String name;
    private String price;

    @Override
    protected Fruit performBuild() {
    
        return new Fruit(this);
    }

    public FruitBuilder buildName(String name) {
    
        this.name = name;
        return this;
    }

    public FruitBuilder buildPrice(String price) {
    
        this.price = price;
        return this;
    }
}

6.5.2.2 FruitConfig

public class FruitConfig implements Config<Fruit, FruitBuilder> {
    

    // 提供 builder 参数
    private String name;
    private String price;

    public FruitConfig(String name, String price) {
    
        this.name = name;
        this.price = price;
    }

    @Override
    public void config(FruitBuilder builder) {
    
        builder.buildName(name).buildPrice(price);
    }
}

6.5.2.3 Fruit

public class Fruit {
    

    public Fruit(FruitBuilder builder) {
    
        this.name = builder.getName();
        this.price = builder.getPrice();
    }

    // 提供 builder 参数
    private String name;
    private String price;
}

Test

Fruit fruit1 = new FruitBuilder().addConfig(new FruitConfig("苹果", "1")).build();
Fruit fruit2 = new FruitBuilder().addConfig(new FruitConfig("梨子", "2")).build();

输出 ->
  	配置好了[FruitConfig(name=苹果, price=1)]
		生成了对象Fruit(name=苹果, price=1)
		配置好了[FruitConfig(name=梨子, price=2)]
		生成了对象Fruit(name=梨子, price=2)