Golang melaksanakan sambungan panjang

Dengan perkembangan Internet, teknologi sambungan panjang telah digunakan secara beransur-ansur dalam komunikasi rangkaian. Dalam aplikasi praktikal, kita mungkin perlu mengekalkan sambungan komunikasi jangka panjang dengan pelanggan Dalam kes ini, kita perlu menggunakan teknologi sambungan panjang. Sebagai bahasa pengaturcaraan yang popular, keselarasan golang dan prestasi tinggi menjadikannya pilihan yang sangat baik untuk melaksanakan sambungan yang panjang. Artikel ini akan memperkenalkan cara menggunakan golang untuk melaksanakan sambungan panjang.

1. Apakah sambungan yang panjang?

Sambungan yang panjang bermakna selepas pelanggan dan pelayan membuat sambungan, mereka boleh menghantar berbilang paket data secara berterusan. Dalam hubungan ini, pelayan tidak akan memutuskan sambungan, tetapi akan sentiasa menunggu permintaan baharu daripada pelanggan dan bertindak balas. Kaedah penghantaran ini digunakan secara meluas dalam komunikasi rangkaian, seperti pemesejan segera, data tolak pelayan, dsb.

Berbanding dengan sambungan pendek, kelebihan sambungan panjang ialah ia mengurangkan masa dan overhed sumber untuk mewujudkan dan memutuskan sambungan, sambil meningkatkan kecekapan dan sifat penghantaran data masa nyata.

2. Cara melaksanakan sambungan panjang dalam golang

Terdapat tiga cara utama untuk melaksanakan sambungan panjang dalam golang:

1. Gunakan sambungan panjang TCP

Menggunakan sambungan panjang TCP untuk melaksanakan sambungan panjang adalah cara yang paling biasa dan mudah dalam golang. Mula-mula buat sambungan TCP, kemudian pindahkan data dalam sambungan, dan kemudian sambungan boleh dikekalkan sehingga sambungan ditutup. Berikut menunjukkan kod asas untuk menggunakan sambungan TCP yang panjang:

package main

import (
    "fmt"
    "net"
)

func main() {
   serverAddr := "127.0.0.1:8888"
   conn, err := net.Dial("tcp", serverAddr)
   if err != nil {
       fmt.Println(err)
   }

   for {
       data := []byte("hello world")
       _, err := conn.Write(data)
       if err != nil {
           fmt.Println(err)
           break
       }

       buf := make([]byte, 1024)
       _, err = conn.Read(buf)
       if err != nil {
           fmt.Println(err)
           break
       }

       fmt.Println(string(buf))
   }
}

Dalam contoh ini, kami mencipta sambungan TCP melalui fungsi net.Dial(), dan kemudian menghantar data ke pelayan melalui conn.Write(), dan conn.Read() daripada Baca data daripada sambungan. Gunakan gelung for untuk memastikan sambungan berterusan.

2. Gunakan sambungan panjang WebSocket

WebSocket ialah protokol komunikasi untuk komunikasi dupleks penuh pada sambungan TCP tunggal, menyediakan kaedah interaksi berasaskan peristiwa. Anda boleh menggunakan perpustakaan pihak ketiga gorilla/websocket dalam golang untuk melaksanakan sambungan panjang WebSocket. Mari kita lihat kod untuk menggunakan WebSocket untuk melaksanakan sambungan panjang:

package main

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

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

func echo(w http.ResponseWriter, r *http.Request) {
    conn, err := upgrader.Upgrade(w, r, nil)
    if err != nil {
        log.Println(err)
        return
    }
    for {
        messageType, p, err := conn.ReadMessage()
        if err != nil {
            log.Println(err)
            break
        }
        log.Println(string(p))
        if err = conn.WriteMessage(messageType, p); err != nil {
            log.Println(err)
            break
        }
    }
}

func main() {
    http.HandleFunc("/echo", echo)
    err := http.ListenAndServe(":8080", nil)
    if err != nil {
        log.Fatal(err)
    }
}

Dalam contoh ini, kami menggunakan Upgrader untuk menaik taraf sambungan HTTP kepada sambungan WebSocket, dan kemudian menggunakan conn.ReadMessage() dan conn.WriteMessage() untuk menyambung data pemindahan. Gunakan gelung for untuk memastikan sambungan berterusan.

3. Gunakan sambungan panjang HTTP

