Tutoriel Golang Websocket : Comment développer la fonction de lecture de musique en ligne

À l'ère d'Internet d'aujourd'hui, les applications Web nécessitent de plus en plus de fonctions d'interaction en temps réel, et Websocket est l'une de ces méthodes d'interaction. En tant que langage de programmation efficace, Golang fournit une bibliothèque native de support Websocket, rendant le développement d'applications interactives en temps réel plus facile et plus efficace. Dans cet article, nous présenterons comment utiliser Golang pour développer une application de lecture de musique en ligne. Cette application utilise pleinement la fonction de transmission de données en temps réel de Websocket et peut permettre à plusieurs utilisateurs de jouer la même musique en même temps. apprenons ensemble !

1. Qu'est-ce que Websocket ?

Websocket fait partie de HTML5 et est un protocole de communication bidirectionnelle en temps réel dans les applications Web. Par rapport au modèle de requête-réponse HTTP traditionnel, Websocket peut établir une connexion persistante entre le client et le serveur. Pendant le processus de connexion, le client et le serveur peuvent s'envoyer librement des messages. Les scénarios d'application typiques de Websocket incluent le chat en ligne, la collaboration en temps réel, les jeux multi-joueurs, la lecture de musique en ligne et d'autres scénarios d'application nécessitant une interaction en temps réel.

2. La bibliothèque Websocket de Golang

Dans Golang, vous pouvez utiliser la bibliothèque Websocket native pour développer des applications Websocket. Cette bibliothèque se trouve sous le package « net/http » et fournit un type de structure WebSocket à travers lequel les clients et serveurs Websocket peuvent être exploités. Cette bibliothèque fournit également trois fonctions, qui sont utilisées pour mettre à niveau la connexion HTTP vers une connexion Websocket, lire les messages envoyés par le client Websocket et envoyer des messages au client Websocket.

3. Développer la fonction de lecture de musique en ligne

Nous commençons maintenant à développer des applications de lecture de musique en ligne. Dans cette application, nous utiliserons Websocket pour permettre à plusieurs personnes de jouer la même musique en même temps. Voici les étapes spécifiques de mise en œuvre :

1. Préparer les fichiers musicaux

Nous devons préparer un fichier musical au format MP3, qui sera utilisé comme fichier source musical dans notre application. Nous pouvons effectuer une recherche en ligne, télécharger un morceau de musique que nous aimons, puis le copier localement. Une fois ce fichier téléchargé sur le serveur, nous devons également utiliser la bibliothèque "gonum.org/v1/plot/vg/draw" dans Golang pour le traiter afin qu'il puisse être lu et manipulé par le code Golang.

2. Démarrez le service Websocket sur le serveur

Tout d'abord, nous devons importer le package "net/http" et le package "golang.org/x/net/websocket". Ensuite, vous pouvez utiliser la fonction http.ListenAndServe() dans le package http pour démarrer le service Websocket.

package main

import (
    "net/http"
    "golang.org/x/net/websocket"
)

func main() {
    // 在路径"/play"上开启Websocket服务
    http.Handle("/play", websocket.Handler(playHandler))
    http.ListenAndServe(":8080", nil)
}

3. Traitement de la demande de connexion du client Websocket

A l'étape 2, nous avons ouvert le service Websocket avec le chemin "/play". Lorsque le client Websocket demande ce chemin, nous devons traiter la demande. Nous pouvons définir une fonction de traitement playHandler() pour cette requête.

func playHandler(ws *websocket.Conn) {
    // 读取客户端发送的音乐播放请求
    playReq := make([]byte, 512)
    n, err := ws.Read(playReq)
    if err != nil {
        return
    }
    playReq = playReq[:n]
    playMusic(playReq, ws)
}

Dans cette fonction, nous utiliserons le paramètre ws de type websocket.Conn pour effectuer des opérations de lecture et d'écriture sur le client Websocket. Tout d’abord, nous devons lire la demande de lecture de musique envoyée par le client. Cette requête sera un tableau d'octets. Ensuite, nous appelons la fonction playMusic() pour gérer cette requête et lire la musique.

4. Jouer de la musique

Dans la fonction playMusic(), nous utiliserons la bibliothèque "gonum.org/v1/plot/vg/draw" dans Golang pour lire et traiter les fichiers musicaux. Cette bibliothèque fournit des fonctions qui encapsulent les fichiers musicaux dans des tranches Golang, nous permettant ainsi d'exploiter la musique plus facilement.

