Лямбда-нотация - попытка рефакторинга, но получение проблем

Question

У меня есть несколько методов, которые отображаются на запросы сервера. Запросы используют promises (из 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())); 
} 

Обратите внимание, что MyReq расширяет MyAbstractReq<T>.

То, что я надеялся сделать, состоял в том, чтобы убрать весь общий код из всех методов действий и расслоить его на один общий метод handleRequest. Однако я стараюсь понять Лямбда-нотацию и не могу изменить код в соответствии с моими целями.

Я понимаю, что () -> new MyReq(data) в основном означает (arg1, arg2, ...) -> { body }, которое можно записать как (я думаю):

MyBean data = new MyBean(getData(request().body())); 

// Anonymous Functional Interface 
MyFunction f = new MyFunction() {  
    @Override 
    public void getReq(){ 
     return new MyReq(data); 
    } 
}; 

Или что-то подобное.

Но что я пытаюсь достичь это что-то вроде этого (не компилируется, но я надеюсь, что это дает достаточно идеи, что я пытаюсь добиться):

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

и каждый внешний вид действий как это:

public static Promise<Result> someAction() { 
    MyBean data = new MyBean(getData(request().body())); 
    return handleRequest(new MyReq(data)); 
} 

может кто-то пожалуйста, указать на то, что это такое, что мне не хватает в отношении лямбда-нотации и объяснить, как я могу добиться того, что я пытаюсь сделать.

Update

Ошибки я получаю

Lambda expression's signature does not match the signature of the functional interface method apply(? super MyAbstractReq<?>)

Я предполагаю, что это потому, что синтаксис был неправильным, это была только моя первая наивная попытка реорганизовать Это.

Метод req.getResponse() не очень актуальны, поскольку это просто создает объект JSON (ObjectNode - Джексон быстрее XML), который может потребляться методом ok() создать Result

Update 2

С что касается использования handleRequest(MyAbstractReq<T> req) У меня на самом деле было это, но ошибка была в основном одинаковой.

Lambda expression's signature does not match the signature of the functional interface method apply(? super MyAbstractReq<T>)

Update 3

Я прошу прощения.Ошибка находится на линии return promise.map(() -> ok(req.getResponse()));

Update 4

я, вероятно, следовало бы отметить, что я знаю, как решить эту проблему путем изменения метода handleRequest() к:

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

Но он чувствует себя неправильно поскольку строка return promise.map((MyAbstractReq<?> notUsed) -> ok(req.getResponse())); принимает аргумент MyAbstractReq<?>, который никогда не используется.

Я не понимаю достаточно об обозначениях лямбда-выражений, чтобы сказать, что это не лучший способ добиться того, чего я хочу (я не упоминал об этом, так как я хотел видеть, какие предложения людей будут без меня ведущими их ответ).

Answer 1

В вашем исходного кода

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())); 
} 

все работает как задумано, как map получает функцию, которая определяет, как обрабатывать аргумент req. Но в вашем переработан код, который вы вдруг пытаетесь получить доступ к переменной из внешней области вместо того, чтобы логика:

public static Promise<Result> handleRequest(MyAbstractReq<?> req) { 
    Promise<MyAbstractReq<?>> promise = Promise.promise(() -> req); 
    // the following function refers to handleRequest’s parameter instead of its argument 
    return promise.map((MyAbstractReq<?> notUsed) -> 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> 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())))); 

, как тогда Promise действительно покрывает всю операцию.

Answer 2

Теперь после обновления 2, вы придумали следующий метод:

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

Прежде чем продолжить, позвольте мне объяснить, что map() делает. При заданном Iterable, когда применяется, map() просто преобразует каждый элемент в нечто другое (которое может быть извлечено из элемента). Для этого мы передаем Function методу map(), который принимает вход и возвращает выход.

В этом случае (MyAbstractReq<?> notUsed) -> ok(req.getResponse()) - это функция. Берет notUsed в качестве аргумента (который один элемент из promise и вызвать метод ok() по реакции этого объекта.

Но вы видите, что вы не используете аргумент, который вы передаёте, но другой объект (тот, который вы прошли в качестве аргумента handleRequest() метода. это не так. вы должны использовать notUsed.getResponse() там.

Кроме того, вам не нужно давать тип notUsed там. Java может определить тип.Итак, измените свой метод на:

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