使用 AI 辅助开发一个开源 IP 信息查询工具：一

sips -Z 380 /Users/soulteary/Downloads/panda.png --out small-panda.png   
/Users/soulteary/Downloads/panda.png
  /Users/soulteary/Lab/github/ip-helper/small-panda.png

package main

import (
	"embed"
	"flag"
	"fmt"
	"io"
	"log"
	"net/http"
	"os"

	"github.com/gin-gonic/gin"
	static "github.com/soulteary/gin-static"
)

type Config struct {
	Domain string
	Port   string
	Token  string
}

// 解析配置参数
func parseConfig() *Config {
	config := &Config{}

	// 解析命令行参数
	flag.StringVar(&config.Port, "port", "", "服务器端口")
	flag.StringVar(&config.Domain, "domain", "", "服务器域名")
	flag.StringVar(&config.Token, "token", "", "API 访问令牌")
	flag.Parse()

	// 尝试从环境变量中获取未设置的内容
	if config.Port == "" {
		config.Port = os.Getenv("SERVER_PORT")
	}
	if config.Domain == "" {
		config.Domain = os.Getenv("SERVER_DOMAIN")
	}
	if config.Token == "" {
		config.Token = os.Getenv("TOKEN")
	}

	// 使用默认值
	if config.Port == "" {
		config.Port = "8080"
	}
	if config.Domain == "" {
		config.Domain = "localhost"
	}
	if config.Token == "" {
		config.Token = ""
		log.Println("提醒：为了提高安全性，可以设置 `TOKEN` 环境变量或 `token` 命令行参数")
	}

	return config
}

// 验证请求中的令牌
func authMiddleware(config *Config) gin.HandlerFunc {
	return func(c *gin.Context) {
		if config.Token != "" {
			token := c.Query("token")
			if token == "" {
				token = c.GetHeader("X-Token")
			}
			if token != config.Token {
				c.JSON(401, gin.H{"error": "无效的认证令牌"})
				c.Abort()
				return
			}
		}
		c.Next()
	}
}

func Get(link string) ([]byte, error) {
	resp, err := http.Get(link)
	if err != nil {
		return nil, err
	}
	defer resp.Body.Close()

	if resp.StatusCode != http.StatusOK {
		return nil, fmt.Errorf("服务器返回非200状态码: %d", resp.StatusCode)
	}

	body, err := io.ReadAll(resp.Body)
	if err != nil {
		return nil, fmt.Errorf("读取响应内容失败: %v", err)
	}
	return body, nil
}

//go:embed public
var EmbedFS embed.FS

func main() {
	config := parseConfig()

	r := gin.Default()
	r.GET("/health", func(c *gin.Context) {
		c.JSON(200, gin.H{
			"status": "ok",
			"domain": config.Domain,
		})
	})

	r.Use(static.Serve("/", static.LocalFile("./public", false)))

	r.Use(authMiddleware(config))
	r.GET("/", func(c *gin.Context) {
		buf, err := Get(fmt.Sprintf("http://localhost:%s/index.template.html", config.Port))
		if err != nil {
			c.String(500, "读取模板文件失败: %v", err)
			return
		}
		c.Data(200, "text/html; charset=utf-8", buf)
	})

	serverAddr := fmt.Sprintf(":%s", config.Port)
	log.Printf("启动服务器于 %s:%s\n", "config.Domain", config.Port)
	if err := r.Run(serverAddr); err != nil {
		log.Fatalf("启动服务器失败: %v", err)
	}
}

// ...

// IPInfo 存储 IP 相关信息
type IPInfo struct {
	ClientIP     string `json:"client_ip"`
	ProxyIP      string `json:"proxy_ip,omitempty"`
	IsProxy      bool   `json:"is_proxy"`
	ForwardedFor string `json:"forwarded_for,omitempty"`
	RealIP       string `json:"real_ip"`
}

