Http.Handle ("/", websocket.Handler (EchoServer) Can EchoServer get a different parameter than ws?

Question

I opened a websocket server to send data to a web component,

func WebSocketServer() {
    http.Handle("/", websocket.Handler(Echoserver))
    err := http.ListenAndServe(":8081", nil)
    CheckError(err)
}

I would like to pass an additional argument (msg, of type String) to the handler (Echoserver) function.

func Echoserver(ws *websocket.Conn, msg String) {
    fmt.Println("Client Connected")
         _ := websocket.JSON.Send(ws, msg);
    }
}

Is it possible to do this using the syntax above? What do you call Echoserver an optional parameter?

Answer 1

, - string, /. , . ( , - , .)

- . , . ( , , ). , "object like". ( , , .)

type echoStuff string

var hey echoStuff = "Hey!"

http.Handle("/", websocket.Handler(hey.EchoServer))
err := http.ListenAndServe(":8081", nil)
CheckError(err)

func (msg echoStuff) Echoserver(ws *websocket.Conn) {
  fmt.Println("Client Connected")
   _ := websocket.JSON.Send(ws, msg);
}

- . , " ". (- . , .)

func WebSocketServer() {
  http.Handle("/", echoHandler("Hey!"))
  err := http.ListenAndServe(":8081", nil)
  CheckError(err)
}

func echoHandler(msg string) websocket.Handler {
  return func(ws *Conn) {
    Echoserver(ws, msg)
  }
}

Answer 2

, websocket.Handler .

func(*Conn)

, , , .
. , :

-, :

yourHandlerFunction := func(ws *websocket.Conn) {
  client := NewClient(ws, self)
  self.addClient <- client
  client.Listen()
  defer ws.Close()
}

( "" , websocket.Conn)

:

for {
  select {

    // Add new a client
    case c := <-self.addClient:
      log.Println("Added new client")
      self.clients = append(self.clients, c)
      for _, msg := range self.messages {
        c.Write() <- msg
    }

, , JSON:

// Listen write request via chanel
func (self *Client) listenWrite() {
  log.Println("Listening write to client")
  for {
    select {

      // send message to the client
      case msg := <-self.ch:
        log.Println("Send:", msg)
        websocket.JSON.Send(self.ws, msg)

      // receive done request
      case <-self.done:
        self.server.RemoveClient() <- self
        self.done <- true // for listenRead method
      return
    }
  }
}