Java playframework-2.3 Akka异步交互移植？

我有一些旧的PlayFramework2.2JavaWebService与akka交互，现在我应该将它们移植到PlayFramework2.3

然而，async已被弃用，即使在阅读了有关async移植（）的文档后，我也无法理解如何将其应用到我的案例中（下面的代码）：

• 在开始构建回复之前，我必须等待超时/akka服务器回复（ok（）），否则我将阻塞线程
• 我也应该使actorselection异步

• 我应该使akka服务器回复解析/回复构造也异步

我环顾四周，找不到这种交互的例子，即使是在类型安全模板中

我怎么能这么做

/* playframework 2.2 code */

public class Resolve extends Controller {

    private final static String RESOLVER_ACTOR = play.Play.application().configuration().getString("actor.resolve");

    @CorsRest
    @VerboseRest
    @RequireAuthentication
    @BodyParser.Of(BodyParser.Json.class)
    public static Result getJsonTree() {
        JsonNode json = request().body().asJson();

        ProtoBufMessages.ResolveRequest msg;
        ResolveRequestInput input;

        try {
            input = new ResolveRequestInput(json);
        } catch (rest.exceptions.MalformedInputException mie) {
            return badRequest(mie.getMessage());
        }

        msg = ((ProtoBufMessages.ResolveRequest)input.getMessage());

        ActorSelection resolver = Akka.system().actorSelection(RESOLVER_ACTOR);


        Timeout tim = new Timeout(Duration.create(4, "seconds"));

        Future<Object> fut = Patterns.ask(resolver, input.getMessage(), tim);

        return async (
                F.Promise.wrap(fut).map(
                        new F.Function<Object, Result>() {
                            public Result apply(Object response) {
                                ProtoBufMessages.ResolveReply rsp = ((ProtoBufMessages.ResolveReply)response);
                                ResolveOutput output = new ResolveOutput(rsp);
                                return ok(output.getJsonReply());
                            }
                        }
                )
        );
    }
}

/*playframework 2.2代码*/
公共类解析扩展控制器{
私有最终静态字符串解析器_ACTOR=play.play.application（）.configuration（）.getString（“ACTOR.resolve”）；
@科斯雷斯特
@冗长的
@要求重新认证
@Of（BodyParser.Json.class）
公共静态结果getJsonTree（）{
JsonNode json=request（）.body（）.asJson（）；
ProtoBufMessages.ResolveRequest消息；
解析请求输入；
试一试{
输入=新的ResolveRequestInput（json）；
}捕获（rest.exceptions.MalformedInputException mie）{
返回badRequest（mie.getMessage（））；
}
msg=（（ProtoBufMessages.ResolveRequest）input.getMessage（））；
ActorSelection解析器=Akka.system（）.ActorSelection（解析器\参与者）；
Timeout tim=新超时（持续时间.create（4，“秒”））；
Future fut=Patterns.ask（解析器，input.getMessage（），tim）；
异步返回(
承诺包裹（未来）地图(
新F.函数（）{
公共结果应用（对象响应）{
ProtoBufMessages.ResolveReply rsp=（（ProtoBufMessages.ResolveReply）响应）；
ResolveOutput=新的ResolveOutput（rsp）；
返回ok（output.getJsonReply（））；
}
}
)
);
}
}

我给出了下面的代码

public class Resolve extends Controller {

    private final static String RESOLVER_ACTOR = play.Play.application().configuration().getString("actor.resolve");
    private final static BrainProtoMessages.ResolveReply request_error = BrainProtoMessages.ResolveReply.newBuilder()
        .setReturnCode(BResults.REQUEST_FAILED)
        .build();

