标签: builder-pattern

我已经创建了一个数据构建器,以便在我的单元测试中创建测试数据.我的数据构建器为所有属性创建默认值,以便使用它们的测试只需指定适用于测试的属性.

请考虑以下构建器:

public class CustomerBuilder
{
    public int id = 0;
    public Order order = new OrderBuilder().Build();

    public CustomerBuilder WithId(int id)
    {
        this.id = id;
        return this;
    }

    public CustomerBuilder WithOrder(Order order)
    {
        this.order = order;
        return this;
    }

    public Customer Build()
    {
        return new Customer(id, order);
    }
}

通过这样做,如果我需要在测试中创建一个客户,其中id对我很重要但订单无关紧要,我可以按如下方式创建对象:

Customer c = new CustomerBuilder()
                  .WithId(99)
                  .Build();

这是一个好主意吗？或者,为什么不应该假设应该如何构建非原始属性？

我只是在研究Builder模式,并不理解Director的观点.

http://en.wikipedia.org/wiki/Builder_pattern

不只是让Builder和他们的子类足够吗？

谢谢

我有一个像这样复杂的业务对象

public class BusinessObject {

    public Team1Object object1;
    public Team2Object object2;
    public String debug;
    ...

}

我使用责任链模式的轻微修改来构建上述对象。

这是我的界面

public interface BusinessObjectAppender {

    public void append(BusinessObjectBuilder businessObject, Context someApplicationContext);

}

现在团队可以来编写他们的附加程序。像这样

public class Team1ObjectAppender implements BusinessObjectAppender {

    public void append(BusinessObjectBuilder businessObject, Context someApplicationContext) {
        Team1Object object1 = somehowComputeObject1();
        businessObject.object1(object1)
    }
}

public class Team2Appender implements BusinessObjectAppender {

    public void append(BusinessObjectBuilder businessObject, Context someApplicationContext) {
        Team2Object object2 = somehowComputeObject2();
        businessObject.object2(object2)
    }
}

通过使用这种方法，在复杂的对象构造的情况下，逻辑不会膨胀。

但它也存在这样的问题

1. Team1 周围没有任何护栏，不会干扰另一个团队的对象或依赖另一个团队的数据。除了代码审查之外。

2. BusinessObject 是多态的情况下，一旦我创建了 1 种类型的构建器，就不可能在附加程序中更改它。

问题

1. 这是正确的做法吗？ …

我知道很多次都会问这个问题,但我只是想澄清一下这个问题.构建器模式可以替换工厂模式.

是构建器模式逐步创建并返回复杂对象,这也可以在工厂模式中完成.

我正在阅读有关构建器模式的内容，并且像往常一样我对工厂模式感到困惑。

我看过一篇很好的文章，它展示了抽象工厂和构建器模式之间的区别。

http://champika-nirosh.blogspot.in/2008/04/what-is-difference- Between-abstract.html

但我的困惑是，除了类似于抽象工厂的构建器模式之外，我觉得它还类似于工厂方法模式。不确定我的理解是否正确。但在工厂方法中，我们也使用一个单独的工厂（具体工厂中的方法）来创建一个特定的对象（而不是一系列产品）。在这种情况下，构建器与工厂方法模式有何不同。我知道 Builder 需要更多步骤来创建对象，除此之外，是否有任何特定场景需要我们使用一个而不是另一个？请指导我。

谢谢。

我有一个下面的构建器类，我从多线程应用程序中使用它，所以我使它成为线程安全的。为简单起见，我在这里只展示了几个字段来演示这个问题。

public final class ClientKey {
  private final long userId;
  private final int clientId;
  private final String processName;
  private final Map<String, String> parameterMap;

  private ClientKey(Builder builder) {
    this.userId = builder.userId;
    this.clientId = builder.clientId;
    this.processName = builder.processName;
    // initializing the required fields
    // and below line throws exception once I try to clone the `ClientKey` object
    builder.parameterMap.put("is_clientid", (clientId == 0) ? "false" : "true");
    this.parameterMap = builder.parameterMap.build();
  }

  public static class Builder {
    private final long userId;
    private final int clientId; …

我正在尝试通过继承支持构建器模式，以允许父级和子级的设置链没有问题。为此，我需要父类知道返回子类型，以使所有方法公开以进行链接。

这是我在本文之后编写的代码示例，我认为它应该可以工作。但是，正如您将看到的，使用a1的第一个示例可以正常工作，但是如果我更改设置器的顺序，则无法识别最后一个设置器。

问题是：一旦我从父类中调用了一个方法，它将以类型而不是子类型返回自身，即使认为T被定义为子类型。

public class JavaApplication1 {

