Question

我正在研究scala中的简单多人游戏，我想通过websockets为JS客户端公开。

这是我的WebsocketServer类

class WebsocketServer(actorRef: ActorRef, protocol: Protocol, system: ActorSystem, materializer: ActorMaterializer) extends Directives {

    val route = get {
      pathEndOrSingleSlash {
        handleWebSocketMessages(websocketFlow)
      }
    }

    def websocketFlow: Flow[Message, Message, Any] =
      Flow[Message]
        .map {
          case TextMessage.Strict(textMessage) => protocol.hydrate(textMessage)
        }
        .via(actorFlow)
        .map(event => TextMessage.Strict(protocol.serialize(event)))


    def actorFlow : Flow[Protocol.Message, Protocol.Event, Any] = {
      val sink =
        Flow[Protocol.Message]
          .to(Sink.actorRef[Protocol.Message](actorRef, Protocol.CloseConnection()))

      val source =
        Source.actorRef[Protocol.Event](1, OverflowStrategy.fail)
          .mapMaterializedValue(actor => actorRef ! Protocol.OpenConnection(actor))

      Flow.fromSinkAndSource(sink, source)
    }
}

这是我的actor的简化代码，它应该从websocket服务器接收消息。

class GameActor() extends Actor {

  private var connections: List[ActorRef] = List()

  override def receive: Receive = {

    case message: Protocol.OpenConnection => {
      this.connections = message.connection :: this.connections
      message.connection ! Protocol.ConnectionEstablished()
    }

    case message: Protocol.CloseConnection => {
      // how can I remove actor from this.connections ?
    }

    case message: Protocol.DoSomething => {
      // how can I identify from which connection this message came in?
    }
  }
}

到目前为止一直很好，目前我能用简单的WelcomeMessage回复客户端，但我仍然不知道如何：

每当演员收到CloseConnection消息时，从连接列表中删除演员？
确定哪个连接消息来自演员？

Answer 1

我认为您需要使用某种key或id来映射您的连接角色。

def websocketFlow: Flow[Message, Message, Any] =
  val randomKey = Random.nextInt()
      Flow[Message]
        .map {
          case TextMessage.Strict(textMessage) => protocol.hydrate(textMessage)
        }
        .via(actorFlow(randomKey))
        .map(event => TextMessage.Strict(protocol.serialize(event)))


    def actorFlow(flowID: Int) : Flow[Protocol.Message, Protocol.Event, Any] = {
      val sink =
        Flow[Protocol.Message]
          .to(Sink.actorRef[Protocol.Message](actorRef, Protocol.CloseConnection(flowID)))

      val source =
        Source.actorRef[Protocol.Event](1, OverflowStrategy.fail)
          .mapMaterializedValue(actor => actorRef ! Protocol.OpenConnection(actor, flowID))

      Flow.fromSinkAndSource(sink, source)
    }

然后在你的演员中，你可以将连接存储在Map而不是List中，这也可以更有效地删除。

Answer 2

这个问题已经得到解答。对于Java人员，这里是java版本：

public class WebsocketRoutes extends AllDirectives {

private final ActorSystem actorSystem;
private final ActorRef connectionManager;

public WebsocketRoutes(final ActorSystem actorSystem, final ActorRef connectionManager) {
    this.actorSystem = actorSystem;
    this.connectionManager = connectionManager;
}

public Route handleWebsocket() {
    return path(PathMatchers.segment(compile("router_v\\d+")).slash(PathMatchers.segment("websocket")).slash(PathMatchers.segment(compile("[^\\\\/\\s]+"))), (version, routerId) ->
            handleWebSocketMessages(createWebsocketFlow(routerId))
    );
}

private Flow<Message, Message, NotUsed> createWebsocketFlow(final String routerId) {

    final ActorRef connection = actorSystem.actorOf(WebsocketConnectionActor.props(connectionManager));

    final Source<Message, NotUsed> source = Source.<RouterWireMessage.Outbound>actorRef(5, OverflowStrategy.fail())
            .map((outbound) -> (Message) TextMessage.create(new String(outbound.message, "utf-8")))
            .throttle(5, FiniteDuration.create(1, TimeUnit.SECONDS), 10, ThrottleMode.shaping())
            .mapMaterializedValue(destinationRef -> {
                connection.tell(new RouterConnected(routerId, destinationRef), ActorRef.noSender());
                return NotUsed.getInstance();
            });

    final Sink<Message, NotUsed> sink = Flow.<Message>create()
            .map((inbound) -> new RouterWireMessage.Inbound(inbound.asTextMessage().getStrictText().getBytes()))
            .throttle(5, FiniteDuration.create(1, TimeUnit.SECONDS), 10, ThrottleMode.shaping())
            .to(Sink.actorRef(connection, PoisonPill.getInstance()));

    return Flow.fromSinkAndSource(sink, source);
}
}

Akka HTTP Websocket，如何识别actor内部的连接

2 个答案: