为什么使用Akka.io的Udp.send总是超时？

执行此代码总是导致超时错误，并且从不发送UDP数据包。 为什么?

我需要写更多的东西，因为stackoverflow不允许我发送问题…；-），但我认为问题很简单，代码是所有需要的

package controllers;

import akka.actor.ActorRef;
import akka.actor.Props;
import akka.actor.UntypedActor;
import akka.dispatch.Recover;
import akka.io.Tcp;
import akka.io.Udp;
import akka.io.UdpMessage;
import akka.japi.Procedure;
import akka.util.ByteString;

import java.net.InetSocketAddress;
import static akka.pattern.Patterns.ask;
import play.libs.Akka;
import play.mvc.Result;
import play.libs.F.Function;
import play.libs.F.Promise;
import play.mvc.*;

public class Application extends Controller {

    static ActorRef myActor = Akka.system().actorOf(Props.create(Listener.class));

    public static Result index() {

        return async(
                Akka.asPromise(
                //Promise.wrap(
                    ask(
                        myActor,
                        UdpMessage.send(ByteString.fromString("esto es una prueba"), new InetSocketAddress("172.80.1.81", 21001)),
                        1000
                    )
//              .recover(
//                      new Recover<Object>() {
//                          @Override
//                          public Object recover(Throwable t) throws Throwable {
//                              if( t instanceof AskTimeoutException ) {
//                                  Logger.error("Got exception: ", t);
//                                  return internalServerError("Timeout");
//                              }
//                              else {
//                                  Logger.error("Got exception: ", t);
//                                  return internalServerError("Got Exception: " + t.getMessage());
//                              }
//                          }
//                      })
                ).map(
                      new Function<Object,Result>() {
                        public Result apply(Object response) {
                          return ok(response.toString());
                        }
                      }
                    )
                  );

    }


  //http://doc.akka.io/docs/akka/2.2-M2/java/io.html
  //https://gist.github.com/kafecho/5353393
  //how to terminate actor on shutdown http://stackoverflow.com/questions/10875101/how-to-stop-an-akka-thread-on-shutdown
  public static class Listener extends UntypedActor {
    final ActorRef nextActor;

    public Listener() {
        this(null);
    }

    public Listener(ActorRef nextActor) {
        this.nextActor = nextActor;
        // request creation of a bound listen socket
        final ActorRef mgr = Udp.get(getContext().system()).getManager();
        mgr.tell(UdpMessage.bind(getSelf(), new InetSocketAddress("localhost",
                31001)), getSelf());
    }

    @Override
    public void onReceive(Object msg) {
        if (msg instanceof Udp.Bound) {
            final Udp.Bound b = (Udp.Bound) msg;
            getContext().become(ready(getSender()));
        } else
            unhandled(msg);
    }

    private Procedure<Object> ready(final ActorRef socket) {
        return new Procedure<Object>() {
            @Override
            public void apply(Object msg) throws Exception {
                if (msg instanceof Udp.Received) {
                    final Udp.Received r = (Udp.Received) msg;
                    // echo server example: send back the data
                    socket.tell(UdpMessage.send(r.data(), r.sender()),
                            getSelf());
                    // or do some processing and forward it on
                    final Object processed = new Object();//TODO parse data etc., e.g. using PipelineStage
                    if(nextActor!=null){
                        nextActor.tell(processed, getSelf());
                    }
                } else if (msg.equals(UdpMessage.unbind())) {
                    socket.tell(msg, getSelf());
                } else if (msg instanceof Udp.Unbound) {
                    getContext().stop(getSelf());
                } else if (msg instanceof Udp.Send){
                    socket.tell(msg, getSelf());
                } else
                    unhandled(msg);
            }
        };
    }
  }
 }

包控制器；
导入akka.actor.ActorRef；
导入akka.actor.Props；
导入akka.actor.UntypedActor；
导入akka.dispatch.Recover；
导入akka.io.Tcp；
导入akka.io.Udp；
导入akka.io.UdpMessage；
导入akka.japi.Procedure；
导入akka.util.ByteString；
导入java.net.InetSocketAddress；
导入静态akka.pattern.Patterns.ask；
导入play.libs.Akka；
导入play.mvc.Result；
导入play.libs.F.函数；
导入play.libs.F.Promise；
导入play.mvc.*；
公共类应用程序扩展控制器{
静态ActorRef myActor=Akka.system（）.actorOf（Props.create（Listener.class））；
公共静态结果索引（）{
异步返回(
阿卡·阿斯普罗米斯(
//答应我(
问(
我的演员，
UdpMessage.send（ByteString.fromString（“esto-es-una-prueba”），新的InetSocketAddress（“172.80.1.81”，21001）），
1000
)
//.恢复(
//新恢复（）{
//@覆盖
//公共对象恢复（Throwable t）抛出Throwable{
//if（AskTimeoutException的t实例）{
//Logger.error（“获取异常：”，t）；
//返回internalServerError（“超时”）；
//                              }
//否则{
//Logger.error（“获取异常：”，t）；
//返回internalServerError（“获取异常：+t.getMessage（））；
//                              }
//                          }
//                      })
).地图(
新函数（）{
公共结果应用（对象响应）{
返回ok（response.toString（））；
}
}
)
);
}
//http://doc.akka.io/docs/akka/2.2-M2/java/io.html
//https://gist.github.com/kafecho/5353393
//如何在关闭时终止actorhttp://stackoverflow.com/questions/10875101/how-to-stop-an-akka-thread-on-shutdown
公共静态类侦听器扩展了UntypedActor{
最终执行人，如nextActor；
公共侦听器（）{
这个（空）；
}
公共侦听器（ActorRef nextActor）{
this.nextActor=nextActor；
//请求创建绑定侦听套接字
最终ActorRef mgr=Udp.get（getContext（）.system（））.getManager（）；
mgr.tell（UdpMessage.bind（getSelf（），新的InetSocketAddress（“localhost”），
31001），getSelf（）；
}
@凌驾
公共void onReceive（对象消息）{
if（msg instanceof Udp.Bound）{
final Udp.Bound b=（Udp.Bound）msg；
getContext（）.been（ready（getSender（）））；
}否则
未处理（味精）；
}
私有过程就绪（最终ActorRef套接字）{
返回新程序（）{
@凌驾
public void apply（对象消息）引发异常{
如果（接收到Udp的消息instanceof）{
最终Udp.Received r=（Udp.Received）消息；
//echo服务器示例：发送回数据
socket.tell（UdpMessage.send（r.data（），r.sender（）），
getSelf（））；
//或者做一些处理并转发给
最终处理对象=新对象（）；//TODO解析数据等，例如使用PipelineStage
if（nextActor！=null）{
tell（已处理，getSelf（））；
}
}else if（msg.equals（UdpMessage.unbind（）））{
tell（msg，getSelf（））；
}else if（msg instanceof Udp.Unbound）{
getContext（）.stop（getSelf（））；
}else if（msg instanceof Udp.Send）{
tell（msg，getSelf（））；
}否则
未处理（味精）；
}
};
}
}
}