java构建器模式用法[重复]

Question

最近，我看到一些开发人员使用嵌套的生成器类来编写VO，如

public class User {

    private String firstName;
    private String lastName;

    public String getFirstName() {
        return firstName;
    }

    public void setFirstName(String firstName) {
        this.firstName = firstName;
    }

    public String getLastName() {
        return lastName;
    }

    public void setLastName(String lastName) {
        this.lastName = lastName;
    }

    public static class UserBuilder {

        private String firstName;
        private String lastName;

        public User build() {
            User user = new User();
            user.firstName = firstName;
            user.lastName = lastName;
            return user;
        }

        public UserBuilder withFirstName(String firstName) {
            this.firstName = firstName;
            return this;
        }

        public UserBuilder withLastName(String lastName) {
            this.firstName = firstName;
            return this;
        }       
    }

}

现在，他们声称这使代码更具可读性。我的观点是，这有以下缺点：

>

我不能简单地添加字段并期望我的IDE为我完成代码，因为现在我也需要更新这个内部类。

简单的POJOs携带与VO无关的代码。

如果我在这里遗漏了什么，我会寻求任何建议。请随意添加您的想法。

修改后的示例代码如下所示:

User user = new User.UserBuilder()
                .withFirstName("Name")
                .withLastName("surName")
                .build();

Answer 1

如果所有的属性都是必需的，那么你应该只使用构造函数。通过这样做，你可能会创建一个漂亮的小的不可变对象。

如果有多个可选字段和不同的方法来创建对象，则需要多个构造函数。

public User (int requiredParameter) { ... }
public User (int reqiredParameter, int optionalParameter) { ... }
public User (int reqiredParameter, int optionalParameter, String optionalParameter2) { ... }
public User (int reqiredParameter, String optionalParameter2) { ... }

它创建了混乱的代码。很难确定应该使用哪个构造函数。在这种情况下，您可以使用嵌套生成器以直观的方式创建对象。

Answer 2

恕我直言，在给定的示例中，使用生成器模式不会获得任何值。您可以在没有生成器的情况下创建 User 对象（因为所有设置器）。在这种特殊情况下，构建器为您提供的唯一内容是 Fluent 界面。

当创建有效对象有各种组合时，应使用生成器模式。因此，您不必实现许多构造函数或工厂方法。

当创建一个需要许多参数的有效对象时，生成器也很有帮助。

生成器应该只负责生成有效的对象。在您的情况下，如果User需要具有名字和姓氏，则Builder不应允许创建没有设置这些属性的User实例。

Answer 3

这是Joshua Bloch的一篇文章。他很好地解释了为什么、何时以及如何使用建筑商：http://www.informit.com/articles/article.aspx?p=1216151

这是他的书《有效的Java》中的一个项目。如果你有一点Java的经验，我强烈建议你阅读这本书。

要点：

当你得到一个有很多属性的类时，有几种方法可以创建一个对象并初始化它。

如果你一个接一个地设置每个属性，它可能会很冗长，你的对象可能会在创建后被改变。使用这种方法，不可能使你的类不可变，你也不能确定你的对象处于一致的状态。

文章中的例子：

public class NutritionFacts {
    // Parameters initialized to default values (if any)
    private int servingSize  = -1; // Required; no default value
    private int servings     = -1;  //     "     "      "      "
    private int calories     = 0;
    private int fat          = 0;
    private int sodium       = 0;
    private int carbohydrate = 0;

    public NutritionFacts() { }
    // Setters
    public void setServingSize(int val)  { servingSize = val; }
    public void setServings(int val)     { servings = val; }
    public void setCalories(int val)     { calories = val; }
    public void setFat(int val)          { fat = val; }
    public void setSodium(int val)       { sodium = val; }
    public void setCarbohydrate(int val) { carbohydrate = val; }
}

你可以使用伸缩构造函数。它可以使你的对象不可变。然而，如果你有很多属性，就很难编写和阅读你的代码。更重要的是，当你只想用一个已设置的属性创建时，不幸的是，这个属性是构造函数的最后一个参数，无论如何你都必须设置所有参数。

文章中的例子：

public class NutritionFacts {
    private final int servingSize;  // (mL)            required
    private final int servings;     // (per container) required
    private final int calories;     //                 optional
    private final int fat;          // (g)             optional
    private final int sodium;       // (mg)            optional
    private final int carbohydrate; // (g)             optional

    public NutritionFacts(int servingSize, int servings) {
        this(servingSize, servings, 0);
    }

    public NutritionFacts(int servingSize, int servings,
            int calories) {
        this(servingSize, servings, calories, 0);
    }

    public NutritionFacts(int servingSize, int servings,
            int calories, int fat) {
        this(servingSize, servings, calories, fat, 0);
    }

    public NutritionFacts(int servingSize, int servings,
            int calories, int fat, int sodium) {
        this(servingSize, servings, calories, fat, sodium, 0);
    }

    public NutritionFacts(int servingSize, int servings,
           int calories, int fat, int sodium, int carbohydrate) {
        this.servingSize  = servingSize;
        this.servings     = servings;
        this.calories     = calories;
        this.fat          = fat;
        this.sodium       = sodium;
        this.carbohydrate = carbohydrate;
    }
}

该生成器使您的代码更具可读性，更易于编写。它还允许您使类不可变。

文章中的例子：

public class NutritionFacts {
    private final int servingSize;
    private final int servings;
    private final int calories;
    private final int fat;
    private final int sodium;
    private final int carbohydrate;

    public static class Builder {
        // Required parameters
        private final int servingSize;
        private final int servings;

        // Optional parameters - initialized to default values
        private int calories      = 0;
        private int fat           = 0;
        private int carbohydrate  = 0;
        private int sodium        = 0;

        public Builder(int servingSize, int servings) {
            this.servingSize = servingSize;
            this.servings    = servings;
        }

        public Builder calories(int val)
            { calories = val;      return this; }
        public Builder fat(int val)
            { fat = val;           return this; }
        public Builder carbohydrate(int val)
            { carbohydrate = val;  return this; }
        public Builder sodium(int val)
            { sodium = val;        return this; }

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

    private NutritionFacts(Builder builder) {
        servingSize  = builder.servingSize;
        servings     = builder.servings;
        calories     = builder.calories;
        fat          = builder.fat;
        sodium       = builder.sodium;
        carbohydrate = builder.carbohydrate;
    }
}

在您的示例中，我不确定为只有两个属性的类创建生成器是否非常有用。

希望这能帮到你。