// 获取并分析 IP 信息的中间件
func IPAnalyzer() gin.HandlerFunc {
	return func(c *gin.Context) {
		ipInfo := analyzeIP(c)
		// 将 IP 信息存储到上下文中
		c.Set("ip_info", ipInfo)
		c.Next()
	}
}

// 分析 IP 信息
func analyzeIP(c *gin.Context) IPInfo {
	var ipInfo IPInfo

	// 获取客户端 IP
	ipInfo.ClientIP = c.ClientIP()

	// 获取 X-Forwarded-For 头信息
	forwardedFor := c.GetHeader("X-Forwarded-For")
	if forwardedFor != "" {
		ipInfo.ForwardedFor = forwardedFor
		// X-Forwarded-For 可能包含多个 IP，第一个是原始客户端 IP
		ips := strings.Split(forwardedFor, ",")
		if len(ips) > 0 {
			ipInfo.RealIP = strings.TrimSpace(ips[0])
			if len(ips) > 1 {
				ipInfo.IsProxy = true
				ipInfo.ProxyIP = strings.TrimSpace(ips[len(ips)-1])
			}
		}
	} else {
		ipInfo.RealIP = ipInfo.ClientIP
	}

	// 获取 X-Real-IP 头信息
	xRealIP := c.GetHeader("X-Real-IP")
	if xRealIP != "" && xRealIP != ipInfo.RealIP {
		ipInfo.IsProxy = true
		ipInfo.ProxyIP = ipInfo.ClientIP
		ipInfo.RealIP = xRealIP
	}

	// 检查是否为私有 IP
	if isPrivateIP(ipInfo.ClientIP) {
		ipInfo.IsProxy = true
	}

	return ipInfo
}

// 检查是否为私有 IP 地址
func isPrivateIP(ipStr string) bool {
	ip := net.ParseIP(ipStr)
	if ip == nil {
		return false
	}

	// 检查是否为私有 IP 范围
	privateIPRanges := []struct {
		start net.IP
		end   net.IP
	}{
		{net.ParseIP("10.0.0.0"), net.ParseIP("10.255.255.255")},
		{net.ParseIP("172.16.0.0"), net.ParseIP("172.31.255.255")},
		{net.ParseIP("192.168.0.0"), net.ParseIP("192.168.255.255")},
	}

	for _, r := range privateIPRanges {
		if bytes.Compare(ip, r.start) >= 0 && bytes.Compare(ip, r.end) <= 0 {
			return true
		}
	}
	return false
}

//go:embed public
var EmbedFS embed.FS

func main() {
	// ...

	r.Use(static.Serve("/", static.LocalFile("./public", false)))

	r.Use(authMiddleware(config))
	// 使用IP分析中间件
	r.Use(IPAnalyzer())
	r.GET("/", func(c *gin.Context) {
		// 先获取 IP 信息
		ipInfo, exists := c.Get("ip_info")
		if !exists {
			c.JSON(500, gin.H{"error": "IP info not found"})
			return
		}

		buf, err := Get(fmt.Sprintf("http://localhost:%s/index.template.html", config.Port))
		if err != nil {
			c.String(500, "读取模板文件失败: %v", err)
			return
		}

		// TODO 将 IP 信息传递给模板
		fmt.Println(ipInfo)

		c.Data(200, "text/html; charset=utf-8", buf)
	})
	// 单独提供一个接口，来获取 IP 信息
	r.GET("/ip", func(c *gin.Context) {
		ipInfo, exists := c.Get("ip_info")
		if !exists {
			c.JSON(500, gin.H{"error": "IP info not found"})
			return
		}
		c.JSON(200, ipInfo)
	})

	serverAddr := fmt.Sprintf(":%s", config.Port)
	log.Printf("启动服务器于 %s:%s\n", "config.Domain", config.Port)
	if err := r.Run(serverAddr); err != nil {
		log.Fatalf("启动服务器失败: %v", err)
	}

	r.Run(":8080")
}

