建造者设计模式

Question

最近在研究设计模式。我正在努力寻找一个可以为该场景实现构建器模式的场景。有人有例子吗？

任何答案将不胜感激。

Answer 1

SQLOrm 是一个很好的例子，它将构建器模式与一组适当的方法名相结合，从而构建SQL 感觉就像使用 DSL。

例如

private String getPersonAndmaybePet_JavaStr(boolean personName, boolean isAdult, int[] petTypes) {
  StringBuilder sb = new StringBuilder();
  // do SELECT
  sb.append("SELECT ");
  if(personName) 
    sb.append("person.name,");
  if(petTypes != null) 
    sb.append("pet.*,");

  // do FROM
  sb.delete(sb.length() - 1, sb.length()); // remove last comma
  sb.append(" FROM person,");
  if(petTypes != null) 
    sb.append(" Pet,");

  // do WHERE
  sb.delete(sb.length() - 1, sb.length()); // remove last comma
  sb.append(" WHERE ");
  if(isAdult) 
    sb.append(" person.age >= 18");
  else 
    sb.append(" person.age < 18");

  if(petTypes != null) {
    StringBuilder commaList = new StringBuilder();
    for(int id : petTypes) {
        commaList.append(id);
        commaList.append(",");
    }
    commaList.delete(commaList.length() - 1, commaList.length());
    sb.append(" AND person.pet_id = pet.id AND pet.pettype IN (" + commaList.toString() + ")");
  }
  return sb.toString();
}

变成

private String getPersonAndmaybePet(boolean personName, boolean isAdult, int[] petTypes) {
  SelectBuilder qry = new SelectBuilder();

  if(personName) 
    qry.select("person.name").from("person");    

  if(isAdult) 
    qry.from("person").where().and("person.age >= 18");
  else 
    qry.from("person").where().and("person.age < 18");

  if(petTypes != null) {
    qry.select("pet.*").from("Pet") //
            .where() //
            .and("person.pet_id = pet.id") //
            .and("pet.pettype IN (#)", QueryBuilderHelper.numbers(petTypes));
  }
  return qry.toSql();
}

Answer 2

如果您有一个非常复杂的对象（例如需要 3、4 个或更多不同的其他对象才能操作），您将使用 Builder 来正确构造该对象。

Answer 3

我喜欢在这里引用 Joshua Bloch 和他的书 Effective Java。

在设计类时，构建器模式是一个不错的选择
构造函数或静态工厂将有多个
参数。

您肯定会遇到像这样的伸缩构造函数：

Pizza(int size) { ... }        
Pizza(int size, boolean cheese) { ... }    
Pizza(int size, boolean cheese, boolean pepperoni) { ... }    
Pizza(int size, boolean cheese, boolean pepperoni, boolean bacon) { ... }

它的问题是，在某些时候，很难记住所需参数的正确顺序以及所有构造函数之间的关系。

作为替代方案（还不是构建器），您可以在此处执行经典的 POJO ：

Pizza pizza = new Pizza(10);
pizza.setCheese(true);
pizza.setPepperoni(true);
pizza.setBacon(true);

但是，它不被认为是线程安全的。

怎么解决呢？是的，构建器模式。考虑一下：

public class Pizza {
  private int size;
  private boolean cheese;
  private boolean pepperoni;
  private boolean bacon;

  public static class Builder {
    //required
    private final int size;

    //optional
    private boolean cheese = false;
    private boolean pepperoni = false;
    private boolean bacon = false;

    public Builder(int size) {
      this.size = size;
    }

    public Builder cheese(boolean value) {
      cheese = value;
      return this;
    }

    public Builder pepperoni(boolean value) {
      pepperoni = value;
      return this;
    }

    public Builder bacon(boolean value) {
      bacon = value;
      return this;
    }

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

  private Pizza(Builder builder) {
    size = builder.size;
    cheese = builder.cheese;
    pepperoni = builder.pepperoni;
    bacon = builder.bacon;
  }
}

您现在将创建的 Pizza 实例将是不可变的，并且它的构建将是简单而简洁的。

Pizza pizza = new Pizza.Builder(12)
                       .cheese(true)
                       .pepperoni(true)
                       .bacon(true)
                       .build();

查看更多 Java Builder 模式示例。

Answer 4

构建器模式通常用于构造 HTML 和 XML 文档。例子：

require 'markaby' # Markaby is an HTML builder library for Ruby

builder = Markaby::Builder.new

builder.html {
  head {
    title 'Sample Title'
    link href: 'style.css', rel: 'stylesheet'
  }

  body {
    h1 'Sample Title'
    ul {
      li 'Item 1'
      li 'Item 2'
    }
  }
}

print builder

Answer 5

当面临许多构造函数参数时，请考虑使用构建器。以下链接详细解释也将消除所有疑虑。

http://www.drdobbs.com /jvm/creating-and-destroying-java-objects-par/208403883?pgno=2

简而言之，当构造函数参数很多而不是记住每个参数的顺序和含义时；构建器模式可用于简化参数传递，从而简化编程、提高可读性、增强参数按预期传递的信心。