Golang melaksanakan proksi http

Golang ialah bahasa pengaturcaraan sumber terbuka yang pantas, cekap dan berkuasa dengan pengkomputeran serentak dan mekanisme pengumpulan sampah. Kemudahan penggunaan dan kecekapannya telah menarik perhatian dan kasih sayang yang meluas. Proksi HTTP ialah mod proksi rangkaian yang sangat biasa, yang biasanya digunakan untuk menyembunyikan alamat IP sebenar pengguna, melaksanakan fungsi seperti menyekat akses dan menjejaki pengguna.

Artikel ini akan menunjukkan cara menggunakan Golang untuk melaksanakan perkhidmatan proksi HTTP dan memperkenalkan butiran pelaksanaan dan kaedah penggunaan yang berkaitan.

1. Pengenalan kepada proksi HTTP

Dalam rangkaian, proksi HTTP boleh membantu pelanggan menghantar dan menerima permintaan dan respons HTTP, dan menyembunyikan alamat IP sebenar untuk pelanggan. Apabila pelanggan membuat permintaan kepada pelayan proksi, pelayan proksi memajukan permintaan kepada pelayan sasaran untuk mendapatkan sumber yang diminta. Pelayan proksi kemudiannya memajukan respons kepada klien, membenarkan pelayan proksi bertindak sebagai perantara antara klien dan pelayan sasaran.

Melalui perkhidmatan proksi HTTP, pelanggan boleh berkomunikasi dengan pelayan lain di Internet melalui pelayan proksi, supaya ia boleh melindungi alamat IPnya sendiri dan juga boleh mengakses tapak web terhad apabila diperlukan. Selain itu, proksi HTTP juga boleh melaksanakan fungsi seperti kawalan aliran, merekod trafik pengguna dan menapis iklan.

2. Golang melaksanakan proksi HTTP

1. Prinsip kerja proksi HTTP

Pelaksanaan proksi HTTP memerlukan langkah berikut:

1. Tubuhkan pelayan proksi dan dengar permintaan sambungan pada pelayan proksi.
2. Apabila permintaan pelanggan mencapai pelayan proksi, pengesahan identiti dan semakan yang berkaitan mula-mula dilakukan, seperti mengesahkan identiti pengguna melalui Pengesahan Asas HTTP dan kaedah lain untuk menyemak sama ada ia mengandungi kod hasad atau permintaan, dsb.
3. Jika permintaan melepasi semakan di atas, pelayan proksi akan mewujudkan sambungan dengan pelayan sasaran dan memajukan permintaan ke pelayan sasaran.
4. Apabila pelayan sasaran membalas semula, pelayan proksi akan mendedikasikan kandungan respons kepada klien.
5. Tutup sambungan dan tunggu permintaan sambungan seterusnya.

Berikut ialah aliran kerja proksi HTTP yang dipermudahkan:

2. Pelaksanaan kod

Mari kita lakukan di bawah Tunjukkan kod untuk melaksanakan proksi HTTP di Golang:

package main

import (
    "fmt"
    "io"
    "net"
    "net/http"
    "os"
)

func main() {
    if len(os.Args) < 2 {
        fmt.Println("usage: go-proxy [port]")
        os.Exit(1)
    }

    port := os.Args[1]
    fmt.Printf("Starting proxy server on port %s...
", port)

    ln, err := net.Listen("tcp", ":"+port) // 监听端口
    if err != nil {
        fmt.Printf("Failed to start proxy server: %s
", err)
        os.Exit(1)
    }

    for {
        conn, err := ln.Accept() // 接收请求
        if err != nil {
            fmt.Printf("Failed to accept connection: %s", err)
            continue
        }
        go handleConnection(conn) // 处理请求
    }
}

func handleConnection(conn net.Conn) {
    defer conn.Close()

    request, err := http.ReadRequest(bufio.NewReader(conn)) // 读取请求
    if err != nil {
        fmt.Printf("Failed to read request: %s
", err)
        return
    }

    fmt.Printf("Proxying request to: %s
", request.URL.String())
    client, err := net.Dial("tcp", request.Host) // 建立连接
    if err != nil {
        fmt.Printf("Failed to dial server: %s
", err)
        return
    }
    defer client.Close()

    err = request.Write(client) // 替换Host头并发送请求
    if err != nil {
        fmt.Printf("Failed to write request: %s
", err)
        return
    }

    response, err := http.ReadResponse(bufio.NewReader(client), request) // 读取响应
    if err != nil {
        fmt.Printf("Failed to read response: %s
", err)
        return
    }
    defer response.Body.Close()

    for k, v := range response.Header { // 将响应头写回客户端
        for _, vv := range v {
            conn.Write([]byte(k + ": " + vv + "
"))
        }
    }

    conn.Write([]byte("
")) // 写入响应行与响应头的分隔符
    io.Copy(conn, response.Body) // 将响应体写回客户端
}

Kod di atas melaksanakan perkhidmatan proksi HTTP yang mudah, mendengar port yang ditentukan dan mendapatkan permintaan sambungan pelanggan melalui net.Listen. Kemudian, gunakan http.ReadRequest untuk membaca permintaan dan mewujudkan sambungan ke pelayan sasaran melalui net.Dial. Seterusnya, gunakan http.Write untuk menghantar permintaan ke pelayan sasaran dan baca respons melalui http.ReadResponse. Akhir sekali, pengepala respons dan badan tindak balas ditulis semula kepada klien.

3. Penggunaan

Simpan kod di atas sebagai go-proxy.go, dan kemudian susunkannya melalui arahan berikut:

$ go build go-proxy.go

Selepas penyusunan, anda boleh Mulakan pelayan proksi HTTP dalam baris arahan:

$ ./go-proxy 8080

Antaranya, 8080 ialah port yang didengari oleh proksi HTTP, yang boleh ditetapkan mengikut situasi sebenar. Seterusnya, konfigurasikan penyemak imbas untuk menggunakan 127.0.0.1:8080 (iaitu, alamat IP dan port tertentu pelayan proksi) sebagai proksi HTTP.

3. Ringkasan

Artikel ini memperkenalkan cara menggunakan Golang untuk melaksanakan perkhidmatan proksi HTTP dan menunjukkan butiran pelaksanaan dan kaedah penggunaan yang berkaitan. Dengan mempelajari artikel ini, pembaca boleh menguasai cara menggunakan Golang untuk melaksanakan perkhidmatan proksi HTTP, yang menyediakan rujukan penting untuk pembangunan sebenar. Pada masa yang sama, pembaca juga boleh mengoptimumkan dan mengembangkan kod seperti yang diperlukan untuk memenuhi senario proksi HTTP yang lebih kompleks.

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