java-ee
Die WebSockets-API

Bemerkungen

WebSocket-Kommunikation erstellen

WebSocket bietet ein Duplex / bidirektionales Kommunikationsprotokoll über eine einzige TCP-Verbindung.

• Der Client stellt eine Verbindung zu einem Server her, der auf eine WebSocket-Anforderung wartet
• Ein Client stellt über einen URI eine Verbindung zu einem Server her.
• Ein Server kann Anforderungen von mehreren Clients abhören.

Server-Endpunkt

Sie können einen WebSocket-Server-Entpoint erstellen, indem Sie einfach einen POJO mit @ServerEndpoint kommentieren. @OnMessage dekoriert eine Methode, die eingehende Nachrichten empfängt. @OnOpen kann zum Dekorieren einer Methode verwendet werden, die aufgerufen wird, wenn eine neue Verbindung von einem Peer empfangen wird. Ebenso wird eine mit @OnClose annotierte Methode aufgerufen, wenn eine Verbindung geschlossen wird.

@ServerEndpoint("/websocket")
public class WebSocketServerEndpoint
{

    @OnOpen
    public void open(Session session) {
     System.out.println("a client connected");
    }

    @OnClose
    public void close(Session session) {
     System.out.println("a client disconnected");
    }

    @OnMessage
    public void handleMessage(String message) {
        System.out.println("received a message from a websocket client! " + message);
    }

}

Client Enpoint

Ähnlich wie beim @ClientEndpoint können Sie einen WebSocket-Clientendpunkt erstellen, indem Sie ein POJO mit @ClientEndpoint kommentieren.

@ClientEndpoint
public class WebsocketClientEndpoint {

    Session userSession = null;
    
    // in our case i.e. "ws://localhost:8080/myApp/websocket"
    public WebsocketClientEndpoint(URI endpointURI) {
        WebSocketContainer container = ContainerProvider.getWebSocketContainer();
        container.connectToServer(this, endpointURI);
    }

    @OnOpen
    public void onOpen(Session userSession) {
        System.out.println("opening websocket");
        this.userSession = userSession;
    }

    @OnClose
    public void onClose(Session userSession, CloseReason reason) {
        System.out.println("closing websocket");
        this.userSession = null;
    }

    @OnMessage
    public void onMessage(String message) {
        System.out.println("received message: "+ message);
    }

    public void sendMessage(String message) {
        System.out.println("sending message: "+ message);
        this.userSession.getAsyncRemote().sendText(message);
    }
}

Encoder und Decoder: Objektorientierte WebSockets

Dank Encodern und Decodern bietet der JSR 356 objektorientierte Kommunikationsmodelle.

Nachrichtendefinition

Angenommen, alle empfangenen Nachrichten müssen vom Server umgewandelt werden, bevor sie an alle verbundenen Sitzungen zurückgesendet werden:

public abstract class AbstractMsg {
    public abstract void transform();
}

Nehmen wir nun an, dass der Server zwei Nachrichtentypen verwaltet: eine textbasierte Nachricht und eine ganzzahlige Nachricht.

Ganzzahlige Nachrichten multiplizieren den Inhalt mit sich selbst.

public class IntegerMsg extends AbstractMsg {

    private Integer content;

    public IntegerMsg(int content) {
        this.content = content;
    }

    public Integer getContent() {
        return content;
    }

    public void setContent(Integer content) {
        this.content = content;
    }

    @Override
    public void transform() {
        this.content = this.content * this.content;
    }
}

String-Nachricht vor einem Text:

public class StringMsg extends AbstractMsg {

    private String content;

    public StringMsg(String content) {
        this.content = content;
    }

    public String getContent() {
        return content;
    }

    public void setContent(String content) {
        this.content = content;
    }

    @Override
    public void transform() {
        this.content = "Someone said: " + this.content;
    }
}

Encoder und Decoder

Es gibt einen Codierer pro Nachrichtentyp und einen einzelnen Decoder für alle Nachrichten. Encoder müssen die Schnittstelle Encoder.XXX<Type> implementieren, wenn Decoder Decoder.XXX<Type> implementieren muss.

Die Kodierung ist ziemlich einfach: Aus einer Nachricht muss die encode einen JSON-formatierten String ausgeben. Hier ist das Beispiel für IntegerMsg .

public class IntegerMsgEncoder implements Encoder.Text<IntegerMsg> {

    @Override
    public String encode(IntegerMsg object) throws EncodeException {
        JsonObjectBuilder builder = Json.createObjectBuilder();
        
        builder.add("content", object.getContent());
        
        JsonObject jsonObject = builder.build();
        return jsonObject.toString();
    }

    @Override
    public void init(EndpointConfig config) {
        System.out.println("IntegerMsgEncoder initializing");
    }

    @Override
    public void destroy() {
        System.out.println("IntegerMsgEncoder closing");
    }
}

Ähnliche Kodierung für die StringMsg Klasse. Offensichtlich können Encoder über abstrakte Klassen faktorisiert werden.

public class StringMsgEncoder implements Encoder.Text<StringMsg> {

    @Override
    public String encode(StringMsg object) throws EncodeException {
        JsonObjectBuilder builder = Json.createObjectBuilder();

        builder.add("content", object.getContent());

        JsonObject jsonObject = builder.build();
        return jsonObject.toString();
    }

    @Override
    public void init(EndpointConfig config) {
        System.out.println("StringMsgEncoder initializing");
    }

    @Override
    public void destroy() {
        System.out.println("StringMsgEncoder closing");
    }

}

Decoder geht in zwei Schritten vor: Prüfen, ob die empfangene Nachricht mit willDecode das ausgenommene Format willDecode und dann die empfangene willDecode Nachricht in ein Objekt mit decode umwandeln:

öffentliche Klasse MsgDecoder implementiert Decoder.Text {

@Override
public AbstractMsg decode(String s) throws DecodeException {
    // Thanks to willDecode(s), one knows that
    // s is a valid JSON and has the attribute
    // "content"
    JsonObject json = Json.createReader(new StringReader(s)).readObject();
    JsonValue contentValue = json.get("content");

    // to know if it is a IntegerMsg or a StringMsg, 
    // contentValue type has to be checked:
    switch (contentValue.getValueType()) {
        case STRING:
            String stringContent = json.getString("content");
            return new StringMsg(stringContent);
        case NUMBER:
            Integer intContent = json.getInt("content");
            return new IntegerMsg(intContent);
        default:
            return null;
    }

}

@Override
public boolean willDecode(String s) {

    // 1) Incoming message is a valid JSON object
    JsonObject json;
    try {
        json = Json.createReader(new StringReader(s)).readObject();
    }
    catch (JsonParsingException e) {
        // ...manage exception...
        return false;
    }
    catch (JsonException e) {
        // ...manage exception...
        return false;
    }

    // 2) Incoming message has required attributes
    boolean hasContent = json.containsKey("content");

    // ... proceed to additional test ...
    return hasContent;
}

@Override
public void init(EndpointConfig config) {
    System.out.println("Decoding incoming message...");
}

@Override
public void destroy() {
    System.out.println("Incoming message decoding finished");
}

}

ServerEndPoint

Der Server EndPoint sieht ziemlich aus wie die WebSocket-Kommunikation mit drei Hauptunterschieden:

1. Die ServerEndPoint-Annotation verfügt über die Attribute encoders und decoders

2. Nachrichten werden nicht mit sendText gesendet, sondern mit sendObject

3. OnError-Annotation wird verwendet. Wenn bei willDecode ein Fehler willDecode , wird dieser hier verarbeitet und die Fehlerinformationen werden an den Client zurückgesendet

   @ServerEndpoint (value = "/ webSocketObjectEndPoint", decoder = {MsgDecoder.class}, encoders = {StringMsgEncoder.class, IntegerMsgEncoder.class}) Öffentliche Klasse ServerEndPoint {

   @OnOpen
   public void onOpen(Session session) {
       System.out.println("A session has joined");
   }
   
   @OnClose
   public void onClose(Session session) {
       System.out.println("A session has left");
   }
   
   @OnMessage
   public void onMessage(Session session, AbstractMsg message) {
       if (message instanceof IntegerMsg) {
           System.out.println("IntegerMsg received!");
       } else if (message instanceof StringMsg) {
           System.out.println("StringMsg received!");
       }
   
       message.transform();
       sendMessageToAllParties(session, message);
   }
   
   @OnError
   public void onError(Session session, Throwable throwable) {
       session.getAsyncRemote().sendText(throwable.getLocalizedMessage());
   }
   
   private void sendMessageToAllParties(Session session, AbstractMsg message) {
       session.getOpenSessions().forEach(s -> {
           s.getAsyncRemote().sendObject(message);
       });
   }
   

   }

