IP 查询服务：二进制协议解析

IP 查询服务：二进制协议解析

每当你访问一个网站，对方的服务器都能通过你的 IP 地址推断出你的地理位置、网络运营商，乃至设备类型。这种能力支撑着内容本地化、广告定向、安全防护、合规限制等大量业务场景。

IP 地理位置查询（IP Geolocation）是一个迷人的工程问题：如何用最小的延迟，从一个包含数百万条记录的数据库中，找到一个 IP 地址对应的地理信息？答案不在于更快的 CPU，而在于数据结构的选择和二进制格式的设计。

本章以 IP 查询服务为主线，讲解二进制文件格式解析、内存映射文件、二分搜索、LRU 缓存和 HTTP API 设计。这些技术组合起来，能够在不使用数据库的情况下，以微秒级延迟完成每次 IP 查询。

Level 1 · IP 地理位置的使用场景与技术背景

为什么需要 IP 地理位置

内容本地化：根据用户所在国家/地区，展示对应语言的内容，遵守当地法律法规（如 GDPR 对欧盟用户的特殊要求）。

流量安全：检测来自高风险地区的异常流量，识别 VPN/代理/Tor 出口节点，是 Web 应用防护（WAF）的基础能力。

广告定向：按地理位置投放广告，这是互联网广告的核心能力之一。

合规管理：流媒体版权授权通常是按地区划分的（Netflix 不同国家的内容库不同），IP 地理位置是实施地区限制的技术基础。

网络诊断：确定一个 IP 属于哪个 AS（自治系统），隶属哪个 ISP，对网络运维至关重要。

MaxMind GeoIP vs IP2Location

业界最常用的两个 IP 数据库提供商：

MaxMind GeoIP2：

• 格式：MMDB（MaxMind Database），专有二进制格式
• 特点：数据质量高，有免费的 GeoLite2 版本（需要账户）
• Go 库：github.com/oschwald/geoip2-golang
• 准确度：城市级约 80%，国家级约 99%

IP2Location：

• 格式：自定义二进制格式，文档开放
• 特点：有完全免费的版本（IP2Location LITE），数据格式简单，适合学习
• 准确度与 MaxMind 相近

本章以 IP2Location BIN 格式为主要示例，因为它的格式是完全公开文档化的，非常适合讲解二进制协议解析的原理。

文本格式 vs 二进制格式：为什么性能相差 100 倍

假设我们用 CSV 存储 IP 地理位置数据：

1.0.0.0,1.0.0.255,AU,Australia,Queensland,Brisbane,...
1.0.1.0,1.0.3.255,CN,China,Fujian,Fuzhou,...

查询 1.0.2.1 时，需要：

1. 逐行扫描文件（或预加载到内存后逐行解析）
2. 将字符串 "1.0.1.0" 转换为整数 16777984 进行范围比较
3. 字符串解析、内存分配——每次查询都有大量 CPU 开销

二进制格式避免了所有这些：

• IP 地址直接存储为 4 字节整数（IPv4）或 16 字节整数（IPv6）
• 记录是固定长度的，可以用偏移量直接跳转
• 无需解析，直接内存读取
• 二分搜索可以在 O(log n) 步内完成查找

对于一个包含 400 万条记录的数据库，二分搜索只需约 22 次比较（log₂(4,000,000) ≈ 22），每次查询耗时在微秒量级。

Level 2 · IP2Location BIN 格式：深入解析

文件结构概览

IP2Location BIN 文件由三部分组成：

┌─────────────────────────────────────────────────────────┐
│                       文件头（64字节）                    │
├─────────────────────────────────────────────────────────┤
│              IPv4 索引段（可选，加速查找）                  │
├─────────────────────────────────────────────────────────┤
│              IPv4 数据记录（固定长度行，按IP排序）           │
├─────────────────────────────────────────────────────────┤
│              IPv6 索引段（可选）                           │
├─────────────────────────────────────────────────────────┤
│              IPv6 数据记录                                │
└─────────────────────────────────────────────────────────┘

