pemajuan proksi golang

Dengan perkembangan pesat Internet, semakin banyak aplikasi perlu mendapatkan data daripada pelayan yang berbeza, dan permintaan data ini mungkin perlu melalui beberapa pelayan perantaraan Oleh itu, selalunya perlu menggunakan proksi semasa membangunkan aplikasi. Permintaan dihantar ke pelayan jauh sehingga data yang diperlukan diperolehi.

Artikel ini akan memperkenalkan cara menggunakan bahasa Go untuk membina pelayan proksi mudah yang memajukan permintaan pelanggan ke pelayan lain dan mengembalikan respons. Pelayan proksi boleh mengendalikan berbilang permintaan pelanggan dengan cekap, mengurangkan tekanan pada pelayan bahagian belakang dan meningkatkan prestasi dan kebolehskalaan aplikasi.

Ikhtisar

Dalam artikel ini, kita akan mempelajari cara mencipta pelayan proksi berasaskan golang yang menghantar permintaan masuk kepada pelanggan dan memajukan respons kepada pelayan sasaran. Kami akan menggunakan pelaksanaan net/http perpustakaan standard, yang menyediakan cara yang mudah dan cekap untuk mengendalikan permintaan dan respons HTTP.

Persediaan

Sebelum kita mula menulis pelayan proksi, kita perlu memasang persekitaran Go terlebih dahulu. Kami boleh memuat turun dan memasang Go dari tapak web rasmi https://golang.org/.

Cara pelayan proksi berfungsi

Dalam pelayan proksi, kita perlu menulis kod menggunakan pakej net/http bahasa Go untuk memintas permintaan pelanggan. Pakej ini menyediakan banyak fungsi dan struktur yang berguna untuk memproses dan menyahkod permintaan dan respons HTTP. Dalam pelayan proksi kami, kami akan menggunakan fungsi http.Handle() untuk memintas permintaan pelanggan dan mengubah halanya ke pelayan jauh. Kami kemudian menggunakan struktur http.Client() untuk menghantar permintaan ke pelayan jauh dan mengembalikan respons kepada klien.

Pseudokod berikut menunjukkan cara pelayan proksi berfungsi:

Apabila pelanggan membuat permintaan:

• Pelanggan menyambung ke pelayan proksi dan menghantar HTTP ask.
• Pelayan proksi memintas permintaan pelanggan dan menghuraikan pengepala permintaan dan badan permintaan.
• Pelayan proksi menyemak sama ada pelayan sasaran yang ditetapkan wujud dan mengembalikan ralat jika ia tidak wujud.
• Pelayan proksi mencipta permintaan HTTP baharu, menyalin permintaan daripada klien ke dalamnya dan menghantarnya ke pelayan sasaran.
• Pelayan sasaran menerima permintaan daripada pelayan proksi dan memproses permintaan itu.
• Pelayan sasaran mencipta dan mengembalikan respons HTTP.
• Pelayan proksi menerima respons daripada pelayan sasaran dan menghantar semula data respons kepada klien.

Menulis pelayan proksi

Sekarang mari kita mula menulis pelaksanaan pelayan proksi. Kita perlu mencipta pelayan HTTP dan menetapkan alamat pendengaran, port dan masa menunggu kliennya. Kami juga perlu menambah peraturan penghalaan supaya pengendali yang berbeza dipilih berdasarkan permintaan pelanggan. Dalam kes kami, kami akan menggunakan fungsi http.Handle() untuk menambah laluan, dan apabila URL yang diminta oleh klien ialah /proksi, kami akan mengubah hala permintaan ke pelayan yang ditentukan. Berikut ialah coretan kod:

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) {
    // 处理代理请求
}

Dalam kod di atas, kami mencipta struktur bernama Proxy dan melaksanakan kaedah ServeHTTP() dalam antara muka http.Handler padanya. Kaedah ServeHTTP() menerima dua parameter: http.ResponseWriter dan *http.Request objek yang pertama mewakili data yang dikembalikan oleh pelayan kepada klien, dan yang kedua mewakili pengepala permintaan HTTP dan badan permintaan yang diminta oleh klien.

Kami kemudiannya menyediakan dengan menambahkan peraturan penghalaan supaya apabila pelanggan meminta /proksi dalam URL, permintaan itu akan diubah hala kepada pengendali kami.

Seterusnya, kami akan menulis kod untuk mengendalikan permintaan proksi. Kita perlu menyemak sama ada pelayan sasaran wujud dan data yang diminta oleh pelanggan adalah betul. Di sini, kita boleh menggunakan fungsi http.NewRequest() untuk mencipta objek permintaan HTTP baharu. Kami kemudian menggunakan kaedah Do() dalam http.Client() untuk menghantar permintaan dan menunggu respons. Akhirnya, kami mengembalikan respons kepada pelanggan.

Berikut ialah kod lengkap:

pakej utama

import (

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

)

func main() {

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

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

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

}

// Struktur pelayan proksi
taip Struktur proksi {
}

// Laksanakan kaedah ServeHTTP antara muka bersih/http.Handler
func (p Proksi) 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 语言构建代理服务器，并演示了代理服务器的操作流程。虽然我们实现的代理服务器比较简单，但可以轻松扩展它来处理更复杂的请求。如果您有进一步的需求，可以使用类似的方法来扩展该服务器，以更好地满足您的需求。

Atas ialah kandungan terperinci pemajuan proksi golang. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!