// Android实现示例（伪代码）
public class IpProxyManager {
    // 代理服务器IP地址列表
    private List proxyIpList;
    // 当前使用的IP地址索引
    private int currentIpIndex = 0;
    
    // 初始化IP列表
    public void initProxyIpList() {
        // 从本地存储加载IP列表
        proxyIpList = loadIpListFromStorage();
        if (proxyIpList.isEmpty()) {
            // 如果本地没有，则使用预置IP
            proxyIpList.add("192.168.1.1");
            proxyIpList.add("192.168.1.2");
            // ... 更多备用IP地址
        }
    }
    
    // 获取当前可用的代理IP
    public String getCurrentProxyIp() {
        return proxyIpList.get(currentIpIndex);
    }
    
    // 切换到下一个IP地址
    public String switchToNextIp() {
        currentIpIndex = (currentIpIndex + 1) % proxyIpList.size();
        return getCurrentProxyIp();
    }
    
    // 定期更新IP列表
    public void updateIpList() {
        // 使用已知可用的IP地址请求更新
        String url = "http://" + getCurrentProxyIp() + "/api/getProxyIpList";
        // 发送请求获取最新IP列表
        // ...
    }
    
    // 检查IP地址健康状态
    public boolean checkIpHealth(String ip) {
        try {
            URL url = new URL("http://" + ip + "/health");
            HttpURLConnection connection = (HttpURLConnection) url.openConnection();
            connection.setConnectTimeout(3000);
            connection.setReadTimeout(3000);
            int responseCode = connection.getResponseCode();
            return responseCode == 200;
        } catch (Exception e) {
            return false;
        }
    }
}

// iOS实现示例（伪代码）
class IpProxyManager {
    // 代理服务器IP地址列表
    private var proxyIpList: [String] = []
    // 当前使用的IP地址索引
    private var currentIpIndex = 0
    
    // 初始化IP列表
    func initProxyIpList() {
        // 从本地存储加载IP列表
        if let savedIpList = UserDefaults.standard.array(forKey: "ProxyIpList") as? [String], !savedIpList.isEmpty {
            proxyIpList = savedIpList
        } else {
            // 如果本地没有，则使用预置IP
            proxyIpList = ["192.168.1.1", "192.168.1.2", "192.168.1.3"]
        }
    }
    
    // 获取当前可用的代理IP
    func getCurrentProxyIp() -> String {
        return proxyIpList[currentIpIndex]
    }
    
    // 切换到下一个IP地址
    func switchToNextIp() -> String {
        currentIpIndex = (currentIpIndex + 1) % proxyIpList.count
        return getCurrentProxyIp()
    }
    
    // HTTP请求拦截和重定向
    func interceptAndRedirect(request: URLRequest) -> URLRequest {
        var newRequest = request
        
        // 检查是否是需要代理的域名
        if let url = request.url, shouldProxy(url: url) {
            // 创建新URL，使用代理IP替换域名
            let proxyIp = getCurrentProxyIp()
            var components = URLComponents(url: url, resolvingAgainstBaseURL: true)!
            
            // 将原始域名信息添加到请求头
            let originalHost = components.host ?? ""
            
            // 修改请求URL使用代理IP
            components.host = proxyIp
            newRequest.url = components.url
            
            // 添加原始主机信息到请求头
            newRequest.addValue(originalHost, forHTTPHeaderField: "X-Original-Host")
        }
        
        return newRequest
    }
    
    // 判断URL是否需要代理
    private func shouldProxy(url: URL) -> Bool {
        // 实现判断逻辑
        let host = url.host ?? ""
        return host.contains("example.com") || host.contains("api.myapp.com")
    }
}

// Nginx配置示例
http {
    # 定义目标服务器组
    upstream backend_servers {
        server 10.0.0.1:80;
        server 10.0.0.2:80;
        server 10.0.0.3:80;
    }
    
    # 代理服务器配置
    server {
        listen 80;
        
        # 健康检查接口
        location /health {
            return 200 'ok';
        }
        
        # IP列表更新接口
        location /api/getProxyIpList {
            # 返回最新的代理IP列表
            return 200 '["192.168.1.1", "192.168.1.2", "192.168.1.3"]';
        }
        
        # 处理所有其他请求
        location / {
            # 从请求头中获取原始主机信息
            proxy_set_header Host $http_x_original_host;
            # 传递原始客户端IP
            proxy_set_header X-Real-IP $remote_addr;
            # 传递客户端IP和经过的代理IP
            proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
            # 传递协议信息
            proxy_set_header X-Forwarded-Proto $scheme;
            
            # 转发请求到后端服务器
            proxy_pass http://backend_servers;
            # 设置超时时间
            proxy_connect_timeout 5s;
            proxy_read_timeout 60s;
            
            # 启用长连接
            proxy_http_version 1.1;
            proxy_set_header Connection "";
        }
    }
}

// Node.js实现示例
const http = require('http');
const https = require('https');

// 创建HTTP代理服务器
const proxyServer = http.createServer((clientReq, clientRes) => {
    // 从请求头中获取原始主机
    const targetHost = clientReq.headers['x-original-host'] || 'default-api.myapp.com';
    
    // 构建目标请求选项
    const options = {
        hostname: targetHost,
        port: 80,
        path: clientReq.url,
        method: clientReq.method,
        headers: { ...clientReq.headers }
    };
    
    // 删除特定请求头
    delete options.headers['x-original-host'];
    delete options.headers['host'];
    
    // 创建对目标服务器的请求
    const proxyReq = http.request(options, (proxyRes) => {
        // 设置响应头
        clientRes.writeHead(proxyRes.statusCode, proxyRes.headers);
        // 转发响应数据
        proxyRes.pipe(clientRes, { end: true });
    });
    
    // 错误处理
    proxyReq.on('error', (e) => {
        console.error(`请求错误: ${e.message}`);
        clientRes.statusCode = 502;
        clientRes.end('代理请求失败');
    });
    
    // 转发客户端请求数据
    clientReq.pipe(proxyReq, { end: true });
});

// 健康检查和IP列表API
proxyServer.on('request', (req, res) => {
    if (req.url === '/health') {
        res.statusCode = 200;
        res.end('ok');
        return;
    }
    
    if (req.url === '/api/getProxyIpList') {
        res.statusCode = 200;
        res.setHeader('Content-Type', 'application/json');
        // 返回当前可用的代理IP列表
        res.end(JSON.stringify(['192.168.1.1', '192.168.1.2', '192.168.1.3']));
        return;
    }
});

// 启动代理服务器
proxyServer.listen(80, () => {
    console.log('代理服务器运行在 80 端口');
});