# curl 127.0.0.1:8080/ip

{"client_ip":"127.0.0.1","is_proxy":false,"real_ip":"127.0.0.1"}

go get github.com/soulteary/ipdb-go

// ...

// 帮助我们对数据库中的内容进行去重
// eg: ["CLOUDFLARE.COM","CLOUDFLARE.COM",""] => ["CLOUDFLARE.COM",""]

func removeDuplicates(strSlice []string) []string {
	// 创建一个 map 用于存储唯一的字符串
	encountered := make(map[string]bool)
	result := []string{}

	// 遍历切片，将未出现过的字符串添加到结果中
	for _, str := range strSlice {
		if !encountered[str] {
			encountered[str] = true
			result = append(result, str)
		}
	}

	return result
}

//go:embed public
var EmbedFS embed.FS

func main() {
	config := parseConfig()

	// 初始化 IP 数据库
	db, err := ipdb.NewCity("./data/ipipfree.ipdb")
	if err != nil {
		log.Fatal(err)
	}
	// 更新 ipdb 文件后可调用 Reload 方法重新加载内容
	// db.Reload("./data/ipipfree.ipdb")

	r := gin.Default()
	r.GET("/health", func(c *gin.Context) {
		c.JSON(200, gin.H{
			"status": "ok",
			"domain": config.Domain,
		})
	})

	r.Use(static.Serve("/", static.LocalFile("./public", false)))

	r.Use(authMiddleware(config))
	r.Use(IPAnalyzer())
	r.GET("/", func(c *gin.Context) {
		ipInfo, exists := c.Get("ip_info")
		if !exists {
			c.JSON(500, gin.H{"error": "IP info not found"})
			return
		}

		buf, err := Get(fmt.Sprintf("http://localhost:%s/index.template.html", config.Port))
		if err != nil {
			c.String(500, "读取模板文件失败: %v", err)
			return
		}

		// TODO 将 IP 信息传递给模板
		fmt.Println(ipInfo)

		c.Data(200, "text/html; charset=utf-8", buf)
	})
	// 获取当前请求方的 IP 地址信息
	r.GET("/ip", func(c *gin.Context) {
		ipInfo, exists := c.Get("ip_info")
		if !exists {
			c.JSON(500, gin.H{"error": "IP info not found"})
			return
		}
		c.JSON(200, ipInfo)
	})
	// 获取指定 IP 地址信息
	r.GET("/ip/:ip", func(c *gin.Context) {
		// 获取 URL 中的 IP 地址
		ipaddr := c.Param("ip")
		fmt.Println("ip", ipaddr)
		if ipaddr == "" {
			ipInfo, exists := c.Get("ip_info")
			if !exists {
				c.JSON(500, gin.H{"error": "IP info not found"})
				return
			}
			ipaddr = ipInfo.(IPInfo).RealIP
		}

		dbInfo, err := db.Find(ipaddr, "CN")
		if err != nil {
			dbInfo = []string{"未找到 IP 地址信息"}
		}
		dbInfo = removeDuplicates(dbInfo)
		c.JSON(200, map[string]any{"ip": ipaddr, "info": dbInfo})
	})

	serverAddr := fmt.Sprintf(":%s", config.Port)
	log.Printf("启动服务器于 %s:%s\n", "config.Domain", config.Port)
	if err := r.Run(serverAddr); err != nil {
		log.Fatalf("启动服务器失败: %v", err)
	}

	r.Run(":8080")
}

# curl 127.0.0.1:8080/ip

{"client_ip":"127.0.0.1","is_proxy":false,"real_ip":"127.0.0.1"}

# curl 127.0.0.1:8080/ip/123.123.123.123

{"info":["中国","北京"],"ip":"123.123.123.123"}

# curl 127.0.0.1:8080/ip/1.1.1.1

{"info":["CLOUDFLARE.COM",""],"ip":"1.1.1.1"}

