Golang implements http proxy

Golang is a fast, efficient and powerful open source programming language with concurrent computing and garbage collection mechanisms. Its ease of use and efficiency have attracted widespread attention and love. HTTP proxy is a very common network proxy mode, which is usually used to hide the user's real IP address, implement functions such as restricting access and tracking users.

This article will show how to use Golang to implement an HTTP proxy service, and introduce the relevant implementation details and usage methods.

1. Introduction to HTTP proxy

In the network, HTTP proxy can help the client send and receive HTTP requests and responses, and hide its real IP address for the client. When a client makes a request to the proxy server, the proxy server forwards the request to the target server to obtain the requested resource. The proxy server then forwards the response to the client, allowing the proxy server to act as an intermediary between the client and the target server.

Through the HTTP proxy service, the client can communicate with other servers on the Internet through the proxy server, so that it can protect its own IP address and can also access restricted websites when needed. In addition, HTTP proxy can also implement functions such as flow control, recording user traffic, and filtering advertisements.

2. Golang implements HTTP proxy

1. HTTP proxy working principle

The implementation of HTTP proxy requires the following steps:

1. Establish a proxy server and listen for connection requests on the proxy server.
2. When a client request reaches the proxy server, identity authentication and related checks are first performed, such as verifying the user's identity through HTTP Basic Auth and other methods; checking whether it contains malicious code or requests, etc.
3. If the request passes the above check, the proxy server will establish a connection with the target server and forward the request to the target server.
4. When the target server response returns, the proxy server will dedicate the response content to the client.
5. Close the connection and wait for the next connection request.

The following is the simplified workflow of HTTP proxy:

2. Code implementation

Let’s do this Show the code for Golang to implement HTTP proxy:

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) // 将响应体写回客户端
}

The above code implements a simple HTTP proxy service, listens to the specified port, and obtains the client’s connection request through net.Listen. Then, use http.ReadRequest to read the request and establish a connection to the target server through net.Dial. Next, use http.Write to send a request to the target server and read the response through http.ReadResponse. Finally, the response headers and response body are written back to the client.

3. Usage method

Save the above code as go-proxy.go, and then compile it through the following command:

$ go build go-proxy.go

After compilation, you can Start the HTTP proxy server in the command line:

$ ./go-proxy 8080

Among them, 8080 is the listening port of the HTTP proxy, which can be set according to the actual situation. Next, configure the browser to use 127.0.0.1:8080 (that is, the IP address and designated port of the proxy server) as the HTTP proxy.

3. Summary

This article introduces how to use Golang to implement HTTP proxy service, and shows the relevant implementation details and usage methods. By studying this article, readers can master how to use Golang to implement HTTP proxy services, which provides an important reference for actual development. At the same time, readers can also optimize and expand the code as needed to meet more complex HTTP proxy scenarios.

The above is the detailed content of Golang implements http proxy. For more information, please follow other related articles on the PHP Chinese website!