Das Erstellen und Verwalten von TCP-Verbindungen ist in der Go-Sprache sehr einfach. In diesem Artikel wird erläutert, wie Sie mithilfe der Go-Sprache einen TCP-Dienst erstellen und TCP-Verbindungen weiterleiten.
- Voraussetzungswissen
Bevor Sie diesen Artikel studieren, müssen Sie die folgenden grundlegenden Wissenspunkte beherrschen:
# 🎜🎜 #Go-Sprachgrundlagen- Grundkonzepte und Verwendung des TCP-Protokolls
-
TCP-Dienst erstellen- #🎜 🎜 #Das Erstellen eines TCP-Dienstes in der Go-Sprache ist sehr einfach. Zuerst müssen wir das Paket
net und das Paket bufio importieren und dann die Methode net.Listen verwenden, um eine Portnummer abzuhören:
package main
import (
"bufio"
"fmt"
"net"
)
func main() {
ln, err := net.Listen("tcp", ":8080")
if err != nil {
fmt.Println("Error listening:", err.Error())
return
}
defer ln.Close()
fmt.Println("Listening on port 8080...")
}Nach dem Login kopieren
#🎜 🎜#Im obigen Beispiel haben wir die Portnummer 8080 abgehört und
Listening on port 8080... auf der Konsole ausgegeben.
net包和bufio包，然后使用net.Listen方法监听一个端口号：for {
conn, err := ln.Accept()
if err != nil {
fmt.Println("Error accepting connection:", err.Error())
return
}
fmt.Println("Connection accepted.")
// 处理连接
go handleConnection(conn)
}
func handleConnection(conn net.Conn) {
// 处理连接
}Nach dem Login kopieren
在上面的例子中，我们监听了8080端口号，并在控制台输出Listening on port 8080...。
- 接受TCP连接
接下来，我们需要接受TCP连接。使用ln.Accept()方法可以在一个连接准备好之前阻塞程序。一旦有一个连接请求，我们就可以创建一个新协程，处理连接：
func handleConnection(conn net.Conn) {
defer conn.Close()
remoteConn, err := net.Dial("tcp", "127.0.0.1:9090")
if err != nil {
fmt.Println("Error connecting to remote server:", err.Error())
return
}
defer remoteConn.Close()
go func() {
defer conn.Close()
defer remoteConn.Close()
for {
data, err := bufio.NewReader(conn).ReadString('
')
if err != nil {
fmt.Println("Error reading from conn:", err.Error())
return
}
_, err = remoteConn.Write([]byte(data))
if err != nil {
fmt.Println("Error writing to remoteConn:", err.Error())
return
}
}
}()
// 从remoteConn读取数据并转发到conn
for {
data, err := bufio.NewReader(remoteConn).ReadString('
')
if err != nil {
fmt.Println("Error reading from remoteConn:", err.Error())
return
}
_, err = conn.Write([]byte(data))
if err != nil {
fmt.Println("Error writing to conn:", err.Error())
return
}
}
}Nach dem Login kopieren
在上面的代码中，我们使用了一个无限循环来不断接受连接请求。当有连接请求时，我们会创建一个新的协程go handleConnection(conn)来处理连接。
- 处理TCP连接
接下来，我们需要对连接进行处理。对于每个客户端连接，我们需要将客户端发送的所有数据转发到另一个服务器上。可以使用bufio包来进行读取和写入。
package main
import (
"bufio"
"fmt"
"net"
)
func main() {
ln, err := net.Listen("tcp", ":8080")
if err != nil {
fmt.Println("Error listening:", err.Error())
return
}
defer ln.Close()
fmt.Println("Listening on port 8080...")
for {
conn, err := ln.Accept()
if err != nil {
fmt.Println("Error accepting connection:", err.Error())
return
}
fmt.Println("Connection accepted.")
go handleConnection(conn)
}
}
func handleConnection(conn net.Conn) {
defer conn.Close()
remoteConn, err := net.Dial("tcp", "127.0.0.1:9090")
if err != nil {
fmt.Println("Error connecting to remote server:", err.Error())
return
}
defer remoteConn.Close()
go func() {
defer conn.Close()
defer remoteConn.Close()
for {
data, err := bufio.NewReader(conn).ReadString('
')
if err != nil {
fmt.Println("Error reading from conn:", err.Error())
return
}
_, err = remoteConn.Write([]byte(data))
if err != nil {
fmt.Println("Error writing to remoteConn:", err.Error())
return
}
}
}()
for {
data, err := bufio.NewReader(remoteConn).ReadString('
')
if err != nil {
fmt.Println("Error reading from remoteConn:", err.Error())
return
}
_, err = conn.Write([]byte(data))
if err != nil {
fmt.Println("Error writing to conn:", err.Error())
return
}
}
}Nach dem Login kopieren
上面的代码中，我们首先使用net.Dial方法连接到另一个服务器，然后开启两个协程：一个协程读取客户端发来的数据并转发给另一个服务器，另一个协程从服务器读取数据并转发给客户端。
需要注意的是，在每个协程中都要使用defer conn.Close()和defer remoteConn.Close()TCP-Verbindung akzeptieren
- Als nächstes müssen wir die TCP-Verbindung akzeptieren. Verwenden Sie die Methode
ln.Accept(), um das Programm zu blockieren, bis eine Verbindung bereit ist. Sobald eine Verbindungsanfrage vorliegt, können wir eine neue Coroutine erstellen, um die Verbindung zu verarbeiten: rrreee
Im obigen Code verwenden wir eine Endlosschleife, um Verbindungsanfragen kontinuierlich anzunehmen. Wenn eine Verbindungsanforderung vorliegt, erstellen wir eine neue Coroutine go handleConnection(conn), um die Verbindung zu verarbeiten.
TCP-Verbindungen verarbeiten
- Als nächstes müssen wir die Verbindung verarbeiten. Für jede Client-Verbindung müssen wir alle vom Client gesendeten Daten an einen anderen Server weiterleiten. Sie können das Paket
bufio zum Lesen und Schreiben verwenden.
rrreeeIm obigen Code verwenden wir zunächst die Methode net.Dial, um eine Verbindung zu einem anderen Server herzustellen, und starten dann zwei Coroutinen: Eine Coroutine liest die vom Client gesendeten Daten Die Daten werden an einen anderen Server weitergeleitet, und eine andere Coroutine liest die Daten vom Server und leitet sie an den Client weiter.
#🎜🎜#Es ist zu beachten, dass defer conn.Close() und defer remoteConn.Close() in jeder Coroutine verwendet werden müssen nicht versehentlich geschlossen werden. #🎜🎜##🎜🎜##🎜🎜#Vollständiger Code#🎜🎜##🎜🎜##🎜🎜#Das Folgende ist der vollständige TCP-Weiterleitungsdienstcode: #🎜🎜#rrreee#🎜🎜##🎜🎜#Zusammenfassung # 🎜🎜##🎜🎜##🎜🎜#Die Go-Sprache macht das Erstellen und Verwalten von TCP-Verbindungen zum Kinderspiel. In diesem Artikel wird erläutert, wie Sie mithilfe der Go-Sprache einen TCP-Dienst erstellen und weiterleiten. Ich hoffe, dass er für Sie hilfreich ist. #🎜🎜#
Das obige ist der detaillierte Inhalt vongolang vorwärts tcp. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!