文件头解析

// IP2Location BIN 文件头（前64字节）
type Header struct {
    DBType       uint8  // 数据库类型（1=DB1 国家, 2=DB2 国家+城市, ...）
    DBColumn     uint8  // 每条记录的列数
    DBYear       uint8  // 数据库年份
    DBMonth      uint8  // 数据库月份
    DBDay        uint8  // 数据库日期
    IPv4Count    uint32 // IPv4 记录数量
    IPv4Addr     uint32 // IPv4 数据段起始地址（文件偏移）
    IPv6Count    uint32 // IPv6 记录数量
    IPv6Addr     uint32 // IPv6 数据段起始地址
    IPv4IndexAddr uint32 // IPv4 索引段起始地址（0=无索引）
    IPv6IndexAddr uint32 // IPv6 索引段起始地址
    ProductCode  uint8  // 产品代码
    LicenseCode  uint8  // 授权代码
    DatabaseSize uint32 // 数据库大小
}

使用 Go 的 encoding/binary 包读取文件头：

import (
    "encoding/binary"
    "os"
    "fmt"
)

func readHeader(f *os.File) (*Header, error) {
    var h Header
    // IP2Location 使用小端字节序（Little-Endian）
    if err := binary.Read(f, binary.LittleEndian, &h); err != nil {
        return nil, fmt.Errorf("读取文件头失败: %w", err)
    }
    return &h, nil
}

字节序（Endianness）：为什么这很重要

多字节整数在内存中有两种排列方式：

• 大端（Big-Endian）：高位字节在低地址。例如 0x12345678 存储为 [0x12, 0x34, 0x56, 0x78]。网络协议（TCP/IP）使用大端，因此也称"网络字节序"。
• 小端（Little-Endian）：低位字节在低地址。同样的值存储为 [0x78, 0x56, 0x34, 0x12]。x86/ARM 架构的 CPU 使用小端（本机字节序）。

IP2Location 使用小端字节序存储多字节整数。如果使用错误的字节序读取，一个表示 "美国" 偏移量的整数会变成完全错误的值，导致读取到错误数据甚至程序崩溃。

// 手动演示字节序的重要性
func demonstrateEndianness() {
    data := []byte{0x78, 0x56, 0x34, 0x12}

    // 正确：小端读取
    leValue := binary.LittleEndian.Uint32(data) // = 0x12345678 = 305419896

    // 错误：大端读取
    beValue := binary.BigEndian.Uint32(data)    // = 0x78563412 = 2018915346

    fmt.Printf("小端: %d\n", leValue) // 305419896
    fmt.Printf("大端: %d\n", beValue) // 2018915346（错误！）
}

数据记录格式

每条 IPv4 记录的结构：

┌──────────────┬──────────────┬─────────────────────────────────────────┐
│  IP起始（4B） │  IP结束（4B） │           数据字段（变长，指针引用）          │
└──────────────┴──────────────┴─────────────────────────────────────────┘

字符串（国家名、城市名）不是直接存在记录中，而是存在文件末尾的字符串池中，记录中存储的是字符串的偏移量（4字节整数）。这样相同的字符串（如 "China"）只需存储一次。

type Record struct {
    IPFrom  uint32 // IP 范围起始（IPv4 整数）
    IPTo    uint32 // IP 范围结束（IPv4 整数）
    // 以下字段是字符串池中的偏移量
    CountryShort uint32 // 国家代码偏移（如 "CN"）
    CountryLong  uint32 // 国家全名偏移（如 "China"）
    Region       uint32 // 省/州偏移
    City         uint32 // 城市偏移
    ISP          uint32 // ISP 名称偏移
    Latitude     float32 // 纬度（直接存储浮点数）
    Longitude    float32 // 经度
}

