Question

我有一个构建器类，我正在我的一个项目中使用。

假设我有metricA作为基于以下课程的构建者。
我需要通过克隆metricB基于metricA制作新的构建器metricA，以便metricB包含metricA中已存在的所有值

在MetricHolder的构造函数中，我正在基于已经设置的字段初始化一些字段（不是直接设置）。

clientTypeOrPayId - 我正在初始化此字段。如果payId存在，那么我将设置此值，或者我将设置clientType。
clientKey - 我也在同一个构造函数中初始化此字段。
最重要的是，我在clientPayload地图中放置了几个必填字段。我不确定这样做的正确方法是什么。但我需要将is_clientid和is_deviceid添加到地图中。（一般来说，我添加了更多的字段）。
然后在构造函数的最后一个，我正在计算延迟差异并将其发送到其他系统。

以下是我的课程：

public final class MetricHolder {
  private final String clientId;
  private final String deviceId;
  private final String payId;
  private final String clientType;
  private final String clientTypeOrPayId;
  private final Schema schema;
  private final String schemaId;
  private final String clientKey;
  private final Map<String, String> clientPayload;
  private final Record record;
  private final long clientCreateTimestamp;
  private final long clientSentTimestamp;

  private MetricHolder(Builder builder) {
    this.payId = builder.payId;
    this.siteId = builder.siteId;
    this.clientType = builder.clientType;
    this.clientId = builder.clientId;
    this.deviceId = builder.deviceId;
    this.schema = builder.schema;
    this.schemaId = builder.schemaId;
    // populating all the required fields in the map and make it immutable
    // not sure whether this is right?
    builder.clientPayload.put("is_clientid", (clientId == null) ? "false" : "true");
    builder.clientPayload.put("is_deviceid", (clientId == null) ? "true" : "false");
    this.clientPayload = Collections.unmodifiableMap(builder.clientPayload);
    this.clientTypeOrPayId = Strings.isNullOrEmpty(payId) ? clientType : payId;
    this.record = builder.record;
    this.clientKey = "process:" + System.currentTimeMillis() + ":"
                        + ((clientId == null) ? deviceId : clientId);
    this.clientCreateTimestamp = builder.clientCreateTimestamp;
    this.clientSentTimestamp = builder.clientSentTimestamp;
    // this will be called twice while cloning
    // what is the right way to do this then?
    SendData.getInstance().insert(clientTypeOrPayId,
        System.currentTimeMillis() - clientCreateTimestamp);
    SendData.getInstance().insert(clientTypeOrPayId,
        System.currentTimeMillis() - clientSentTimestamp);
  }

  public static class Builder {
    private final Record record;
    private Schema schema;
    private String schemaId;
    private String clientId;
    private String deviceId;
    private String payId;
    private String clientType;
    private Map<String, String> clientPayload;
    private long clientCreateTimestamp;
    private long clientSentTimestamp;

    // this is for cloning
    public Builder(MetricHolder packet) {
      this.record = packet.record;
      this.schema = packet.schema;
      this.schemaId = packet.schemaId;
      this.clientId = packet.clientId;
      this.deviceId = packet.deviceId;
      this.payId = packet.payId;
      this.clientType = packet.clientType;
      // make a new map and check whether mandatory fields are present already or not
      // and if they are present don't add it again.
      this.clientPayload = new HashMap<>();
      for (Map.Entry<String, String> entry : packet.clientPayload.entrySet()) {
        if (!("is_clientid".equals(entry.getKey()) || "is_deviceid".equals(entry.getKey())) {
          this.clientPayload.put(entry.getKey(), entry.getValue());
        }
      }
      this.clientCreateTimestamp = packet.clientCreateTimestamp;
      this.clientSentTimestamp = packet.clientSentTimestamp;
    }

    public Builder(Record record) {
      this.record = record;
    }

    public Builder setSchema(Schema schema) {
      this.schema = schema;
      return this;
    }

    public Builder setSchemaId(String schemaId) {
      this.schemaId = schemaId;
      return this;
    }

    public Builder setClientId(String clientId) {
      this.clientId = clientId;
      return this;
    }

    public Builder setDeviceId(String deviceId) {
      this.deviceId = deviceId;
      return this;
    }

    public Builder setPayId(String payId) {
      this.payId = payId;
      return this;
    }

    public Builder setClientType(String clientType) {
      this.clientType = clientType;
      return this;
    }

    public Builder setClientPayload(Map<String, String> payload) {
      this.clientPayload = payload;
      return this;
    }

    public Builder setClientCreateTimestamp(long clientCreateTimestamp) {
      this.clientCreateTimestamp = clientCreateTimestamp;
      return this;
    }

    public Builder setClientSentTimestamp(long clientSentTimestamp) {
      this.clientSentTimestamp = clientSentTimestamp;
      return this;
    }

    public MetricHolder build() {
      return new MetricHolder(this);
    }
  }

