Golang Websocket-Tutorial: So entwickeln Sie eine Online-Musikwiedergabefunktion

Im heutigen Internetzeitalter erfordern Webanwendungen zunehmend Echtzeit-Interaktionsfunktionen, und Websocket ist eine dieser Interaktionsmethoden. Als effiziente Programmiersprache bietet Golang eine native Websocket-Unterstützungsbibliothek, die die Entwicklung interaktiver Echtzeitanwendungen einfacher und effizienter macht. In diesem Artikel stellen wir vor, wie man mit Golang eine Online-Musikwiedergabeanwendung entwickelt. Diese Anwendung nutzt die Echtzeit-Datenübertragungsfunktion von Websocket vollständig aus und kann es mehreren Benutzern ermöglichen, dieselbe Musik gleichzeitig abzuspielen wir lernen gemeinsam!

1. Was ist Websocket?

Websocket ist Teil von HTML5 und ein Protokoll für die bidirektionale Echtzeitkommunikation in Webanwendungen. Im Vergleich zum herkömmlichen HTTP-Anfrage-Antwort-Modell kann Websocket eine dauerhafte Verbindung zwischen dem Client und dem Server herstellen. Während des Verbindungsprozesses können Client und Server frei Nachrichten aneinander senden. Zu den typischen Anwendungsszenarien von Websocket gehören Online-Chat, Echtzeit-Zusammenarbeit, Multiplayer-Spiele, Online-Musikwiedergabe und andere Anwendungsszenarien, die Echtzeit-Interaktion erfordern.

2. Golangs Websocket-Bibliothek

In Golang können Sie die native Websocket-Bibliothek verwenden, um Websocket-Anwendungen zu entwickeln. Diese Bibliothek befindet sich im Paket „net/http“ und stellt einen WebSocket-Strukturtyp bereit, über den Websocket-Clients und -Server betrieben werden können. Diese Bibliothek bietet außerdem drei Funktionen, mit denen die HTTP-Verbindung auf eine Websocket-Verbindung aktualisiert, vom Websocket-Client gesendete Nachrichten gelesen und Nachrichten an den Websocket-Client gesendet werden können.

3. Online-Musikwiedergabefunktion entwickeln

Wir beginnen jetzt mit der Entwicklung von Online-Musikwiedergabeanwendungen. In dieser Anwendung verwenden wir Websocket, um mehreren Personen das gleichzeitige Abspielen derselben Musik zu ermöglichen. Im Folgenden sind die spezifischen Implementierungsschritte aufgeführt:

1. Musikdateien vorbereiten

Wir müssen eine Musikdatei im MP3-Format vorbereiten, die als Musikquelldatei in unserer Anwendung verwendet wird. Wir können online suchen, ein Musikstück herunterladen, das uns gefällt, und es dann lokal kopieren. Nachdem diese Datei auf den Server hochgeladen wurde, müssen wir sie auch mit der Bibliothek „gonum.org/v1/plot/vg/draw“ in Golang verarbeiten, damit sie vom Golang-Code gelesen und manipuliert werden kann.

2. Starten Sie den Websocket-Dienst auf dem Server

Zuerst müssen wir die Pakete „net/http“ und „golang.org/x/net/websocket“ importieren. Anschließend können Sie die Funktion http.ListenAndServe() im http-Paket verwenden, um den Websocket-Dienst zu starten.

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. Verarbeitung der Verbindungsanfrage des Websocket-Clients

In Schritt 2 haben wir den Websocket-Dienst mit dem Pfad „/play“ geöffnet. Wenn der Websocket-Client diesen Pfad anfordert, müssen wir die Anfrage verarbeiten. Für diese Anfrage können wir eine Verarbeitungsfunktion playHandler() festlegen.

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

In dieser Funktion verwenden wir den ws-Parameter vom Typ websocket.Conn, um Lese- und Schreibvorgänge auf dem Websocket-Client auszuführen. Zuerst müssen wir die vom Client gesendete Musikwiedergabeanforderung lesen. Diese Anfrage wird ein Byte-Array sein. Dann rufen wir die Funktion playMusic() auf, um diese Anfrage zu verarbeiten und die Musik abzuspielen.

4. Musik abspielen

In der Funktion playMusic() verwenden wir die Bibliothek „gonum.org/v1/plot/vg/draw“ in Golang, um Musikdateien zu lesen und zu verarbeiten. Diese Bibliothek bietet Funktionen, die Musikdateien in Golang-Slices kapseln, sodass wir Musik bequemer bedienen können.

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
        }
    }()
}

In dieser Funktion analysieren wir zunächst den vom Websocket-Client gesendeten Namen der Musikdatei. Verwenden Sie dann die Funktion ioutil.ReadFile(), um die Datei zu lesen, und verwenden Sie die Funktion mp3.Decode(), um die Datei in Musikdaten zu dekodieren. Nachdem die Musikdaten dekodiert wurden, übergeben wir die Aufgabe der Musikwiedergabe an eine Coroutine. In dieser Coroutine lesen wir kontinuierlich die vom Websocket-Client gesendeten Steuerdaten und steuern die Position der Musikwiedergabe basierend auf diesen Daten. Nachdem die Musikdaten gelesen wurden, fragmentieren wir sie in 1024-Byte-Frames und senden sie an den Websocket-Client. Wenn die Musikwiedergabe abgeschlossen ist, schließen wir die Verbindung zum Websocket-Client.

5. Verwenden Sie den Websocket-Client, um Musik abzuspielen

Da wir nun die Musikwiedergabefunktion auf der Serverseite abgeschlossen haben, müssen wir als Nächstes Websocket-Code auf dem Client schreiben, um diese Funktion zu verwenden. Der Websocket-Client sendet den Namen der Musikdatei und die Steuerdaten für die Wiedergabeposition an den Server, um die Wiedergabeposition der Musik zu steuern.

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)
    }
}

In diesem Code verwenden wir zunächst die Funktion websocket.Dial(), um eine Verbindung zum Server herzustellen. Anschließend senden wir den Namen der Musikdatei und die Steuerungsdaten für die Wiedergabeposition an den Server. In diesem Code verwenden wir eine Endlosschleife, um kontinuierlich Steuerdaten zu senden. Jede Sekunde werden Steuerdaten gesendet, um zu steuern, wo die Musik abgespielt wird. Diese Schleife kann fortgesetzt werden, bis wir sie manuell stoppen.

4. Zusammenfassung

In diesem Artikel stellen wir vor, wie man mit Golang eine Online-Musikwiedergabeanwendung entwickelt. In dieser Anwendung wird die Echtzeit-Datenübertragungsfunktion von Websocket vollständig genutzt, um mehrere Personen beim gleichzeitigen Abspielen derselben Musik zu unterstützen. Als bidirektionales Echtzeit-Kommunikationsprotokoll spielt Websocket eine wichtige Rolle in interaktiven Echtzeitanwendungen. Darüber hinaus bietet Golang als effiziente Programmiersprache viele Annehmlichkeiten für die Entwicklung von Websocket-Anwendungen. Ich glaube, dass Sie nach dem Lesen dieses Artikels die grundlegenden Fähigkeiten zur Verwendung von Golang zum Entwickeln von Websocket-Anwendungen beherrschen.

Das obige ist der detaillierte Inhalt vonGolang Websocket-Tutorial: So entwickeln Sie eine Online-Musikwiedergabefunktion. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!