// 读取字符串（从字符串池）
// IP2Location 字符串格式：[1字节长度][内容字节]
func readString(data []byte, offset uint32) string {
    if int(offset) >= len(data) {
        return ""
    }
    length := int(data[offset]) // 第一个字节是长度
    start := int(offset) + 1
    end := start + length
    if end > len(data) {
        return ""
    }
    return string(data[start:end])
}

内存映射文件：零拷贝读取

对于频繁读取的只读文件，内存映射（mmap）是最高效的访问方式。它将文件直接映射到进程的虚拟地址空间，由操作系统的页缓存机制按需加载数据，避免了 read() 系统调用的数据拷贝。

import (
    "os"
    "syscall"
    "golang.org/x/sys/unix"
)

type MmapFile struct {
    data []byte
    f    *os.File
}

func OpenMmap(path string) (*MmapFile, error) {
    f, err := os.Open(path)
    if err != nil {
        return nil, err
    }

    stat, err := f.Stat()
    if err != nil {
        f.Close()
        return nil, err
    }

    // 将文件映射到内存
    data, err := syscall.Mmap(
        int(f.Fd()),
        0,               // 从文件开头开始
        int(stat.Size()),
        syscall.PROT_READ,    // 只读
        syscall.MAP_SHARED,   // 与其他进程共享映射（对只读文件更高效）
    )
    if err != nil {
        f.Close()
        return nil, fmt.Errorf("mmap: %w", err)
    }

    return &MmapFile{data: data, f: f}, nil
}

func (m *MmapFile) Close() error {
    syscall.Munmap(m.data)
    return m.f.Close()
}

// 直接以字节切片方式访问，无需系统调用
func (m *MmapFile) ReadUint32LE(offset int) uint32 {
    return binary.LittleEndian.Uint32(m.data[offset:])
}

mmap 相比 os.File.Read() 的核心优势：

1. 零拷贝：操作系统直接将磁盘页映射到进程地址空间，无需内核→用户空间数据拷贝
2. 页缓存共享：多个进程打开同一文件时，内核只维护一份页缓存
3. 随机访问高效：直接按偏移量访问，无需 seek 系统调用

Level 3 · 实现 IP 查询

IP 地址解析：IPv4 与 IPv6

net 包提供了 IP 地址的解析和操作：

import "net"

// IPv4 地址转换为 uint32（用于与数据库中的整数比较）
func ipv4ToUint32(ip net.IP) uint32 {
    // net.IP 可能是 4 字节（IPv4）或 16 字节（IPv4-in-IPv6）
    ip = ip.To4()
    if ip == nil {
        return 0
    }
    // IP 字节序是大端，需要手动转换
    return uint32(ip[0])<<24 | uint32(ip[1])<<16 | uint32(ip[2])<<8 | uint32(ip[3])
}

// uint32 转回 net.IP
func uint32ToIPv4(n uint32) net.IP {
    return net.IPv4(
        byte(n>>24),
        byte(n>>16),
        byte(n>>8),
        byte(n),
    )
}

// 处理私有 IP 范围（RFC 1918）
func isPrivateIP(ip net.IP) bool {
    privateRanges := []string{
        "10.0.0.0/8",
        "172.16.0.0/12",
        "192.168.0.0/16",
        "127.0.0.0/8",       // 回环地址
        "169.254.0.0/16",    // 链路本地地址
        "::1/128",           // IPv6 回环
        "fc00::/7",          // IPv6 私有地址
    }
    for _, cidr := range privateRanges {
        _, network, _ := net.ParseCIDR(cidr)
        if network.Contains(ip) {
            return true
        }
    }
    return false
}

更高效的做法是预先计算私有 IP 范围，避免每次查询都解析 CIDR 字符串：

type PrivateChecker struct {
    ranges []*net.IPNet
}

