在Play Java中编写动作

Question

I know we have same types of questions in Stackoverflow, but to my best knowledge these are all written in Scala. In the official documentation , you can see how to compose Action. Actually I am not clear of it, but

public class VerboseAction extends play.mvc.Action.Simple {
public CompletionStage<Result> call(Http.Context ctx) {
    Logger.info("Calling action for {}", ctx);
    return delegate.call(ctx);
}

This above code is same with a below one?

@With(VerboseAction.class)

public Result verboseIndex() {
    return ok("It works!"); }

And they write we have to delegate to the wrapped Action, but in above code which action is called? What does delegate.call(ctx) mean? I know Play's Action is an instance of Action , but the return value is actually CompletionStage<Result> , not Action .
So, I am confused. Maybe I have tiny misunderstandings, so could anyone point out it?

Thanks.

Answer 1

An Action is a unit of work that provides a Result (in the end). Your first block of code constructs an Action that will execute the log statement, and then return with a call to the delegate , which will be the next Action unit (either another annotation or the controller method) to execute and calls that, passing the context along the entire time.

Your misunderstanding in the last part of the question is that the return type of the call is not the next Action to undertake. It is the (eventual) Result of all the Action s.

Answer 2

I will try to answer question by question:

This above code is same with a below one?

No, its actually composing both actions with "with" annotation.

but in above code which action is called?

Action is process of serving response to request received. This action will be called whenever a request to this method receive (request are mapped to methods in routes file).

And they write we have to delegate to the wrapped Action, What does delegate.call(ctx) mean?

delegate is:

/**
 * The wrapped action.
 */
"public Action<?> delegate;" 

and call is:

/**
 * Executes this action with the given HTTP context and returns the result.
 */
"public abstract Promise<Result> call(Context ctx) throws Throwable"

in Action class. so delegate.call means that wrap parametes in action and return result.

I know Play's Action is an instance of Action, but the return value is actually CompletionStage, not Action.

CompletionStage is actually is: "public interface CompletionStage" Its documentation describes it:

A stage of a possibly asynchronous computation, that performs an action or computes a value when another CompletionStage completes. A stage completes upon termination of its computation, but this may in turn trigger other dependent stages. The functionality defined in this interface takes only a few basic forms, which expand out to a larger set of methods to capture a range of usage styles:

The computation performed by a stage may be expressed as a Function, Consumer, or Runnable (using methods with names including apply , accept , or run , respectively) depending on whether it requires arguments and/or produces results. For example, {@code stage.thenApply(x -> square(x)).thenAccept(x -> System.out.print(x)).thenRun(() -> System.out.println())}. An additional form ( compose ) applies functions of stages themselves, rather than their results.

This

"A stage of a possibly asynchronous computation, that performs an action or computes a value when another CompletionStage completes."

and

"The computation performed by a stage may be expressed as a Function, Consumer, or Runnable"

Clears that it is function, Consumer, or Runnable that performs some computation. You are actually composing actions and returning

return ok("It works!");

not CompletionStage.