我有一个类层次结构,其中有一个抽象基类和多个子类。基类有大约 25 个字段,每个子类还有额外的 0-8 个字段。
我想使用Builder模式来构造每个子实例,并且我想尽可能使用Lombok来保持代码简洁。遵循这个建议我的代码如下:
@AllArgsConstructor
@Data
public abstract class Base {
private int b1, b2, ... , b25;
}
public class C1 extends Base {
private int c11, c12, ... , c16;
@Builder
private C1(int b1, int b2, ..., int b25, int c11, ... int c16) {
super(b1, b2, ...., b25);
this.c11 = c11;
...
this.c16 = c16;
}
}
public class C2 extends Base {
@Builder
private C2(int b1, int b2, ..., int b25) {
super(b1, b2, ...., b25);
}
}
这使得构建子类变得很容易
C1 c1 = C1.builder().b1(1).b2(2)....b25(25).c11(101).c12(102).build();
C2 c2 = C2.builder().b1(1).b2(2)....b25(25).build();
问题是每次创建任何子类时都会重复
.b1().b2()...
链式调用。
理想情况下,我想要一种通用的方法来设置 B 值,无论正在构建哪个子类。 (假设还有另一个名为
BValuesProvider
的类可以提供这些值)
public void setBValues(BValuesProvider bv, // what else goes here??? //) {
// something.b1(bv.b1()).b2(bv.b2()) ...
}
public createC1(BValuesProvider bv, c11, c12, ..., c16) {
C1.Builder c1b = C1.builder().c11(c11).c12(c12)....c16(c16);
// Call setBValues somehow
return c1b.build();
}
public createC2(BValuesProvider bv) {
// Call setBValues somehow
return c2b.build();
}
我当前的解决方案是将
@Data
注释附加到基类以公开 setter/getter,所以我的代码如下所示:
public void setBValues(BValuesProvider bv, Base cx) {
cx.setB1(bv.b1());
cx.setB2(bv.b2());
...
cx.setB25(bv.b25());
}
public createC1(BValuesProvider bv, c11, c12, ..., c16) {
C1 c1 = C1.builder().c11(c11).c12(c12)....c16(c16).build();
setBValues(bv, c1);
return c1;
}
public createC2(BValuesProvider bv) {
C2 c2 = C2.builder().build();
setBValues(bv, c2);
return c2;
}
问题:
有更好的方法吗?具体来说,我觉得首先(完全)构建一个子类,然后在其上调用
setBxx()
函数似乎是一个糟糕的模式。暴露 setter 本身会使类变得非常可变。还有其他关于构建者/继承的问题
然而,他们都没有谈到每个孩子都有一个“基地建设者” builder 是 的子类。所以,我无法弄清楚使用泛型,
setBValues
函数的第二个参数应该是什么。@Superbuilder
注释,但同样,虽然它极大地简化了代码,但我仍然不知道如何获取基础构建器。 这可以使用(实验性)
@SuperBuilder
注释和 lombok >= 1.18.4 来实现。您可以通过添加一个以 @SuperBuilder
作为参数并设置其中所有值的方法来自定义 Base
的 BValuesProvider
:
@SuperBuilder
public abstract class Base {
public static abstract class BaseBuilder<C extends Base, B extends BaseBuilder<C, B>> {
public B fillFromProvider(BValuesProvider bv) {
b1(bv.b1());
b2(bv.b2());
...
return self();
}
}
...
}
然后你可以像这样使用它(其中
bv
是一个BValuesProvider
实例):
C1 c1 = C1.builder().fillFromProvider(bv).c11(11).build();
在这里。虽然这不是我提出的确切问题的答案,但我想分享一个仍然使用 Lombok 但不使用 @Builder 的替代方案。
@Getter
public abstract class Base<T extends Base> {
private int b1, b2, ... , b25;
private T cast() { return (T) this; }
public T setB1(final int b1) { this.b1 = b1; return cast(); }
public T setB2(final int b2) { this.b2 = b2; return cast(); }
...
}
@Getter @Setter @Accessors(chain = true)
public class C1 extends Base<C1> {
private int c11, c12, ... , c16;
public static C1 init() { return new C1(); }
private C1() {}
}
@Getter @Setter @Accessors(chain = true)
public class C2 extends Base<C2> {
public static C2 init() { return new C2(); }
private C2() {}
}
我刚刚泛化了基类并在子类上使用了链式访问器。然后调用者将被修改为:
public void setBValues(BValuesProvider bv, Base cx) {
cx.setB1(bv.b1())
.setB2(bv.b2())
...
.setB25(bv.b25());
}
public createC1(BValuesProvider bv, c11, c12, ..., c16) {
C1 c1 = C1.init().setC11(c11)....setC16(c16);
setBValues(bv, c1);
return c1;
}
public createC2(BValuesProvider bv) {
C2 c2 = C2.init();
setBValues(bv, c2);
return c2;
}
优点:
BValuesProvider
缺点:
.builder().x(x).y(y).build()
。我通过创建一个构建并返回父类的方法来让它为我工作,然后我将我的子类转换为父类并继续设置字段。
public Child toChild() {
return (Child) toBaseRequest()
.toBuilder()
.someOtherFieldFromChild(1)
.build();
}
private Parent toBaseRequest() {
return Parent.builder()
.fooBar(new FooBar())
.build();
}
确保孩子和家长班级都有
@SuperBuilder(toBuilder = true)