func NewPrivateChecker() *PrivateChecker {
    cidrs := []string{
        "10.0.0.0/8", "172.16.0.0/12", "192.168.0.0/16",
        "127.0.0.0/8", "169.254.0.0/16", "::1/128", "fc00::/7",
        "100.64.0.0/10", // RFC 6598 共享地址空间
    }
    pc := &PrivateChecker{}
    for _, cidr := range cidrs {
        _, network, err := net.ParseCIDR(cidr)
        if err == nil {
            pc.ranges = append(pc.ranges, network)
        }
    }
    return pc
}

func (pc *PrivateChecker) IsPrivate(ip net.IP) bool {
    for _, network := range pc.ranges {
        if network.Contains(ip) {
            return true
        }
    }
    return false
}

二分搜索：O(log n) IP 范围查找

IP 数据库的核心查找算法是二分搜索。数据记录按 IP 起始地址排序，二分搜索找到包含目标 IP 的范围记录：

type DB struct {
    data        []byte         // mmap 数据
    header      *Header
    recordSize  int            // 每条记录的字节数
    private     *PrivateChecker
}

// Lookup 查找给定 IP 的地理信息
func (db *DB) Lookup(ipStr string) (*GeoInfo, error) {
    ip := net.ParseIP(ipStr)
    if ip == nil {
        return nil, fmt.Errorf("无效的 IP 地址: %s", ipStr)
    }

    // 检查私有 IP
    if db.private.IsPrivate(ip) {
        return &GeoInfo{
            IP:      ipStr,
            Country: "PRIVATE",
            City:    "PRIVATE",
        }, nil
    }

    ipInt := ipv4ToUint32(ip.To4())
    record, err := db.binarySearch(ipInt)
    if err != nil {
        return nil, err
    }

    return db.parseRecord(record, ipStr), nil
}

// binarySearch 在排序的记录数组中查找包含 target 的 IP 范围
func (db *DB) binarySearch(target uint32) (offset uint32, err error) {
    count := int(db.header.IPv4Count)
    base := int(db.header.IPv4Addr) - 1 // 文件偏移（1-indexed）

    low, high := 0, count-1

    for low <= high {
        mid := (low + high) / 2

        // 读取第 mid 条记录的 IP 范围
        recordOffset := base + mid*db.recordSize
        ipFrom := binary.LittleEndian.Uint32(db.data[recordOffset:])
        ipTo   := binary.LittleEndian.Uint32(db.data[recordOffset+4:])

        switch {
        case target < ipFrom:
            high = mid - 1
        case target > ipTo:
            low = mid + 1
        default:
            // 找到！返回记录偏移
            return uint32(recordOffset), nil
        }
    }

    return 0, fmt.Errorf("IP %d 未找到匹配记录", target)
}

type GeoInfo struct {
    IP        string  `json:"ip"`
    Country   string  `json:"country"`
    CountryCode string `json:"country_code"`
    Region    string  `json:"region"`
    City      string  `json:"city"`
    ISP       string  `json:"isp"`
    Latitude  float32 `json:"latitude"`
    Longitude float32 `json:"longitude"`
}

func (db *DB) parseRecord(offset uint32, ipStr string) *GeoInfo {
    data := db.data

    // 跳过 IP 范围（8字节），读取各字段偏移
    base := int(offset) + 8

    countryCodeOffset := binary.LittleEndian.Uint32(data[base:])
    countryOffset     := binary.LittleEndian.Uint32(data[base+4:])
    regionOffset      := binary.LittleEndian.Uint32(data[base+8:])
    cityOffset        := binary.LittleEndian.Uint32(data[base+12:])
    ispOffset         := binary.LittleEndian.Uint32(data[base+16:])
    lat := math.Float32frombits(binary.LittleEndian.Uint32(data[base+20:]))
    lon := math.Float32frombits(binary.LittleEndian.Uint32(data[base+24:]))

    return &GeoInfo{
        IP:          ipStr,
        CountryCode: readString(data, countryCodeOffset),
        Country:     readString(data, countryOffset),
        Region:      readString(data, regionOffset),
        City:        readString(data, cityOffset),
        ISP:         readString(data, ispOffset),
        Latitude:    lat,
        Longitude:   lon,
    }
}