// ...
func main() {
	// ...
	r.GET("/", func(c *gin.Context) {
		ipInfo, exists := c.Get("ip_info")
		if !exists {
			c.JSON(500, gin.H{"error": "IP info not found"})
			return
		}

		// 查询 IP 地址具体信息
		dbInfo, err := db.Find(ipInfo.(IPInfo).RealIP, "CN")
		if err != nil {
			dbInfo = []string{"未找到 IP 地址信息"}
		}
		// 读取默认模版
		template, err := Get(fmt.Sprintf("http://localhost:%s/index.template.html", config.Port))
		if err != nil {
			c.String(500, "读取模板文件失败: %v", err)
			return
		}
		// 更新模版中的 IP 地址
		template = bytes.ReplaceAll(template, []byte("%IP_ADDR%"), []byte(ipInfo.(IPInfo).ClientIP))
		// 更新模版中的域名
		template = bytes.ReplaceAll(template, []byte("%DOMAIN%"), []byte(config.Domain))
		// 更新模版中的 IP 地址信息
		template = bytes.ReplaceAll(template, []byte("%DATA_1_INFO%"), []byte(strings.Join(removeDuplicates(dbInfo), " ")))

		c.Data(200, "text/html; charset=utf-8", template)
	})
// ...
}

SERVER_DOMAIN=localhost:8080 go run main.go

<div class="search-container">
  <form action="/" method="post">
    <input type="text" name="ip" class="search-input" placeholder="请输入要查询的 IP 地址" value="%IP_ADDR%" />
    <button class="search-button" type="submit">查询</button>  
  </form>
</div>

// ...
// 使用 net 包验证 IP 地址
func isValidIPAddress(ip string) bool {
	if parsedIP := net.ParseIP(ip); parsedIP != nil {
		return true
	}
	return false
}

// IPForm 定义表单结构
type IPForm struct {
	IP string `form:"ip" binding:"required"`
}

func main() {
	// ...
	// 处理 POST 请求，解析表单数据
	r.POST("/", func(c *gin.Context) {
		// 获取请求中的 IP 地址信息
		ipInfo, exists := c.Get("ip_info")
		if !exists {
			c.JSON(500, gin.H{"error": "IP info not found"})
			return
		}
		// 默认 IP 地址为空
		ip := ""
		var form IPForm
		// 使用 ShouldBind 绑定表单数据
		if err := c.ShouldBind(&form); err != nil {
			// 如果绑定失败，使用请求中的 IP 地址
			ip = ipInfo.(IPInfo).RealIP
		} else {
			// 获取到 IP 地址后的处理逻辑
			ip = form.IP
			// 如果 IP 地址不合法，使用请求中的 IP 地址
			if !isValidIPAddress(ip) {
				ip = ipInfo.(IPInfo).RealIP
			}
		}
		c.Redirect(302, fmt.Sprintf("/ip/%s", ip))
	})
// ...
}

