Cara Menghubungkan Aplikasi Golang dengan WebSocket

WebSocket adalah protokol komunikasi dua arah yang memungkinkan komunikasi real-time antara klien dan server. Dalam tutorial ini, kita akan membahas cara menggunakan bahasa pemrograman Go (Golang) untuk membangun aplikasi WebSocket sederhana. Aplikasi ini akan terdiri dari server WebSocket yang akan mengirim pesan ke klien secara periodik.

Persiapan

Sebelum memulai, pastikan Anda memiliki Go terinstal di komputer Anda. Anda dapat mengunduh dan menginstalnya dari situs resmi Go (https://go.dev/).

Langkah 1: Membuat Server WebSocket

Langkah pertama adalah membuat server WebSocket menggunakan Go. Berikut adalah contoh kode untuk membuat server WebSocket sederhana:

package main

import (
    "log"
    "net/http"

    "github.com/gorilla/websocket"
)

var upgrader = websocket.Upgrader{
    ReadBufferSize:  1024,
    WriteBufferSize: 1024,
}

func main() {
    http.HandleFunc("/", handleWebSocket)
    log.Fatal(http.ListenAndServe(":8080", nil))
}

func handleWebSocket(w http.ResponseWriter, r *http.Request) {
    conn, err := upgrader.Upgrade(w, r, nil)
    if err != nil {
        log.Println("Failed to upgrade connection:", err)
        return
    }
    defer conn.Close()

    for {
        // Menerima pesan dari klien
        messageType, p, err := conn.ReadMessage()
        if err != nil {
            log.Println("Failed to read message:", err)
            break
        }

        // Menampilkan pesan yang diterima dari klien
        log.Printf("Received message: %s", p)

        // Mengirim pesan ke klien
        err = conn.WriteMessage(messageType, p)
        if err != nil {
            log.Println("Failed to send message:", err)
            break
        }
    }
}

Kode di atas menggunakan paket gorilla/websocket yang populer untuk mempermudah penggunaan WebSocket di Go. Ini mendefinisikan fungsi handleWebSocket sebagai penanganan permintaan WebSocket. Fungsi ini menghubungkan klien dengan server, membaca pesan yang diterima dari klien, menampilkan pesan tersebut, dan mengirim kembali pesan yang sama ke klien.

Kode di atas juga menggunakan http.HandleFunc untuk mengaitkan permintaan ke URL root (“/”) dengan fungsi handleWebSocket. Kemudian, http.ListenAndServe digunakan untuk memulai server dan mendengarkan permintaan masuk di port 8080.

Langkah 2: Membuat Klien WebSocket

Setelah membuat server WebSocket, langkah selanjutnya adalah membuat klien WebSocket untuk terhubung ke server. Berikut adalah contoh kode untuk membuat klien WebSocket menggunakan Go:

package main

import (
    "log"
    "os"
    "os/signal"
    "time"

    "github.com/gorilla/websocket"
)

func main() {
    interrupt := make(chan os.Signal, 1)
    signal.Notify(interrupt, os.Interrupt)

    u := "ws://localhost:8080/"
    log.Printf("Connecting to %s", u)

    c, _, err := websocket.DefaultDialer.Dial(u, nil)
    if err != nil {
        log.Fatal("Failed to connect:", err)
    }
    defer c.Close()

    done := make(chan struct{})

    go func() {
        defer close(done)
        for {
            _, message, err := c.ReadMessage()
            if err != nil {
                log.Println("Failed to read message:", err)
                return
            }
            log.Printf("Received message: %s", message)
        }
    }()

    ticker := time.NewTicker(time.Second)
    defer ticker.Stop()

    for {
        select {
        case <-done:
            return
        case <-ticker.C:
            err := c.WriteMessage(websocket.TextMessage, []byte("Hello, server!"))
            if err != nil {
                log.Println("Failed to send message:", err)
                return
            }
            log.Println("Message sent to server")
        case <-interrupt:
            log.Println("Interrupt signal received, exiting...")
            err := c.WriteMessage(websocket.CloseMessage, websocket.FormatCloseMessage(websocket.CloseNormalClosure, ""))
            if err != nil {
                log.Println("Failed to send close message:", err)
                return
            }
            select {
            case <-done:
            case <-time.After(time.Second):
            }
            return
        }
    }
}

Kode di atas menggunakan paket gorilla/websocket yang sama untuk membuat koneksi WebSocket ke server. Kode ini menghubungkan klien ke server WebSocket yang berjalan di ws://localhost:8080/.

Klien akan membaca pesan yang diterima dari server dan menampilkannya. Selain itu, klien juga akan mengirim pesan “Hello, server!” ke server setiap detik menggunakan time.Ticker.

Menjalankan Aplikasi

Setelah menyelesaikan langkah-langkah di atas, Anda dapat menjalankan aplikasi dengan menjalankan server dan klien di terminal terpisah.

Buka terminal pertama, lalu masuk ke direktori server, dan jalankan server dengan menjalankan perintah berikut:

go run server.go

Buka terminal kedua, masuk ke direktori klien, dan jalankan klien dengan menjalankan perintah berikut:

go run client.go

Jika semuanya berjalan dengan sukses, Anda akan melihat pesan “Hello, server!” yang diterima oleh klien dan dicetak di terminal server.

Kesimpulan

Dalam tutorial ini, kita telah belajar cara menggunakan Golang untuk membangun aplikasi WebSocket sederhana. Kita membuat server WebSocket menggunakan paket gorilla/websocket dan klien WebSocket untuk terhubung ke server. Anda sekarang dapat mengembangkan aplikasi WebSocket yang lebih kompleks dengan menggunakan dasar-dasar yang diperoleh dari tutorial ini.