LRU 缓存：热点 IP 加速

虽然二分搜索已经很快（微秒级），但对于同一个 IP 被频繁查询的场景（如安全系统中重复检测攻击者 IP），缓存可以进一步降低 CPU 开销。

LRU（Least Recently Used）缓存会淘汰最久未使用的条目：

import "github.com/hashicorp/golang-lru/v2"

type CachedDB struct {
    db    *DB
    cache *lru.Cache[string, *GeoInfo]
}

func NewCachedDB(db *DB, cacheSize int) (*CachedDB, error) {
    cache, err := lru.New[string, *GeoInfo](cacheSize)
    if err != nil {
        return nil, err
    }
    return &CachedDB{db: db, cache: cache}, nil
}

func (c *CachedDB) Lookup(ipStr string) (*GeoInfo, error) {
    // 先查缓存
    if info, ok := c.cache.Get(ipStr); ok {
        return info, nil
    }

    // 缓存未命中，查数据库
    info, err := c.db.Lookup(ipStr)
    if err != nil {
        return nil, err
    }

    // 写入缓存
    c.cache.Add(ipStr, info)
    return info, nil
}

github.com/hashicorp/golang-lru/v2 使用泛型，线程安全，内部用双向链表 + 哈希表实现 O(1) 的读写。

HTTP API 端点

将查询能力封装为 HTTP API：

package main

import (
    "encoding/json"
    "log"
    "net"
    "net/http"
    "strings"
    "time"
)

type Server struct {
    db  *CachedDB
    mux *http.ServeMux
}

func NewServer(db *CachedDB) *Server {
    s := &Server{db: db, mux: http.NewServeMux()}
    s.mux.HandleFunc("/lookup/", s.handleLookup)
    s.mux.HandleFunc("/batch", s.handleBatch)
    s.mux.HandleFunc("/health", s.handleHealth)
    return s
}

// GET /lookup/{ip}
func (s *Server) handleLookup(w http.ResponseWriter, r *http.Request) {
    ipStr := strings.TrimPrefix(r.URL.Path, "/lookup/")
    ipStr = strings.TrimSpace(ipStr)

    if ipStr == "" {
        // 如果没有指定 IP，使用请求来源 IP
        ipStr = getClientIP(r)
    }

    // 输入验证
    if net.ParseIP(ipStr) == nil {
        http.Error(w, `{"error":"invalid IP address"}`, http.StatusBadRequest)
        return
    }

    info, err := s.db.Lookup(ipStr)
    if err != nil {
        http.Error(w, `{"error":"lookup failed"}`, http.StatusInternalServerError)
        log.Printf("lookup error for %s: %v", ipStr, err)
        return
    }

    w.Header().Set("Content-Type", "application/json")
    w.Header().Set("Cache-Control", "public, max-age=3600") // IP 地理位置变化缓慢
    json.NewEncoder(w).Encode(info)
}

// POST /batch（批量查询）
func (s *Server) handleBatch(w http.ResponseWriter, r *http.Request) {
    if r.Method != http.MethodPost {
        http.Error(w, "Method Not Allowed", http.StatusMethodNotAllowed)
        return
    }

    var ips []string
    if err := json.NewDecoder(r.Body).Decode(&ips); err != nil {
        http.Error(w, `{"error":"invalid JSON"}`, http.StatusBadRequest)
        return
    }

    if len(ips) > 100 {
        http.Error(w, `{"error":"max 100 IPs per batch"}`, http.StatusBadRequest)
        return
    }

    results := make([]*GeoInfo, 0, len(ips))
    for _, ip := range ips {
        if net.ParseIP(ip) == nil {
            results = append(results, &GeoInfo{IP: ip, Country: "INVALID"})
            continue
        }
        info, err := s.db.Lookup(ip)
        if err != nil {
            results = append(results, &GeoInfo{IP: ip, Country: "UNKNOWN"})
            continue
        }
        results = append(results, info)
    }

    w.Header().Set("Content-Type", "application/json")
    json.NewEncoder(w).Encode(results)
}

