penyelesaian sambungan panjang golang

Golang ialah bahasa pengaturcaraan yang cepat, ditaip secara statik dan disusun yang direka dan dibangunkan oleh Google pada asalnya. Golang digunakan secara meluas dalam aplikasi web dan pembangunan sistem awan, terutamanya dalam senario konkurensi tinggi.

Dalam aplikasi web moden, sambungan panjang adalah teknologi yang sangat penting. Ini kerana dalam permintaan HTTP biasa, sambungan ditutup sebaik sahaja klien menerima respons daripada pelayan. Ini akan menyebabkan setiap permintaan untuk mewujudkan dan menutup sambungan, yang akan memberi kesan yang besar terhadap prestasi pelayan dan pelanggan. Teknologi sambungan panjang ialah satu cara untuk mengekalkan sambungan, supaya pelanggan dan pelayan boleh berkomunikasi antara satu sama lain dan mengekalkan sambungan secara berterusan. Artikel ini akan memperkenalkan penyelesaian sambungan panjang Golang dan membincangkan kelebihan dan kekurangannya.

1. WebSocket

WebSocket ialah protokol untuk komunikasi dupleks penuh melalui satu sambungan TCP. Ia menggunakan protokol HTTP untuk mewujudkan sambungan dan kemudian menukarnya kepada protokol WebSocket untuk mencapai sambungan yang panjang. Menggunakan protokol WebSocket, pelanggan dan pelayan boleh berkomunikasi antara satu sama lain tanpa perlu menutup sambungan, membolehkan mesej dihantar dengan cekap.

Pustaka standard Golang menyediakan pakej WebSocket terbina dalam ("net/http") yang boleh digunakan untuk melaksanakan pelayan dan pelanggan WebSocket. Berikut ialah contoh pelayan WebSocket mudah:

package main

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

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

func wsHandler(w http.ResponseWriter, r *http.Request) {
    conn, err := upgrader.Upgrade(w, r, nil)
    if err != nil {
        log.Println("websocket upgrade error:", err)
        return
    }

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

        fmt.Printf("received message: %s
", msg)
    }
}

func main() {
    http.HandleFunc("/ws", wsHandler)
    http.ListenAndServe(":8080", nil)
}

Dalam contoh ini, kami menggunakan perpustakaan Gorilla WebSocket, yang boleh mengendalikan permintaan WebSocket dengan lebih mudah. Gunakan fungsi websocket.Upgrader() untuk menaik taraf sambungan HTTP kepada sambungan WebSocket. Dalam fungsi wsHandler(), kami sentiasa mendengar mesej daripada pelanggan.

Kelebihan menggunakan WebSocket ialah ia boleh mencapai komunikasi dua hala dengan mudah. Kedua-dua pelanggan dan pelayan boleh menghantar dan menerima mesej tanpa menutup sambungan. Selain itu, protokol WebSocket mempunyai overhed yang kurang dan boleh menghantar data dengan cekap. Kelemahannya ialah WebSocket memerlukan sokongan khas daripada pelayar atau aplikasi klien. Untuk sesetengah penyemak imbas atau pelanggan versi lebih rendah, teknologi WebSocket mungkin mempunyai beberapa masalah. Di samping itu, kerana sambungan WebSocket adalah dupleks penuh, jika pelayan perlu menyiarkan mesej kepada sejumlah besar pelanggan, ia perlu mengekalkan sejumlah besar sambungan panjang, yang akan menduduki banyak sumber memori.

2. Acara Dihantar Pelayan

Acara Dihantar Pelayan (SSE) ialah satu lagi teknologi untuk melaksanakan sambungan panjang dalam aplikasi web. SSE menyediakan kaedah untuk pelayan menghantar data kepada pelanggan, dan data ini adalah masa nyata. Tidak seperti WebSocket, SSE ialah aliran tunggal, yang hanya membenarkan pelayan menghantar data kepada klien, tetapi tidak menyokong klien menghantar data ke pelayan.

Melaksanakan SSE menggunakan Golang adalah sangat mudah. Berikut ialah contoh pelayan SSE:

package main

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

func sseHandler(w http.ResponseWriter, r *http.Request) {
    w.Header().Set("Content-Type", "text/event-stream")
    w.Header().Set("Cache-Control", "no-cache")
    w.Header().Set("Connection", "keep-alive")

    for {
        fmt.Fprintf(w, "data: %s

", "Hello, world!")
        w.(http.Flusher).Flush()

        // Artificially slow down the server so
        // that we're forced to use multiple connections.
        time.Sleep(1 * time.Second)
    }
}

func main() {
    http.HandleFunc("/sse", sseHandler)
    http.ListenAndServe(":8080", nil)
}

Dalam contoh ini, kami menetapkan pengepala respons HTTP untuk memberitahu penyemak imbas bahawa ia menerima Peristiwa Dihantar Pelayan dan bukannya menunggu respons sekali sahaja. Kami menghantar mesej ringkas kepada pelanggan dan menggunakan http.Flusher untuk menghantar respons segera kepada pelanggan. Kemudian kami menunggu sebentar dan menghantar mesej baharu sekali lagi.

Kelebihan menggunakan Acara Dihantar Pelayan ialah ia menggunakan protokol HTTP dan oleh itu tidak memerlukan sebarang sokongan protokol khas. Selain itu, data SSE mudah dihuraikan, menjadikannya sesuai untuk aplikasi yang menyokong pelayan menolak data kepada pelanggan dalam masa nyata. Kelemahannya ialah SSE hanya menyokong komunikasi sehala dan hanya membenarkan pelayan menghantar data kepada klien. Untuk aplikasi yang memerlukan pelanggan menghantar data ke pelayan, SSE mungkin tidak sesuai.

3. gRPC

gRPC ialah protokol panggilan prosedur jauh (RPC) yang sangat berskala dan dioptimumkan prestasi yang menggunakan Penampan Protokol Google untuk pertukaran data. Matlamatnya adalah untuk membolehkan aplikasi klien berkomunikasi dengan aplikasi pelayan dalam masa linear dan menyediakan alternatif berskala dan cekap kepada HTTP REST API tradisional.

Walaupun gRPC tidak direka khusus untuk sambungan panjang, ia juga boleh digunakan untuk melaksanakan sambungan panjang. Oleh kerana gRPC menggunakan HTTP/2 untuk pengangkutan, ia dapat memindahkan sejumlah besar data dengan cepat dan boleh dipercayai, serta menyokong tolakan pelayan. Menggunakan gRPC, pelanggan boleh mewujudkan sambungan yang panjang dengan pelayan, dan pelayan boleh menolak mesej kepada klien pada bila-bila masa.

Berikut ialah contoh pelayan gRPC yang mudah:

package main

import (
    "context"
    "fmt"
    "log"
    "net"
    "google.golang.org/grpc"
    pb "github.com/proto/example"
)

type server struct{}

func (s *server) Push(ctx context.Context, in *pb.Message) (*pb.Response, error) {
    log.Printf("received message: %v", in)

    return &pb.Response{Code: 200}, nil
}

func main() {
    lis, err := net.Listen("tcp", ":9090")
    if err != nil {
        log.Fatalf("failed to listen: %v", err)
    }
    s := grpc.NewServer()
    pb.RegisterPushServer(s, &server{})
    if err := s.Serve(lis); err != nil {
        log.Fatalf("failed to serve: %v", err)
    }
}

Dalam contoh ini, kami mentakrifkan fungsi Push() yang akan dipanggil apabila mesej diterima daripada klien. Dalam fungsi ini kita boleh memproses maklumat daripada klien mengikut keperluan dan menolak mesej kepada klien jika perlu.

Kelebihan menggunakan gRPC ialah keupayaannya untuk memindahkan sejumlah besar data dengan cepat dan boleh dipercayai, dan sokongannya untuk tolakan pelayan. Selain itu, memandangkan gRPC menggunakan HTTP/2 untuk pengangkutan, anda boleh memanfaatkan beberapa kelebihan HTTP/2, seperti pemultipleksan dan tolakan pelayan. Kelemahannya ialah gRPC mungkin memerlukan lebih banyak masa dan sumber untuk menyediakan dan memulakan, dan memerlukan kedua-dua pelanggan dan pelayan untuk menyokong protokol gRPC.

Ringkasan

Setiap teknologi sambungan panjang mempunyai kelebihan dan kekurangannya yang unik. WebSocket ialah teknologi sambungan jangka panjang yang berkuasa yang boleh mencapai komunikasi dua hala, tetapi ia memerlukan sokongan khas dan mempunyai permintaan yang besar untuk sumber pelayan. Acara Dihantar Pelayan ialah satu lagi teknologi sambungan jangka panjang ringkas yang mudah digunakan dan dilaksanakan, tetapi hanya menyokong komunikasi sehala. gRPC ialah protokol panggilan prosedur jauh (RPC) yang sangat berskala dan dioptimumkan prestasi yang boleh memindahkan sejumlah besar data dengan cepat dan boleh dipercayai serta menyokong tolakan pelayan, tetapi mungkin memerlukan lebih banyak masa dan sumber untuk menyediakan dan memulakan, dan memerlukan Kedua-dua pelanggan dan sokongan pelayan protokol gRPC.

Untuk kebanyakan aplikasi web, WebSocket dan Acara Dihantar Pelayan mungkin merupakan pilihan terbaik. Ia mudah digunakan dan dilaksanakan, dan dalam kebanyakan kes boleh memenuhi keperluan sambungan yang panjang. Jika anda perlu memproses sejumlah besar data, atau memerlukan pelayan untuk menolak data kepada klien dalam masa nyata, gRPC mungkin merupakan pilihan yang lebih baik. Mana-mana teknologi yang dipilih, ia harus dipilih dan dioptimumkan berdasarkan keperluan dan senario aplikasi.

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