当前位置：首页 > 文章列表 > Golang > Go问答 > 能否使用 quic/http3 协议与服务器进行通信？

能否使用 quic/http3 协议与服务器进行通信？

来源：stackoverflow 2024-02-17 11:36:23 0浏览收藏

编程并不是一个机械性的工作，而是需要有思考，有创新的工作，语法是固定的，但解决问题的思路则是依靠人的思维，这就需要我们坚持学习和更新自己的知识。今天golang学习网就整理分享《能否使用 quic/http3 协议与服务器进行通信？》，文章讲解的知识点主要包括，如果你对Golang方面的知识点感兴趣，就不要错过golang学习网，在这可以对大家的知识积累有所帮助，助力开发能力的提升。

问题内容

我使用quic-go来实现我的想法，我需要服务器转发请求到客户端以获得响应，就像我们通常客户端向web服务器发送请求一样。但是使用 quic-go，在建立连接后，服务器可以初始化流以向客户端发送请求并获取响应吗？我做了尝试，但还没有成功。下面的代码来自示例目录的echo.go，注释行之间的两部分是我添加的。

package main

import (
    "context"
    "crypto/rand"
    "crypto/rsa"
    "crypto/tls"
    "crypto/x509"
    "encoding/pem"
    "fmt"
    "io"
    "log"
    "math/big"

    "github.com/lucas-clemente/quic-go"
)

const addr = "localhost:4242"

const message = "foobar"

// We start a server echoing data on the first stream the client opens,
// then connect with a client, send the message, and wait for its receipt.
func main() {
    go func() { log.Fatal(echoServer()) }()

    err := clientMain()
    if err != nil {
        panic(err)
    }
}

// Start a server that echos all data on the first stream opened by the client
func echoServer() error {
    listener, err := quic.ListenAddr(addr, generateTLSConfig(), nil)
    if err != nil {
        return err
    }
    conn, err := listener.Accept(context.Background())
    if err != nil {
        return err
    }
    stream, err := conn.AcceptStream(context.Background())
    if err != nil {
        panic(err)
    }
    // Echo through the loggingWriter
    _, err = io.Copy(loggingWriter{stream}, stream)
    if err != nil {
        panic(err)
    }

    //------------------------------
    stream1, err := conn.OpenStream()
    if err != nil {
        panic(err)
    }

    message := "aaaaa"

    fmt.Printf("2-Server: Sending '%s'\n", message)

    _, err = stream1.Write([]byte(message))
    //------------------------------
    return err
}

func clientMain() error {
    tlsConf := &tls.Config{
        InsecureSkipVerify: true,
        NextProtos:         []string{"quic-echo-example"},
    }
    conn, err := quic.DialAddr(addr, tlsConf, nil)
    if err != nil {
        return err
    }

    stream, err := conn.OpenStreamSync(context.Background())
    if err != nil {
        return err
    }

    fmt.Printf("Client: Sending '%s'\n", message)
    _, err = stream.Write([]byte(message))
    if err != nil {
        return err
    }

    buf := make([]byte, len(message))
    _, err = io.ReadFull(stream, buf)
    if err != nil {
        return err
    }
    fmt.Printf("Client: Got '%s'\n", buf)
    err = stream.Close()
    if err != nil {
        return err
    }

    //-------------------------------
    for {
        stream1, err := conn.AcceptStream(context.Background())
        if err != nil {
            panic(err)
        }

        buf1 := make([]byte, len(message))
        _, err = io.ReadFull(stream1, buf1)
        if err != nil {
            panic(err)
        }
        fmt.Printf("2-Client: Got '%s'\n", buf1)

        err = stream1.Close()
        if err != nil {
            panic(err)
        }
    }
    //-------------------------------

    return nil
}

// A wrapper for io.Writer that also logs the message.
type loggingWriter struct{ io.Writer }

func (w loggingWriter) Write(b []byte) (int, error) {
    fmt.Printf("Server: Got '%s'\n", string(b))
    return w.Writer.Write(b)
}

// Setup a bare-bones TLS config for the server
func generateTLSConfig() *tls.Config {
    key, err := rsa.GenerateKey(rand.Reader, 1024)
    if err != nil {
        panic(err)
    }
    template := x509.Certificate{SerialNumber: big.NewInt(1)}
    certDER, err := x509.CreateCertificate(rand.Reader, &template, &template, &key.PublicKey, key)
    if err != nil {
        panic(err)
    }
    keyPEM := pem.EncodeToMemory(&pem.Block{Type: "RSA PRIVATE KEY", Bytes: x509.MarshalPKCS1PrivateKey(key)})
    certPEM := pem.EncodeToMemory(&pem.Block{Type: "CERTIFICATE", Bytes: certDER})

    tlsCert, err := tls.X509KeyPair(certPEM, keyPEM)
    if err != nil {
        panic(err)
    }
    return &tls.Config{
        Certificates: []tls.Certificate{tlsCert},
        NextProtos:   []string{"quic-echo-example"},
    }
}

正确答案

你已经很接近了。

注意服务器如何写入，然后返回，在客户端有机会读取和处理数据之前它就到达了 log.fatal。

注意 message 变量，一个是 6 长度，另一个只有 5 长度。

正确关闭您的流，服务器在移交之前没有结束它；

package main

import (
    "context"
    "crypto/rand"
    "crypto/rsa"
    "crypto/tls"
    "crypto/x509"
    "encoding/pem"
    "fmt"
    "io"
    "log"
    "math/big"

    "github.com/lucas-clemente/quic-go"
)

const addr = "localhost:4242"

const message = "foobar"

// We start a server echoing data on the first stream the client opens,
// then connect with a client, send the message, and wait for its receipt.
func main() {
    go func() {
        err := echoServer()
        if err != nil {
            log.Println(err)
        }
    }()

    err := clientMain()
    if err != nil {
        panic(err)
    }
}

// Start a server that echos all data on the first stream opened by the client
func echoServer() error {
    listener, err := quic.ListenAddr(addr, generateTLSConfig(), nil)
    if err != nil {
        return err
    }
    conn, err := listener.Accept(context.Background())
    if err != nil {
        return err
    }
    stream, err := conn.AcceptStream(context.Background())
    if err != nil {
        panic(err)
    }
    // Echo through the loggingWriter
    _, err = io.Copy(loggingWriter{stream}, stream)
    if err != nil {
        log.Println(err)
        return err
    }

    //------------------------------
    fmt.Printf("Server: open stream\n")
    stream1, err := conn.OpenStream()
    if err != nil {
        return err
    }

    fmt.Printf("2-Server: Sending '%s'\n", message)

    var n int
    n, err = stream1.Write([]byte(message))
    fmt.Printf("Server: write %v %v\n", n, err)
    stream1.Close()
    //------------------------------
    return err
}

func clientMain() error {
    tlsConf := &tls.Config{
        InsecureSkipVerify: true,
        NextProtos:         []string{"quic-echo-example"},
    }
    conn, err := quic.DialAddr(addr, tlsConf, nil)
    if err != nil {
        return err
    }

    stream, err := conn.OpenStreamSync(context.Background())
    if err != nil {
        return err
    }

    fmt.Printf("Client: Sending '%s'\n", message)
    _, err = stream.Write([]byte(message))
    if err != nil {
        return err
    }

    buf := make([]byte, len(message))
    _, err = io.ReadFull(stream, buf)
    if err != nil {
        return err
    }
    fmt.Printf("Client: Got '%s'\n", buf)
    err = stream.Close()
    if err != nil {
        return err
    }

    //-------------------------------
    for {
        fmt.Printf("Client: accept stream\n")
        stream1, err := conn.AcceptStream(context.Background())
        if err != nil {
            return err
        }

        fmt.Printf("Client: got stream %v\n", err)
        buf1 := make([]byte, len(message))
        _, err = io.ReadFull(stream1, buf1)
        if err != nil {
            return err
        }
        fmt.Printf("2-Client: Got '%s'\n", buf1)

        err = stream1.Close()
        if err != nil {
            return err
        }
        break
    }
    //-------------------------------

    return nil
}

// A wrapper for io.Writer that also logs the message.
type loggingWriter struct{ io.Writer }

func (w loggingWriter) Write(b []byte) (int, error) {
    fmt.Printf("Server: Got '%s'\n", string(b))
    return w.Writer.Write(b)
}

// Setup a bare-bones TLS config for the server
func generateTLSConfig() *tls.Config {
    key, err := rsa.GenerateKey(rand.Reader, 1024)
    if err != nil {
        panic(err)
    }
    template := x509.Certificate{SerialNumber: big.NewInt(1)}
    certDER, err := x509.CreateCertificate(rand.Reader, &template, &template, &key.PublicKey, key)
    if err != nil {
        panic(err)
    }
    keyPEM := pem.EncodeToMemory(&pem.Block{Type: "RSA PRIVATE KEY", Bytes: x509.MarshalPKCS1PrivateKey(key)})
    certPEM := pem.EncodeToMemory(&pem.Block{Type: "CERTIFICATE", Bytes: certDER})

    tlsCert, err := tls.X509KeyPair(certPEM, keyPEM)
    if err != nil {
        panic(err)
    }
    return &tls.Config{
        Certificates: []tls.Certificate{tlsCert},
        NextProtos:   []string{"quic-echo-example"},
    }
}

今天关于《能否使用 quic/http3 协议与服务器进行通信？》的内容介绍就到此结束，如果有什么疑问或者建议，可以在golang学习网公众号下多多回复交流；文中若有不正之处，也希望回复留言以告知！

版本声明

本文转载于：stackoverflow 如有侵犯，请联系study_golang@163.com删除