func playMusic(playReq []byte, ws *websocket.Conn) {
    // 解析请求，获取要播放的音乐文件名
    filename := string(playReq)
    filename = filename[:strings.Index(filename, "
")]

    // 使用Golang处理获取音乐文件
    musicFile, err := ioutil.ReadFile(filename)
    if err != nil {
        fmt.Fprintf(os.Stderr, "Error: %v
", err)
        return
    }
    musicData, err := mp3.Decode(audioContext, bytes.NewReader(musicFile), len(musicFile))
    if err != nil {
        fmt.Fprintf(os.Stderr, "Error: %v
", err)
        return
    }
    
    // 将播放任务交给一个协程处理
    go func() {
        for {
            // 读取客户端发送的播放位置控制数据
            pos := make([]byte, 8)
            n, err := ws.Read(pos)
            if err != nil {
                // 断开与客户端的连接
                ws.Close()
                break
            }
            pos = pos[:n]

            // 把客户端发送的控制数据转换成时间（秒）
            t := float64(binary.LittleEndian.Uint64(pos)) / float64(SampleRate) + 1.0

            // 每秒播放一次音乐
            time.Sleep(time.Second)

            // 从指定位置开始播放音乐
            musicData.Seek(time.Duration(t)*time.Second, 0)
            buf := make([]byte, 1024)
            // 把音乐数据分帧发送给客户端
            for musicData.Err() == nil {
                n, err := musicData.Read(buf)
                if err != nil {
                    break
                }
                ws.Write(buf[:n])
            }
            // 音乐播放完成后，关闭连接
            ws.Close()
            break
        }
    }()
}

Dans cette fonction, nous analysons d'abord le nom du fichier musical envoyé par le client Websocket. Ensuite, utilisez la fonction ioutil.ReadFile() pour lire le fichier et utilisez la fonction mp3.Decode() pour décoder le fichier en données musicales. Une fois les données musicales décodées, nous confierons la tâche de lecture de musique à une coroutine. Dans cette coroutine, nous lirons en continu les données de contrôle envoyées par le client Websocket et contrôlerons la position de la lecture de la musique en fonction de ces données. Une fois les données musicales lues, nous les fragmenterons en trames de 1 024 octets et les enverrons au client Websocket. Une fois la lecture de la musique terminée, nous fermerons la connexion au client Websocket.

5. Utilisez le client Websocket pour lire de la musique

Maintenant que nous avons terminé la fonction de lecture de musique côté serveur, nous devons ensuite écrire le code Websocket sur le client pour utiliser cette fonction. Le client Websocket enverra le nom du fichier musical et les données de contrôle de la position de lecture au serveur pour contrôler la position de lecture de la musique.

func main() {
    // 使用Golang内置的WebSocket库连接服务器
    ws, err := websocket.Dial("ws://127.0.0.1:8080/play", "", "http://127.0.0.1:8080")
    if err != nil {
        log.Fatal(err)
    }
    defer ws.Close()

    // 发送播放请求
    filename := "music.mp3
"
    pos := make([]byte, 8)

    for {
        // 持续发送控制数据
        binary.LittleEndian.PutUint64(pos, uint64(time.Now().UnixNano()))
        ws.Write(pos)

        // 一秒钟发送一次控制数据
        time.Sleep(time.Second)
    }
}

Dans ce code, nous utilisons d'abord la fonction websocket.Dial() pour nous connecter au serveur. Ensuite, nous envoyons le nom du fichier musical et les données de contrôle de la position de lecture au serveur. Dans ce code, nous utilisons une boucle infinie pour envoyer en continu des données de contrôle. Les données de contrôle sont envoyées toutes les secondes pour contrôler où la musique est diffusée. Cette boucle peut continuer jusqu'à ce que nous l'arrêtions manuellement.

4.Résumé

Dans cet article, nous expliquons comment utiliser Golang pour développer une application de lecture de musique en ligne. Dans cette application, la fonction de transmission de données en temps réel de Websocket est pleinement utilisée pour permettre à plusieurs personnes de jouer la même musique en même temps. En tant que protocole de communication bidirectionnelle en temps réel, Websocket joue un rôle important dans les applications interactives en temps réel. De plus, en tant que langage de programmation efficace, Golang offre également de nombreuses commodités pour le développement d'applications Websocket. Je pense qu'après avoir lu cet article, vous maîtrisez les compétences de base nécessaires à l'utilisation de Golang pour développer des applications Websocket.

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!