在 Java 中为不同接口实现的构建者创建一个通用函数

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
    }
}