Java Web套接字服务器

时间：2015-12-12 09:22:38

标签： java websocket server

我正在尝试为Processing.org开发一个Web套接字库，我想使用Tyrus实现。

我设法使客户端工作没有任何问题。问题出现在Web套接字服务器周围 - 它看起来似乎不必要地复杂，并且创建服务器很麻烦（我在Python和node.js中开发了服务器，之前没有任何实际问题）。

本质上我想要一个简单的Web套接字服务器类，我可以在Processing中实例化。我想象的方式如下（加工草图）：

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); 
}

首先，没有必要关注子协议等细节。我只是希望Processing开发人员能够启动一个简单的Web套接字服务器，在构造函数，端口中声明完全限定的URI，并定义onMessage eventlistener方法。

我现在已经尝试解决这个问题几天了，我根本无法理解它。当使用Tyrus Annotated端点方法时，我会说代码非常干净，并且可以理解，但是一切看起来都是完全沙盒化的。我不能用我想要的参数介绍我自己的构造函数，我无法弄清楚如何以编程方式设置服务器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);

作为对程序化端点的最后评论，似乎完全没有必要强制通过addMessageHandler来定义onMessage事件，而addMessageHandler似乎经常从onOpen中调用：

@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方法时会出现问题 - 尽管讨论不同。）

我的整体质疑是，是否有人可以指出我的方向，如何解决我的问题？

提前致谢

Lasse

1 个答案:

答案 0 :(得分：0)

我终于找到了解决问题的方法，从这两个帖子中获得了很大的灵感：

My 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实现是最合适的（包括文档和示例）。

此致

拉​​塞

相关问题
最新问题