    /**
     * @param args the command line arguments
     */
    public static void main(String[] args) {
        // TODO code application logic here

        A a1 = new B<>().setAge(0).setId(0).setName("name"); //Works fine
        A a2 = new B<>().setAge(0).setName("name").setId(0); //setId is not found

    }

    static class A<T extends A> {
        private String mpName;

        T setName(String name) {
            mpName = name;
            return (T) this;       
        }
    }

    static class B<T extends B> extends A<T> {
        private int mpAge;
        private …

我想在Kotlin中改进此代码，似乎太多余了

.forEach和Lambda可以实现，但我不知道有人能帮忙吗？

val Point1 : List<Double> = topleft
                .split(",")
                .map {
                    it
                            .trim()
                            .toDouble()
                }
        val Point2 : List<Double> = topright
                .split(",")
                .map {
                    it
                            .trim()
                            .toDouble()
                }
        val Point3 : List<Double> = bottomright
                .split(",")
                .map {
                    it
                            .trim()
                            .toDouble()
                }
        val Point4 : List<Double> = bottomleft
                .split(",")
                .map {
                    it
                            .trim()
                            .toDouble()
                }

最后，我想拥有一个包含所有这些值的清单。topleft，topright ...是类似42.1234,54.23423
（地理坐标）的字符串

这不是一个难题.我只是想知道你认为这两个C++代码片段中的哪一个更好(可读性与长度对比锅炉):

选项1

Entity* square = Entity::Builder().positionX(0.0).positionY(0.0).
    controller(ctrl).representation(rep).build();

选项#2

Entity::Builder bld;
bld.positionX(0.0).positionY(0.0).controller(ctrl).representation(rep);
Entity* square = bld.build();

我个人更喜欢第一个选项,但这可能是因为我是代码的作者并且已经知道代码的作用(对于不了解代码的人来说可能会让人感到困惑).我更喜欢它,因为它显示了Entity对象而不是对象的焦点Entity::Builder(因为它更短).

我有一个构建器模式，在该模式中，很可能所有参数都是必需的，因此我创建了一个长的构造函数，如下代码所示。

public final class ResponseHolder {

    // all below six are related to response information
    private final String response;
    private final boolean isLinking;
    private final TypeHold typeOfId;
    private final long userTimeInMs;
    private final long userLmdInDays;
    private final String maskInfo;

    // below two are related to error handling
    private final ErrorCode error;
    private final StatusCode status;

    private ResponseHolder(Builder builder) {
        this.response = builder.response;
        this.isLinking = builder.isLinking;
        this.typeOfId = builder.typeOfId;
        this.userTimeInMs = builder.userTimeInMs;
        this.userLmdInDays = builder.userLmdInDays;
        this.maskInfo = builder.maskInfo;
        this.error = builder.error; …

基于以下示例,可以在Rust中使用链式方法调用编写构建模式,该方法调用通过值或通过引用传递(使用生命周期说明符)

• 是否可以创建一个宏来实现构建器模式方法？
• 如何重载"新"方法？(回答)
• https://github.com/rust-unofficial/patterns/blob/master/patterns/builder.md

Rust中的构建器模式可能如下所示:

 ui::Button::new()
    .label("Test")
    .align(Align::Center)
    .build();

在写作惯用的Rust时,有一种强烈的偏好吗？

有没有一个很好的例子,如何在Rust中写这个？

实际上，我想问一下我的方法是否正确，因为也许我不应该在这里使用构建器模式。

我目前有以下课程CsvItem：

public class CsvItem {
    private CsvItemGroup group;
    private CsvItemEntity entity;
    private String att1;
    private String att2;
    private String att3;
    private String att4;
    private String att5;
    private String att6;
    private String att7;
    private String att8;

    CsvItem(
            CsvItemGroup group,
            CsvItemEntity entity,
            String att1,
            String att2,
            String att3,
            String att4,
            String att5,
            String att6,
            String att7,
            String att8) {

        this.group = group;
        this.entity = entity;
        this.att1 = att1;
        this.att2 = att2;
        this.att3 = att3;
        this.att4 = att4;
        this.att5 = …