javax.websocket client einfaches beispiel

103

Kann mir bitte jemand ein sehr einfaches Beispiel für die Verwendung eines Websocket-Clients geben javax.websocket?

Ich möchte eine Verbindung zum Websocket (ws: //socket.example.com: 1234) herstellen, eine Nachricht senden (Kanal hinzufügen) und Nachrichten abhören. Alle Nachrichten (gesendet und abgehört) sind im JSON-Format.

Und übrigens ist diese Bibliothek die beste für die einfache Websocket-Kommunikation?

Martin
quelle

Antworten:

120

Ich habe hier ein großartiges Beispiel javax.websocketgefunden:

http://www.programmingforliving.com/2013/08/jsr-356-java-api-for-websocket-client-api.html

Hier der Code basierend auf dem oben verlinkten Beispiel:

TestApp.java::

package testapp;

import java.net.URI;
import java.net.URISyntaxException;

public class TestApp {

    public static void main(String[] args) {
        try {
            // open websocket
            final WebsocketClientEndpoint clientEndPoint = new WebsocketClientEndpoint(new URI("wss://real.okcoin.cn:10440/websocket/okcoinapi"));

            // add listener
            clientEndPoint.addMessageHandler(new WebsocketClientEndpoint.MessageHandler() {
                public void handleMessage(String message) {
                    System.out.println(message);
                }
            });

            // send message to websocket
            clientEndPoint.sendMessage("{'event':'addChannel','channel':'ok_btccny_ticker'}");

            // wait 5 seconds for messages from websocket
            Thread.sleep(5000);

        } catch (InterruptedException ex) {
            System.err.println("InterruptedException exception: " + ex.getMessage());
        } catch (URISyntaxException ex) {
            System.err.println("URISyntaxException exception: " + ex.getMessage());
        }
    }
}

WebsocketClientEndpoint.java::

package testapp;

import java.net.URI;
import javax.websocket.ClientEndpoint;
import javax.websocket.CloseReason;
import javax.websocket.ContainerProvider;
import javax.websocket.OnClose;
import javax.websocket.OnMessage;
import javax.websocket.OnOpen;
import javax.websocket.Session;
import javax.websocket.WebSocketContainer;

/**
 * ChatServer Client
 *
 * @author Jiji_Sasidharan
 */
@ClientEndpoint
public class WebsocketClientEndpoint {

    Session userSession = null;
    private MessageHandler messageHandler;

    public WebsocketClientEndpoint(URI endpointURI) {
        try {
            WebSocketContainer container = ContainerProvider.getWebSocketContainer();
            container.connectToServer(this, endpointURI);
        } catch (Exception e) {
            throw new RuntimeException(e);
        }
    }

    /**
     * Callback hook for Connection open events.
     *
     * @param userSession the userSession which is opened.
     */
    @OnOpen
    public void onOpen(Session userSession) {
        System.out.println("opening websocket");
        this.userSession = userSession;
    }

    /**
     * Callback hook for Connection close events.
     *
     * @param userSession the userSession which is getting closed.
     * @param reason the reason for connection close
     */
    @OnClose
    public void onClose(Session userSession, CloseReason reason) {
        System.out.println("closing websocket");
        this.userSession = null;
    }

    /**
     * Callback hook for Message Events. This method will be invoked when a client send a message.
     *
     * @param message The text message
     */
    @OnMessage
    public void onMessage(String message) {
        if (this.messageHandler != null) {
            this.messageHandler.handleMessage(message);
        }
    }

    /**
     * register message handler
     *
     * @param msgHandler
     */
    public void addMessageHandler(MessageHandler msgHandler) {
        this.messageHandler = msgHandler;
    }

    /**
     * Send a message.
     *
     * @param message
     */
    public void sendMessage(String message) {
        this.userSession.getAsyncRemote().sendText(message);
    }

    /**
     * Message handler.
     *
     * @author Jiji_Sasidharan
     */
    public static interface MessageHandler {

        public void handleMessage(String message);
    }
}
Martin
quelle
1
Hallo, wie funktioniert dieser Code, wenn der websocketServer einen kontinuierlichen Nachrichtenstrom sendet und websocketClient die Nachrichten einzeln verarbeiten muss? Ich erhalte die Fehlermeldung "Die dekodierte Textnachricht war zu groß für den Ausgabepuffer und der Endpunkt unterstützt keine Teilnachrichten", nachdem
ich
Stellen Sie sicher, dass Sie org.java-websocket maven-importieren.
Albert Hendriks
8
Dieser Code schlägt mit dem Fehler fehl: Es konnte keine Implementierungsklasse gefunden werden.
Kirk Sefchik
2
@deathgaze javax.websocket api ist nur die Spezifikation nicht vollständig implementiert Sie müssen möglicherweise die JAR-Datei tyrus-standalone-client-1.9.jar nehmen und das gleiche Beispiel versuchen, das Ihr Problem lösen sollte. Ich habe mit meinem Beispiel getestet und es funktioniert gut. hoffe das wird dir helfen.
SRK
@Martin Wie kann ich beim Öffnen eine Nachricht senden? Beispiel: Ich muss '{"type": "subscribe", "symbol": "AAPL"}' senden, wenn ich den Websocket zum Abonnieren öffne.
Buddhika
40

TooTallNate hat eine einfache clientseitige https://github.com/TooTallNate/Java-WebSocket

Fügen Sie einfach die Datei java_websocket.jar im Ordner dist in Ihr Projekt ein.

 import org.java_websocket.client.WebSocketClient;
 import org.java_websocket.drafts.Draft_10;
 import org.java_websocket.handshake.ServerHandshake;
 import org.json.JSONException;
 import org.json.JSONObject;

  WebSocketClient mWs = new WebSocketClient( new URI( "ws://socket.example.com:1234" ), new Draft_10() )
{
                    @Override
                    public void onMessage( String message ) {
                     JSONObject obj = new JSONObject(message);
                     String channel = obj.getString("channel");
                    }

                    @Override
                    public void onOpen( ServerHandshake handshake ) {
                        System.out.println( "opened connection" );
                    }

                    @Override
                    public void onClose( int code, String reason, boolean remote ) {
                        System.out.println( "closed connection" );
                    }

                    @Override
                    public void onError( Exception ex ) {
                        ex.printStackTrace();
                    }

                };
 //open websocket
 mWs.connect();
 JSONObject obj = new JSONObject();
 obj.put("event", "addChannel");
 obj.put("channel", "ok_btccny_ticker");
 String message = obj.toString();
 //send message
 mWs.send(message);

// und um den Websocket zu schließen

 mWs.close();
TCassells
quelle
4
Der Server war Ubuntu und arbeitete unter Windows 7, Windows 8 und OS X Mountain Lion mit Eclipse.
TCassells
1
Warum sollten Sie diese Bibliothek anstelle von Javax wählen?
BvuRVKyUVlViVIc7
2
weil es offensichtlich einfacher ist
Kyle Luke
4
Welche Änderungen sind erforderlich, um das WSS-Protokoll (gesichertes WS) zu unterstützen?
Mihailo Stupar
2
Tolle Bibliothek, aber es gibt Probleme mit wss. Das Projekt hat mehrere offene Probleme, und der Entwickler kommentiert, dass er keine Zeit mehr hat.
SiKing
18

Schauen Sie sich diese Java EE 7-Beispiele von Arun Gupta an.

Ich gabelte es auf Github .

Main

/**
 * @author Arun Gupta
 */
public class Client {

    final static CountDownLatch messageLatch = new CountDownLatch(1);

    public static void main(String[] args) {
        try {
            WebSocketContainer container = ContainerProvider.getWebSocketContainer();
            String uri = "ws://echo.websocket.org:80/";
            System.out.println("Connecting to " + uri);
            container.connectToServer(MyClientEndpoint.class, URI.create(uri));
            messageLatch.await(100, TimeUnit.SECONDS);
        } catch (DeploymentException | InterruptedException | IOException ex) {
            Logger.getLogger(Client.class.getName()).log(Level.SEVERE, null, ex);
        }
    }
}

ClientEndpoint

/**
 * @author Arun Gupta
 */
@ClientEndpoint
public class MyClientEndpoint {
    @OnOpen
    public void onOpen(Session session) {
        System.out.println("Connected to endpoint: " + session.getBasicRemote());
        try {
            String name = "Duke";
            System.out.println("Sending message to endpoint: " + name);
            session.getBasicRemote().sendText(name);
        } catch (IOException ex) {
            Logger.getLogger(MyClientEndpoint.class.getName()).log(Level.SEVERE, null, ex);
        }
    }

    @OnMessage
    public void processMessage(String message) {
        System.out.println("Received message in client: " + message);
        Client.messageLatch.countDown();
    }

    @OnError
    public void processError(Throwable t) {
        t.printStackTrace();
    }
}
Koekiebox
quelle
Sie sollten erwähnen, dass die Websocket-Abhängigkeit
Java Main
1

Verwenden Sie diese Bibliothek org.java_websocket

Als erstes sollten Sie diese Bibliothek in build.gradle importieren

repositories {
 mavenCentral()
 }

Fügen Sie dann die Implementierung in Abhängigkeit {} hinzu

implementation "org.java-websocket:Java-WebSocket:1.3.0"

Dann können Sie diesen Code verwenden

In Ihrer Aktivität deklarieren Sie Objekt für Websocketclient wie

private WebSocketClient mWebSocketClient;

Fügen Sie dann diese Methode für den Rückruf hinzu

 private void ConnectToWebSocket() {
URI uri;
try {
    uri = new URI("ws://your web socket url");
} catch (URISyntaxException e) {
    e.printStackTrace();
    return;
}

mWebSocketClient = new WebSocketClient(uri) {
    @Override
    public void onOpen(ServerHandshake serverHandshake) {
        Log.i("Websocket", "Opened");
        mWebSocketClient.send("Hello from " + Build.MANUFACTURER + " " + Build.MODEL);
    }

    @Override
    public void onMessage(String s) {
        final String message = s;
        runOnUiThread(new Runnable() {
            @Override
            public void run() {
                TextView textView = (TextView)findViewById(R.id.edittext_chatbox);
                textView.setText(textView.getText() + "\n" + message);
            }
        });
    }

    @Override
    public void onClose(int i, String s, boolean b) {
        Log.i("Websocket", "Closed " + s);
    }

    @Override
    public void onError(Exception e) {
        Log.i("Websocket", "Error " + e.getMessage());
    }
};
mWebSocketClient.connect();

}}

Muhammed Fasil
quelle
-2

Ich habe Spring 4.2 in meinem Projekt und viele SockJS Stomp-Implementierungen funktionieren normalerweise gut mit Spring Boot-Implementierungen. Diese Implementierung von Baeldung hat funktioniert (für mich ohne Wechsel von Spring 4.2 auf 5). Nachdem ich die in seinem Blog erwähnten Abhängigkeiten verwendet hatte, gab es mir immer noch ClassNotFoundError. Ich habe die folgende Abhängigkeit hinzugefügt, um das Problem zu beheben.

<dependency>
        <groupId>org.springframework</groupId>
        <artifactId>spring-core</artifactId>
        <version>4.2.3.RELEASE</version>
    </dependency>
veritas
quelle