多态对象层次结构的构建器模式：Java可能吗？

时间：2012-02-04 02:57:41

标签： java design-patterns builder

我有一个接口层次结构，Child实现Parent。我想使用不可变对象，所以我想设计Builder类，方便地构造这些对象。但是，我有许多Child接口，我不想重复在每种类型的子构建器中构建Parent的代码。

因此，假设以下定义：

public interface Parent {
    public Long getParentProperty();
}

public interface Child1 extends Parent {
    public Integer getChild1Property(); 
}

public interface Child2 extends Parent {
    public String getChild2PropertyA();
    public Object getChild2PropertyB();
}

如何有效地实施构建器Child1Builder和Child2Builder？他们应该支持以下操作：

Child1 child1 = Child1Builder.newChild1().withChild1Property(5).withParentProperty(10L);

和

Child2 child2 = Child2Builder.newChild2().withChild2PropertyA("Hello").withParentProperty(10L).withChild2PropertyB(new Object());

我不想为每个子构建器实现withParentProperty的特殊情况。

编辑将第二个属性添加到Child2以澄清这不能用简单的泛型来完成。我不是在寻找一种方法来组合Child1和Child2 - 我正在寻找一种方法来实现一个Builder系统，它不会为每个孩子重复构建父类的工作类。

感谢您的帮助！

6 个答案:

答案 0 :(得分：21)

我想象的解决方案就像Curiously Recurring Template Pattern或 CRTP 。您可以定义一个基类来处理与父相关的初始化，但您仍然可能会发现两个样板getParent()和getThis()方法在每个派生的与子相关的构建器类中重复过多。

看看：

abstract class ParentBase implements Parent
{
  @Override
  public final Long getParentProperty()
  {
      return parentProperty_;
  }


  protected void setParentProperty(Long value)
  {
      parentProperty_ = value;
  }


  private Long parentProperty_;
}


abstract class ParentBuilder<T extends ParentBuilder<T>>
{
  T withParentProperty(Long value)
  {
      getParent().setParentProperty(value);
      return getThis();
  }


  protected abstract ParentBase getParent();


  protected abstract T getThis();
}


final class ConcreteChild1 extends ParentBase implements Child1
{
  @Override
  public Integer getChild1Property()
  {
      return childProperty_;
  }


  public void setChild1Property(Integer value)
  {
      childProperty_ = value;
  }


  private Integer childProperty_;
}


final class Child1Builder extends ParentBuilder<Child1Builder>
{
  public Child1Builder()
  {
     pending_ = new ConcreteChild1();
  }


  public Child1Builder withChild1Property(Integer value)
  {
      pending_.setChild1Property(value);
      return this;
  }


  @Override
  protected ParentBase getParent()
  {
      return pending_;
  }


  @Override
  protected Child1Builder getThis()
  {
      return this;
  }


  private final ConcreteChild1 pending_;
}

如您所见，ParentBuilder类型希望与派生类型协作以允许它返回正确类型的实例。它自己的this引用不会到期，因为this中ParentBuilder的类型当然是ParentBuilder，而不是Child1Builder旨在维持“流畅”的电话链。

我欠Angelika Langer's tutorial entry的“getThis()技巧”。

答案 1 :(得分：8)

如果您愿意接受getParent()方法从“最年轻”到“最老”的限制，我认为getThis()和withXXXProperty()是不必要的： 

class Parent
{
    private final long parentProperty;

    public long getParentProperty()
    {
        return parentProperty;
    }

    public static abstract class Builder<T extends Parent>
    {
        private long parentProperty;

        public Builder<T> withParentProperty( long parentProperty )
        {
            this.parentProperty = parentProperty;
            return this;
        }

        public abstract T build();
    }

    public static Builder<?> builder()
    {
        return new Builder<Parent>()
        {
            @Override
            public Parent build()
            {
                return new Parent(this);
            }
        };
    }

    protected Parent( Builder<?> builder )
    {
        this.parentProperty = builder.parentProperty;
    }
}

class Child1 extends Parent
{
    private final int child1Property;

    public int getChild1Property()
    {
        return child1Property;
    }

    public static abstract class Builder<T extends Child1> extends Parent.Builder<T>
    {
        private int child1Property;

