标签: builder-pattern

这可能是一个非常主观的问题,但我想知道一些更多的意见.我用Spring MVC构建了一个Rest API服务,并实现了DTO-Domain-Entity模式.我想知道你对在DTO中实现Builder模式有什么看法,比如说

public class UserResponseDTO
    extends AbstractResponseDTO {

    private String username;
    private Boolean enabled;

    public UserResponseDTO(String username, Boolean enabled) {
        this.username = username;
        this.enabled = enabled;
    }

    public String getUsername() {
        return this.username;
    }

    public Boolean getEnabled() {
        return this.enabled;
    }

    public static class Builder {

        private String username;
        private Boolean enabled;

        public void setUsername(String username) {
            this.username = username;
        }

        public void setEnabled(Boolean enabled) {
            this.enabled = enabled;
        }

        public UserResponseDTO build(){
            return new UserResponseDTO(username, enabled); …

为什么我们不能在构造函数本身内构建不同的构建步骤.如果构建步骤采用参数,为什么它们不能作为构造函数的参数提供,并在构造函数中用于创建对象.

AFAIK,在Builder模式中,客户端要创建的特定对象; 那么在创建Class的对象中使用构建器而不是带有参数的构造函数有什么好处？

让我们假设一个使用构建器模式构造的对象.

此构建器模式将包含一个build侧重于字段验证然后转换为目标类型的方法.

可以使用以下方式实现此验证:

• Either[FailureObject, TargetObject] 类型
• Try[TargetObject] (Scala 2.10的新功能)
• Validation[FailureObject, TargetObject]或者ValidationNEL[FailureObject, TargetObject]来自scalaz图书馆

我读到Validation过度Either类型的一个主要优点是Validation可以"开箱即用"累积故障.

但那"新" Try方式呢？我注意到,Try有"一元"的方法开箱也是一样的map,flatMap等...什么是真正与任何一种类型的不帮助失踪Projection.

因此,我想象每个字段验证方法返回a Try[FieldType],更确切地说,在任何失败的情况下,a Try[SpecificFieldExceptionType]; 这个嵌套的包含String消息字段和rootCause字段,可以在整个build方法中累积.

使用Scala 2.10,可以或应该Try练习替换scalaz验证库以进行简单验证,例如构建器模式涉及吗？

**编辑****

通过阅读Try源代码,它听起来Try不能累积多个异常,因此面向失败快速.甚至Try.flatMap返回可能的先前失败,因此没有积累的概念:

def flatMap[U](f: T => Try[U]): Try[U] = this.asInstanceOf[Try[U]]

相反ValidationNEL,处理累积功能.

任何确认？

我正在学习Builder模式

在上面的链接(Java示例)中,我注意到Builder提供了构造多个组件的接口.除了调用它们之外,我们还调用了getProduct().

我不明白的一点是,为什么Director需要逐个调用所有这些组件构造方法并最终获得结果.

     /** "Director" */
 class Waiter {
    private PizzaBuilder pizzaBuilder;


public void setPizzaBuilder(PizzaBuilder pb) { pizzaBuilder = pb; }
public Pizza getPizza() { return pizzaBuilder.getPizza(); }

public void constructPizza() {
   pizzaBuilder.createNewPizzaProduct(); 
   pizzaBuilder.buildDough(); // construct component 1
   pizzaBuilder.buildSauce(); // construct component 2
   pizzaBuilder.buildTopping();  // construct component 3
}

}

为什么我们不在ConcreteBuilder类中包含构造组件1,2,3的代码,而不是在Director中,实际上消除了Director层.

我知道上述方法可能会将Builder模式转变为其他方式,但我不明白为什么Director会逐步完成工作.有什么好处？如果有多个导演,会有重复的代码,对吧？我可能不理解执行Builder模式背后的动机......

更新:Builder模式是否专注于在创建更大的复杂对象时提供可自定义组件选择？否则,截至目前,我没有看到引入额外层的重点,即主任.

即使是这种情况,Decorator模式也可能是通过动态定制组件来实现相同目标.在某处,我错过了Builder背后的那一点...... :(

我正在阅读Effective Java书籍,并为我将来的参考创建笔记,我遇到了Builder Pattern.

好吧,我明白它是什么以及如何使用它.在这个过程中,我创建了两个构建器模式的示例变体.

我需要帮助列出每个人的差异和优势吗？我当然注意到,Example 1暴露较少的方法,通过较少的限制和更通用,允许它更灵活地使用.

请指出我错过的其他事情？

例1

package item2;

/**
 * @author Sudhakar Duraiswamy
 *
 */
public  class Vehicle {

    private String type;
    private int wheels;

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

    public static class CarBuilder implements Builder<Vehicle>{
        private String type;
        private int wheels;     

        CarBuilder createVehicle(){
            this.type= "Car";
            return this;
        }

        CarBuilder addWheels(int wheels){
            this.wheels = wheels;
            return this;
        }

        public Vehicle build(){
            Vehicle v = new Vehicle();
            v.type = type;
            v.wheels = wheels;
            return v;
        } …

使用Builder Pattern时为什么不重用builder-object来访问对象配置？例如:

正常方式:

ObjectA(ObjectBuilder b) {
    this.a = b.getA();
}
public Object getA(){
    return this.a;
}

但为什么我不能只使用它:

ObjectA(ObjectBuilder b) {
    this.builder = b;
}
public Object getA(){
    return this.builder.getA();
}

谢谢 :)

让我们说我有一个复合设置如下:

public abstract class Element {
    //position, size, etc.

    //element methods

    //setters/getters
}

public class SimpleElement1 extends Element {
    //...
}

public class SimpleElement2 extends Element {
   //...
}

public class CompositeElement extends Element {
     protected List<Element> childrenElements;

     //methods to add/remove/get children
}

现在,我将如何将这个Composite包装到Builder模式中,这样我就可以简化客户端代码,使其不关心(或者更少关心)如何将子项链接到Composite上的复杂性？

我正在尝试为我的班级使用 Builder Pattern..

下面是我按照 Joshua Bloch 在 Effective Java, 2nd Edition 中展示的版本构建的 Builder 类。我们的客户大多会通过userId，clientId但其他字段是可选的，他们可能会也可能不会通过。这里 Preference 是一个包含四个字段的 ENUM 类。

public final class InputKeys {

    private long userid;
    private long clientid;
    private long timeout = 500L;
    private Preference pref;
    private boolean debug;
    private Map<String, String> parameterMap;

    private InputKeys(Builder builder) {
        this.userid = builder.userId;
        this.clientid = builder.clientId;
        this.pref = builder.preference;
        this.parameterMap = builder.parameterMap;
        this.timeout = builder.timeout;
        this.debug = builder.debug;
    }

    public static class Builder {
        protected final long userId; …

建造者模式的定义： 建造者模式将复杂对象的规范与其实际构造分开。相同的构建过程可以创建不同的表示。

好吧，我有一个像这样的 Builder Pattern 代码示例

class Director
    {
        // Build a Product from several parts
        public void Construct(IBuilder builder)
        {
            builder.BuildPartA();
            builder.BuildPartB();
            builder.BuildPartB();
        }
    }

    interface IBuilder
    {
        void BuildPartA();
        void BuildPartB();
        Product GetResult();
    }

    class Builder1 : IBuilder
    {
        private Product product = new Product();
        public void BuildPartA()
        {
            product.Add("PartA ");
        }

        public void BuildPartB()
        {
            product.Add("PartB ");
        }

        public Product GetResult()
        {
            return product;
        }
    }

    class Builder2 : IBuilder
    {
        private Product product = new Product(); …

我有一个 Kotlin 数据类，我正在使用许多不可变属性构建它，这些属性是从单独的 SQL 查询中获取的。如果我想使用构建器模式构造数据类，如何在不使这些属性可变的情况下执行此操作？

例如，而不是通过构建

var data = MyData(val1, val2, val3)

我想用

builder.someVal(val1)
// compute val2
builder.someOtherVal(val2)
// ... 
var data = builder.build()

同时仍然使用 Kotlin 的数据类功能和不可变属性。