Question

我尝试使用套接字与客户沟通。

在对我的API发出一些请求后会创建一个套接字。这意味着，客户端连接自己（仅通过请求），但随后，他加入了聊天，因此创建了一个套接字并链接到好的渠道。

我已经使用了套接字，所以我理解它是如何工作的（C，C ++，C＃，Java），但是我想要做什么，我在网上看到的，我认为它是可能的，但我不知道＃39;了解如何使用golang处理它。

我创建了第一台服务器：

func main() {
    r := mux.NewRouter()
    r.HandleFunc("/", HomeHandler)
    r.HandleFunc("/products", ProductsHandler)
    r.HandleFunc("/articles", ArticlesHandler)
    http.Handle("/", r)
}

但对于socket，我还需要另一个吗？

package main

import "net"
import "fmt"
import "bufio"
import "strings" // only needed below for sample processing

func main() {

    fmt.Println("Launching server...")

    // listen on all interfaces
    ln, _ := net.Listen("tcp", ":8081")

    // accept connection on port
    conn, _ := ln.Accept()   

    // run loop forever (or until ctrl-c)
    for {     
        // will listen for message to process ending in newline (\n)
        message, _ := bufio.NewReader(conn).ReadString('\n')
        // output message received     
        fmt.Print("Message Received:", string(message))
        // sample process for string received     
        newmessage := strings.ToUpper(message)
        // send new string back to client     
        conn.Write([]byte(newmessage + "\n"))   
    } 
}

感谢您的帮助！

Answer 1

默认的http服务器接受一个＆＃34; host：port＆＃34;仅

答案取决于您将使用哪种协议通过套接字进行通信。

