Comment utiliser WebSocket pour le transfert de fichiers en temps réel en Java

Dans les applications Internet modernes, le transfert de fichiers en temps réel fait partie intégrante. Il existe de nombreuses méthodes de transmission en temps réel, et WebSocket est la plus couramment utilisée. L'API WebSocket en Java vous permet d'implémenter simplement et facilement la fonctionnalité de transfert de fichiers en temps réel. Cet article vous montrera comment utiliser WebSocket pour le transfert de fichiers en temps réel en Java, tout en fournissant quelques exemples de code concrets.

Introduction à WebSocket

WebSocket fait partie du standard HTML5 et est un protocole réseau basé sur TCP. Ce protocole offre une capacité réseau de communication bidirectionnelle sur une seule connexion TCP, permettant une transmission en temps réel. Ceci est différent du protocole HTTP traditionnel, qui est un protocole sans état et nécessite l'établissement d'une nouvelle connexion pour chaque requête.

Les principales fonctionnalités du protocole WebSocket sont les suivantes :

1. Temps réel : WebSocket peut maintenir une longue connexion, réaliser une transmission en temps réel et transférer tout type de données entre le serveur et le client.
2. Communication bidirectionnelle : WebSocket prend en charge la communication bidirectionnelle. Le serveur peut envoyer activement des messages au client au lieu de simplement attendre la demande du client.
3. Prend en charge plusieurs formats de données : WebSocket peut transmettre plusieurs types de données telles que du texte, des binaires, etc., et peut répondre aux besoins de différents types d'applications.

Utilisation de l'API Java WebSocket

Java8 introduit JSR-356, qui est l'API standard WebSocket en Java. Les principales classes de l'API Java WebSocket se trouvent dans le package javax.websocket. Son API est principalement divisée en deux catégories. L'une est l'API liée à la connexion WebSocket elle-même et l'autre est l'API liée au traitement des messages.

API liée à la connexion WebSocket

Endpoint : représente un point de terminaison WebSocket qui peut recevoir des demandes de connexion client et des demandes de déconnexion de connexion.

Session : Représente une session de connexion WebSocket, utilisée pour envoyer et recevoir des messages texte et binaires.

MessageHandler : interface de traitement de messages WebSocket, avec deux classes d'implémentation Text et Binary. Les utilisateurs peuvent écouter les messages et les traiter en s'abonnant à cette interface.

API liée au traitement des messages WebSocket

OnMessage : La méthode de traitement des messages envoyés par le client WebSocket peut être implémentée via des annotations.

RemoteEndpoint : utilisé pour envoyer des messages.

Utilisation de WebSocket

Dans le développement réel, un serveur WebSocket et un client WebSocket sont généralement requis. Ci-dessous, nous expliquerons comment utiliser WebSocket pour implémenter la fonction de transfert de fichiers.

Serveur WebSocket

1. Tout d'abord, nous devons créer un point de terminaison WebSocket. Dans ce point de terminaison, nous pouvons gérer les demandes de connexion WebSocket et les demandes de déconnexion de connexion, et créer une instance de session pour établir une session avec le client.

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. Dans l'extrait de code ci-dessus, nous avons implémenté trois méthodes onMessage pour gérer les données de types ByteBuffer, String et PongMessage respectivement.
3. Démarrez le serveur pour que le serveur WebSocket accepte la demande de connexion du client.

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. Dans l'extrait de code ci-dessus, nous avons créé un serveur WebSocket via la classe Server, qui écoute le port local 8080 et transmet la demande de connexion client à FileTransferEndpoint classe pour le traitement. 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

Tout d'abord, nous devons créer un client WebSocket et nous connecter au serveur.

rrreee

🎜Dans l'extrait de code ci-dessus, nous créons un client WebSocket et nous nous connectons à l'URL ws://localhost:8080/filetransfer sur le serveur. 🎜🎜Démarrez le client, le client enverra la chaîne "Hello World" au serveur et recevra la réponse du serveur. 🎜🎜🎜Résumé🎜🎜Jusqu'à présent, cet article a présenté la méthode d'utilisation de WebSocket pour le transfert de fichiers en temps réel en Java. Il a présenté en détail la mise en œuvre du transfert de fichiers en temps réel sous les aspects du protocole WebSocket et de l'utilisation de Java. API WebSocket et implémentation des étapes spécifiques au serveur et au client WebSocket. L'utilisation de WebSocket permet un transfert de fichiers en temps réel efficace et fiable et constitue un élément essentiel des applications modernes. 🎜

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!