Sambungan panjang HTTP ialah teknologi sambungan panjang berdasarkan protokol HTTP. Berbanding dengan sambungan berterusan TCP, sambungan berterusan HTTP memerlukan sambungan HTTP, dan kemudian data boleh dihantar secara berterusan melalui sambungan ini. Anda boleh menggunakan pustaka net/http dalam golang untuk melaksanakan sambungan panjang HTTP. Berikut menunjukkan cara menggunakan sambungan HTTP yang panjang:

package main

import (
    "bufio"
    "fmt"
    "log"
    "net/http"
)

func handler(w http.ResponseWriter, r *http.Request) {
    if r.Method != "GET" {
        http.Error(w, "Method not allowed", 405)
        return
    }
    fmt.Fprintf(w, "HTTP/1.1 200 OK
")
    fmt.Fprintf(w, "Content-Type: text/plain
")
    fmt.Fprintf(w, "Connection: keep-alive
")
    fmt.Fprintf(w, "
")

    writer := bufio.NewWriter(w)
    for {
        _, err := writer.WriteString("hello world
")
        if err != nil {
            log.Println(err)
            break
        }
        writer.Flush()
    }
}

func main() {
    http.HandleFunc("/", handler)
    err := http.ListenAndServe(":8080", nil)
    if err != nil {
        log.Fatal(err)
    }
}

Dalam contoh ini, kami menetapkan pengepala Connection: keep-alive dalam respons HTTP untuk memastikan sambungan HTTP berterusan, dan kemudian menggunakan bufio.NewWriter() untuk menyambung setiap kali Write data.

3. Bagaimana untuk memilih kaedah sambungan jangka panjang yang sesuai?

Walaupun terdapat tiga cara untuk melaksanakan sambungan panjang dalam golang, anda mesti memilih kaedah yang sesuai mengikut keperluan sebenar. Berikut adalah beberapa aspek yang perlu diberi perhatian:

1. Sambungan panjang TCP

Kelebihan menggunakan sambungan panjang TCP ialah ia mudah dan langsung, serta dapat merealisasikan sambungan panjang dengan cepat . Walau bagaimanapun, sambungan panjang TCP tidak disulitkan semasa penghantaran data, dan paket data perlu dipasang secara manual setiap kali Pada masa yang sama, protokol tersuai diperlukan untuk melaksanakan pengepakan data dan panggilan balik tak segerak. Ia sesuai untuk senario di mana jumlah data adalah kecil dan bilangan sambungan adalah kecil.

2. Sambungan panjang WebSocket

Sambungan panjang WebSocket menggunakan kaedah tak segerak untuk menghantar data, menyokong pelayan untuk menolak data kepada pelanggan, penghantaran data lebih fleksibel dan ia juga mempunyai subkontrak automatik dan memulakan semula Keupayaan untuk mengumpulkan pakej. Walau bagaimanapun, sambungan lama WebSocket perlu menghantar permintaan HTTP semasa jabat tangan pertama, iaitu sekali lagi daripada permintaan sambungan panjang TCP.

3. Sambungan berterusan HTTP

Sambungan berterusan HTTP perlu mewujudkan sambungan TCP seperti sambungan berterusan TCP apabila membuat sambungan buat kali pertama, tetapi ia boleh dikawal melalui Pengepala HTTP semasa penghantaran data Kegigihan sambungan, sambungan boleh menghantar berbilang permintaan dan respons HTTP. Walau bagaimanapun, kecekapan komunikasi sambungan panjang HTTP adalah lebih rendah sedikit daripada sambungan panjang TCP dan sambungan panjang WebSocket.

4. Ringkasan

Artikel ini memperkenalkan tiga cara untuk golang melaksanakan sambungan panjang: sambungan panjang TCP, sambungan panjang WebSocket dan sambungan panjang HTTP juga menganalisis kelebihan masing-masing dan senario yang berkenaan. Dalam pembangunan sebenar, kaedah yang sesuai perlu dipilih berdasarkan senario tertentu. Teknologi sambungan jangka panjang mempunyai prospek aplikasi yang luas dalam aplikasi praktikal Pada masa hadapan, kita akan melihat kemunculan teknologi sambungan jangka panjang yang lebih cekap, boleh dipercayai dan selamat.

Atas ialah kandungan terperinci Golang melaksanakan sambungan panjang. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!