API代码示例:参数以及代码

import java.io.BufferedReader;
import java.io.InputStreamReader;
import java.net.HttpURLConnection;
import java.net.URL;

public class ProxyIPExtractor {
    
    public static void main(String[] args) {
        try {
            // API配置
            String apiUrl = "http://ip-api.hotlogin.com/api/ip";
            String secret = "your_secret_key";  // 替换为您的密钥
            int num = 10;  // 提取数量
            
            // 构建请求URL
            String urlString = String.format(
                "%s?secret=%s&num=%d&pl=1&rep=1&ft=txt",
                apiUrl, secret, num
            );
            
            // 发送HTTP GET请求
            URL url = new URL(urlString);
            HttpURLConnection conn = (HttpURLConnection) url.openConnection();
            conn.setRequestMethod("GET");
            conn.setConnectTimeout(5000);
            conn.setReadTimeout(5000);
            
            // 读取响应
            int responseCode = conn.getResponseCode();
            if (responseCode == HttpURLConnection.HTTP_OK) {
                BufferedReader reader = new BufferedReader(
                    new InputStreamReader(conn.getInputStream())
                );
                
                String line;
                StringBuilder response = new StringBuilder();
                while ((line = reader.readLine()) != null) {
                    response.append(line).append("");
                }
                reader.close();
                
                // 输出结果
                System.out.println("提取的IP列表：");
                System.out.println(response.toString());
                
            } else {
                System.out.println("请求失败，状态码：" + responseCode);
            }
            
            conn.disconnect();
            
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

import requests
import json

def extract_proxy_ips():
    """提取代理IP"""
    
    # API配置
    api_url = "http://ip-api.hotlogin.com/api/ip"
    
    # 请求参数
    params = {
        'secret': 'your_secret_key',  # 替换为您的密钥
        'num': 10,                    # 提取数量
        'pl': 1,                      # 1-HTTP
        'rep': 1,                     # 1-去重
        'ft': 'json'                  # 返回JSON格式
    }
    
    try:
        # 发送GET请求
        response = requests.get(api_url, params=params, timeout=10)
        
        if response.status_code == 200:
            # 解析JSON响应
            data = response.json()
            
            if data['code'] == 0:
                ip_list = data['data']
                print(f"成功提取 {len(ip_list)} 个IP：")
                
                for ip_info in ip_list:
                    print(f"IP: {ip_info['ip']}:{ip_info['port']}")
                    
                return ip_list
            else:
                print(f"提取失败：{data.get('msg', '未知错误')}")
        else:
            print(f"请求失败，状态码：{response.status_code}")
            
    except requests.RequestException as e:
        print(f"请求异常：{str(e)}")
    
    return None


if __name__ == "__main__":
    extract_proxy_ips()

const axios = require('axios');

// 提取代理IP
async function extractProxyIPs() {
    // API配置
    const apiUrl = 'http://ip-api.hotlogin.com/api/ip';
    
    // 请求参数
    const params = {
        secret: 'your_secret_key',  // 替换为您的密钥
        num: 10,                    // 提取数量
        pl: 1,                      // 1-HTTP
        rep: 1,                     // 1-去重
        ft: 'json'                  // 返回JSON格式
    };
    
    try {
        // 发送GET请求
        const response = await axios.get(apiUrl, {
            params: params,
            timeout: 10000  // 10秒超时
        });
        
        if (response.data.code === 0) {
            const ipList = response.data.data;
            console.log(`成功提取 ${ipList.length} 个IP：`);
            
            ipList.forEach((ipInfo, index) => {
                console.log(`${index + 1}. IP: ${ipInfo.ip}:${ipInfo.port}`);
            });
            
            return ipList;
        } else {
            console.error(`提取失败：${response.data.msg || '未知错误'}`);
        }
        
    } catch (error) {
        if (error.response) {
            // 服务器返回错误响应
            console.error(`请求失败，状态码：${error.response.status}`);
        } else if (error.request) {
            // 请求已发送但未收到响应
            console.error('未收到服务器响应');
        } else {
            // 请求配置错误
            console.error(`请求错误：${error.message}`);
        }
    }
    
    return null;
}

// 调用函数
extractProxyIPs();

import java.io.BufferedReader;
import java.io.InputStreamReader;
import java.net.HttpURLConnection;
import java.net.URL;
import java.net.URLEncoder;

public class WhitelistManager {
    
    private static final String BASE_URL = "http://ip-api.hotlogin.com/api/whitelist/";
    private static final String API_KEY = "your_api_key";
    private static final String API_SIGN = "your_sign";
    
    // 添加白名单
    public static String addWhitelist(String ip) {
        return sendRequest("add", ip);
    }
    
    // 删除白名单
    public static String deleteWhitelist(String ip) {
        return sendRequest("delete", ip);
    }
    
    // 查询白名单
    public static String queryWhitelist() {
        return sendRequest("info", null);
    }
    
    private static String sendRequest(String action, String ip) {
        try {
            // 构建URL
            StringBuilder urlBuilder = new StringBuilder(BASE_URL + action);
            urlBuilder.append("?key=").append(API_KEY);
            urlBuilder.append("&sign=").append(API_SIGN);
            
            if (ip != null) {
                urlBuilder.append("&ip=").append(URLEncoder.encode(ip, "UTF-8"));
            }
            
            // 发送请求
            URL url = new URL(urlBuilder.toString());
            HttpURLConnection conn = (HttpURLConnection) url.openConnection();
            conn.setRequestMethod("GET");
            conn.setConnectTimeout(5000);
            
            // 读取响应
            int responseCode = conn.getResponseCode();
            if (responseCode == HttpURLConnection.HTTP_OK) {
                BufferedReader reader = new BufferedReader(
                    new InputStreamReader(conn.getInputStream())
                );
                
                StringBuilder response = new StringBuilder();
                String line;
                while ((line = reader.readLine()) != null) {
                    response.append(line);
                }
                reader.close();
                
                return response.toString();
            }
            
            conn.disconnect();
            
        } catch (Exception e) {
            e.printStackTrace();
        }
        
        return null;
    }
    
    public static void main(String[] args) {
        // 添加白名单
        String addResult = addWhitelist("192.168.1.100");
        System.out.println("添加结果：" + addResult);
        
        // 查询白名单
        String queryResult = queryWhitelist();
        System.out.println("查询结果：" + queryResult);
        
        // 删除白名单
        String deleteResult = deleteWhitelist("192.168.1.100");
        System.out.println("删除结果：" + deleteResult);
    }
}

import requests

class WhitelistManager:
    """白名单管理类"""
    
    def __init__(self, api_key, api_sign):
        self.base_url = "http://ip-api.hotlogin.com/api/whitelist/"
        self.api_key = api_key
        self.api_sign = api_sign
    
    def _send_request(self, action, ip=None):
        """发送请求的通用方法"""
        url = self.base_url + action
        
        # 构建参数
        params = {
            'key': self.api_key,
            'sign': self.api_sign
        }
        
        if ip:
            params['ip'] = ip
        
        try:
            response = requests.get(url, params=params, timeout=10)
            
            if response.status_code == 200:
                return response.json()
            else:
                return {'code': -1, 'msg': f'请求失败，状态码：{response.status_code}'}
                
        except requests.RequestException as e:
            return {'code': -1, 'msg': f'请求异常：{str(e)}'}
    
    def add_whitelist(self, ip):
        """添加白名单"""
        return self._send_request('add', ip)
    
    def delete_whitelist(self, ip):
        """删除白名单"""
        return self._send_request('delete', ip)
    
    def query_whitelist(self):
        """查询白名单"""
        return self._send_request('info')


# 使用示例
if __name__ == "__main__":
    # 初始化管理器
    manager = WhitelistManager(
        api_key='your_api_key',
        api_sign='your_sign'
    )
    
    # 添加白名单
    add_result = manager.add_whitelist('192.168.1.100')
    print(f"添加结果：{add_result}")
    
    # 查询白名单
    query_result = manager.query_whitelist()
    print(f"查询结果：{query_result}")
    
    # 删除白名单
    delete_result = manager.delete_whitelist('192.168.1.100')
    print(f"删除结果：{delete_result}")

const axios = require('axios');

class WhitelistManager {
    /**
     * 白名单管理类
     * @param {string} apiKey - API密钥
     * @param {string} apiSign - API签名
     */
    constructor(apiKey, apiSign) {
        this.baseUrl = 'http://ip-api.hotlogin.com/api/whitelist/';
        this.apiKey = apiKey;
        this.apiSign = apiSign;
    }
    
    /**
     * 发送请求的通用方法
     * @param {string} action - 操作类型
     * @param {string} ip - IP地址（可选）
     */
    async _sendRequest(action, ip = null) {
        const url = this.baseUrl + action;
        
        // 构建参数
        const params = {
            key: this.apiKey,
            sign: this.apiSign
        };
        
        if (ip) {
            params.ip = ip;
        }
        
        try {
            const response = await axios.get(url, {
                params: params,
                timeout: 10000
            });
            
            return response.data;
            
        } catch (error) {
            if (error.response) {
                return {
                    code: -1,
                    msg: `请求失败，状态码：${error.response.status}`
                };
            } else {
                return {
                    code: -1,
                    msg: `请求异常：${error.message}`
                };
            }
        }
    }
    
    /**
     * 添加白名单
     * @param {string} ip - IP地址
     */
    async addWhitelist(ip) {
        return await this._sendRequest('add', ip);
    }
    
    /**
     * 删除白名单
     * @param {string} ip - IP地址
     */
    async deleteWhitelist(ip) {
        return await this._sendRequest('delete', ip);
    }
    
    /**
     * 查询白名单
     */
    async queryWhitelist() {
        return await this._sendRequest('info');
    }
}

// 使用示例
async function main() {
    // 初始化管理器
    const manager = new WhitelistManager(
        'your_api_key',
        'your_sign'
    );
    
    // 添加白名单
    const addResult = await manager.addWhitelist('192.168.1.100');
    console.log('添加结果：', addResult);
    
    // 查询白名单
    const queryResult = await manager.queryWhitelist();
    console.log('查询结果：', queryResult);
    
    // 删除白名单
    const deleteResult = await manager.deleteWhitelist('192.168.1.100');
    console.log('删除结果：', deleteResult);
}

// 运行示例
main();