// ...
func main() {
	//...
	// 获取客户端 IP 信息
	getClientIPInfo := func(c *gin.Context, ipaddr string) (resultIP string, resultDBInfo []string, err error) {
		// 判断是否有传入 IP 地址
		if ipaddr == "" {
			// 如果没有有效 IP，默认使用发起请求的客户端 IP 信息
			ipInfo, exists := c.Get("ip_info")
			if !exists {
				return resultIP, resultDBInfo, fmt.Errorf("IP info not found")
			}
			ipaddr = ipInfo.(IPInfo).RealIP
		}

		dbInfo, err := db.Find(ipaddr, "CN")
		if err != nil {
			dbInfo = []string{"未找到 IP 地址信息"}
		}
		dbInfo = removeDuplicates(dbInfo)
		return ipaddr, dbInfo, nil
	}

	// 渲染模板
	renderTemplate := func(globalTemplate []byte, ipaddr string, dbInfo []string) []byte {
		template := bytes.ReplaceAll(globalTemplate, []byte("%IP_ADDR%"), []byte(ipaddr))
		template = bytes.ReplaceAll(template, []byte("%DOMAIN%"), []byte(config.Domain))
		template = bytes.ReplaceAll(template, []byte("%DATA_1_INFO%"), []byte(strings.Join(removeDuplicates(dbInfo), " ")))
		return template
	}

	// 渲染 JSON
	renderJSON := func(ipaddr string, dbInfo []string) map[string]any {
		return map[string]any{"ip": ipaddr, "info": dbInfo}
	}

	globalTemplate := []byte{}

	r.GET("/", func(c *gin.Context) {
		// 预缓存模板文件
		if len(globalTemplate) == 0 {
			globalTemplate, err = Get(fmt.Sprintf("http://localhost:%s/index.template.html", config.Port))
			if err != nil {
				log.Fatalf("读取模板文件失败: %v\n", err)
				return
			}
		}

		// 获取客户端 IP 信息，首页不需要传入 IP 地址
		ipAddr, dbInfo, err := getClientIPInfo(c, "")
		if err != nil {
			c.JSON(500, gin.H{"error": err.Error()})
			return
		}
		// 返回渲染后的 HTML 内容
		c.Data(200, "text/html; charset=utf-8", renderTemplate(globalTemplate, ipAddr, dbInfo))
	})

	r.GET("/ip/:ip", func(c *gin.Context) {
		ip := c.Param("ip")
		// 获取指定 IP 地址的信息
		ipAddr, dbInfo, err := getClientIPInfo(c, ip)
		if err != nil {
			c.JSON(500, gin.H{"error": err.Error()})
			return
		}
		c.JSON(200, renderJSON(ipAddr, dbInfo))
	})
    // ...
}

// ...
// 判断请求发起方是否为“下载工具”
func IsDownloadTool(userAgent string) bool {
	// 转换为小写以便不区分大小写比较
	ua := strings.ToLower(userAgent)

	// 常见下载工具的特征字符串
	downloadTools := []string{
		"curl",
		"wget",
		"aria2",
		"python-requests",
		"axios",
		"got",
		"postman",
	}

	for _, tool := range downloadTools {
		if strings.Contains(ua, tool) {
			return true
		}
	}

	return false
}

func main() {
	// ...
	r.GET("/", func(c *gin.Context) {
		if len(globalTemplate) == 0 {
			globalTemplate, err = Get(fmt.Sprintf("http://localhost:%s/index.template.html", config.Port))
			if err != nil {
				log.Fatalf("读取模板文件失败: %v\n", err)
				return
			}
		}

		ipAddr, dbInfo, err := getClientIPInfo(c, "")
		if err != nil {
			c.JSON(500, gin.H{"error": err.Error()})
			return
		}

		// 获取请求头中的 User-Agent 信息
		userAgent := c.GetHeader("User-Agent")
		// 使用下载工具访问时返回 JSON 格式
		if IsDownloadTool(userAgent) {
			c.JSON(200, renderJSON(ipAddr, dbInfo))
		} else {
			c.Data(200, "text/html; charset=utf-8", renderTemplate(globalTemplate, ipAddr, dbInfo))
		}
	})

	r.GET("/ip/:ip", func(c *gin.Context) {
		ip := c.Param("ip")
		ipAddr, dbInfo, err := getClientIPInfo(c, ip)
		if err != nil {
			c.JSON(500, gin.H{"error": err.Error()})
			return
		}
		// 获取请求头中的 User-Agent 信息
		userAgent := c.GetHeader("User-Agent")
		// 使用下载工具访问时返回 JSON 格式
		if IsDownloadTool(userAgent) {
			c.JSON(200, renderJSON(ipAddr, dbInfo))
		} else {
			c.Data(200, "text/html; charset=utf-8", renderTemplate(globalTemplate, ipAddr, dbInfo))
		}
	})

	// ...
}