La combinaison de Java et WebSocket : comment réaliser une communication audio en temps réel

La combinaison de Java et WebSocket : Comment réaliser une communication audio en temps réel

Introduction :
Avec le développement d'Internet, la communication en temps réel est devenue l'un des besoins fondamentaux des applications sociales modernes. Parmi eux, la communication audio en temps réel, en tant que méthode de communication en temps réel importante, joue un rôle important dans les scénarios d'application tels que les appels vocaux et les chats vocaux. Cet article explique comment utiliser Java et WebSocket pour implémenter une communication audio en temps réel et fournit des exemples de code spécifiques.

1. Introduction à WebSocket :
WebSocket est un protocole de communication full-duplex qui permet une communication bidirectionnelle en temps réel entre le client et le serveur via une connexion TCP longue durée. Contrairement au modèle requête-réponse HTTP, le protocole WebSocket permet au serveur d'envoyer activement des messages au client, atteignant ainsi l'objectif de communication en temps réel.

2. Utilisation de WebSocket en Java :
En Java, nous pouvons utiliser Java WebSocket (API Javax WebSocket) pour implémenter les fonctions WebSocket. L'API Java WebSocket a été introduite dans Java 8 et fournit un ensemble de classes et d'interfaces pour le développement d'applications WebSocket.

1. Serveur WebSocket :
   Tout d'abord, nous devons créer un serveur WebSocket pour recevoir la connexion du client et gérer la communication. Voici un exemple de code pour un simple serveur WebSocket :

@ServerEndpoint("/audio")
public class AudioServer {

    @OnOpen
    public void onOpen(Session session) {
        // 当有新连接建立时的操作
    }

    @OnMessage
    public void onMessage(byte[] audioData, Session session) {
        // 处理收到的音频数据
    }

    @OnClose
    public void onClose(Session session) {
        // 当连接关闭时的操作
    }

    @OnError
    public void onError(Session session, Throwable throwable) {
        // 处理错误
    }
}

Le code ci-dessus utilise l'annotation @ServerEndpoint pour marquer la classe AudioServer comme serveur WebSocket et transmet @OnOpen, @OnMessage, @OnClose et @OnError définissent les méthodes correspondantes pour gérer l'établissement de connexion et la réception d'événements tels que tels que les messages, les fermetures de connexion et les erreurs. @ServerEndpoint注解将类AudioServer标记为WebSocket服务器端，并通过@OnOpen、@OnMessage、@OnClose和@OnError注解定义了对应的方法，用于处理连接建立、接收消息、连接关闭和错误等事件。

2. WebSocket Client端：
   接下来，我们需要创建一个WebSocket客户端，连接到上述的服务器端，并进行音频通信。以下是一个简单的WebSocket客户端的示例代码：

public class AudioClient {

    public static void main(String[] args) throws Exception {
        WebSocketContainer container = ContainerProvider.getWebSocketContainer();
        Session session = container.connectToServer(new Endpoint() {
            @Override
            public void onOpen(Session session, EndpointConfig config) {
                // 连接建立后的操作
            }

            @Override
            public void onClose(Session session, CloseReason closeReason) {
                // 连接关闭后的操作
            }

            @Override
            public void onError(Session session, Throwable throwable) {
                // 处理错误
            }

            @Override
            public void onMessage(String text, Session session) {
                // 处理收到的消息
            }
        }, new URI("ws://localhost:8080/audio"));

        // 发送音频数据
        byte[] audioData = new byte[1024];
        session.getBasicRemote().sendBinary(ByteBuffer.wrap(audioData));

        // 关闭连接
        session.close();
    }
}

以上代码使用了WebSocketContainer和Session类来连接WebSocket服务器端，并通过Endpoint类的实现方式处理连接建立、连接关闭、错误和收到消息等事件。

三、实时音频通信的实现：
通过上述介绍的WebSocket服务器端和客户端，我们可以在此基础上进行实时音频通信的实现。

1. 实时音频采集：首先，我们可以使用Java的Audio API实时采集音频数据，并发送给WebSocket服务器端。具体代码如下：