我建议这样做:(简化）

单独保留http.Server来为您的API提供服务（它实现协议HTTP 1。* / 2，所以您不必担心它）

实施您自己的＆＃34; MultiSocketServer＆＃34;，这样做：

2.1实现GracefulListener（必须实现net.Listener）（当你不再需要它时需要关闭套接字，对吗？）

2.2实现MultiSocketServer.Serve（l GracefulListener）（hello http.Server.Serve（））来提供单独的连接（你通过套接字与客户端通信的协议就在这里。像net.textproto这样的东西很容易实现，因为你GracefulListener.Accept（）将返回net.Conn）

2.3将方法MultiSocketServer.ListenAndServe（addr），MultiSocketServer.StopServe（l GracefulListener）添加到MultiSocketServer

type MultiSocketServer struct {
    listeners GracefulListener[] //or map?

    // lots of other stuff
}


// looks familiar? (http.Server.ListenAndServe) 
func (s *MultiSocketServer) ListenAndServe(addr string) {
    ln, err := net.Listen("tcp", addr)
    graceful_listner = &GracefulListener(ln)

    s.listeners = append(s.listeners, graceful_listner)

    go s.Serve(graceful_listner)
    return graceful_listner
}

func (s *MultiSocketServer) StopServe(graceful_listner  GracefulListener) {
    graceful_listner.Stop()
    //pseudocode
    remove_listener_from_slice(s.listeners, graceful_listner)
}

当然，你需要添加错误检查和互斥（可以）来保护MultiSocketServer.listeners以使其线程安全。

在你的main（）中启动你的API http.Server，并初始化你的MultiSocketServer。现在，从http.Server的http.Handler / http.HandlerFunc，你应该可以调用MultiSocketServer.ListenAndServe（addr）来监听和服务你的套接字连接。

根据问题更新

然而，我不确定理解部分＆＃34;在你的主要（）＆＃34;。如果我理解它很好，你说我有我的API，并在启动后，我初始化MultiSocketServer。但是哪里？我的API启动后？或者你的意思是我将代码的逻辑用作API会更好吗？每个请求都通过套接字

BTW：更新了MultiSocketServer.ListenAndServe以启动Listen并返回graceful_listner

func main() {
    //init MultiSocketServer
    multi_socket_server = &MultiSocketServer{} //nil for GracefulListener[] is fine for now, complex initialization will be added later
    // no listners yet, serves nothing

    // create new Handeler for your "socket requests"
    SocketRequestHandler := function(w http.ResponseWriter, r *http.Request) {
       // identify client, assign him an address to connect
       addr_to_listen := parse_request(r) //pseudocode

       listener := multi_socket_server.ListenAndServe(addr_to_listen)
       // TODO: handle errors
       // now your multi_socket_server listen to addr_to_listen and serves it with multi_socket_server.Serve method in its own goroutine
       // as i said MultiSocketServer.Serve method must implement your protocol (plaintext Reader/Writer on listener for now?)

       save_listener_in_context_or_whatever_you_like_to_track_it(listener) //pseudo
   }  

    SocketDisconnectHandler := function(w http.ResponseWriter, r *http.Request) {
      // identify client 
      some_client := parse_request(r) //pseudocode
      // get listener based on info
      listener := get_listener_from_context_or_whatever(some_client) //pseudo

      multi_socket_server.StopServe(listener)
      // TODO: handle errors
    }

    //initialize your API http.Server
    r := mux.NewRouter()
    r.HandleFunc("/", HomeHandler)
    r.HandleFunc("/products", ProductsHandler)
    r.HandleFunc("/articles", ArticlesHandler)
    r.HandleFunc("/socket_request", SocketRequestHandler) // added
    r.HandleFunc("/socket_disconnect", SocketDisconnectHandler) //added
    http.Handle("/", r)

    // it creates new http.Server with DefaultServeMux as Handler (which is configured with your http.Handle("/", r) call)
   http.ListenAndServe(":8080") // start serving API via HTTP proto
}

实际上，您可以从API服务器中的任何处理程序中调用multi_socket_server.ListenAndServe(addr_to_listen)和multi_socket_server.StopServe(listener)。

每次你调用multi_socket_server.ListenAndServe(addr_to_listen)它都会创建新的监听器并在其上发送，你必须控制它（不要再听同一个地址一次（我认为无论如何都会出错））

您的MultiSocketServer.Serve可能如下所示：

func (s *MultiSocketServer) Serve(l net.Listener) {
    defer l.Close()

    for {     
        // will listen for message to process ending in newline (\n)
        message, _ := bufio.NewReader(conn).ReadString('\n')
        // output message received     
        fmt.Print("Message Received:", string(message))
        // sample process for string received     
        newmessage := strings.ToUpper(message)
        // send new string back to client     
        conn.Write([]byte(newmessage + "\n"))   
    } 
}

可能是GracefulListener implementation github

或者你想要实现完全不同的东西？ =）

Answer 2

根据我们的聊天讨论。

OVER 包含大量伪代码的简化示例

import (
    "net"
    "encoding/json"
    "errors"
)

type User struct {
    name string
}

type Message {
    Action string
    Params map[string]string
}

type Server struct {
    connected_users map[*User]net.Conn
    users_connected_with_each_other map[*User][]*User
    good_users map[string]*User
}

func (srv *Server) ListenAndServe(addr string) error {
    ln, err := net.Listen("tcp", addr)
    if err != nil {
        return err
    }
    return srv.Serve(tcpKeepAliveListener{ln.(*net.TCPListener)})
}

func (srv *Server) Serve(l net.Listener) error {
    defer l.Close()

    for {
        rw, e := l.Accept()
        if e != nil {
            return e
        }

        // you want to create server_conn here with buffers, channels and stuff
        // to use async thread safe read/write from it
        go srv.serve_conn(rw)
    }
}

func (srv *Server) serve_conn(rw net.Conn) error {  
    dec := json.NewDecoder(rw)

    var message Message

    //read 1st message he sent, should be token to connect
    dec.Decode(&message)

    token := get_token(Message)

    user, ok := srv.good_users[token]

    if !ok {
        return errors.New("BAD USER!")
    }
    // store connected user
    srv.connected_users[user] = rw

    for {
        // async reader will be nice
        dec.Decode(&message)

        switch message.Action {
            case "Message":
                // find users to send message to
                if chats_with, err := users_connected_with_each_other[user]; err == nil {                   
                    for user_to_send_message_to := range chats_with {
                        // find connections to send message to
                        if conn, err := srv.connected_users[user_to_send_message_to]; err == nil {
                            // send json encoded message
                            err := json.NewEncoder(conn).Encode(message)
                            //if write failed store message for later
                        }
                    }
                }

            //other cases

            default:
                // log?
        }       
    }
}

func main() {
    known_users_with_tokens := make(map[string]*User)


    srv := &Server{
        connected_users: make(map[*User]net.Conn),
        users_connected_with_each_other: make(map[*User][]*User),
        good_users: known_users_with_tokens, // map is reference type, so treat it like pointer
    }
    // start our server
    go srv.ListenAndServe(":54321")


    ConnRequestHandler := function(w http.ResponseWriter, r *http.Request) {
        user := create_user_based_on_request(r)
        token := create_token(user)

        // now user will be able to connect to server with token
        known_users_with_tokens[token] = user
    }

    ConnectUsersHandler := function(user1,user2) {
        // you should guard your srv.* members to avoid concurrent read/writes to map
        srv.users_connected_with_each_other[user1] = append(srv.users_connected_with_each_other[user1], user2)
        srv.users_connected_with_each_other[user2] = append(srv.users_connected_with_each_other[user2], user1)
    }

    //initialize your API http.Server
    r := mux.NewRouter()
    r.HandleFunc("/", HomeHandler)
    r.HandleFunc("/products", ProductsHandler)
    r.HandleFunc("/articles", ArticlesHandler)
    r.HandleFunc("/connection_request", ConnRequestHandler) // added
    http.Handle("/", r)
}

致电ConnectUsersHandler(user1, user2)，让他们互相沟通。

known_users_with_tokens[token] = user允许用户连接到服务器

您需要为服务器连接实现异步读取器/写入器。有用的结构保持良好的用户。 Guard Server struct成员并提供线程安全访问以更新它。

<强> UDP

看起来json.NewEncoder(connection).Encode(&message)和json.NewDecoder(connection).Decode(&message)是异步和线程安全的。所以你可以同时从不同的goroutines写。无需手动同步，YAY！

Golang - API服务器和Socket同时使用

2 个答案: