Golang-Proxy-Weiterleitung

Mit der rasanten Entwicklung des Internets müssen immer mehr Anwendungen Daten von verschiedenen Servern abrufen, und diese Datenanforderungen müssen möglicherweise über mehrere Zwischenserver erfolgen. Daher ist es häufig erforderlich, bei der Entwicklung von Anwendungen einen Proxy zu verwenden . Senden Sie die Anfrage an den Remote-Server, bis die erforderlichen Daten vorliegen.

In diesem Artikel wird erläutert, wie Sie mithilfe der Go-Sprache einen einfachen Proxyserver erstellen, der Clientanforderungen an einen anderen Server weiterleitet und eine Antwort zurückgibt. Proxy-Server können mehrere Client-Anfragen effizient verarbeiten, wodurch der Druck auf Back-End-Server verringert und die Anwendungsleistung und Skalierbarkeit verbessert wird.

Übersicht

In diesem Artikel erfahren Sie, wie Sie einen Golang-basierten Proxyserver erstellen, der eingehende Anfragen an den Client sendet und die Antwort an den Zielserver weiterleitet. Wir werden die Standardbibliothek net/http-Implementierung verwenden, die eine einfache und effiziente Möglichkeit bietet, HTTP-Anfragen und -Antworten zu verarbeiten.

Vorbereitung

Bevor wir mit dem Schreiben des Proxyservers beginnen, müssen wir zuerst die Go-Umgebung installieren. Wir können Go von der offiziellen Website https://golang.org/ herunterladen und installieren.

So funktioniert der Proxyserver

Im Proxyserver müssen wir Code mit dem Net/http-Paket der Go-Sprache schreiben, um Clientanfragen abzufangen. Dieses Paket bietet viele nützliche Funktionen und Strukturen zum Verarbeiten und Dekodieren von HTTP-Anfragen und -Antworten. In unserem Proxy-Server verwenden wir die Funktion http.Handle(), um Client-Anfragen abzufangen und sie an den Remote-Server umzuleiten. Anschließend verwenden wir die Struktur http.Client(), um eine Anfrage an den Remote-Server zu senden und die Antwort an den Client zurückzusenden.

zeigt, wie der Proxyserver mit dem folgenden Pseudocode funktioniert:

Wenn der Client eine Anfrage stellt:

• Client-Verbindung zum Proxyserver und senden Sie eine HTTP-Anfrage.
• Der Proxyserver fängt die Clientanforderung ab und analysiert den Anforderungsheader und den Anforderungstext.
• Der Proxyserver prüft, ob der festgelegte Zielserver existiert, und gibt einen Fehler zurück, wenn er nicht existiert.
• Der Proxyserver erstellt eine neue HTTP-Anfrage, kopiert die Anfrage vom Client hinein und sendet sie an den Zielserver.
• Der Zielserver empfängt die Anfrage vom Proxyserver und verarbeitet die Anfrage.
• Der Zielserver erstellt eine HTTP-Antwort und gibt sie zurück.
• Der Proxyserver empfängt die Antwort vom Zielserver und sendet die Antwortdaten zurück an den Client.

Proxyserver schreiben

Jetzt beginnen wir mit dem Schreiben der Implementierung des Proxyservers. Wir müssen einen HTTP-Server erstellen und dessen Abhöradresse, Port und Client-Wartezeit festlegen. Wir müssen außerdem Routing-Regeln hinzufügen, damit basierend auf Client-Anfragen unterschiedliche Handler ausgewählt werden. In unserem Fall verwenden wir die Funktion http.Handle(), um eine Route hinzuzufügen, und wenn die vom Client angeforderte URL /proxy lautet, leiten wir die Anfrage an den angegebenen Server um. Das Folgende ist ein Codeausschnitt:

package main

import (
    "log"
    "net/http"
)

func main() {
    // 创建 http 服务器
    proxy := &Proxy{}

    // 添加路由规则
    http.Handle("/proxy", proxy)

    // 监听地址及端口
    log.Fatal(http.ListenAndServe(":8080", nil))
}

// 代理服务器结构体
type Proxy struct {
}

// 实现 http.Handler 接口的 ServeHTTP 方法
func (p *Proxy) ServeHTTP(w http.ResponseWriter, r *http.Request) {
    // 处理代理请求
}

Im obigen Code erstellen wir eine Struktur namens Proxy und implementieren darauf die ServeHTTP()-Methode in der http.Handler-Schnittstelle. Die ServeHTTP()-Methode empfängt zwei Parameter: http.ResponseWriter- und *http.Request-Objekte. Ersteres stellt die vom Server an den Client zurückgegebenen Daten dar, und letzteres stellt den vom Client angeforderten HTTP-Anforderungsheader und Anforderungstext dar.

Wir richten dann die Einrichtung ein, indem wir eine Routing-Regel hinzufügen, um festzulegen, dass die Anfrage an unseren Handler umgeleitet wird, wenn ein Client /proxy in der URL anfordert.

Als nächstes müssen wir den Code schreiben, um die Proxy-Anfrage zu bearbeiten. Wir müssen überprüfen, ob der Zielserver existiert und ob die vom Client angeforderten Daten korrekt sind. Hier können wir die Funktion http.NewRequest() verwenden, um ein neues HTTP-Anfrageobjekt zu erstellen. Anschließend verwenden wir die Do()-Methode in http.Client(), um die Anfrage zu senden und auf die Antwort zu warten. Abschließend senden wir die Antwort an den Client zurück.

Das Folgende ist der vollständige Code:

package main

import (

"io/ioutil"
"log"
"net/http"

)

# 🎜 🎜#func main() {

// 创建 http 服务器
proxy := &Proxy{}

// 添加路由规则
http.Handle("/proxy", proxy)

// 监听地址及端口
log.Fatal(http.ListenAndServe(":8080", nil))

}

// Proxyserverstruktur

type Proxystruktur {
}
#🎜 🎜#// Implementieren Sie die ServeHTTP-Methode der net/http.Handler-Schnittstelle

func (p

Proxy) ServeHTTP(w http.ResponseWriter, r
http.Request) {

// 检查目标服务器是否存在
targetUrl := "http://localhost:8888"
if len(targetUrl) == 0 {
    w.WriteHeader(http.StatusBadGateway)
    return
}

// 检查客户端请求的数据是否正确
if r.Method != "GET" {
    w.WriteHeader(http.StatusMethodNotAllowed)
    return
}

// 创建一个新的 HTTP 请求对象
req, err := http.NewRequest("GET", targetUrl, nil)
if err != nil {
    log.Fatal("请求创建失败", err)
}

// 使用 http.Client() 发送请求
client := &http.Client{}
resp, err := client.Do(req)
if err != nil {
    log.Fatal("请求发送失败", err)
}

defer resp.Body.Close()

// 读取响应的数据
body, err := ioutil.ReadAll(resp.Body)
if err != nil {
    log.Fatal("读取响应数据失败", err)
}

// 将响应数据返回给客户端
w.Write(body)

# 🎜🎜#}

运行代理服务器

现在我们已经完成了代理服务器的编写，请使用以下命令在命令行中运行该服务器，其中 targetUrl 是我们要转发的目标服务器的 IP 地址和端口。

$ go run main.go -targetUrl=http://localhost:8888

接下来，在浏览器中输入以下 URL，将客户端请求发送到代理服务器中：

http://localhost:8080/proxy

此时，代理服务器将转发该请求到目标服务器，并等待响应。当目标服务器返回响应时，代理服务器将响应数据返回给客户端。我们可以在代码中设置超时时间来控制客户端请求的等待时间，以及设置日志记录来实时查看代理服务器的运行情况。

结论

本文介绍了如何使用 Go 语言构建代理服务器，并演示了代理服务器的操作流程。虽然我们实现的代理服务器比较简单，但可以轻松扩展它来处理更复杂的请求。如果您有进一步的需求，可以使用类似的方法来扩展该服务器，以更好地满足您的需求。

Das obige ist der detaillierte Inhalt vonGolang-Proxy-Weiterleitung. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!