Backend DevelopmentGolangHow to use Go language to develop a real-time data transmission system based on WebsocketHow to use Go language to develop a real-time data transmission system based on Websocket
How to use Go language to develop a real-time data transmission system based on Websocket, specific code examples are required
Websocket is a full-duplex protocol, which can be used without refreshing the page Achieve real-time data transmission under the circumstances. In modern web applications, real-time data transfer is a crucial part. This article will introduce how to use Go language to develop a real-time data transmission system based on Websocket, including how to implement server-side and client-side code, and provide specific code examples.
- Create WebSocket server
To create a real-time data transmission system based on Websocket, you first need to create a Websocket server. In Go, you can use the gorilla/websocket library to create a Websocket server.
The following is a sample code for a simple Websocket server:
package main
import (
"fmt"
"net/http"
"github.com/gorilla/websocket"
)
// 定义升级器
var upgrader = websocket.Upgrader{
ReadBufferSize: 1024,
WriteBufferSize: 1024,
}
func serveWs(w http.ResponseWriter, r *http.Request) {
// 升级请求为Websocket
conn, err := upgrader.Upgrade(w, r, nil)
if err != nil {
fmt.Println(err)
return
}
// 读取Websocket消息
for {
messageType, p, err := conn.ReadMessage()
if err != nil {
fmt.Println(err)
return
}
// 处理消息
fmt.Println(string(p))
// 回复消息
err = conn.WriteMessage(messageType, p)
if err != nil {
fmt.Println(err)
return
}
}
}
func main() {
http.HandleFunc("/ws", serveWs)
http.ListenAndServe(":8080", nil)
}In this example, we first define an upgrader (upgrader), which is used to upgrade HTTP connections to Websocket connect. Then, we define a function serveWs that receives an HTTP response writer (w) and HTTP request (r) and upgrades the HTTP connection to a Websocket connection.
In the serveWs function, we first upgrade the HTTP connection to a Websocket connection. We then use a loop to read the Websocket messages. Once we have read the message, we process it and send the same message back to the client.
Finally, in the main function, we associate the serveWs function with the path /ws and start the HTTP server on port 8080.
- Create Websocket client
Before creating the Websocket client, we need to create an HTML page that will communicate with the server through Websocket. The following is a sample code for a basic HTML page:
<!DOCTYPE html>
<html>
<head>
<title>Websocket Example</title>
</head>
<body>
<textarea id="message"></textarea>
<button onclick="send()">Send</button>
<script>
// 创建Websocket对象
var ws = new WebSocket("ws://localhost:8080/ws");
// 接收来自服务器的消息
ws.onmessage = function(event) {
console.log(event.data);
};
// 发送消息到服务器
function send() {
var input = document.getElementById("message");
ws.send(input.value);
input.value = "";
}
</script>
</body>
</html>In this example, we create a text area (message) and a button (send). When the user clicks the send button, we send the entered text to the server via Websocket.
In JavaScript, we use the WebSocket object to create a Websocket client. In our example, the Websocket client will connect to the /ws path and when it receives messages from the server, it will output them to the console.
- Running Websocket Server and Client
To run Websocket Server and Client, follow these steps:
- In the terminal, Use the command line to change to the directory containing the sample server code.
- Enter the following command to start the server:
go run main.go
- In a browser, open the following URL to load the sample HTML page:
http://localhost:8080/
- Enter some text in the text area and click the send button. You should see messages being sent to and returned from the server, and output in the browser console.
- Real-time data transmission
Now, we have successfully created a simple Websocket server and client, but this is just the beginning. To achieve real-time data transmission, we need to modify the server-side and client-side code and use goroutine on the server-side to handle multiple Websocket connections.
The following is a sample code that implements real-time data transmission:
package main
import (
"fmt"
"net/http"
"time"
"github.com/gorilla/websocket"
)
// 定义升级器
var upgrader = websocket.Upgrader{
ReadBufferSize: 1024,
WriteBufferSize: 1024,
}
// 定义客户端
type Client struct {
conn *websocket.Conn
send chan []byte
}
// 处理客户端消息
func (c *Client) read() {
defer func() {
c.conn.Close()
}()
for {
messageType, p, err := c.conn.ReadMessage()
if err != nil {
fmt.Println(err)
return
}
// 处理消息
fmt.Printf("Received: %s
", p)
}
}
// 发送消息到客户端
func (c *Client) write() {
defer func() {
c.conn.Close()
}()
for {
select {
case message, ok := <-c.send:
if !ok {
c.conn.WriteMessage(websocket.CloseMessage, []byte{})
return
}
writer, err := c.conn.NextWriter(websocket.TextMessage)
if err != nil {
return
}
writer.Write(message)
if err := writer.Close(); err != nil {
return
}
}
}
}
// 定义Hub
type Hub struct {
clients map[*Client]bool
broadcast chan []byte
register chan *Client
unregister chan *Client
}
// 创建Hub
func newHub() *Hub {
return &Hub{
clients: make(map[*Client]bool),
broadcast: make(chan []byte),
register: make(chan *Client),
unregister: make(chan *Client),
}
}
// 运行Hub
func (h *Hub) run() {
for {
select {
case client := <-h.register:
h.clients[client] = true
fmt.Println("Client registered")
case client := <-h.unregister:
if _, ok := h.clients[client]; ok {
delete(h.clients, client)
close(client.send)
fmt.Println("Client unregistered")
}
case message := <-h.broadcast:
for client := range h.clients {
select {
case client.send <- message:
fmt.Printf("Sent: %s
", message)
default:
close(client.send)
delete(h.clients, client)
}
}
}
}
}
func serveWs(hub *Hub, w http.ResponseWriter, r *http.Request) {
// 升级请求为Websocket
conn, err := upgrader.Upgrade(w, r, nil)
if err != nil {
fmt.Println(err)
return
}
// 创建客户端
client := &Client{
conn: conn,
send: make(chan []byte),
}
// 注册客户端
hub.register <- client
// 读取Websocket消息
go client.read()
// 发送Websocket消息
go client.write()
}
func main() {
// 创建Hub
hub := newHub()
// 运行Hub
go hub.run()
// 定期广播消息
go func() {
for {
hub.broadcast <- []byte(fmt.Sprintf("Server Time: %s", time.Now().Format("2006-01-02 15:04:05")))
time.Sleep(1 * time.Second)
}
}()
// 启动HTTP服务器
http.HandleFunc("/ws", func(w http.ResponseWriter, r *http.Request) {
serveWs(hub, w, r)
})
http.Handle("/", http.FileServer(http.Dir(".")))
err := http.ListenAndServe(":8080", nil)
if err != nil {
panic(err)
}
}In this example, we define a Hub that manages multiple Websocket clients. Each client has a read (receive) goroutine and a write (send) goroutine, which handle messages read from the client and messages sent to the client respectively.
In addition to processing client messages, Hub also contains a broadcast channel for broadcasting messages to all clients. In our example, the Hub periodically broadcasts the current date and time.
- Conclusion
Through the code examples in this article, we have learned how to use Go language to create a real-time data transmission system based on Websocket. We learned how to use the gorilla/websocket library to create a Websocket server and client, and implemented how to handle the client's input, how to send messages to the client, and implemented a Hub that manages multiple Websocket clients, and implemented The logic of broadcast messages.
The above is the detailed content of How to use Go language to develop a real-time data transmission system based on Websocket. For more information, please follow other related articles on the PHP Chinese website!
Golang and Python: Understanding the DifferencesApr 18, 2025 am 12:21 AMThe main differences between Golang and Python are concurrency models, type systems, performance and execution speed. 1. Golang uses the CSP model, which is suitable for high concurrent tasks; Python relies on multi-threading and GIL, which is suitable for I/O-intensive tasks. 2. Golang is a static type, and Python is a dynamic type. 3. Golang compiled language execution speed is fast, and Python interpreted language development is fast.
Golang vs. C : Assessing the Speed DifferenceApr 18, 2025 am 12:20 AMGolang is usually slower than C, but Golang has more advantages in concurrent programming and development efficiency: 1) Golang's garbage collection and concurrency model makes it perform well in high concurrency scenarios; 2) C obtains higher performance through manual memory management and hardware optimization, but has higher development complexity.
Golang: A Key Language for Cloud Computing and DevOpsApr 18, 2025 am 12:18 AMGolang is widely used in cloud computing and DevOps, and its advantages lie in simplicity, efficiency and concurrent programming capabilities. 1) In cloud computing, Golang efficiently handles concurrent requests through goroutine and channel mechanisms. 2) In DevOps, Golang's fast compilation and cross-platform features make it the first choice for automation tools.
Golang and C : Understanding Execution EfficiencyApr 18, 2025 am 12:16 AMGolang and C each have their own advantages in performance efficiency. 1) Golang improves efficiency through goroutine and garbage collection, but may introduce pause time. 2) C realizes high performance through manual memory management and optimization, but developers need to deal with memory leaks and other issues. When choosing, you need to consider project requirements and team technology stack.
Golang vs. Python: Concurrency and MultithreadingApr 17, 2025 am 12:20 AMGolang is more suitable for high concurrency tasks, while Python has more advantages in flexibility. 1.Golang efficiently handles concurrency through goroutine and channel. 2. Python relies on threading and asyncio, which is affected by GIL, but provides multiple concurrency methods. The choice should be based on specific needs.
Golang and C : The Trade-offs in PerformanceApr 17, 2025 am 12:18 AMThe performance differences between Golang and C are mainly reflected in memory management, compilation optimization and runtime efficiency. 1) Golang's garbage collection mechanism is convenient but may affect performance, 2) C's manual memory management and compiler optimization are more efficient in recursive computing.
Golang vs. Python: Applications and Use CasesApr 17, 2025 am 12:17 AMChooseGolangforhighperformanceandconcurrency,idealforbackendservicesandnetworkprogramming;selectPythonforrapiddevelopment,datascience,andmachinelearningduetoitsversatilityandextensivelibraries.
Golang vs. Python: Key Differences and SimilaritiesApr 17, 2025 am 12:15 AMGolang and Python each have their own advantages: Golang is suitable for high performance and concurrent programming, while Python is suitable for data science and web development. Golang is known for its concurrency model and efficient performance, while Python is known for its concise syntax and rich library ecosystem.
Hot AI Tools
Undresser.AI Undress
AI-powered app for creating realistic nude photos
AI Clothes Remover
Online AI tool for removing clothes from photos.
Undress AI Tool
Undress images for free
Clothoff.io
AI clothes remover
AI Hentai Generator
Generate AI Hentai for free.
Hot Article
Hot Tools
Safe Exam Browser
Safe Exam Browser is a secure browser environment for taking online exams securely. This software turns any computer into a secure workstation. It controls access to any utility and prevents students from using unauthorized resources.
WebStorm Mac version
Useful JavaScript development tools
SAP NetWeaver Server Adapter for Eclipse
Integrate Eclipse with SAP NetWeaver application server.
MinGW - Minimalist GNU for Windows
This project is in the process of being migrated to osdn.net/projects/mingw, you can continue to follow us there. MinGW: A native Windows port of the GNU Compiler Collection (GCC), freely distributable import libraries and header files for building native Windows applications; includes extensions to the MSVC runtime to support C99 functionality. All MinGW software can run on 64-bit Windows platforms.
Atom editor mac version download
The most popular open source editor
