如何在一个单一的框架中利用多个通道

知识点掌握了，还需要不断练习才能熟练运用。下面golang学习网给大家带来一个Golang开发实战，手把手教大家学习《如何在一个单一的框架中利用多个通道》，在实现功能的过程中也带大家重新温习相关知识点，温故而知新，回头看看说不定又有不一样的感悟！

在我的代码中我想执行以下操作：

1. 从输入中接收数据作为 event 和 message
2. 根据 event 格式化接收到的数据

我想使用类似于 oop 中方法的东西，但看起来我把事情搞砸了。

我写的是：

// define the structs that contains the channels
type ssedata struct {
    event, message string
}
type datapasser struct {
    data       chan ssedata
    logs       chan string
    connection chan struct{} // to control maximum allowed clients connections
}

// define the struct's reciever that do the formating based on the input date
func (p *datapasser) format() {
    data := <-p.data
    switch {
    case len(data.event) > 0:
        p.logs <- fmt.sprintf("event: %v\ndata: %v\n\n", data.event, data.message)
    case len(data.event) == 0:
        p.logs <- fmt.sprintf("data: %v\n\n", data.message)
    }

}

然后我有以下内容：

func (p *datapasser) handlesignal(w http.responsewriter, r *http.request) {
    w.header().set("content-type", "text/event-stream; charset=utf-8")
    w.header().set("cache-control", "no-cache")
    w.header().set("connection", "keep-alive")
    setupcors(&w, r)

    fmt.println("client connected from ip:", r.remoteaddr)

    p.connection <- struct{}{}
    flusher, ok := w.(http.flusher)
    if !ok {
        http.error(w, "internal error", 500)
        return
    }

    fmt.fprint(w, "event: notification\ndata: connection to whatsapp server ...\n\n")
    flusher.flush()

    // connect to the whatsapp client
    go connect()

    // prepare dataparser `p` to recieve data through its ssedata channel
    go p.format()


    for {
        select {
        case c := <-p.logs:
            fmt.fprint(w, c)
            flusher.flush()
        case <-r.context().done():
            <-p.connection
            fmt.println("connection closed")
            return
        }
    }
}

func setupcors(w *http.responsewriter, req *http.request) {
    (*w).header().set("cache-control", "no-cache")
    (*w).header().set("access-control-allow-origin", "*")
    (*w).header().set("access-control-allow-methods", "post, get, options, put, delete")
    (*w).header().set("access-control-allow-headers", "accept, content-type, content-length, accept-encoding, x-csrf-token, authorization")
}

anf 在连接函数中，我有：

package main

import (
    "context"
    "fmt"
)

var err error

func connect() {
    fmt.println("connected")
    if client.isconnected() {
        client.disconnect()
        passer.data <- ssedata{
            event:   "notification",
            message: "reconnecting to whatsapp server ...",
        }
    }

    if client.store.id == nil {
        // no id stored, new login
    getqr:
        qrchan, _ := client.getqrchannel(context.background())
        err = client.connect()
        if err != nil {
            //  panic(err)
            //passer.logs <- "can not connect with whatapp server, try again later"
            passer.data <- ssedata{
                event:   "notification",
                message: "can not connect with whatapp server, try again later",
            }
            fmt.println("sorry", err)
        }

        for evt := range qrchan {
            switch evt.event {
            case "success":
                {
                    //passer.logs <- "success"
                    passer.data <- ssedata{
                        event:   "notification",
                        message: "success",
                    }
                    fmt.println("login event: success")
                }
            case "timeout":
                {
                    //passer.logs <- "timeout/refreshing"
                    passer.data <- ssedata{
                        event:   "notification",
                        message: "timeout/refreshing",
                    }
                    fmt.println("login event: timeout")
                    goto getqr
                }
            case "code":
                {
                    fmt.println("new code recieved")
                    fmt.println(evt.code)
                    //passer.logs <- evt.code
                    passer.data <- ssedata{
                        event:   "qrcode",
                        message: evt.code,
                    }
                }
            }
        }
    } else {
        // already logged in, just connect
        //passer.logs <- "already logged"
        passer.data <- ssedata{
            event:   "notification",
            message: "already logged in",
        }
        fmt.println("already logged")
        err = client.connect()
        if err != nil {
            panic(err)
        }
    }
    /*
        c := make(chan os.signal, 1)
        signal.notify(c, os.interrupt, syscall.sigterm)

        <-c
        passer.data <- ssedata{
            event:   "notification",
            message: "server got shut down",
        }
    */
}

在主文件中，我确实有：

var passer *DataPasser

const maxClients = 1

func init() {
    passer = &DataPasser{
        data:       make(chan sseData),
        logs:       make(chan string),
        connection: make(chan struct{}, maxClients),
    }
}

func main() {

    http.HandleFunc("/sse", passer.HandleSignal)
    go http.ListenAndServe(":1234", nil)

    // Listen to Ctrl+C (you can also do something else that prevents the program from exiting)
    c := make(chan os.Signal, 1)
    signal.Notify(c, os.Interrupt, syscall.SIGTERM)

    <-c
    if client.IsConnected() {
        client.Disconnect()
    }
}

发生的情况是服务器仅正确发送第一个 sse，并且看起来它挂在通道通信中的某个位置。

有什么想法吗？

正确答案

我通过写解决了这个问题：

    // Connect to the WhatsApp client
    go Connect()

    for {
        select {
        case data := <-p.data:
            fmt.Println("recieved")

            switch {
            case len(data.event) > 0:
                fmt.Fprintf(w, "event: %v\ndata: %v\n\n", data.event, data.message)
            case len(data.event) == 0:
                fmt.Fprintf(w, "data: %v\n\n", data.message)
            }
            flusher.Flush()
        case <-r.Context().Done():
            <-p.connection
            fmt.Println("Connection closed")
            return
        }
    }

但我仍然对拆分操作和使用接收器感兴趣，我不能接受这个答案，因为它是问题的解决方案，但不是问题的答案。 有什么想法吗？

当您从 go connect() 例程向 passer.data 发送数据时，例程 go p.format() 不会监听。由于您对 parser.data 使用无缓冲通道，但没有接收器在侦听，因此您的代码被卡住。使用 parser.data 的缓冲通道，或者确保启动例行监听来自数据通道的传入消息，并在实际将数据发送到通道之前进行监听。就您而言，我想在 connect 例程之前启动 format 例程应该足够了。

以上就是本文的全部内容了，是否有顺利帮助你解决问题？若是能给你带来学习上的帮助，请大家多多支持golang学习网！更多关于Golang的相关知识，也可关注golang学习网公众号。