Java Web套接字服务器

Question

I'm trying to develop a Web socket library for Processing.org, and I want to use the Tyrus implementation.

I have managed to make the client work without any issues. The problems arrive around the Web socket server - it simply seems unnecessarily complex, and cumbersome to create a server (I have developed servers in both Python, and node.js previously without any real issues).

In essence I want to have a simple Web socket server class I can instantiate in Processing. The way I imagine it to be is as follows (a Processing sketch):

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

At first it is not necessary to focus on specifics like sub-protocols and the like. I simply want a Processing developer to be able to spin up a simple web socket server, stating the fully qualified URI in the constructor, the port, and define the onMessage eventlistener method.

I have now been trying to solve this for a few days, and I simply can't get my head around it. When using the Tyrus Annotated endpoint approach I would say that the code is quite clean, and understandable, but everything seems completely sandboxed. I can't introduce my own constructor with the parameters I want, and I can't figure out how to set the server URI programatically. When I can't introduce my own existing objects in the server endpoint, I can't propagate messages to my event listener method from above (webSocketServerEvent). Additionally, the URI needs to be hardcoded as a parameter in the annotation (@ServerEndpoint(value = "/game")), which is a nice feature, but to me this would only be useful in very specific situations, and not the common use case.

My preliminary conclusion on the annotation approach is that it is very sandboxed, and primarily developed for standalone situations, where there is no need to be integrated into an other Java project. I'm fully aware that this conclusion can't be correct, which is exactly why I'm asking you guys to help me understand how to go about the issue.

I have also been looking into the programmatic approach to Tyrus, and is seems like it is actually possible to configure your server to your needs. But this is where it becomes completely confusing for me - this is where the entire Java Web socket approach becomes unnecessarily complex and cumbersome (comparing to other languages).

First of all, I have a class extending Endpoint, then I need to create a new class implementing ServerApplicationConfig, and I finally need to create a ServerEndpointConfig. I then need to have a main class somewhere else, to actually initiate the entire stack. I do recognise that this is typical Java behavior, but why do I need to create these completely arbitrary configuration classes and objects? I now run into an other complexity on defining the server endpoint URI, since I now have to define the base URI and port in the instantiation of the web socket server, and I then need to add a suffix in the ServerEndpointConfig (ServerEndpointConfig.Builder.create(MyEndpoint.class, "/websocket")), meaning that I now have two places to define a single URI.

On top of the above I now run into the same issues as with the annotation approach regarding the class that extends Endpoint. This class defines all the events like onOpen, onClose etc., which is quite nice from a devision of code perspective. The issue is that it seems like I can't provide my own constructor here as well. When instantiating the web socket server I can only refer to the Endpoint class and not provide any user data. I have found two different examples of this:

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

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

As a final remark to the programmatic endpoint, it seems completely unnecessary to force the definition of the onMessage event to happen through an addMessageHandler that often times seems to be called from within 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);
        }
      }
  });

I have tried quite a few different approaches now, and my preliminary code is as follows:

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

I have tried to make the ServerEndpoint into an inner class, which doesn't work (I know there exists an other post on this issue, but I haven't been able to solve my issue from that post). The reason why I post the above code, is to provide an example of how I would like the coding procedure to be.

All-in-all, I'm quite confused about how to create a simple web socket server with Tyrus (or any of the other Java implementations for that matter - the one I got furthest with is the one from TallNate, but there seems to be some issues with that library as well - it's quite understandable, but the issues arise when i call the run method - different discussion though).

My overall question is if anyone could point me in a direction, on how to solve my problem?

Thanks in advance

Lasse

Answer 1

I finally found a solution to my problem, with great inspiration from these two posts:

• How do I access instantiated WebSockets in Jetty 9?
• Can i run WebAppContext with WebSocketHandler in same instance?

My Maven POM file:

<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>

My final server code is as follows:

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

It might not be the best of solutions, but I does the job. The most confusing and obscure part is definitely the idea of handlers. There are quite a few of them, and it's really hard to figure out which to use when and why.

After my latest experiences with Web sockets in Java I must sat that, I would not encourage anyone to use Java as foundation for this kind of applications. If possible you should definitely look into node.js, Python or the like (way easier to understand and use). If you still want / are forced to use Java, then I have found the Jetty implementation to be the best suited (including documentation and example wise).

Regards

Lasse