Question

想象一下我有一个封装另一个类的类：

@Builder
public class Dragon {

  private Dimensions dimensions;
  private String name;

  public static class ParentBuilder {
    DimensionsBuilder innerBuilder = Dimensions.builder();

    public DragonBuilder height(double height) {
      this.innerBuilder.height(height);
      return this;
    }

    public DragonBuilder length(double length) {
      this.innerBuilder.length(length);
      return this;
    }

    public Dragon build() {
      return Dragon.builder()
        .dimensions(this.innerBuilder.build())
        .name(this.name)
        .build();
    }
  } 
}

@Builder
public class Dimensions {
  private double height;
  private double length;
}

请记住，这是一个非常简单的示例，真实的代码（不幸的是，不是关于龙的）将很多的属性委托给{{ 1}}。

这样，我可以像这样实例化该类：

innerBuilder

而不是这样：

Dragon dragon = Dragon.builder()
  .height(12.0)
  .length(25.0)
  .name("Smaug")
  .build();

添加构建器方法来直接构建内部类也是一种好的编码实践吗？还是因为某些设计原理太紧密而违反了某些设计原则？

我已经遇到的一个问题是在进行内部类的重构时，我还必须对父类进行几乎相同的重构。

Answer 1

我认为，从样式/设计的角度来看，您的方法从根本上没有错。但是，正如用户JB Nizet在评论中所解释的那样，存在两个主要问题：

您遇到了维护问题，因为您必须复制每个外部构建器方法。（Lombok的@Delegate在这里无济于事，因为它不适用于Lombok本身生成的类。）
构建器的用户可以调用dimensions(Dimensions)和委托方法，这非常令人困惑。

从用户的角度来看，我希望像这样使用构建器：

Dragon dragon = Dragon.builder()
    .dimensions()
        .height(12.0)
        .length(25.0)
        .back()
    .name("Smaug")
    .build();

这是实现它的方法（使用Lombok 1.18.8）：

@Builder
public class Dragon {
    private Dimensions dimensions;
    private String name;

    public static class DragonBuilder {

        private Dimensions.DimensionsBuilder innerBuilder = 
                new Dimensions.DimensionsBuilder(this);

        // If a method of the same name exists, Lombok does not generate
        // another one even if the parameters differ.
        // In this way, users cannot set their own dimensions object.
        public Dimensions.DimensionsBuilder dimensions() {
            return innerBuilder;
        }

        // Customize build() so that your innerBuilder is used to create 
        // the Dimensions instance.
        public Dragon build() {
            return new Dragon(innerBuilder.build(), name);
        }
    }
}

Dimensions的构建器拥有对容器DragonBuilder的引用：

// Don't let Lombok create a builder() method, so users cannot 
// instantiate builders on their own.
@Builder(builderMethodName = "")
public class Dimensions {
    private double height;
    private double length;

    public static class DimensionsBuilder {
        private Dragon.DragonBuilder parentBuilder;

        // The only constructor takes a reference to the containing builder.
        DimensionsBuilder(Dragon.DragonBuilder parentBuilder) {
            this.parentBuilder = parentBuilder;
        }

        // Provide a method that returns the containing builder.
        public Dragon.DragonBuilder back() {
            return parentBuilder;
        }

        // The build() method should not be called directly, so 
        // we make it package-private.
        Dimensions build() {
            return new Dimensions(height, length);
        }
    }
}

这种方法可以扩展，因为Lombok会在生成器中自动生成所有必要的其余setter方法。此外，由于用户提供了自己的Dimensions实例，因此可能不会感到意外。（您可以允许这样做，但是我强烈建议您在运行时检查潜在的冲突，例如通过检查是否同时调用了这两种方法。）

缺点是Dimensions.builder()不再可用，因此不能直接使用，也不能在具有Dimensions字段的其他类的构建器中使用。但是，还有一种解决方案：使用@SuperBuilder Dimensions并在class NestedDimensionsBuilder extends Dimensions.DimensionsBuilder<Dimensions, NestedDimensionsBuilder>中定义DragonBuilder。

使用Builder也可以构建封装的对象

1 个答案: