在制作了一些测试 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: %vn", err)
}
}
func getsocketsrv() *socketio.server {
return sckserver
}
func broadcasttotag(tag string, payload string) {
fmt.printf("broadcasttotag tag: %s, payload: %sn", tag, payload)
if sckserver != nil {
broadcaststat := sckserver.broadcasttonamespace(namespace, tag, payload)
fmt.printf("broadcaststat: %vn", broadcaststat)
} else {
fmt.printf("sckserver = niln")
}
}
这是我的 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://<local_ip>: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/<me>/<project_name>/api/proto/out"
cmmHelpers "github.com/<me>/<project_name>/cmd/commons/helpers"
"github.com/<me>/<project_name>/cmd/server/handlers"
"github.com/<me>/<project_name>/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: %sn", 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)
}
}