        public Builder<T> withChild1Property( int child1Property )
        {
            this.child1Property = child1Property;
            return this;
        }

        public abstract T build();
    }

    public static Builder<?> builder()
    {
        return new Builder<Child1>()
        {
            @Override
            public Child1 build()
            {
                return new Child1(this);
            }
        };
    }

    protected Child1( Builder<?> builder )
    {
        super(builder);
        this.child1Property = builder.child1Property;
    }

}

class Child2 extends Parent
{

    private final String child2PropertyA;
    private final Object child2PropertyB;

    public String getChild2PropertyA()
    {
        return child2PropertyA;
    }

    public Object getChild2PropertyB()
    {
        return child2PropertyB;
    }

    public static abstract class Builder<T extends Child2> extends Parent.Builder<T>
    {
        private String child2PropertyA;
        private Object child2PropertyB;

        public Builder<T> withChild2PropertyA( String child2PropertyA )
        {
            this.child2PropertyA = child2PropertyA;
            return this;
        }

        public Builder<T> withChild2PropertyB( Object child2PropertyB )
        {
            this.child2PropertyB = child2PropertyB;
            return this;
        }
    }

    public static Builder<?> builder()
    {
        return new Builder<Child2>()
        {
            @Override
            public Child2 build()
            {
                return new Child2(this);
            }
        };
    }

    protected Child2( Builder<?> builder )
    {
        super(builder);
        this.child2PropertyA = builder.child2PropertyA;
        this.child2PropertyB = builder.child2PropertyB;
    }
}

class BuilderTest
{
    public static void main( String[] args )
    {
        Child1 child1 = Child1.builder()
                .withChild1Property(-3)
                .withParentProperty(5L)
                .build();

        Child2 grandchild = Child2.builder()
                .withChild2PropertyA("hello")
                .withChild2PropertyB(new Object())
                .withParentProperty(10L)
                .build();
    }
}

这里还有一些样板：每个Builder方法中的匿名具体builder()和每个构造函数中的super()调用。 （注意：假设每个级别都是为了进一步继承而设计的。如果在任何时候你有一个final后代，你可以使构建器类具体化，构造函数变为私有。）

但我认为这个版本更容易理解，对于下一个程序员来说，他必须维护你的代码（对于初学者来说，没有自我引用的泛型; Builder<X>构建Xs）。恕我直言，要求在父属性之前在构建器上设置子属性在一致性方面同样具有优势，因为它在灵活性方面是不利的。

答案 2 :(得分：1)

也许这样没有建设者？：

interface P {
    public Long getParentProperty();
}
interface C1 extends P {
    public Integer getChild1Property();
}
interface C2 extends P {
    public String getChild2PropertyA();
    public Object getChild2PropertyB();
}
abstract class PABC implements P {
    @Override public final Long getParentProperty() {
        return parentLong;
    }
    protected Long parentLong;
    protected PABC setParentProperty(Long value) {
        parentLong = value;
        return this;
    }
}
final class C1Impl extends PABC implements C1 {
    protected C1Impl setParentProperty(Long value) {
        super.setParentProperty(value);
        return this;
    }
    @Override public Integer getChild1Property() {
        return n;
    }
    public C1Impl setChild1Property(Integer value) {
        n = value;
        return this;
    }
    private Integer n;
}
final class C2Impl extends PABC implements C2 {
    private String string;
    private Object object;

    protected C2Impl setParentProperty(Long value) {
        super.setParentProperty(value);
        return this;
    }
    @Override public String getChild2PropertyA() {
    return string;
    }

    @Override public Object getChild2PropertyB() {
        return object;
    }
    C2Impl setChild2PropertyA(String string) {
        this.string=string;
        return this;
    }
    C2Impl setChild2PropertyB(Object o) {
        this.object=o;
        return this;
    }
}
public class Myso9138027 {
    public static void main(String[] args) {
        C1Impl c1 = new C1Impl().setChild1Property(5).setParentProperty(10L);
        C2Impl c2 = new C2Impl().setChild2PropertyA("Hello").setParentProperty(10L).setChild2PropertyB(new Object());
    }
}