// 获取真实客户端 IP（考虑代理）
func getClientIP(r *http.Request) string {
    // 按优先级尝试各个 header
    for _, header := range []string{"X-Real-IP", "X-Forwarded-For", "CF-Connecting-IP"} {
        if ip := r.Header.Get(header); ip != "" {
            // X-Forwarded-For 可能包含多个 IP（逗号分隔），取第一个
            if idx := strings.IndexByte(ip, ','); idx != -1 {
                ip = ip[:idx]
            }
            ip = strings.TrimSpace(ip)
            if net.ParseIP(ip) != nil {
                return ip
            }
        }
    }
    // 直接从连接获取
    host, _, _ := net.SplitHostPort(r.RemoteAddr)
    return host
}

func (s *Server) handleHealth(w http.ResponseWriter, r *http.Request) {
    w.Header().Set("Content-Type", "application/json")
    json.NewEncoder(w).Encode(map[string]string{
        "status": "ok",
        "time":   time.Now().UTC().Format(time.RFC3339),
    })
}

func main() {
    // 打开并内存映射数据库文件
    mmapFile, err := OpenMmap("IP2LOCATION-LITE-DB11.BIN")
    if err != nil {
        log.Fatalf("打开数据库失败: %v", err)
    }
    defer mmapFile.Close()

    db, err := NewDB(mmapFile)
    if err != nil {
        log.Fatalf("初始化数据库失败: %v", err)
    }

    // 带 LRU 缓存（缓存最近 100,000 个 IP 查询结果）
    cachedDB, err := NewCachedDB(db, 100_000)
    if err != nil {
        log.Fatalf("初始化缓存失败: %v", err)
    }

    server := NewServer(cachedDB)

    httpServer := &http.Server{
        Addr:         ":8080",
        Handler:      server.mux,
        ReadTimeout:  5 * time.Second,
        WriteTimeout: 10 * time.Second,
        IdleTimeout:  60 * time.Second,
    }

    log.Println("IP 查询服务启动，监听 :8080")
    log.Fatal(httpServer.ListenAndServe())
}

Level 4 · 高级主题

CGo：调用 C 语言库

MaxMind 官方提供了 libmaxminddb C 库，性能比纯 Go 实现略高（因为可以利用 SIMD 指令）。CGo 是 Go 调用 C 代码的机制：

package maxmind

/*
#cgo LDFLAGS: -lmaxminddb
#include <maxminddb.h>
#include <stdlib.h>
*/
import "C"
import (
    "fmt"
    "net"
    "unsafe"
)

type MMDBReader struct {
    db C.MMDB_s
}

func Open(path string) (*MMDBReader, error) {
    cPath := C.CString(path)
    defer C.free(unsafe.Pointer(cPath))

    r := &MMDBReader{}
    status := C.MMDB_open(cPath, C.MMDB_MODE_MMAP, &r.db)
    if status != C.MMDB_SUCCESS {
        return nil, fmt.Errorf("MMDB_open 失败: %s", C.GoString(C.MMDB_strerror(status)))
    }
    return r, nil
}

