Overview
WebSocket is a communication protocol that is very common in web development. It provides two-way, persistent connections and is suitable for real-time data transmission and real-time communication scenarios. In Golang, we can easily create and manage WebSocket connections using the net/http and /gorilla/websocket packages from the standard library. This article will explain how to use Golang to create a separate WebSocket session, including establishing a connection, messaging, and closing a connection.
Preparation
Before we start, we need to make sure that Golang andgorilla/websocketBag. You can install it through the following commandgorilla/websocketBag:
go get /gorilla/websocket
Create a WebSocket connection
First, we need to set up an HTTP server so that the client can establish a WebSocket connection via HTTP requests. Here is a simple example:
package main
import (
"fmt"
"log"
"net/http"
"/gorilla/websocket"
)
var upgrader = {
ReadBufferSize: 1024,
WriteBufferSize: 1024,
}
func main() {
("/ws", handleWebSocket)
((":8080", nil))
}
func handleWebSocket(w , r *) {
conn, err := (w, r, nil)
if err != nil {
(err)
return
}
// Handle WebSocket connections here}
The above code creates a simple HTTP server and passes/wsPath processing WebSocket connection. existhandleWebSocketIn the function, we useMethod to upgrade HTTP connection to WebSocket connection.
Message delivery
Once a WebSocket connection is established, we can start delivering messages. WebSocket providesandMethod, used to read and write messages from a connection. Here is a simple example:
func handleWebSocket(w , r *) {
conn, err := (w, r, nil)
if err != nil {
(err)
return
}
for {
// Read the message _, message, err := ()
if err != nil {
(err)
break
}
// Process messages ("Received message: ", string(message))
// Send a message err = (, []byte("Hello from server"))
if err != nil {
(err)
break
}
}
}
In the example above, we use an infinite loop to read and send messages.Method is used to read messages sent by the client.Method is used to send messages to the client. In practical applications, we can process the received messages according to business needs and send corresponding responses.
Close the connection
When we have completed communication with the client, we need to close the WebSocket connection correctly. For this we can useMethod to close the connection. Here is an example:
func handleWebSocket(w , r *) {
conn, err := (w, r, nil)
if err != nil {
(err)
return
}
defer ()
// Handle connection}
In the example above, we usedeferKeywords to ensure that the connection is closed before the function returns. This ensures that you exit whenever you wanthandleWebSocketFunctions and connections will be closed correctly.
Separate session management
Sometimes, we may need to create separate sessions for each connection in order to track and manage the status of each user. This can be accomplished by associating connections and sessions. Here is an example:
type Session struct {
Conn *
IsAlive bool
}
func handleWebSocket(w , r *) {
conn, err := (w, r, nil)
if err != nil {
(err)
return
}
session := &Session{
Conn: conn,
IsAlive: true,
}
defer ()
// Handle connections and conversations}
In the example above, we define a structure called Session that contains a type of join and a bool type IsAlive field. In the handleWebSocket function, we create a separate session for each connection and associate the connection with the session.
To manage sessions, we can use a separate manager that can store and track all sessions. Here is a simple example:
type SessionManager struct {
sessions map[string]*Session
lock
}
func (sm *SessionManager) AddSession(id string, session *Session) {
()
defer ()
[id] = session
}
func (sm *SessionManager) RemoveSession(id string) {
()
defer ()
delete(, id)
}
func (sm *SessionManager) GetSession(id string) *Session {
()
defer ()
return [id]
}
func handleWebSocket(w , r *) {
conn, err := (w, r, nil)
if err != nil {
(err)
return
}
session := &Session{
Conn: conn,
IsAlive: true,
}
// Associate the connection and the session (sessionID, session)
defer func() {
// Remove session from session manager (sessionID)
// Close the connection ()
}()
// Handle connections and conversations}
In the example above, we define a structure called SessionManager that contains a sessions field of type map. The SessionManager structure also contains methods such as AddSession, RemoveSession, and GetSession to add, remove, and get sessions. In the handleWebSocket function, we add the session to the session manager and remove it from the session manager before the function returns.
Through the Session Manager, we can easily track and manage the sessions of each connection and further process them according to business needs.
Case
Case 1: Live Chat Application
We can use WebSocket to create a live chat application that allows real-time text exchange between users. Here is a simple example:
func handleWebSocket(w , r *) {
conn, err := (w, r, nil)
if err != nil {
(err)
return
}
session := &Session{
Conn: conn,
IsAlive: true,
}
// Associate the connection and the session (sessionID, session)
defer func() {
// Remove session from session manager (sessionID)
// Close the connection ()
}()
for {
// Read the message _, message, err := ()
if err != nil {
(err)
break
}
// Process messages ("Received message: ", string(message))
// Broadcast messages to all connections ([]byte("User says: " + string(message)))
}
}
In the example above, we used the session manager mentioned earlier to associate each connection with the session. When a connection receives a message, it broadcasts the message to all connections to achieve the effect of live chat.
Case 2: Real-time data update
We can use WebSocket to update data in real time in the browser so that users can see the latest information immediately. Here is a simple example:
func handleWebSocket(w , r *) {
conn, err := (w, r, nil)
if err != nil {
(err)
return
}
session := &Session{
Conn: conn,
IsAlive: true,
}
// Associate the connection and the session (sessionID, session)
defer func() {
// Remove session from session manager (sessionID)
// Close the connection ()
}()
for {
// Simulate to get the latest data data := fetchData()
// Send the latest data to the connection err := (data)
if err != nil {
(err)
break
}
// Wait for a while and continue to send the latest data ( * 5)
}
}
In the above example, we simulate a function to get the latest datafetchData, and then send the latest data to the connection via WebSocket. By sending the latest data regularly, we can achieve real-time data update effect.
Case 3: Multiplayer Game
We can use WebSocket to create a multiplayer game that allows real-time game interaction between multiple players. Here is a simple example:
func handleWebSocket(w , r *) {
conn, err := (w, r, nil)
if err != nil {
(err)
return
}
session := &Session{
Conn: conn,
IsAlive: true,
}
// Associate the connection and the session (sessionID, session)
defer func() {
// Remove session from session manager (sessionID)
// Close the connection ()
}()
for {
// Read the message _, message, err := ()
if err != nil {
(err)
break
}
// Handle game logic gameLogic(sessionID, message)
}
}
In the above example, we can process messages between players according to game logic to achieve real-time interaction effects of multiplayer games.
These cases are just a small part of WebSocket application scenarios that you can further expand and customize according to your needs. WebSocket provides powerful real-time communication capabilities, making real-time interactions easier and more efficient in web development. Hope this article is helpful to you, thank you for reading!
in conclusion
In this article, we learned how to create a separate WebSocket session using Golang. We learned how to establish connections, messaging, and close connections, and explained how to use the Session Manager to track and manage sessions for each connection. WebSocket is a powerful communication protocol that plays an important role in real-time data transmission and real-time communication scenarios. By using the Golang and gorilla/websocket packages, we can easily create and manage WebSocket connections and implement real-time two-way communications in our applications. Hope this article is helpful to you, thanks for reading!
The above is the detailed content of using Golang to create a separate WebSocket session. For more information about Golang to create a websocket session, please follow my other related articles!