堆棧內存溢出
  簡體   English   中英

Java Web套接字服務器

[英]Java web socket server

 原文  2015-12-12 09:22:37  3   1    java/ websocket/ server

問題描述

我正在嘗試為Processing.org開發Web套接字庫，並且我想使用Tyrus實現。

我設法使客戶端正常工作。 問題出現在Web套接字服務器周圍-看起來不必要地復雜，並且創建服務器很麻煩（我以前在Python和node.js中都開發了服務器，以前沒有任何實際問題）。

本質上，我希望有一個可以在Processing中實例化的簡單Web套接字服務器類。 我的想象方式如下（一個處理草圖）： 

import websockets.*;

WSServer ws;

void setup(){
  ws= new WSServer(this,"localhost",8025); //this=PApplet (Processing specific detail)

  ws.sendMessage("A message"); //How I want to send messages to all clients
}

void draw(){
}

//Event listener for incoming messages
void webSocketServerEvent(String msg){
 println(msg); 
}

首先，沒有必要專注於諸如子協議之類的細節。 我只是希望處理開發人員能夠啟動一個簡單的Web套接字服務器，在構造函數，端口中聲明完全限定的URI，並定義onMessage eventlistener方法。

我現在已經嘗試解決了幾天，但我實在無法解決。 當使用Tyrus帶注釋的終結點方法時，我會說代碼很干凈並且可以理解，但是所有內容似乎都被沙盒化了。 我無法用所需的參數介紹自己的構造函數，也無法弄清楚如何以編程方式設置服務器URI。 當我無法在服務器端點中引入自己的現有對象時，就無法從上方將消息傳播到事件監聽器方法（webSocketServerEvent）。 此外，URI需要在​​注釋（@ServerEndpoint（value =“ / game”））中作為參數硬編碼，這是一個不錯的功能，但是對我來說，這僅在非常特殊的情況下有用，而不是常見的情況用例。

我對注釋方法的初步結論是，它非常沙盒化，主要是針對不需要集成到其他Java項目中的獨立情況而開發的。 我完全知道這個結論是不正確的，這就是為什么我要你們幫助我理解如何解決這個問題。

我也一直在研究Tyrus的編程方法，似乎實際上可以根據需要配置服務器。 但這對我來說完全令人困惑-這就是整個Java Web套接字方法不必要地變得復雜和繁瑣（與其他語言相比）。

首先，我有一個擴展Endpoint的類，然后我需要創建一個實現ServerApplicationConfig的新類，最后我需要創建一個ServerEndpointConfig。 然后，我需要在其他地方有一個主類，以實際啟動整個堆棧。 我確實認識到這是典型的Java行為，但是為什么我需要創建這些完全任意的配置類和對象？ 我現在在定義服務器端點URI時遇到了另一種復雜性，因為我現在必須在Web套接字服務器的實例化中定義基本URI和端口，然后需要在ServerEndpointConfig（ServerEndpointConfig.Builder中添加后綴。 create（MyEndpoint.class，“ / websocket”）），這意味着我現在有兩個地方可以定義單個URI。

最重要的是，我現在遇到了與注釋方法有關擴展Endpoint類的相同問題。 此類定義了所有事件，例如onOpen，onClose等，從代碼角度來看，這是非常不錯的。 問題在於，似乎我也無法在此處提供自己的構造函數。 實例化Web套接字服務器時，我只能引用Endpoint類，而不能提供任何用戶數據。 我發現了兩個不同的例子：

container.connectToServer(MyClient.class, URI.create(uri)); 

Server server = new Server("localhost", 8025, "/websockets", WordgameServerEndpoint.class);

作為對編程端點的最后說明，似乎完全沒有必要通過通常似乎是從onOpen內調用的addMessageHandler來強制onMessage事件的定義： 

@Override
  public void onOpen(final Session session, EndpointConfig ec) {
    session.addMessageHandler(new MessageHandler.Whole<String>() {

      @Override
      public void onMessage(String text) {
        try {
          session.getBasicRemote().sendText(text);
        } catch (IOException ex) {
          Logger.getLogger(MyEndpoint.class.getName()).log(Level.SEVERE, null, ex);
        }
      }
  });

我現在嘗試了許多不同的方法，而我的初步代碼如下： 

package websockets;

import java.lang.reflect.Method;
import javax.websocket.CloseReason;
import javax.websocket.DeploymentException;
import javax.websocket.OnClose;
import javax.websocket.OnMessage;
import javax.websocket.OnOpen;
import javax.websocket.Session;
import javax.websocket.server.ServerEndpoint;
import org.glassfish.tyrus.server.Server;
import processing.core.PApplet;

public class WebsocketServer3 {
    private PApplet parent;
    private Method webSocketServerEvent;
    private Session userSession = null;

    public WebsocketServer3(PApplet parent, String domain, int port, String uri){
        this.parent=parent;
        this.parent.registerMethod("dispose", this);

        Server server = new Server(domain, port, uri, WebsocketServerInstance.class);
        try {
            server.start();
        } catch (DeploymentException e) {
            e.printStackTrace();
        }

        try {
            webSocketServerEvent = parent.getClass().getMethod("webSocketServerEvent", String.class);
        } catch (Exception e) {
            // no such method, or an error.. which is fine, just ignore
        }
    }

    public void dispose(){
        // Anything in here will be called automatically when 
        // the parent sketch shuts down. For instance, this might
        // shut down a thread used by this library.
    }

    public void sendMessage(String mes){
        userSession.getAsyncRemote().sendText(mes);
    }


    @ServerEndpoint("/")
    public class WebsocketServerInstance {

        @OnOpen
        public void onOpen(Session session) {
            userSession=session;
            System.out.println("HI!!");
        }

        @OnMessage
        public void onMessage(String message, Session session) {
            if (webSocketServerEvent != null) {
                try {
                    webSocketServerEvent.invoke(parent, message);
                } catch (Exception e) {
                    System.err.println("Disabling webSocketServerEvent() because of an error.");
                    e.printStackTrace();
                    webSocketServerEvent = null;
                }
            }
        }

        @OnClose
        public void onClose(Session session, CloseReason closeReason) {
            System.out.println(String.format("Session %s closed because of %s",
                    session.getId(), closeReason));
        }
    }
}

我試圖使ServerEndpoint成為一個內部類，這是行不通的（我知道關於此問題還有另一篇文章，但是我無法從那篇文章中解決我的問題）。 我發布上述代碼的原因是為了提供一個示例，說明我希望編碼過程如何。

總而言之，我對於如何用Tyrus（或其他任何Java實現）創建一個簡單的Web套接字服務器感到非常困惑-我最了解的是TallNate的實現，但是似乎該庫也有一些問題-這是可以理解的，但是當我調用run方法時會出現問題-盡管討論不同。

我的總體問題是，是否有人可以指出我的方向，如何解決我的問題？

提前致謝

拉塞

1 個解決方案

解決方案1
 0 已采納  2015-12-15 12:55:55

我終於從這兩個帖子中得到了啟發，找到了解決問題的方法：

我的Maven POM文件： 

<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>
    <groupId>my.group.id</groupId>
    <artifactId>websockets</artifactId>
    <version>0.0.1-SNAPSHOT</version>

    <dependencies>
        <dependency>
            <groupId>org.slf4j</groupId>
            <artifactId>slf4j-api</artifactId>
            <version>1.7.13</version>
        </dependency>

        <dependency>
            <groupId>org.slf4j</groupId>
            <artifactId>slf4j-simple</artifactId>
            <version>1.7.13</version>
        </dependency>

        <dependency>
            <groupId>org.eclipse.jetty</groupId>
            <artifactId>jetty-server</artifactId>
            <version>9.3.6.v20151106</version>
        </dependency>

        <dependency>
            <groupId>org.eclipse.jetty</groupId>
            <artifactId>jetty-servlet</artifactId>
            <version>9.3.6.v20151106</version>
        </dependency>

        <dependency>
            <groupId>org.eclipse.jetty.websocket</groupId>
            <artifactId>websocket-server</artifactId>
            <version>9.3.6.v20151106</version>
        </dependency>

        <dependency>
            <groupId>org.eclipse.jetty.websocket</groupId>
            <artifactId>websocket-client</artifactId>
            <version>9.3.6.v20151106</version>
        </dependency>

    </dependencies>

    <build>
        <plugins>
            <plugin>
                <groupId>org.apache.maven.plugins</groupId>
                <artifactId>maven-dependency-plugin</artifactId>
                <version>2.5.1</version>
                <executions>
                    <execution>
                        <id>copy-dependencies</id>
                        <phase>package</phase>
                        <goals>
                            <goal>copy-dependencies</goal>
                        </goals>
                        <configuration>
                            <includeScope>runtime</includeScope>
                            <outputDirectory>${project.build.directory}/dependency-jars/</outputDirectory>
                        </configuration>
                    </execution>
                </executions>
            </plugin>
        </plugins>
    </build>

</project>

我的最終服務器代碼如下：

WebsocketServer.java 

package websockets;

import java.lang.reflect.Method;

import org.eclipse.jetty.server.Server;
import org.eclipse.jetty.server.handler.ContextHandler;
import org.eclipse.jetty.websocket.server.WebSocketHandler;
import org.eclipse.jetty.websocket.servlet.WebSocketServletFactory;

import processing.core.PApplet;

public class WebsocketServer {
    private PApplet parent;
    private Method websocketServerEvent;
    private WebsocketServerController serverController;

    public WebsocketServer(PApplet parent, int port, String uri){
        this.parent=parent;
        this.parent.registerMethod("dispose", this);

        try {
            websocketServerEvent = parent.getClass().getMethod("webSocketServerEvent", String.class);
        } catch (Exception e) {
            // no such method, or an error.. which is fine, just ignore
        }

        Server server = new Server(port);
        serverController = new WebsocketServerController(parent, websocketServerEvent);

        WebSocketHandler wsHandler = new WebSocketHandler(){

                @Override
                public void configure(WebSocketServletFactory factory){
                    factory.setCreator(new WebsocketServerCreator(serverController));
                }
        };

        ContextHandler contextHandler = new ContextHandler(uri);
        contextHandler.setAllowNullPathInfo(true); // disable redirect from /ws to /ws/
        contextHandler.setHandler(wsHandler);

        server.setHandler(contextHandler);

        try {
            server.start();
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

    //TODO: Add possibility for sending back to specific client
    public void sendMessage(String message){
        serverController.writeAllMembers(message);

    }

    public void dispose(){
        // Anything in here will be called automatically when 
        // the parent sketch shuts down. For instance, this might
        // shut down a thread used by this library.
    }
}

WebsocketServerCreator.java 

package websockets;

import org.eclipse.jetty.websocket.servlet.ServletUpgradeRequest;
import org.eclipse.jetty.websocket.servlet.ServletUpgradeResponse;
import org.eclipse.jetty.websocket.servlet.WebSocketCreator;

public class WebsocketServerCreator implements WebSocketCreator{
    private WebsocketServerController ctrl;

    public WebsocketServerCreator(WebsocketServerController ctrl){
        this.ctrl = ctrl;
    }

    public Object createWebSocket(ServletUpgradeRequest request, ServletUpgradeResponse response){
        return new WebsocketServerEvents(ctrl);
    }
}

WebsocketServerController 

package websockets;

import java.lang.reflect.Method;
import java.util.ArrayList;
import java.util.List;

import processing.core.PApplet;

public class WebsocketServerController {

    private List<WebsocketServerEvents> members = new ArrayList<>();
    private PApplet parent;
    private Method serverEvent;

    public WebsocketServerController(PApplet p, Method serverEvent){
        parent=p;
        this.serverEvent=serverEvent;
    }

    public void join(WebsocketServerEvents socket) {
        members.add(socket);
    }

    public void remove(WebsocketServerEvents socket) {
        members.remove(socket);
    }

    public void writeAllMembers(String message) {
        for (WebsocketServerEvents member : members) {
            member.session.getRemote().sendStringByFuture(message);
        }
    }

    public void writeSpecificMember(String memberName, String message) {
        WebsocketServerEvents member = findMemberByName(memberName);
        member.session.getRemote().sendStringByFuture(message);
    }

    public WebsocketServerEvents findMemberByName(String memberName) {
        return null;
    }

    public void sendToOnMessageListener(String message){
        if (serverEvent != null) {
            try {
                serverEvent.invoke(parent, message);
            } catch (Exception e) {
                System.err.println("Disabling webSocketEvent() because of an error.");
                e.printStackTrace();
                serverEvent = null;
            }
        }
    }
}

WebsocketServerEvents 

package websockets;

import org.eclipse.jetty.websocket.api.Session;
import org.eclipse.jetty.websocket.api.annotations.OnWebSocketClose;
import org.eclipse.jetty.websocket.api.annotations.OnWebSocketConnect;
import org.eclipse.jetty.websocket.api.annotations.OnWebSocketError;
import org.eclipse.jetty.websocket.api.annotations.OnWebSocketMessage;
import org.eclipse.jetty.websocket.api.annotations.WebSocket;

@WebSocket
public class WebsocketServerEvents {

    public Session session;
    public WebsocketServerController ctrl;

    public WebsocketServerEvents(WebsocketServerController ctrl) {
        this.ctrl=ctrl;
    }

    @OnWebSocketConnect
    public void handleConnect(Session session) {
        this.session = session;
        ctrl.join(this);
    }

    @OnWebSocketClose
    public void handleClose(int statusCode, String reason) {
        ctrl.remove(this);
    }

    @OnWebSocketMessage
    public void handleMessage(String message) {
        ctrl.sendToOnMessageListener(message);
    }

    @OnWebSocketError
    public void handleError(Throwable error) {
        error.printStackTrace();    
    }
}

它可能不是最好的解決方案，但我可以做到。 最令人困惑和晦澀的部分肯定是處理程序的概念。 其中有很多，並且很難弄清楚何時以及為什么使用哪個。

在使用Java使用Web套接字的最新經驗之后，我必須坐下來，我不鼓勵任何人使用Java作為此類應用程序的基礎。 如果可能的話，您絕對應該研究node.js，Python或類似工具（更易於理解和使用）。 如果您仍然想/被迫使用Java，那么我發現Jetty實現是最合適的（包括文檔和示例）。

問候

拉塞

暫無
暫無

聲明:本站的技術帖子網頁，遵循CC BY-SA 4.0協議，如果您需要轉載，請注明本站網址或者原文地址。任何問題請咨詢:yoyou2525@163.com.

相關問題 Java Server Socket 將字符串傳輸到 Web 套接字 使用Java套接字類連接到Web服務器 Java SSL套接字Web服務器錯誤證書 服務器外部的Web Socket Java客戶端 Java Socket Server-重定向到Web應用程序（Web服務） Java Web應用程序和C ++服務器之間的套接字通信 Java和Web套接字中的TimerTask Java的Web套接字映射 Java HTTP / 2服務器套接字 Java / SSL服務器套接字
相關標簽
 
粵ICP備18138465號  © 2020-2024 STACKOOM.COM