Question

public interface A extends C {
    String getCh();
    String getId();
    String getReview();
}

public interface B extends C {
    String getCh();
    String getId();
    String getReview();
}

@Data
@Builder
public class AImpl implements A{
    private String ch;
    private String id;
    private String review;
}

@Data
@Builder
public class BImpl implements B{
    private String ch;
    private String id;
    private String review;
}

so now to use the builders of these I do:

return AImpl.builder()
        .ch("ch")
        .id("id")
        .review("somerview");

For B I do:
return BImpl.builder()
        .ch("ch1")
        .id("id1")
        .review("some new review");

有没有办法让这个构建器成为一个函数？我不喜欢再次重复相同代码的想法。就像我可以在一个函数中传递id通道并查看的那样我可以使用该对象吗？

Answer 1

免责声明：我从未真正处理过构建器，所以可能有更好的选择：D

此方法单独为每个接口编写构建器。这确实需要接口提供setter方法。使用泛型，RootBuilder和BaseABuilder的方法返回ImplABuilder的一个实例，以便链可以正常继续。

这是一个非常简单的Thistype泛型实现，默认情况下存在于其他语言中。此实现还依赖于转换为实际的Thistype，但如果您正确设置泛型，那不应该是一个问题。

public class Test
{
    public static void main(String[] args)
    {
        ImplA implA = ImplA
            .builder()
            .id("id")
            .description("description")
            .valueA("a")
            .build();
    }
}

public interface Root
{
    String getId();
    void setId(String id);
    String getDescription();
    void setDescription(String description);
}

public class RootBuilder<Thistype extends RootBuilder<Thistype, Instance>, Instance extends Root>
{
    protected final Instance object;

    RootBuilder(Instance object)
    {
        this.object = object;
    }

    public Thistype id(String value)
    {
        object.setId(value);
        return (Thistype)this;
    }

    public Thistype description(String value)
    {
        object.setDescription(value);
        return (Thistype)this;
    }

    public Instance build()
    {
        return object;
    }
}

public interface BaseA extends Root
{
    String getValueA();
    void setValueA(String valueA);
}

public class BaseABuilder<Thistype extends BaseABuilder<Thistype, Instance>, Instance extends BaseA> extends RootBuilder<Thistype, Instance>
{
    protected Instance object;

    BaseABuilder(Instance object)
    {
        super(object);
    }

    public Thistype valueA(String value)
    {
        object.setValueA(value);
        return (Thistype)this;
    }
}

public interface BaseB extends Root
{
    String getValueB();
    void setValueB(String valueB);
}

public interface BaseC extends Root
{
    String getValueC();
    void setValueC(String valueC);
}

public final class ImplA implements BaseA
{
    private String id;
    private String description;
    private String valueA;

    private ImplA() { }

    public static ImplABuilder builder()
    {
        return new ImplABuilder(new ImplA());
    }

    private static class ImplABuilder extends BaseABuilder<ImplABuilder, ImplA> // assuming ImplA is final
    {
        ImplABuilder(ImplA object)
        {
            super(object);
        }

        // additional methods for ImplA class
    }
}

为Java中的通用函数创建不同接口实现的构建器

1 个答案: