java-ee
WebSockets API

Anmärkningar

Skapa en WebSocket-kommunikation

WebSocket tillhandahåller ett duplex / dubbelriktat kommunikationsprotokoll över en enda TCP-anslutning.

• klienten öppnar en anslutning till en server som lyssnar efter en WebSocket-begäran
• en klient ansluter till en server med en URI.
• En server kan lyssna på förfrågningar från flera klienter.

Server Endpoint

Du kan skapa en WebSocket-server entpoint genom att bara kommentera en POJO med @ServerEndpoint . @OnMessage dekorerar en metod som tar emot inkommande meddelanden. @OnOpen kan användas för att dekorera en metod som ska kallas när en ny anslutning från en kamrat tas emot. På liknande sätt kallas en metod som är antecknad med @OnClose när en anslutning stängs.

@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

I likhet med serverens slutpunkt kan du skapa en WebSocket-klientens slutpunkt genom att kommentera en POJO med @ClientEndpoint .

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

Kodare och avkodare: Objektorienterade webbuttag

Tack vare kodare och avkodare erbjuder JSR 356 en objektorienterad kommunikationsmodell.

Meddelandets definition

Låt oss anta att alla mottagna meddelanden måste omvandlas av servern innan de skickas tillbaka till alla anslutna sessioner:

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

Låt oss nu anta att servern hanterar två meddelandetyper: ett textbaserat meddelande och ett heltalbaserat meddelande.

Heltalsmeddelanden multiplicerar innehållet med sig själv.

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

Strängmeddelande beror på en del 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;
    }
}

Kodare och avkodare

Det finns en kodare per meddelandetyp och en enda avkodare för alla meddelanden. Kodare måste implementera Encoder.XXX<Type> när avkodaren måste implementera Decoder.XXX<Type> .

Kodning är ganska enkelt: från ett meddelande, att encode metoden måste avge en JSON formaterad sträng. Här är exemplet 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");
    }
}

Liknande kodning för StringMsg klassen. Uppenbarligen kan kodare faktoriseras via abstrakta klasser.

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

}

Avkodaren fortsätter i två steg: kontrollera om det mottagna meddelandet passar det undantagna formatet med willDecode och förvandlar sedan det mottagna råmeddelandet till ett objekt med decode :

public class MsgDecoder implementerar 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

Server EndPoint ser ganska ut som WebSocket-kommunikationen med tre huvudskillnader:

1. ServerEndPoint-anteckningen har attributen encoders och decoders

2. Meddelanden skickas inte med sendText utan med sendObject

3. OnError-kommentar används. Om ett fel kastades under willDecode kommer det att behandlas här och felinformation skickas tillbaka till klienten

   @ServerEndpoint (value = "/ webSocketObjectEndPoint", avkodare = {MsgDecoder.class}, kodare = {StringMsgEncoder.class, IntegerMsgEncoder.class}) public class 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);
       });
   }
   

   }

Eftersom jag var ganska fullständig, här är en grundläggande JavaScript-klient för dig som vill ha ett visuellt exempel. Observera att detta är ett chattliknande exempel: alla anslutna parter får svaret.

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

Koden är fullständig och testades under Payara 4.1. Exempel är ren standard (inget externt bibliotek / ramverk)