Java 通用构建器

Question

假设我需要一些DerivedBuilder 来扩展一些BaseBuilder。基础构建器有一些方法，如foo（返回BaseBuilder）。派生构建器具有方法bar。方法bar 应该在方法foo 之后调用。为了做到这一点，我可以像这样覆盖DerivedBuilder 中的foo 方法：

@Override
public DerivedBuilder foo() {
    super.foo();
    return this;
}

问题是BaseBuilder 有很多像foo 这样的方法，我必须覆盖它们中的每一个。我不想这样做，所以我尝试使用泛型：

public class BaseBuilder<T extends BaseBuilder> {
    ...

    public T foo() {
        ...
        return (T)this;
    }
}

public class DerivedBuilder<T extends DerivedBuilder> extends BaseBuilder<T> {
    public T bar() {
        ...
        return (T)this;
    }
}

但问题是我还是不会写

new DerivedBuilder<DerivedBuilder>()
        .foo()
        .bar()

尽管T 这里是DerivedBuilder。我该怎么做才能不覆盖很多功能？

Answer 1

你的问题是DerivedBuilder的定义：

class DerivedBuilder<T extends DerivedBuilder>;

然后用类型擦除参数 new DerivedBuilder<DerivedBuilder<...what?...>>() 实例化它。

您需要一个完全定义的派生类型，如下所示：

public class BaseBuilder<T extends BaseBuilder<T>> {
    @SuppressWarnings("unchecked")
    public T foo() {
        return (T)this;
    }
}

public class DerivedBuilder extends BaseBuilder<DerivedBuilder> {
    public DerivedBuilder bar() {
        return this;
    }
}

检查ideone.com。

Answer 2

除了BeyelerStudios's answer之外，如果你想进一步嵌套，你可以使用这个：

class Base<T extends Base<?>> {
    public T alpha() { return (T) this; }
    public T bravo() { return (T) this; }
    public T foxtrot() { return (T) this; }
}

class Derived<T extends Derived<?>> extends Base<T> {
    public T charlie() { return (T) this; }
    public T golf() { return (T) this; }
}

class FurtherDerived<T extends FurtherDerived<?>> extends Derived<T> {
    public T delta() { return (T) this; }
    public T hotel() { return (T) this; }
}

class MuchFurtherDerived<T extends MuchFurtherDerived<?>> extends FurtherDerived<T> {
    public T echo() { return (T) this; }
}

public static void main(String[] args) {
    new MuchFurtherDerived<MuchFurtherDerived<?>>()
        .alpha().bravo().charlie().delta().echo().foxtrot().golf().hotel()
        .bravo().golf().delta().delta().delta().hotel().alpha().echo()
        .echo().alpha().hotel().foxtrot();
}

Answer 3

我在这里做了一个Class.cast(this)，而不是return (T) this;。

实现：

BaseBuilder.build(ExtendedBuilder.class).foo().bar().foo().bar();

层次结构中的每个类都需要知道实际的最终子类，因此我选择在基类中创建一个工厂方法build。

将this 转换为实际的孩子也是在基类的final 方法中完成的，提供return me();。

class BaseBuilder<B extends BaseBuilder<B>> {

    protected Class<B> type;

    public static <T extends BaseBuilder<T>> T build(Class<T> type) {
        try {
            T b = type.newInstance();
            b.type = type;
            return b;
        } catch (InstantiationException | IllegalAccessException e) {
            throw new IllegalStateException(e);
        }
    }

    protected final B me() {
        return type.cast(this);
    }

    B foo() {
        System.out.println("foo");
        return me();
    }
}

class ExtendedBuilder extends BaseBuilder<ExtendedBuilder> {

    ExtendedBuilder bar() {
        System.out.println("bar");
        return me();
    }
}

Answer 4

我从你的问题中了解到，方法 foo() 应该在方法 bar() 之前执行。
如果正确，您可以应用模板设计模式。
在 BaseBuilder 中创建抽象方法栏。
还有一种新方法说“模板”。方法模板将定义顺序——首先执行 foo()，然后执行 bar()。
DerivedBuilder 将提供方法栏的实现。

public abstract class BaseBuilder {

    public void foo(){
        System.out.println("foo");
    }

    public abstract void bar();

    public void template(){
        foo();
        bar();
    }
}

public class DerivedBuilder extends BaseBuilder{

    @Override
    public void bar() {
        System.out.println("bar");      
    }

    public static void main(String[] args) {
        BaseBuilder builder = new DerivedBuilder();
        builder.template();
    }
}

希望这会有所帮助。