golang domain name forwarding

Golang is a powerful programming language commonly used in web development, network programming and other fields. In network programming, domain name forwarding is an important function. This article will introduce how to use Golang to implement domain name forwarding.

1. Domain Name Resolution

Before forwarding the domain name, we need to perform domain name resolution first. Domain name resolution refers to the process of converting domain names into IP addresses. Golang provides the net package, which contains functions related to DNS resolution. The following is a simple domain name resolution example:

package main

import (
    "fmt"
    "net"
)

func main() {
    ips, err := net.LookupIP("www.baidu.com")
    if err != nil {
        fmt.Println("域名解析失败：", err)
        return
    }

    for _, ip := range ips {
        fmt.Println(ip.String())
    }
}

Running the above code will output Baidu’s IP address. It should be noted that since domain name resolution requires access to the DNS server, it is necessary to ensure that the network connection is normal.

2. Basic HTTP forwarding

When forwarding domain names, we need to map the domain name to an IP address and then forward the request to the IP address. This can be achieved with simple HTTP forwarding. Here is an example of a very basic HTTP forwarder:

package main

import (
    "log"
    "net/http"
)

func main() {
    http.HandleFunc("/", func(w http.ResponseWriter, r *http.Request) {
        log.Printf("收到请求：%v
", r.URL)

        // 创建并发送请求
        resp, err := http.Get("http://127.0.0.1:8080" + r.URL.Path)
        if err != nil {
            log.Printf("请求失败：%v
", err)
            w.WriteHeader(http.StatusInternalServerError)
            w.Write([]byte(err.Error()))
            return
        }
        defer resp.Body.Close()

        // 复制响应头
        for k, v := range resp.Header {
            w.Header().Set(k, v[0])
        }

        // 发送响应体
        w.WriteHeader(resp.StatusCode)
        _, err = io.Copy(w, resp.Body)
        if err != nil {
            log.Printf("响应失败：%v
", err)
        }
    })

    log.Println("开始监听：127.0.0.1:80")
    err := http.ListenAndServe(":80", nil)
    if err != nil {
        log.Fatal("监听失败：", err)
    }
}

The above code will forward all requests to the local port 8080. It should be noted that this forwarder is very simple and cannot handle complex HTTP requests. If you need to handle more complex requests, you can use a third-party HTTP library, such as Gin or Echo.

3. Dynamic domain name forwarding

In the above example, we forward all requests to the same IP address. Now, let's consider how to map multiple domain names to different IP addresses. This can be achieved through a configuration file. The following is a simple configuration file example:

www.example.com=192.168.0.1
api.example.com=192.168.0.2

We can read this configuration file when the program starts, and save these domain name and IP address mapping relationships in a map. Then when a request is received, the corresponding IP address is found based on the requested domain name and the request is forwarded to the IP address. The following is an example:

package main

import (
    "bufio"
    "io"
    "log"
    "net"
    "net/http"
    "os"
    "strings"
    "sync"
)

var mu sync.RWMutex
var addrMap = make(map[string]string)

func main() {
    // 读取配置文件
    f, err := os.Open("config.txt")
    if err != nil {
        log.Fatal("读取配置文件失败：", err)
    }
    defer f.Close()

    reader := bufio.NewReader(f)
    for {
        line, _, err := reader.ReadLine()
        if err == io.EOF {
            break
        } else if err != nil {
            log.Fatal("读取配置文件失败：", err)
        }
        parts := strings.Split(string(line), "=")
        if len(parts) != 2 {
            continue
        }
        addrMap[parts[0]] = parts[1]
    }

    http.HandleFunc("/", func(w http.ResponseWriter, r *http.Request) {
        log.Printf("收到请求：%v
", r.URL)
        var addr string

        // 解析域名
        host := strings.Split(r.Host, ":")[0]
        mu.RLock()
        addr, ok := addrMap[host]
        mu.RUnlock()
        if !ok {
            http.NotFound(w, r)
            return
        }

        // 创建并发送请求
        resp, err := http.Get("http://" + addr + r.URL.Path)
        if err != nil {
            log.Printf("请求失败：%v
", err)
            w.WriteHeader(http.StatusInternalServerError)
            w.Write([]byte(err.Error()))
            return
        }
        defer resp.Body.Close()

        // 复制响应头
        for k, v := range resp.Header {
            w.Header().Set(k, v[0])
        }

        // 发送响应体
        w.WriteHeader(resp.StatusCode)
        _, err = io.Copy(w, resp.Body)
        if err != nil {
            log.Printf("响应失败：%v
", err)
        }
    })

    log.Println("开始监听：127.0.0.1:80")
    err = http.ListenAndServe(":80", nil)
    if err != nil {
        log.Fatal("监听失败：", err)
    }
}

In the above example, we use a map to save the mapping relationship between domain names and IP addresses. When receiving a request, we will find the corresponding IP address from this map and forward the request to the IP address. Since multiple requests may access this mapping relationship at the same time, a read-write lock needs to be used to protect this map.

Summary

In this article, we introduced how to use Golang to implement domain name forwarding. We first introduced how to perform domain name resolution, and then introduced simple HTTP forwarding and dynamic domain name forwarding. It should be noted that the examples in this article are only the most basic implementations. In actual development, more factors need to be considered, such as caching, load balancing, etc.

The above is the detailed content of golang domain name forwarding. For more information, please follow other related articles on the PHP Chinese website!