So verwenden Sie WebSocket für die Echtzeit-Dateiübertragung in Java

In modernen Internetanwendungen ist die Dateiübertragung in Echtzeit ein fester Bestandteil. Es gibt viele Methoden für die Echtzeitübertragung, wobei WebSocket die am häufigsten verwendete ist. Mit der WebSocket-API in Java können Sie einfach und unkompliziert Echtzeit-Dateiübertragungsfunktionen implementieren. Dieser Artikel zeigt Ihnen, wie Sie WebSocket für die Echtzeit-Dateiübertragung in Java verwenden, und stellt einige konkrete Codebeispiele bereit.

Einführung in WebSocket

WebSocket ist Teil des HTML5-Standards und ein auf TCP basierendes Netzwerkprotokoll. Dieses Protokoll bietet eine Netzwerkfähigkeit für die bidirektionale Kommunikation über eine einzelne TCP-Verbindung und ermöglicht so eine Übertragung in Echtzeit. Dies unterscheidet sich vom herkömmlichen HTTP-Protokoll, das ein zustandsloses Protokoll ist und für jede Anfrage den Aufbau einer neuen Verbindung erfordert.

Die Hauptmerkmale des WebSocket-Protokolls sind wie folgt:

1. Echtzeit: WebSocket kann eine lange Verbindung aufrechterhalten, eine Echtzeitübertragung erreichen und jede Art von Daten zwischen dem Server und dem Client übertragen.
2. Zwei-Wege-Kommunikation: WebSocket unterstützt die bidirektionale Kommunikation, anstatt nur auf die Anfrage des Clients zu warten.
3. Unterstützt mehrere Datenformate: WebSocket kann mehrere Datentypen wie Text, Binärdaten usw. übertragen und die Anforderungen verschiedener Arten von Anwendungen erfüllen.

Verwendung der Java WebSocket API

Java8 führt JSR-356 ein, die WebSocket-Standard-API in Java. Die Hauptklassen der Java WebSocket-API befinden sich im Paket javax.websocket. Die API ist hauptsächlich in zwei Kategorien unterteilt, die sich auf die WebSocket-Verbindung selbst beziehen, und die andere auf die Nachrichtenverarbeitung.

WebSocket-verbindungsbezogene API

Endpunkt: stellt einen WebSocket-Endpunkt dar, der Client-Verbindungsanfragen und Verbindungstrennungsanfragen empfangen kann.

Sitzung: Stellt eine WebSocket-Verbindungssitzung dar, die zum Senden und Empfangen von Text- und Binärnachrichten verwendet wird.

MessageHandler: WebSocket-Nachrichtenverarbeitungsschnittstelle mit zwei Implementierungsklassen Text und Binary. Benutzer können Nachrichten abhören und verarbeiten, indem sie diese Schnittstelle abonnieren.

API für die WebSocket-Nachrichtenverarbeitung

OnMessage: Die Verarbeitungsmethode der vom WebSocket-Client gesendeten Nachrichten kann durch Anmerkungen implementiert werden.

RemoteEndpoint: wird zum Senden von Nachrichten verwendet.

Verwendung von WebSocket

In der tatsächlichen Entwicklung sind normalerweise ein WebSocket-Server und ein WebSocket-Client erforderlich. Im Folgenden stellen wir vor, wie WebSocket zur Implementierung der Dateiübertragungsfunktion verwendet wird.

WebSocket-Server

1. Zunächst müssen wir einen WebSocket-Endpunkt erstellen. In diesem Endpunkt können wir WebSocket-Verbindungsanfragen und Verbindungstrennungsanfragen verarbeiten und eine Sitzungsinstanz erstellen, um eine Sitzung mit dem Client aufzubauen.

import java.io.IOException;
import java.nio.ByteBuffer;
import java.util.logging.Level;
import java.util.logging.Logger;

import javax.websocket.OnClose;
import javax.websocket.OnError;
import javax.websocket.OnMessage;
import javax.websocket.OnOpen;
import javax.websocket.PongMessage;
import javax.websocket.RemoteEndpoint;
import javax.websocket.Session;
import javax.websocket.server.ServerEndpoint;

@ServerEndpoint("/filetransfer")
public class FileTransferEndpoint {

    private static final Logger LOGGER = Logger.getLogger(FileTransferEndpoint.class.getName());

    @OnOpen
    public void onOpen(Session session) {
        LOGGER.log(Level.INFO, "Session " + session.getId() + " has opened a connection");
    }

    @OnMessage
    public void onMessage(ByteBuffer message, Session session) {
        LOGGER.log(Level.INFO, "Received ByteBuffer message from " + session.getId());
        try {
            RemoteEndpoint.Basic remote = session.getBasicRemote();
            remote.sendText("Hello, " + message.toString());
        } catch (IOException e) {
            LOGGER.log(Level.SEVERE, "Failed to send ByteBuffer message ", e);
        }
    }