public class AudioCapture {

    public static void main(String[] args) throws LineUnavailableException {
        AudioFormat format = new AudioFormat(16000, 16, 1, true, true);
        DataLine.Info info = new DataLine.Info(TargetDataLine.class, format);
        TargetDataLine line = (TargetDataLine) AudioSystem.getLine(info);
        line.open(format);
        line.start();

        // 创建WebSocket客户端并连接服务器
        AudioClient client = new AudioClient();

        // 循环采集音频数据并发送至服务器
        byte[] buffer = new byte[1024];
        while (true){
          line.read(buffer, 0, buffer.length);
          client.send(buffer);
        }
    }
}

以上代码使用了Java的音频API，通过TargetDataLine类实时采集音频数据，并将数据通过WebSocket客户端发送至服务器端。

2. 实时音频播放：在客户端接收到服务器端的音频数据之后，我们可以使用Java的音频API实时播放音频。具体代码如下：

public class AudioPlayer {

    public static void main(String[] args) throws LineUnavailableException {
        AudioFormat format = new AudioFormat(16000, 16, 1, true, true);
        DataLine.Info info = new DataLine.Info(SourceDataLine.class, format);
        SourceDataLine line = (SourceDataLine) AudioSystem.getLine(info);
        line.open(format);
        line.start();

        // 创建WebSocket客户端并连接服务器
        AudioClient client = new AudioClient();

        // 循环接收服务器端发送的音频数据并播放
        client.setAudioListener(new AudioListener() {
            @Override
            public void onAudioReceived(byte[] audioData) {
                line.write(audioData, 0, audioData.length);
            }
        });
    }
}

以上代码使用了Java的音频API，通过SourceDataLine

Client WebSocket :

Ensuite, nous devons créer un client WebSocket pour nous connecter au serveur ci-dessus et effectuer une communication audio. Voici un exemple de code pour un client WebSocket simple :


rrreee

Le code ci-dessus utilise les classes WebSocketContainer et Session pour se connecter au serveur WebSocket et transmettre Endpoint gère les événements tels que l'établissement de la connexion, la fermeture de la connexion, les erreurs et la réception des messages.

3. Mise en œuvre de la communication audio en temps réel :
1. Grâce au serveur et au client WebSocket présentés ci-dessus, nous pouvons mettre en œuvre une communication audio en temps réel sur cette base.
🎜Collecte audio en temps réel : tout d'abord, nous pouvons utiliser l'API audio de Java pour collecter des données audio en temps réel et les envoyer au serveur WebSocket. Le code spécifique est le suivant : 🎜🎜rrreee🎜Le code ci-dessus utilise l'API audio de Java, collecte les données audio en temps réel via la classe TargetDataLine et envoie les données au serveur via le client WebSocket. 🎜
🎜Lecture audio en temps réel : une fois que le client a reçu les données audio du serveur, nous pouvons utiliser l'API audio de Java pour lire l'audio en temps réel. Le code spécifique est le suivant : 🎜🎜rrreee🎜Le code ci-dessus utilise l'API audio de Java pour lire des données audio en temps réel via la classe SourceDataLine. Après avoir reçu les données audio du serveur via le client WebSocket, exécutez la fonction de rappel pour écrire les données audio sur le lecteur. 🎜🎜Conclusion : 🎜Grâce à la combinaison de Java et WebSocket, nous pouvons réaliser une communication audio en temps réel. Côté serveur, nous utilisons le serveur WebSocket pour gérer des opérations telles que la connexion, la réception et l'envoi de données audio ; côté client, nous utilisons le client WebSocket pour nous connecter au serveur et effectuer des opérations de collecte et de lecture audio. L'ensemble du processus est mis en œuvre à l'aide de l'API audio de Java et de l'API WebSocket. Tout en réalisant une communication audio en temps réel, il fournit également d'autres espaces d'extension de fonctions flexibles. 🎜🎜Référence : 🎜🎜🎜Documentation officielle d'Oracle - API Java WebSocket : https://docs.oracle.com/javaee/8/api/javax/websocket/package-summary.html🎜🎜

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!