func (r *MMDBReader) LookupIPString(ipStr string) (map[string]interface{}, error) {
    cIP := C.CString(ipStr)
    defer C.free(unsafe.Pointer(cIP))

    var gaiError C.int
    var mmdbError C.int

    result := C.MMDB_lookup_string(&r.db, cIP, &gaiError, &mmdbError)
    if gaiError != 0 {
        return nil, fmt.Errorf("getaddrinfo 错误: %d", gaiError)
    }
    if mmdbError != C.MMDB_SUCCESS {
        return nil, fmt.Errorf("MMDB 查询错误: %s", C.GoString(C.MMDB_strerror(mmdbError)))
    }
    if !result.found_entry {
        return nil, nil
    }

    // 从结果中提取字段
    var entryData C.MMDB_entry_data_s

    // 查询国家代码
    status := C.MMDB_get_value(&result.entry, &entryData,
        C.CString("country"), C.CString("iso_code"), nil)
    if status == C.MMDB_SUCCESS && entryData.has_data {
        countryCode := C.GoStringN(entryData.utf8_string, C.int(entryData.data_size))
        return map[string]interface{}{"country_code": countryCode}, nil
    }
    return nil, nil
}

func (r *MMDBReader) Close() {
    C.MMDB_close(&r.db)
}

CGo 的性能代价：每次 Go→C 函数调用有约 20-50ns 的开销（线程切换和栈调整）。对于批量查询，这个开销可以接受；对于超高频查询（每秒数百万次），纯 Go 实现通常更快，因为避免了 CGo 的调用开销。

net.IP 和 net.IPNet 的深入操作

Go 标准库提供了丰富的 IP 操作工具：

import "net"

// CIDR 操作
func demonstrateIPNetOps() {
    // 解析 CIDR 表达式
    _, network, _ := net.ParseCIDR("192.168.1.0/24")

    // 检查 IP 是否在网络中
    ip := net.ParseIP("192.168.1.100")
    fmt.Println(network.Contains(ip)) // true

    // 获取网络地址和广播地址
    mask := network.Mask
    broadcast := make(net.IP, len(network.IP))
    for i := range network.IP {
        broadcast[i] = network.IP[i] | ^mask[i]
    }
    fmt.Println("网络地址:", network.IP)
    fmt.Println("广播地址:", broadcast)

    // 计算子网中的 IP 数量
    ones, bits := mask.Size()
    count := 1 << uint(bits-ones)
    fmt.Printf("子网包含 %d 个 IP 地址\n", count)
}

// IP 版本检测
func detectIPVersion(ipStr string) string {
    ip := net.ParseIP(ipStr)
    if ip == nil {
        return "invalid"
    }
    if ip.To4() != nil {
        return "IPv4"
    }
    return "IPv6"
}

// AS（自治系统）号查询（通过 BGP 路由表）
// 实际实现需要维护 BGP 路由表数据库
func lookupASN(ip net.IP) (uint32, string) {
    // 示意代码：实际需要 BGP 数据库
    return 4134, "CHINANET-BACKBONE No.31,Jin-rong Street"
}

IP 信誉查询：实时威胁情报

IP 地理位置查询通常与 IP 信誉系统结合，检测恶意 IP：

type ReputationLevel int

const (
    ReputationClean   ReputationLevel = iota
    ReputationSuspect                 // 可疑
    ReputationMalicious               // 恶意
    ReputationBanned                  // 封禁
)

type ThreatInfo struct {
    IP         string
    Level      ReputationLevel
    Categories []string // "spam", "botnet", "tor-exit", "vpn", "proxy"
    LastSeen   time.Time
    Confidence float32 // 置信度 0-1
}

// 本地黑名单（Bloom Filter）
type IPBlocklist struct {
    filter *bloom.BloomFilter
    mu     sync.RWMutex
}

func (bl *IPBlocklist) IsBlocked(ip string) bool {
    bl.mu.RLock()
    defer bl.mu.RUnlock()
    return bl.filter.TestString(ip)
}

func (bl *IPBlocklist) LoadFromFile(path string) error {
    f, err := os.Open(path)
    if err != nil {
        return err
    }
    defer f.Close()

    bl.mu.Lock()
    defer bl.mu.Unlock()

    scanner := bufio.NewScanner(f)
    for scanner.Scan() {
        line := strings.TrimSpace(scanner.Text())
        if line == "" || strings.HasPrefix(line, "#") {
            continue
        }
        bl.filter.AddString(line)
    }
    return scanner.Err()
}