答案 3 :(得分：0)

使用泛型，如下所示：

public interface Parent {
    public Long getParentProperty();
}

public interface Child<T> {
    public T getChildProperty(); 
}

然后使用Child<Integer>代替Child1，而不是Child2，使用Child<String>。

答案 4 :(得分：0)

package so9138027take2;
import java.util.*;
import so9138027take2.C2.Names;
interface P {
    public Object getParentProperty(Names name);
    enum Names {
        i(Integer.class), d(Double.class), s(String.class);
        Names(Class<?> clazz) {
            this.clazz = clazz;
        }
        final Class<?> clazz;
    }
}
interface C1 extends P {
    public Object getChildProperty(Names name);
    enum Names {
        a(Integer.class), b(Double.class), c(String.class);
        Names(Class<?> clazz) {
            this.clazz = clazz;
        }
        final Class<?> clazz;
    }
}
interface C2 extends P {
    public Object getChildProperty(Names name);
    enum Names {
        x(Integer.class), y(Double.class), z(String.class);
        Names(Class<?> clazz) {
            this.clazz = clazz;
        }
        final Class<?> clazz;
    }
}
abstract class PABCImmutable implements P {
    public PABCImmutable(PABC parent) {
        parentNameToValue = Collections.unmodifiableMap(parent.parentNameToValue);
    }
    @Override public final Object getParentProperty(Names name) {
        return parentNameToValue.get(name);
    }
    public String toString() {
        return parentNameToValue.toString();
    }
    final Map<Names, Object> parentNameToValue;
}
abstract class PABC implements P {
    @Override public final Object getParentProperty(Names name) {
        return parentNameToValue.get(name);
    }
    protected PABC setParentProperty(Names name, Object value) {
        if (name.clazz.isInstance(value)) parentNameToValue.put(name, value);
        else
            throw new RuntimeException("value is not valid for " + name);
        return this;
    }
    public String toString() {
        return parentNameToValue.toString();
    }
    EnumMap<Names, Object> parentNameToValue = new EnumMap<Names, Object>(P.Names.class);
}
final class C1Immutable extends PABCImmutable implements C1 {
    public C1Immutable(C1Impl c1) {
        super(c1);
        nameToValue =  Collections.unmodifiableMap(c1.nameToValue);
    }
    @Override public Object getChildProperty(C1.Names name) {
        return nameToValue.get(name);
    }
    public String toString() {
        return super.toString() + nameToValue.toString();
    }
    final Map<C1.Names, Object> nameToValue;
}
final class C1Impl extends PABC implements C1 {
    @Override public Object getChildProperty(C1.Names name) {
        return nameToValue.get(name);
    }
    public Object setChildProperty(C1.Names name, Object value) {
        if (name.clazz.isInstance(value)) nameToValue.put(name, value);
        else
            throw new RuntimeException("value is not valid for " + name);
        return this;
    }
    public String toString() {
        return super.toString() + nameToValue.toString();
    }
    EnumMap<C1.Names, Object> nameToValue = new EnumMap<C1.Names, Object>(C1.Names.class);
}
final class C2Immutable extends PABCImmutable implements C2 {
    public C2Immutable(C2Impl c2) {
        super(c2);
        this.nameToValue = Collections.unmodifiableMap(c2.nameToValue);
    }
    @Override public Object getChildProperty(C2.Names name) {
        return nameToValue.get(name);
    }
    public String toString() {
        return super.toString() + nameToValue.toString();
    }
    final Map<C2.Names, Object> nameToValue;
}
final class C2Impl extends PABC implements C2 {
    @Override public Object getChildProperty(C2.Names name) {
        return nameToValue.get(name);
    }
    public Object setChildProperty(C2.Names name, Object value) {
        if (name.clazz.isInstance(value)) {
            nameToValue.put(name, value);
        } else {
            System.out.println("name=" + name + ", value=" + value);
            throw new RuntimeException("value is not valid for " + name);
        }
        return this;
    }
    public String toString() {
        return super.toString() + nameToValue.toString();
    }
    EnumMap<C2.Names, Object> nameToValue = new EnumMap<C2.Names, Object>(C2.Names.class);
}
public class So9138027take2 {
    public static void main(String[] args) {
        Object[] parentValues = new Object[] { 1, 2., "foo" };
        C1Impl c1 = new C1Impl();
        Object[] c1Values = new Object[] { 3, 4., "bar" };
        for (P.Names name : P.Names.values())
            c1.setParentProperty(name, parentValues[name.ordinal()]);
        for (C1.Names name : C1.Names.values())
            c1.setChildProperty(name, c1Values[name.ordinal()]);
        C2Impl c2 = new C2Impl();
        Object[] c2Values = new Object[] { 5, 6., "baz" };
        for (P.Names name : P.Names.values())
            c2.setParentProperty(name, parentValues[name.ordinal()]);
        for (C2.Names name : C2.Names.values())
            c2.setChildProperty(name, c2Values[name.ordinal()]);
        C1 immutableC1 = new C1Immutable(c1);
        System.out.println("child 1: "+immutableC1);
        C2 immutableC2 = new C2Immutable(c2);
        System.out.println("child 2: "+immutableC2);
    }
}

