Java 返回对象或在调用范围/上下文中导致返回的Helper方法

我想不出如何计算出这段代码

  private CompletionStage<Response<String>> foo(RequestContext rc) {

    final Optional<String> campaignIdOpt = rc.request().parameter("campaignId").filter(s -> !s.isEmpty());
    final Optional<String> creativeIdOpt = rc.request().parameter("creativeId").filter(s -> !s.isEmpty());

    Optional<Uuid> campaignIdOptOfUuid = Optional.empty();
    if (campaignIdOpt.isPresent()) {
      try {
        campaignIdOptOfUuid = Optional.of(UuidUtils.fromString(campaignIdOpt.get()));
      } catch (IllegalArgumentException e) {
        LOG.error(String.format("Invalid campaignId: %s", campaignIdOpt.get()), e);
        return CompletableFuture.completedFuture(
            Response.forStatus(Status.BAD_REQUEST.withReasonPhrase("Invalid campaignId provided.")));
      }
    }

    Optional<Uuid> creativeIdOptOfUuid = Optional.empty();
    if (creativeIdOpt.isPresent()) {
      try {
        creativeIdOptOfUuid = Optional.of(UuidUtils.fromString(creativeIdOpt.get()));
      } catch (IllegalArgumentException e) {
        LOG.error(String.format("Invalid creativeId: %s", creativeIdOpt.get()), e);
        return CompletableFuture.completedFuture(
            Response.forStatus(Status.BAD_REQUEST.withReasonPhrase("Invalid creativeId provided.")));
      }
    }

    // Simplified, do something with Uuids.
    return bar(campaignIdOptOfUuid, creativeIdOptOfUuid);
  }

private CompletionStage foo（RequestContext rc）{
最终可选的活动ID=rc.request（）.parameter（“活动ID”）.filter（s->！s.isEmpty（））；
最终可选creativeIdOpt=rc.request（）.parameter（“creativeId”）.filter（s->！s.isEmpty（））；
可选活动IDoptofuid=Optional.empty（）；
if（activitidopt.isPresent（））{
试一试{
activitidoptofuid=Optional.of（UuidUtils.fromString（activitidopt.get（））；
}捕获（IllegalArgumentException e）{
LOG.error（String.format（“无效的活动ID:%s”，活动ID.get（）），e）；
返回CompletableFuture.completedFuture(
Response.forStatus（Status.BAD_REQUEST.withReasonPhrase（“提供了无效的活动ID”））；
}
}
Optional creativeIdOptOfUuid=Optional.empty（）；
if（creativeIdOpt.isPresent（））{
试一试{
creativeidoptouid=Optional.of（UuidUtils.fromString（creativeIdOpt.get（））；
}捕获（IllegalArgumentException e）{
LOG.error（String.format（“无效的creativeId:%s”，creativeIdOpt.get（）），e）；
返回CompletableFuture.completedFuture(
Response.forStatus（Status.BAD_REQUEST.withReasonPhrase（“提供了无效的creativeId”））；
}
}
//简单地说，使用uuid做一些事情。
返回栏（活动IDoptouId、CreativeIDoptouId）；
}

基本上，我们经常需要从查询字符串解析GoogleProtobuf

Uuid

s，以传递给另一个将查找（或不查找）的服务。如果没有设置参数，我们需要传递一个空的可选值，或者传递一个空字符串，这两种情况都意味着“不要按此参数过滤”。最后，如果字符串根本没有解析，那么我们希望立即返回一个错误400（错误请求），而不是向服务传递一个无意义的参数

所以，在代码方面，我想要一个实用的方法

采用

可选

，并且

返回一个

Optional

如果存在，

Optional.empty（）

否则，以及

如果引发异常，

从原始上下文返回一个错误

---

但很明显，我不能“双倍回报”。我用什么模式来实现这一点呢？我试图为

可选

和

完成阶段

创建一个封装器，但很尴尬。有什么惯用的方法吗？

您可以使用循环。循环允许您平等地处理所有元素，从而消除代码重复，同时仍然允许立即返回：

private CompletionStage<Response<String>> foo(RequestContext rc) {
    String[] parameters = {"campaignId", "creativeId" };
    List<Optional<Uuid>> uuids = new ArrayList<>(parameters.length);
    for(String param: parameters) {
        Optional<String> o1 = rc.request().parameter(param).filter(s -> !s.isEmpty());
        Optional<Uuid> o2;
        try {
            o2 = o1.map(UuidUtils::fromString);
        } catch(IllegalArgumentException e) {
            LOG.error(String.format("Invalid %s: %s", param, o1.get()), e);
            return CompletableFuture.completedFuture(
                Response.forStatus(Status.BAD_REQUEST
                    .withReasonPhrase("Invalid "+param+ " provided.")));
        }
        uuids.add(o2);
    }
    // Simplified, do something with Uuids.
    return bar(uuids.get(0), uuids.get(1));
}

private CompletionStage foo（RequestContext rc）{
字符串[]参数={“活动ID”，“创建ID”}；
列表UUID=新的ArrayList（parameters.length）；
for（字符串参数：参数）{
可选o1=rc.request（）.param.filter（s->！s.isEmpty（））；
可选氧气；
试一试{
o2=o1.map（UuidUtils:：fromString）；
}捕获（IllegalArgumentException e）{
LOG.error（String.format（“无效的%s:%s”，param，o1.get（）），e）；
返回CompletableFuture.completedFuture(
响应。forStatus（Status.BAD_请求
。使用合理的短语（“无效”+参数+”提供）；
}
添加（o2）；
}
//简单地说，使用uuid做一些事情。
返回条（uuids.get（0），uuids.get（1））；
}

否则，您需要创建一个方法，返回一个包含两个可选结果的对象（如

或
）；JDK还没有提供这样的类型。一个方法可以简单地抛出一个错误的条件，但当公共代码主要是异常处理时，这将使您回到原点

请注意，在空的可选项上调用
Optional.map
将返回一个空的可选项，而不评估提供的函数，因此您不需要通过
ifPresent
等进行检查。
这将属于代码审阅，它是seems@DwB（虽然您的答案已被删除）-抱歉，我的样本中有一个错误。
.isPresent（）
应该在原始选项上，而不是在上面设置的选项上。抢手货在简化我的示例时，我做了一个错误的复制粘贴。