嵌入数据库：go:embed + 压缩

对于小型应用，可以将整个 IP 数据库嵌入二进制文件：

import (
    "bytes"
    "compress/gzip"
    "embed"
    "io"
)

//go:embed data/IP2LOCATION-LITE-DB1.BIN.gz
var embeddedDB embed.FS

func openEmbeddedDB() (*DB, error) {
    compressedData, err := embeddedDB.ReadFile("data/IP2LOCATION-LITE-DB1.BIN.gz")
    if err != nil {
        return nil, fmt.Errorf("读取嵌入数据库: %w", err)
    }

    // 解压
    gr, err := gzip.NewReader(bytes.NewReader(compressedData))
    if err != nil {
        return nil, err
    }
    defer gr.Close()

    data, err := io.ReadAll(gr)
    if err != nil {
        return nil, err
    }

    // 使用解压后的数据创建 DB（不用 mmap，直接用内存）
    return NewDBFromBytes(data)
}

IP2Location LITE DB1（仅国家级数据）的原始大小约 2MB，gzip 压缩后约 800KB。嵌入后，整个服务是一个约 10MB 的无依赖单一二进制文件。

API 限速：保护查询服务

IP 查询 API 本身也需要限速，防止滥用：

import "golang.org/x/time/rate"

type RateLimitedServer struct {
    *Server
    limiters sync.Map // map[string]*rate.Limiter，按客户端 IP 限速
    rps      float64
    burst    int
}

func (s *RateLimitedServer) getLimiter(clientIP string) *rate.Limiter {
    // LoadOrStore 是原子的，避免竞态条件
    actual, _ := s.limiters.LoadOrStore(
        clientIP,
        rate.NewLimiter(rate.Limit(s.rps), s.burst),
    )
    return actual.(*rate.Limiter)
}

func (s *RateLimitedServer) ServeHTTP(w http.ResponseWriter, r *http.Request) {
    clientIP := getClientIP(r)
    limiter := s.getLimiter(clientIP)

    if !limiter.Allow() {
        w.Header().Set("Retry-After", "1")
        http.Error(w, `{"error":"rate limit exceeded"}`, http.StatusTooManyRequests)
        return
    }

    s.Server.mux.ServeHTTP(w, r)
}

// 定期清理过期的限速器（防止内存泄漏）
func (s *RateLimitedServer) cleanupLimiters() {
    ticker := time.NewTicker(10 * time.Minute)
    for range ticker.C {
        s.limiters.Range(func(key, value interface{}) bool {
            limiter := value.(*rate.Limiter)
            // 如果令牌桶已满，说明该客户端长时间未发请求，可以清理
            if limiter.Tokens() >= float64(s.burst) {
                s.limiters.Delete(key)
            }
            return true
        })
    }
}

工程总结：性能分析数据

一个完整的 Go IP 查询服务，在合理的硬件上（4核 CPU，8GB RAM）可以达到：

核心优化点：

1. mmap：将文件 I/O 转换为内存访问，消除系统调用开销
2. 二分搜索：O(log n) 查找，400 万记录只需 22 次比较
3. LRU 缓存：热点 IP 的重复查询降低到 O(1)
4. 固定长度记录：可以直接计算偏移量，无需链表遍历
5. 字符串池：重复字符串（国家名）只存储一次，节省空间

这套架构的思维模型——二进制格式 + 内存映射 + 二分搜索 + 缓存——可以应用到任何需要高性能只读查询的场景：GeoIP 查询、ASN 数据库、证书吊销列表（CRL）、安全情报数据库。Go 的 encoding/binary、syscall.Mmap 和 net 包，是实现这类系统的完整工具集。