答案 5 :(得分：0)

这是使用泛型的解决方案。

(\W)
public abstract class ParentBuilder<T extends ParentBuilder<T>> {
    private long parentProperty;

    protected abstract T self();

    public T withParentProperty(long parentProperty) {
        this.parentProperty = parentProperty;
        return self();
    }

    protected static class SimpleParent implements Parent {
        private long parentProperty;

        public SimpleParent(ParentBuilder<?> builder) {
            this.parentProperty = builder.parentProperty;
        }

        @Override
        public Long getParentProperty() {
            return parentProperty;
        }
    }
}

public final class Child1Builder extends ParentBuilder<Child1Builder> {
    private int child1Property;

    private Child1Builder() {}

    public static Child1Builder newChild1() {
        return new Child1Builder();
    }

    @Override
    protected Child1Builder self() {
        return this;
    }

    public Child1Builder withChild1Property(int child1Property) {
        this.child1Property = child1Property;
        return self();
    }

    public Child1 build() {
        return new SimpleChild1(this);
    }

    private final class SimpleChild1 extends SimpleParent implements Child1 {
        private int child1Property;

        public SimpleChild1(Child1Builder builder) {
            super(builder);
            this.child1Property = builder.child1Property;
        }

        @Override
        public Integer getChild1Property() {
            return child1Property;
        }
    }
}

对于较大的层次结构或具体类不只是叶子的类，有必要将上述具体构建器的一部分提取到中间抽象类中。例如，public final class Child2Builder extends ParentBuilder<Child2Builder> { private String child2propertyA; private Object child2propertyB; private Child2Builder() {} public static Child2Builder newChild2() { return new Child2Builder(); } @Override protected Child2Builder self() { return this; } public Child2Builder withChild2PropertyA(String child2propertyA) { this.child2propertyA = child2propertyA; return self(); } public Child2Builder withChild2PropertyB(Object child2propertyB) { this.child2propertyB = child2propertyB; return self(); } public Child2 build() { return new SimpleChild2(this); } private static final class SimpleChild2 extends SimpleParent implements Child2 { private String child2propertyA; private Object child2propertyB; public SimpleChild2(Child2Builder builder) { super(builder); this.child2propertyA = builder.child2propertyA; this.child2propertyB = builder.child2propertyB; } @Override public String getChild2PropertyA() { return child2propertyA; } @Override public Object getChild2PropertyB() { return child2propertyB; } } } 可以分为以下两个类Child1Builder和Child1Builder，其中又一个子生成器可以扩展后者。

AbstractChild1Builder
public abstract class AbstractChild1Builder<T extends AbstractChild1Builder<T>> extends ParentBuilder<T> {

    protected int child1Property;

    public T withChild1Property(int child1Property) {
        this.child1Property = child1Property;
        return self();
    }

    protected final class SimpleChild1 extends SimpleParent implements Child1 {
        private int child1Property;

        public SimpleChild1(AbstractChild1Builder<Child1Builder> builder) {
            super(builder);
            this.child1Property = builder.child1Property;
        }

        @Override
        public Integer getChild1Property() {
            return child1Property;
        }
    }
}
相关问题
最新问题