    @CorsRest
    @VerboseRest
    @RequireAuthentication
    @BodyParser.Of(BodyParser.Json.class)

public static Result resolve_map() {

    final ResolveRequestInput input;
    final F.Promise<ActorSelection> selected_target;
    final F.Promise<Future<Object>> backend_request;
    final F.Promise<BrainProtoMessages.ResolveReply> backend_reply;
    final F.Promise<ObjectNode> decode_json;
    final F.Promise<Result> ok_result;
    final JsonNode json = request().body().asJson();

    try {
        input = new ResolveRequestInput(json);
    } catch (rest.exceptions.MalformedInputException mie) {
        return badRequest(mie.getMessage());
    }

    selected_target = F.Promise.promise(
      new F.Function0<ActorSelection>() {
          @Override
          public ActorSelection apply() throws Throwable {
              return Akka.system().actorSelection(RESOLVER_ACTOR);    
          }
      }      
    );

    backend_request =
            selected_target.map(
                    new F.Function<ActorSelection, Future<Object>>() {
                        @Override
                        public Future<Object> apply(ActorSelection actorSelection) throws Throwable {
                            return Patterns.ask(actorSelection, input.getMessage(),new Timeout(Duration.create(4, "seconds")));
                        }
                    }
            );

    backend_reply = backend_request.map(

            new F.Function<Future<Object>, BrainProtoMessages.ResolveReply>() {
                @Override
                public BrainProtoMessages.ResolveReply apply(Future<Object> akka_reply) throws Throwable {
                    try {
                        return (BrainProtoMessages.ResolveReply) Await.result(akka_reply, Duration.create(4, "seconds"));
                    }catch(Exception error)
                    {
                        return request_error;
                    }    
                }
            }
    );

    decode_json = backend_reply.map(

            new F.Function<BrainProtoMessages.ResolveReply, ObjectNode>() {
                @Override
                public ObjectNode apply(BrainProtoMessages.ResolveReply response) throws Throwable {
                    return new ResolveOutput(response).getJsonReply();
                }
            }
        );

    ok_result = decode_json.map(
            new F.Function<ObjectNode, Result>() {
                @Override
                public Result apply(ObjectNode reply) {
                    return ok(reply);
                }
            }
    );

    try {
        return ok_result.get(8000);
    }catch(Exception error)
    {
        return internalServerError();
    }

}

公共类解析扩展控制器{
私有最终静态字符串解析器_ACTOR=play.play.application（）.configuration（）.getString（“ACTOR.resolve”）；
私有最终静态BrainProtoMessages.ResolveReply请求\u错误=BrainProtoMessages.ResolveReply.newBuilder（）
.setReturnCode（BResults.REQUEST_失败）
.build（）；
@科斯雷斯特
@冗长的
@要求重新认证
@Of（BodyParser.Json.class）
公共静态结果解析映射（）{
最终解析请求输入；
最终F.承诺选定的目标；
最终的F.承诺和U请求；
最终的F.承诺和U回复；
最终F.承诺解码；
最终F.承诺ok_结果；
final JsonNode json=request（）.body（）.asJson（）；
试一试{
输入=新的ResolveRequestInput（json）；
}捕获（rest.exceptions.MalformedInputException mie）{
返回badRequest（mie.getMessage（））；
}
所选目标=F.Promise.Promise(
新F.函数0（）{
@凌驾
public ActorSelection apply（）可丢弃{
返回Akka.system（）.actorSelection（解析器\u ACTOR）；
}
}      
);
后端请求=
选定的\u target.map(
新F.函数（）{
@凌驾
公共未来应用（ActorSelection ActorSelection）可丢弃{
返回Patterns.ask（actorSelection，input.getMessage（），新超时（Duration.create（4，“秒”））；
}
}
);
backend\u reply=backend\u request.map(
新建F.Function（）{
@凌驾
public BrainProtoMessages.ResolveReply apply（未来的akka_回复）抛出可丢弃{
试一试{
return（BrainProtoMessages.ResolveReply）wait.result（akka_reply，Duration.create（4，“秒”）；
}捕获（异常错误）
{
返回请求错误；
}    
}
}
);
decode_json=backend_reply.map(
新F.函数（）{
@凌驾
public ObjectNode apply（BrainProtoMessages.ResolveReply响应）抛出Throwable{
返回新的ResolveOutput（response）.getJsonReply（）；
}
}
);
ok_result=decode_json.map(
新F.函数（）{
@凌驾
公共结果应用（ObjectNode回复）{
返回ok（回复）；
}
}
);
试一试{
返回ok_结果。获取（8000）；
}捕获（异常错误）
{
返回internalServerError（）；
}
}

}