Java Lambda表示法-尝试重构但遇到问题

我有许多映射到服务器请求的方法。请求使用（来自Play Framework）在将来某个时间返回响应。以下是我的一个行动示例：

public static Promise<Result> someAction() {
    MyBean data = new MyBean(getData(request().body()));
    Promise<MyReq> promise = Promise.promise(() -> new MyReq(data));
    return promise.map((MyReq req) -> ok(req.getResponse()));
}

或者类似的

但我试图实现的是这样的东西（不编译，但我希望它提供足够的想法，我试图实现）：

但是它感觉不正确，因为行

返回promise.map（（MyAbstractReq notUsed）->ok（req.getResponse（））

接受一个从未使用过的参数

MyAbstractReq

我对Lambda表达式的表示法了解不够，无法判断这是否是实现我想要的最好方法（我没有提到它，因为我想知道人们的建议是什么，而不需要我给他们一个答案）。

在您的初始代码中

public static Promise<Result> someAction() {
    MyBean data = new MyBean(getData(request().body()));
    Promise<MyReq> promise = Promise.promise(() -> new MyReq(data));
    return promise.map((MyReq req) -> ok(req.getResponse()));
}

这在这种特殊情况下有效，但事实上，正如你的感觉告诉你的那样，这是错误的

只需保持原来的逻辑：

public static Promise<Result> handleRequest(MyAbstractReq<?> req) {
    Promise<MyAbstractReq<?>> promise = Promise.promise(() -> req);
    // arg is unrelated to req here though both variables happen to have to same contents
    return promise.map(arg -> ok(arg.getResponse()));
}

因此，

承诺将真正涵盖整个操作。
在初始代码中

public static Promise<Result> someAction() {
    MyBean data = new MyBean(getData(request().body()));
    Promise<MyReq> promise = Promise.promise(() -> new MyReq(data));
    return promise.map((MyReq req) -> ok(req.getResponse()));
}

这在这种特殊情况下有效，但事实上，正如你的感觉告诉你的那样，这是错误的

只需保持原来的逻辑：

public static Promise<Result> handleRequest(MyAbstractReq<?> req) {
    Promise<MyAbstractReq<?>> promise = Promise.promise(() -> req);
    // arg is unrelated to req here though both variables happen to have to same contents
    return promise.map(arg -> ok(arg.getResponse()));
}

因为那时，
承诺将真正涵盖整个操作。
在更新2之后，您提出了以下方法：

public static Promise<Result> handleRequest(MyAbstractReq<?> req) {=
    Promise<MyAbstractReq<?>> promise = Promise.promise(() -> req);
    return promise.map((MyAbstractReq<?> notUsed) -> ok(req.getResponse()));
}

现在，在更新2之后，您提出了以下方法：

public static Promise<Result> handleRequest(MyAbstractReq<?> req) {=
    Promise<MyAbstractReq<?>> promise = Promise.promise(() -> req);
    return promise.map((MyAbstractReq<?> notUsed) -> ok(req.getResponse()));
}

问题是什么？有什么错误吗？您的
getResponse（）
方法定义在哪里？我更新了该问题以解决您的评论。关于它与Lambda表达式的关系，我正在尝试重构Lambda表达式，但我不知道如何重构。这些错误表明“Lambda表达式的签名”中有错误。如果我的问题不清楚，请告诉我您不理解的部分，以便我澄清。@Neilos您使用了错误的变量来获取lamdba中的响应，我将不胜感激。它应该
未使用。getResponse（）
。有什么问题？有什么错误吗？您的
getResponse（）
方法定义在哪里？我更新了该问题以解决您的评论。关于它与Lambda表达式的关系，我正在尝试重构Lambda表达式，但我不知道如何重构。错误表明“Lambda表达式签名”中存在错误。如果我的问题不清楚，如果您能告诉我哪些部分您不理解，以便我能澄清，我将不胜感激。@Neilos您使用错误的变量在Lamda中获得响应。它应该是
notUsed.getResponse（）
“arg在这里与req无关，尽管这两个变量恰好有相同的内容”我不知道为什么会这样。是因为我将
req
传递给promise，然后在调用
promise.map
时，它使用
req
的值并将其作为参数传递给函数吗？但这将使相同的对象。它是一个副本还是什么？“因为承诺将真正涵盖整个操作”我确实想知道对象创建是否应该在承诺中而不是以前。我认为，这一点实际上是我将其更改为之前发生的情况时整个问题出现的地方（我真的不知道如何否则做）。感谢您指出这一点。映射函数的参数将包含供应商函数返回的引用的副本，因此它指向同一个对象实例。因此，它是同一个对象，但变量的选择在语义上有很大的区别，因为
arg->ok（arg.getResponse（））
是一个处理其参数的函数，而
notUsed->ok（req.getResponse（））
是一个处理lambda实例化中捕获的无关对象的函数。“arg在这里与req无关，尽管这两个变量恰好具有相同的内容“我不知道为什么会这样。是因为我将
req
传递给promise，然后在调用
promise.map
时，它使用
req
的值并将其作为参数传递给函数吗？但这将使相同的对象。它是一个副本还是什么？“因为承诺将真正涵盖整个操作”我确实想知道对象创建是否应该在承诺中而不是以前。我认为，这一点实际上是我将其更改为之前发生的情况时整个问题出现的地方（我真的不知道如何否则做）。感谢您指出这一点。映射函数的参数将包含供应商函数返回的引用的副本，因此它指向同一个对象实例。因此，它是同一个对象，但变量的选择在语义上有很大的区别，因为
arg->ok（arg.getResponse（））
是一个函数，它在
notUsed->ok（req.getResponse（））时处理其参数
是一个作用于lambda实例化中捕获的无关对象的函数。我不知道
req
和
promReq
如何包含相同的数据。。。它们是同一个对象，只是存储在promise中作为引用吗？@Neilos，这取决于
promise.promise（）
方法的作用。它使用一个函数，该函数只返回您传递的
req
。现在我不知道它对
req
做了什么。如果它没有创建新对象，那么是的
req
和
promReq
引用都指向同一个对象。我不明白的是
req
和
promReq
如何包含相同的数据。。。它们是同一个对象，只是存储在promise中作为引用吗？@Neilos，这取决于
promise.promise（）
方法的作用。它使用一个函数，该函数只返回您传递的
req
。现在我不知道它对
req
做了什么。如果它不创建新对象，则是
req
和
promReq
引用都指向同一对象。
public static Promise<Result> handleRequest(MyAbstractReq<?> req) {
    Promise<MyAbstractReq<?>> promise = Promise.promise(() -> req);
    // arg is unrelated to req here though both variables happen to have to same contents
    return promise.map(arg -> ok(arg.getResponse()));
}

public static Promise<Result> handleRequest(Function0<MyAbstractReq<?>> supplier) {
    Promise<MyAbstractReq<?>> promise = Promise.promise(supplier);
    return promise.map(arg -> ok(arg.getResponse()));
}

handleRequest( ()-> new MyReq(new MyBean(getData(request().body()))) );

public static Promise<Result> handleRequest(MyAbstractReq<?> req) {=
    Promise<MyAbstractReq<?>> promise = Promise.promise(() -> req);
    return promise.map((MyAbstractReq<?> notUsed) -> ok(req.getResponse()));
}

public static Promise<Result> handleRequest(MyAbstractReq<?> req) {=
    Promise<MyAbstractReq<?>> promise = Promise.promise(() -> req);
    return promise.map(promReq -> ok(promReq.getResponse()));
}