    @OnMessage
    public void onMessage(String message, Session session) {
        LOGGER.log(Level.INFO, "Received Text message from " + session.getId() + ": " + message);
        try {
            RemoteEndpoint.Basic remote = session.getBasicRemote();
            remote.sendText("Hello, " + message);
        } catch (IOException e) {
            LOGGER.log(Level.SEVERE, "Failed to send Text message ", e);
        }
    }

    @OnMessage
    public void onMessage(PongMessage message, Session session) {
        LOGGER.log(Level.INFO, "Received pong message from " + session.getId() + ": " + message);
    }

    @OnError
    public void onError(Throwable exception, Session session) {
        LOGGER.log(Level.SEVERE, "Session " + session.getId() + " occurred exception ", exception);
    }

    @OnClose
    public void onClose(Session session) {
        LOGGER.log(Level.INFO, "Session " + session.getId() + " has closed the connection");
    }
}

2. Im obigen Codeausschnitt haben wir drei onMessage-Methoden implementiert, um Daten der Typen ByteBuffer, String und PongMessage zu verarbeiten.
3. Starten Sie den Server, damit der WebSocket-Server die Verbindungsanfrage des Clients akzeptiert.

import javax.websocket.WebSocketContainer;
import javax.websocket.server.ServerEndpointConfig;
import org.glassfish.tyrus.server.Server;

public class Main {

    public static void main(String[] args) {
        Server server = new Server("localhost", 8080, "/", null, FileTransferEndpoint.class);

        try {
            server.start();
            System.in.read();
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            server.stop();
        }
    }
}

4. Im obigen Codeausschnitt haben wir über die Klasse Server einen WebSocket-Server erstellt, der den lokalen Port 8080 überwacht und die Client-Verbindungsanfrage an FileTransferEndpoint weiterleitet Klasse zur Bearbeitung. Server 类创建了一个 WebSocket 服务端，它监听本机的 8080 端口，并将客户端连接请求转发到 FileTransferEndpoint 类中进行处理。

WebSocket 客户端

1. 首先，我们需要创建一个 WebSocket 客户端，连接到服务端。

import java.net.URI;
import java.net.URISyntaxException;
import java.util.Scanner;

import javax.websocket.ContainerProvider;
import javax.websocket.DeploymentException;
import javax.websocket.WebSocketContainer;

public class Client {

    private static Object waitLock = new Object();

    public static void main(String[] args) {
        URI uri;
        try {
            uri = new URI("ws://localhost:8080/filetransfer");
        } catch (URISyntaxException e) {
            e.printStackTrace();
            return;
        }

        WebSocketContainer container = ContainerProvider.getWebSocketContainer();

        try {
            Session session = container.connectToServer(MyClientEndpoint.class, uri);
            synchronized(waitLock) {
                waitLock.wait();
            }
        } catch (DeploymentException | InterruptedException e) {
            e.printStackTrace();
        } finally {
            container.getDefaultSessionMaxIdleTimeout();
        }
    }

    public static class MyClientEndpoint extends Endpoint {

        @Override
        public void onOpen(Session session, EndpointConfig config) {
            session.addMessageHandler(new MessageHandler.Whole<String>() {

                @Override
                public void onMessage(String message) {
                    System.out.println(message);
                }
            });

            try {
                ByteBuffer buffer = ByteBuffer.wrap("Hello World".getBytes());
                session.getBasicRemote().sendBinary(buffer);
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }
}

2. 在上面的代码片段中，我们创建了一个 WebSocket 客户端，连接到服务端的 ws://localhost:8080/filetransfer
3. WebSocket-Client

Zuerst müssen wir einen WebSocket-Client erstellen und eine Verbindung zum Server herstellen.

rrreee

🎜Im obigen Codeausschnitt erstellen wir einen WebSocket-Client und stellen eine Verbindung zur URL ws://localhost:8080/filetransfer auf dem Server her. 🎜🎜Starten Sie den Client. Der Client sendet die Zeichenfolge „Hello World“ an den Server und erhält die Antwort vom Server. 🎜🎜🎜Zusammenfassung🎜🎜In diesem Artikel wurde bisher die Methode zur Verwendung von WebSocket für die Echtzeit-Dateiübertragung in Java vorgestellt. Er hat die Implementierung der Echtzeit-Dateiübertragung unter den Aspekten des WebSocket-Protokolls und der Verwendung von Java ausführlich vorgestellt WebSocket-API und Implementierung von WebSocket-Server- und -Client-spezifischen Schritten. Die Verwendung von WebSocket ermöglicht eine effiziente und zuverlässige Dateiübertragung in Echtzeit und ist ein wesentlicher Bestandteil moderner Anwendungen. 🎜

Das obige ist der detaillierte Inhalt vonSo verwenden Sie WebSocket für die Echtzeit-Dateiübertragung in Java. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!