    // getters
}

问题： -

以下是我如何制作metricA构建器对象：

MetricHolder metricA = new MetricHolder.Builder(record).setClientId("123456").setDeviceId("abcdefhg")
                .           setPayId("98765").setClientPayload(payloadMapHolder).setClientCreateTimestamp(createTimestamp)
                            .setClientSentTimestamp(sentTimestamp).build();

现在，当我获得如下所示的所有其他字段时，这就是我稍后在代码中克隆metricA对象的方式：

MetricHolder metricB = new MetricHolder.Builder(metricA).setSchema(schema).setSchemaId("345").build();

我现在看到两个问题：

首先，SendData.getInstance()构造函数中的MetricHolder行将被调用两次。首先是当我通过克隆metricA进行metricB和第二次metricA时。但是当我尝试创建metricA构建器对象时，我只想将其称为？我怎样才能做到这一点？
其次，我使用clientPayload构造函数中的两个必填字段填充MetricHolder地图的方式对我来说不合适。有没有其他更好的方法来做同样的事情？

我想整个问题正在发生，因为我克隆metricA以制作metricB构建器对象的方式？做这个的最好方式是什么？我想以正确的方式实现上述两件事。

Answer 1

但是我只想在尝试创建metricA builder对象时只调用一次？我怎样才能做到这一点？

最直接的方法是在构建器中有一个标志，指示它是由Record创建还是通过克隆创建：

class Builder {
  final boolean cloned;

  Builder(MetricHolder packet) {
    this.cloned = true;
    // ...
  }

  Builder(Record record) {
    this.cloned = false;
    // ...
  }
}

然后，在MetricHolder的构造函数中：

if (!builder.cloned) {
  SendData.getInstance().whatever();
}

但值得指出的是，拨打SendData是doing too much work in the constructor的一个例子。你应该仔细考虑你是否真的想在构造函数中进行这个调用，或者你是否可以将其分解为另一种方法。

其次，我在MetricHolder构造函数中使用两个必填字段填充clientPayload映射的方式并不适合我。有没有其他更好的方法来做同样的事情？

你误解了＆＃34;无法修改的＆＃34;使用Collections.unmodifiableMap的一点：它只是map参数的不可修改的视图;你仍然可以修改基础地图。

这是一个JUnit测试，用于演示：

Map<String, String> original = new HashMap<>();
original.put("hello", "world");

// Obviously false, we just put something into it.
assertFalse(original.isEmpty());

Map<String, String> unmodifiable = Collections.unmodifiableMap(original);
// We didn't modify the original, so we don't expect this to have changed.
assertFalse(original.isEmpty());
// We expect this to be the same as for the original.
assertFalse(unmodifiable.isEmpty());

try {
  unmodifiable.clear();
  fail("Expected this to fail, as it's unmodifiable");
} catch (UnsupportedOperationException expected) {}

// Yep, still the same contents.
assertFalse(original.isEmpty());
assertFalse(unmodifiable.isEmpty());

// But here's where it gets sticky - no exception is thrown.
original.clear();
// Yep, we expect this...
assertTrue(original.isEmpty());

// But - uh-oh - the unmodifiable map has changed!
assertTrue(unmodifiable.isEmpty());

问题是，如果地图上没有其他参考，地图只能是不可修改的：如果您没有引用original，unmodifiable实际上是不可修改的;否则，你不能依赖地图永远不会改变。

在您的特定情况下，您只需将clientPayload地图包装在不可修改的集合中。因此，您将覆盖以前构造的实例的值。

例如：

MetricHolder.Builder builder = new MetricHolder.Builder();
MetricHolder first = builder.build();
assertEquals("false", first.clientPayload.get("is_clientid"));
assertEquals("true", first.clientPayload.get("is_deviceid"));

builder.setClientId("").build();
// Hmm, first has changed.
assertEquals("true", first.clientPayload.get("is_clientid"));
assertEquals("false", first.clientPayload.get("is_deviceid"));

正确的方法不是包裹builder.clientPayload。获取地图的副本，修改它，然后用unmodifiableMap包裹：

{
  Map<String, String> copyOfClientPayload = new HashMap<>(builder.clientPayload);
  copyOfClientPayload.put("is_clientid", (clientId == null) ? "false" : "true");
  copyOfClientPayload.put("is_deviceid", (clientId == null) ? "true" : "false");
  this.clientPayload = Collections.unmodifiableMap(copyOfClientPayload);
}

周围{}并非严格必要，但它们会限制copyOfClientPayload的范围，因此您无法在构造函数中意外重复使用它。

如何克隆旧构建器以创建新的构建器对象？

1 个答案: