Golang socket.io 服务器遭遇故障的原因

在将 socket.io 代码复制到服务器和客户端应用程序后，该应用程序不再有效。服务器显示客户端已断开连接，并且重建应用程序似乎不会断开连接。但是，当与原始代码配对时，一切正常。对 go build 命令的怀疑导致了对 net 包功能的探索，最终发现了问题并使用纯净代码解决了问题。

在制作了一些测试 golang 和 android kotlin 代码来尝试 socket.io 后，我将这些代码复制到我的项目的服务器和客户端应用程序中。

我与原始代码的唯一区别是由于必要而将套接字服务器启动作为 coroutine 运行，因为仅调用 startsocket 似乎本质上是一个阻塞函数。

更新后，我测试了代码是否仍然有效，并且确实有效。应用程序可以连接到服务器，应用程序也可以发送到服务器，并且iirc应用程序还可以接收来自服务器的发送。

当我重建应用程序时，服务器显示客户端已断开连接。现在，只有连接部分起作用。即使原来的应用程序现在无法发出，重建应用程序似乎也不再断开它的连接。客户端再次重复断开连接，但现在它悄无声息地发生，就像终端上只出现一条新连接的消息一样。在重复断开连接之前至少告诉客户端断开连接的一些原因。

如果我 go run 原始代码并将其与原始应用程序配对，则一切正常。我 go build 我的项目代码，但我怀疑这会影响socket.io。当我几乎没有改变任何东西时，我对为什么一切（大部分）都不再起作用感到束手无策。

这是我的 golang 代码：

package helpers

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

    socketio "github.com/googollee/go-socket.io"
    "github.com/googollee/go-socket.io/engineio"
    "github.com/googollee/go-socket.io/engineio/transport"
    "github.com/googollee/go-socket.io/engineio/transport/polling"
    "github.com/googollee/go-socket.io/engineio/transport/websocket"
)

var alloworiginfunc = func(r *http.request) bool {
    return true
}
var (
    port = flag.int("socket_server_port", 8000, "socket sckserver port")
)

var sckserver *socketio.server

const warning_tag = "warning"
const alert_tag = "alert"
const namespace = "notifications"
const simple_tag = "simple"
const room = "notif_room"

func startsocket() {
    flag.parse()

    sckserver = socketio.newserver(&engineio.options{
        transports: []transport.transport{
            &polling.transport{
                checkorigin: alloworiginfunc,
            },
            &websocket.transport{
                checkorigin: alloworiginfunc,
            },
        },
    })

    sckserver.onconnect("/", func(s socketio.conn) error {
        s.setcontext("")
        fmt.println("connected:", s.id())

        s.emit("notice", "new user connected")
        return nil
    })

    sckserver.onevent("/", "notice", func(s socketio.conn, msg string) {
        fmt.println("notice:", msg)
        s.emit("notice", "have "+msg)
    })

    sckserver.onerror("/", func(s socketio.conn, e error) {
        fmt.println("socket error:", e)
    })

    sckserver.ondisconnect("/", func(s socketio.conn, reason string) {
        fmt.println("closed", reason)
    })

    go sckserver.serve()
    defer sckserver.close()

    http.handle("/socket.io/", sckserver)
    http.handle("/", http.fileserver(http.dir("./asset")))

    fmt.printf("socket sckserver serving at localhost:%d...\n", *port)

    err := http.listenandserve(fmt.sprintf(":%d", *port), nil)

    if err != nil {
        log.fatalf("failed to start socket sckserver: %v\n", err)
    }
}

func getsocketsrv() *socketio.server {
    return sckserver
}

func broadcasttotag(tag string, payload string) {
    fmt.printf("broadcasttotag tag: %s, payload: %s\n", tag, payload)

    if sckserver != nil {
        broadcaststat := sckserver.broadcasttonamespace(namespace, tag, payload)
        fmt.printf("broadcaststat: %v\n", broadcaststat)
    } else {
        fmt.printf("sckserver = nil\n")
    }
}

这是我的 android kotlin 代码：

import android.util.log
import io.socket.client.io
import io.socket.client.socket
import io.socket.emitter.emitter
import java.net.connectexception
import java.net.urisyntaxexception

class sockethelper {
    private lateinit var msocket: socket
    private val onalertnotif =
        emitter.listener { args ->
            log.i(tag, "onalertnotif args: ${args[0]}")
        }

    private val onwarningnotif =
        emitter.listener { args ->
            log.i(tag, "onwarningnotif args: ${args[0]}")
        }

    private val onsimplenotif =
        emitter.listener { args ->
            log.i(tag, "onsimplenotif args: ${args[0]}")
        }

    init {
        try {
            msocket = io.socket("http://:8000/")
        }catch (e: connectexception) {
            log.e(tag, "socket connexc: ${e.localizedmessage}")
        }catch (e: urisyntaxexception) {
            log.e(tag, "socket urisynexc: ${e.localizedmessage}")
        }catch (e: exception){
            log.e(tag, "socket exc: ${e.localizedmessage}")
        }
    }

    fun send(eventname: string, msg: string){
        msocket.emit(eventname, msg)
    }

    fun open(){
        msocket.on("alert", onalertnotif)
        msocket.on("warning", onwarningnotif)
        msocket.on("simple", onsimplenotif)

        msocket.connect()
    }

    fun stop(){
        msocket.off()
        msocket.disconnect()
    }

    companion object{
        const val tag = "sockethelper"
    }
}

class mainactivity : appcompatactivity() {
    private val sockethelper = sockethelper()
    
    override fun oncreate(savedinstancestate: bundle?) {
        ...
        sockethelper.open()
    }
    
     override fun ondestroy() {
        super.ondestroy()

        sockethelper.stop()
    }
}

更新：

作为更新，我还将分享服务器端的 main.go，因为它可能对你们有帮助：

package main

import (
    "flag"
    "fmt"
    "log"
    "net"

    pb "github.com///api/proto/out"
    cmmHelpers "github.com///cmd/commons/helpers"
    "github.com///cmd/server/handlers"
    "github.com///cmd/server/helpers"

    "google.golang.org/grpc"
    "google.golang.org/grpc/credentials"
)

func init() {
    cmmHelpers.DatabaseConnection()
}

var (
    tls      = flag.Bool("tls", true, "Connection uses TLS if true, else plain TCP")
    certFile = flag.String("cert_file", "", "The TLS cert file")
    keyFile  = flag.String("key_file", "", "The TLS key file")
    port     = flag.Int("port", 50051, "The server port")
)

func main() {
    flag.Parse()

    lis, err := net.Listen("tcp", fmt.Sprintf("localhost:%d", *port))
    if err != nil {
        log.Fatalf("failed to listen: %v", err)
    }

    var opts []grpc.ServerOption
    if *tls {
        if *certFile == "" {
            *certFile = "service.pem"
        }

        if *keyFile == "" {
            *keyFile = "service.key"
        }

        creds, err := credentials.NewServerTLSFromFile(*certFile, *keyFile)

        if err != nil {
            log.Fatalf("Failed to generate credentials: %v", err)
        }

        opts = []grpc.ServerOption{grpc.Creds(creds)}
    }

    mServ := grpc.NewServer(opts...)

    fmt.Println("gRPC server running ...")

    //some gRPC related boiler plate

    log.Printf("Server listening at %v", lis.Addr())

    go helpers.StartSocket()

    if err := mServ.Serve(lis); err != nil {
        log.Fatalf("failed to serve : %v", err)
    }
}

正确答案

我已经找到了答案，但这是破坏性的。我完全放弃了 socket.io 并使用内置的 net 包所具有的内容。如果需要的话，我稍后会弄清楚如何实现 socket.io 的那些奇特功能。代码如下所示：

import (
    "flag"
    "fmt"
    "log"
    "net"
    "os"
)

var (
    socket_port   = flag.int("socket_server_port", 9001, "socket sckserver port")
    host          = flag.string("host name", "localhost", "server host name")
    socketconnarr = make(map[string]net.conn)
)

func startsocket() {
    listen, err := net.listen(type, fmt.sprintf(":%d", *socket_port))
    if err != nil {
        log.fatalf("conn err: %s", err)
        os.exit(1)
    }

    defer listen.close()

    fmt.printf("socket sckserver serving at localhost:%d...\n", *socket_port)

    for {
        conn, err := listen.accept()
        if err != nil {
            log.fatalf("accept err: %s", err)
            continue
        }
        socketconnarr[conn.remoteaddr().string()] = conn

        fmt.printf("socket client on: %s\n", conn.remoteaddr().string())

        go connwrite(conn, "socket server ack")
        go connread(conn)
    }
}

func connread(conn net.conn) {
    fmt.println("reading")
    buffer := make([]byte, 1024)
    bytesread, err := conn.read(buffer)
    if err != nil {
        log.fatalf("req err: %s", err)
    }

    fmt.printf("read %d bytes: %s", bytesread, string(buffer[:bytesread]))
}

func connwrite(conn net.conn, message string) {
    fmt.println("sending")
    conn.write([]byte("\n")) //for some reason, this is very important
    conn.write([]byte(message))
    conn.write([]byte("\n"))
}

然后在android端：

lifecycleScope.launch(Dispatchers.IO) {
    var response = ""

    try {
        socket = Socket(SERVER_IP, SERVER_PORT)
        writer = PrintWriter(socket.getOutputStream())
        reader = BufferedReader(InputStreamReader(socket.getInputStream()))

        writer.println(socketInitMsg)
        writer.flush()

        while (true) {
            if (reader.readLine() != null) {
                response = reader.readLine()
                Log.i(SocketHelper.TAG, "response: $response")
            }
        }
    } catch (e: IOException) {
        Log.e(SocketHelper.TAG, "err1: " + e.localizedMessage)
    } catch (e: Exception) {
        Log.e(SocketHelper.TAG, "err11: " + e.localizedMessage)
    }
}

文中关于的知识介绍，希望对你的学习有所帮助！若是受益匪浅，那就动动鼠标收藏这篇《Golang socket.io 服务器遭遇故障的原因》文章吧，也可关注golang学习网公众号了解相关技术文章。