EP.76 การใช้ WebSocket ในการส่งข้อมูลขนาดใหญ่ (Handling Large Data Transfers)

ในตอนนี้ เราจะพูดถึงวิธีการส่ง ข้อมูลขนาดใหญ่ผ่าน WebSocket Server อย่างมีประสิทธิภาพ โดยใช้เทคนิคสำคัญ เช่น

การแบ่งข้อมูลเป็นชิ้นเล็ก ๆ (Chunking)
การบีบอัดข้อมูล (Compression)
การใช้ข้อมูลแบบไบนารี (Binary Data)

เทคนิคเหล่านี้ช่วยให้ระบบ WebSocket Chat หรือแอปพลิเคชันแบบ Real-Time สามารถส่งข้อมูลจำนวนมากได้โดยไม่ส่งผลกระทบต่อประสิทธิภาพของระบบ

🔸 ทำไมต้องใช้ WebSocket ส่งข้อมูลขนาดใหญ่?

1. ส่งข้อมูลแบบ Real-Time:
WebSocket รองรับการเชื่อมต่อแบบ persistent ทำให้สามารถส่งข้อมูลได้ทันทีโดยไม่ต้องเปิดการเชื่อมต่อใหม่ทุกครั้ง

2. จัดการข้อมูลขนาดใหญ่ได้ดี:
เมื่อใช้ร่วมกับ Chunking หรือ Compression ระบบจะสามารถจัดการข้อมูลใหญ่ได้อย่างลื่นไหล

3. ลดการใช้แบนด์วิดธ์:
การบีบอัดข้อมูลก่อนส่งช่วยลดปริมาณข้อมูลที่ต้องส่งผ่านเครือข่าย

4. รองรับการส่งข้อมูลสองทาง:
WebSocket รองรับการสื่อสารแบบ Full-Duplex ระหว่าง Server และ Client พร้อมกัน

🔸 วิธีการส่งข้อมูลขนาดใหญ่ใน WebSocket

✅ 1. การแบ่งข้อมูล (Chunking)

การแบ่งข้อมูลเป็นชิ้นเล็ก ๆ เพื่อส่งต่อแบบต่อเนื่อง ช่วยป้องกันการล่มของการเชื่อมต่อ และทำให้การส่งข้อมูลขนาดใหญ่เป็นไปอย่างปลอดภัย

🔧 ตัวอย่างโค้ด Go (Chunking):

func chunkData(data []byte, chunkSize int) [][]byte {
    var chunks [][]byte
    for i := 0; i < len(data); i += chunkSize {
        end := i + chunkSize
        if end > len(data) {
            end = len(data)
        }
        chunks = append(chunks, data[i:end])
    }
    return chunks
}

ระบบจะตัดข้อมูลออกเป็นหลาย ๆ ส่วนตามขนาด chunkSize และสามารถส่งออกไปทีละชิ้น

✅ 2. การบีบอัดข้อมูล (Compression)

การบีบอัดข้อมูลก่อนส่งจะช่วยลดขนาด Payload และทำให้การส่งข้อมูลเร็วขึ้น

🔧 โค้ด Go สำหรับเปิดใช้งาน Compression:

conn.EnableWriteCompression = true
conn.EnableReadCompression = true

เมื่อเปิดใช้งาน Compression บน WebSocket การส่งข้อความจะถูกบีบอัดโดยอัตโนมัติ (หากฝั่ง Client รองรับ)

✅ 3. การใช้ Binary Data

แทนที่จะส่งข้อมูลในรูปแบบข้อความหรือ JSON เราสามารถส่งข้อมูลแบบ Binary เช่นไฟล์รูปภาพ ไฟล์ PDF หรือข้อมูลเข้ารหัส ซึ่งช่วยประหยัดขนาดและประมวลผลได้เร็วกว่า

ใน Go สามารถส่ง Binary โดยใช้ websocket.BinaryMessage:

conn.WriteMessage(websocket.BinaryMessage, binaryData)

🔸 ตัวอย่างระบบ WebSocket ที่รองรับ Chunking

package main

import (
    "log"
    "net/http"
    "github.com/gorilla/websocket"
)

var clients = make(map[*websocket.Conn]bool)
var broadcast = make(chan []byte)

var upgrader = websocket.Upgrader{
    CheckOrigin: func(r *http.Request) bool {
        return true
    },
}

func handleConnections(w http.ResponseWriter, r *http.Request) {
    conn, err := upgrader.Upgrade(w, r, nil)
    if err != nil {
        log.Println(err)
        return
    }
    defer conn.Close()

    clients[conn] = true

    for {
        _, msg, err := conn.ReadMessage()
        if err != nil {
            log.Println(err)
            delete(clients, conn)
            break
        }

        chunks := chunkData(msg, 1024)
        for _, chunk := range chunks {
            broadcast <- chunk
        }
    }
}

func chunkData(data []byte, chunkSize int) [][]byte {
    var chunks [][]byte
    for i := 0; i < len(data); i += chunkSize {
        end := i + chunkSize
        if end > len(data) {
            end = len(data)
        }
        chunks = append(chunks, data[i:end])
    }
    return chunks
}

func handleMessages() {
    for {
        msg := <-broadcast
        for client := range clients {
            err := client.WriteMessage(websocket.TextMessage, msg)
            if err != nil {
                log.Println(err)
                client.Close()
                delete(clients, client)
            }
        }
    }
}

func main() {
    http.HandleFunc("/", handleConnections)
    go handleMessages()
    log.Println("Server started on :8080")
    log.Fatal(http.ListenAndServe(":8080", nil))
}

🔸 การทดสอบระบบ

✅ ทดสอบการแบ่งข้อมูล:
ส่งข้อมูลขนาดใหญ่และตรวจสอบว่าระบบสามารถแบ่งส่งได้ครบถ้วน

✅ ทดสอบการบีบอัด:
เปิดใช้ Compression และตรวจสอบว่าข้อมูลที่ส่งมีขนาดเล็กลง

✅ ทดสอบกับผู้ใช้หลายคน:
จำลองการส่งข้อมูลจากหลาย Client เพื่อดูว่าระบบยังคงทำงานได้ราบรื่น

💡 ท้าให้ลอง!

ลองสร้างระบบอัปโหลดไฟล์หรือส่งวิดีโอผ่าน WebSocket โดยใช้ Chunking ร่วมกับ Compression แล้ววัดประสิทธิภาพการส่งข้อมูลจริง!

🔜 EP ถัดไป:

EP.77 - การสร้างระบบแจ้งเตือนแบบทันที (Instant Notification System) ด้วย WebSocket
เรียนรู้การแจ้งเตือนผู้ใช้แบบ Real-Time เมื่อมีเหตุการณ์เกิดขึ้น — เช่น มีข้อความใหม่ การตอบกลับ หรือการเปลี่ยนแปลงสถานะ!

อ่านบทความ Series อื่นๆ

🔵 Facebook: Superdev School (Superdev)

📸 Instagram: superdevschool

🎬 TikTok: superdevschool

🌐 Website: www.superdev.school