Da ich ziemlich ausführlich war, hier ein grundlegender JavaScript-Client für diejenigen, die ein visuelles Beispiel haben möchten. Bitte beachten Sie, dass dies ein Chat-ähnliches Beispiel ist: Alle verbundenen Parteien erhalten die Antwort.

<!DOCTYPE html>
<html>
    <head>
        <title>Websocket-object</title>
        <meta http-equiv="Content-Type" content="text/html; charset=UTF-8">        
        <!-- start of BAD PRACTICE! all style and script must go into a
             dedicated CSS / JavaScript file-->
        <style>
            body{
                background: dimgray;
            }

            .container{
                width: 100%;
                display: flex;
            }

            .left-side{
                width: 30%;
                padding: 2%;
                box-sizing:  border-box;
                margin: auto;
                margin-top: 0;
                background: antiquewhite;
            }
            .left-side table{
                width: 100%;
                border: 1px solid black;
                margin: 5px;
            }
            .left-side table td{
                padding: 2px;
                width: 50%;
            }
            .left-side table input{
                width: 100%;
                box-sizing: border-box;
            }

            .right-side{
                width: 70%;
                background: floralwhite;
            }
        </style>

        <script>
            var ws = null;
            window.onload = function () {
                // replace the 'websocket-object' with the
                // context root of your web application.
                ws = new WebSocket("ws://localhost:8080/websocket-object/webSocketObjectEndPoint");
                ws.onopen = onOpen;
                ws.onclose = onClose;
                ws.onmessage = onMessage;
            };

            function onOpen() {
                printText("", "connected to server");
            }

            function onClose() {
                printText("", "disconnected from server");
            }

            function onMessage(event) {
                var msg = JSON.parse(event.data);
                printText("server", JSON.stringify(msg.content));
            }

            function sendNumberMessage() {
                var content = new Number(document.getElementById("inputNumber").value);
                var json = {content: content};
                ws.send(JSON.stringify(json));
                printText("client", JSON.stringify(json));
            }

            function sendTextMessage() {
                var content = document.getElementById("inputText").value;
                var json = {content: content};
                ws.send(JSON.stringify(json));
                printText("client", JSON.stringify(json));
            }

            function printText(sender, text) {
                var table = document.getElementById("outputTable");
                var row = table.insertRow(1);
                var cell1 = row.insertCell(0);
                var cell2 = row.insertCell(1);
                var cell3 = row.insertCell(2);

                switch (sender) {
                    case "client":
                        row.style.color = "orange";
                        break;
                    case "server":
                        row.style.color = "green";
                        break;
                    default:
                        row.style.color = "powderblue";
                }
                cell1.innerHTML = new Date().toISOString();
                cell2.innerHTML = sender;
                cell3.innerHTML = text;
            }
        </script>

        <!-- end of bad practice -->
    </head>
    <body>

        <div class="container">
            <div class="left-side">
                <table>
                    <tr>
                        <td>Enter a text</td>
                        <td><input id="inputText" type="text" /></td>
                    </tr>
                    <tr>
                        <td>Send as text</td>
                        <td><input type="submit" value="Send" onclick="sendTextMessage();"/></td>
                    </tr>
                </table>

                <table>
                    <tr>
                        <td>Enter a number</td>
                        <td><input id="inputNumber" type="number" /></td>
                    </tr>
                    <tr>
                        <td>Send as number</td>
                        <td><input type="submit" value="Send" onclick="sendNumberMessage();"/></td>
                    </tr>
                </table>
            </div>
            <div class="right-side">
                <table id="outputTable">
                    <tr>
                        <th>Date</th>
                        <th>Sender</th>
                        <th>Message</th>
                    </tr>
                </table>
            </div>
        </div>
    </body>
</html>

Code ist vollständig und wurde unter Payara 4.1 getestet. Beispiel ist reiner Standard (keine externe Bibliothek / Framework)