高效网络代理云服务，为企业加速赋能

package main

import (
    "encoding/json"
    "fmt"
    "io/ioutil"
    "net/http"
    "net/url"
    "time"
)

// 定义响应结构
type ProxyResponse struct {
    Count  string      `json:"count"`
    Status string      `json:"status"`
    List   []ProxyInfo `json:"list"`
}

type ProxyInfo struct {
    Sever    string `json:"sever"`
    Port     int    `json:"port"`
    NetType  int    `json:"net_type"`
    Username string `json:"username"`
    Password string `json:"password"`
}

func main() {
    // API请求地址
    apiURL := "http://apitest.jianyunip.com:8200/api/getshortipurl"
    
    // 创建请求参数
    params := url.Values{}
    params.Add("po", "A17421991409711421")     // 订单编号
    params.Add("count", "100")                // 单次提取数量
    params.Add("posecret", "b8f8a3f54d")      // 订单密钥
    params.Add("formattype", "json")          // 返回格式(text或json)
    params.Add("proxytype", "2")              // 代理类型(1=http, 2=socks)
    params.Add("net", "0")                    // 网络类型(0=不筛选, 1=电信, 2=移动, 3=联通)
    params.Add("filter", "1")                 // 是否去重(1=是, 0=否)
    params.Add("province", "110000")          // 省份编号
    params.Add("city", "110100")              // 城市编号
    params.Add("separator", "\\r\\n")         // 分隔符
    
    // 构建完整URL
    fullURL := apiURL + "?" + params.Encode()
    
    // 创建客户端
    client := &http.Client{
        Timeout: 10 * time.Second,
    }
    
    // 记录开始时间
    startTime := time.Now()
    
    // 发送GET请求
    resp, err := client.Get(fullURL)
    if err != nil {
        fmt.Printf("请求发生错误: %v\n", err)
        return
    }
    defer resp.Body.Close()
    
    // 计算耗时
    elapsed := time.Since(startTime)
    
    // 检查响应状态
    if resp.StatusCode == http.StatusOK {
        // 读取响应内容
        body, err := ioutil.ReadAll(resp.Body)
        if err != nil {
            fmt.Printf("读取响应失败: %v\n", err)
            return
        }
        
        // 解析JSON响应
        var response ProxyResponse
        if err := json.Unmarshal(body, &response); err != nil {
            fmt.Printf("解析JSON失败: %v\n", err)
            fmt.Println(string(body))
            return
        }
        
        // 打印结果
        fmt.Printf("提取状态: %s\n", response.Status)
        fmt.Printf("提取数量: %s\n", response.Count)
        
        // 打印IP列表
        if len(response.List) > 0 {
            fmt.Println("\n代理IP列表:")
            for i, proxy := range response.List {
                fmt.Printf("代理 %d: %s:%d 用户名:%s 密码:%s 网络:%d\n", 
                    i+1, proxy.Sever, proxy.Port, proxy.Username, proxy.Password, proxy.NetType)
            }
        }
    } else {
        fmt.Printf("请求失败，状态码: %d\n", resp.StatusCode)
        body, _ := ioutil.ReadAll(resp.Body)
        fmt.Println(string(body))
    }
    
    fmt.Printf("\n耗时: %v\n", elapsed)
}

using System;
using System.Diagnostics;
using System.Net;
using System.Net.Http;
using System.Threading.Tasks;

namespace HttpProxyExample
{
    class Program
    {
        static async Task Main(string[] args)
        {
            // 设置代理服务器
            var proxy = new WebProxy
            {
                Address = new Uri("http://代理IP:代理端口"),
                UseDefaultCredentials = false,
                // 如果需要账号密码认证
                // Credentials = new NetworkCredential("账号", "密码")
            };

            // 创建HttpClientHandler并设置代理
            var handler = new HttpClientHandler { Proxy = proxy };
            using var client = new HttpClient(handler)
            {
                Timeout = TimeSpan.FromSeconds(10)
            };

            // 记录开始时间
            var stopwatch = Stopwatch.StartNew();

            // 发送请求
            var response = await client.GetAsync("http://myip.ipip.net");
            var content = await response.Content.ReadAsStringAsync();

            // 计算耗时
            stopwatch.Stop();

            Console.WriteLine(content);
            Console.WriteLine($"耗时: {stopwatch.ElapsedMilliseconds} ms");
        }
    }
}

// Node.js 环境中的 HTTP 代理示例
const axios = require('axios');
const HttpsProxyAgent = require('https-proxy-agent');

// 设置代理服务器
const proxyHost = '代理IP';
const proxyPort = 代理端口;

// 创建代理配置
const proxyConfig = `http://${proxyHost}:${proxyPort}`;
// 如果需要账号密码认证
// const proxyConfig = `http://账号:密码@${proxyHost}:${proxyPort}`;

const httpsAgent = new HttpsProxyAgent(proxyConfig);

// 开始时间
const startTime = new Date().getTime();

// 发送请求
axios.get('http://myip.ipip.net', {
  httpsAgent,
  proxy: false,  // 使用自定义代理，而不是axios的默认配置
  timeout: 10000
})
.then(response => {
  const endTime = new Date().getTime();
  console.log(response.data);
  console.log(`耗时: ${endTime - startTime} ms`);
})
.catch(error => {
  console.error('请求发生错误:', error);
});

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

public class HttpProxyExample {
    public static void main(String[] args) {
        try {
            // 设置代理服务器
            String proxyHost = "代理IP";
            int proxyPort = 代理端口;  // 替换为实际端口

            // 创建代理对象
            Proxy proxy = new Proxy(Proxy.Type.HTTP, new InetSocketAddress(proxyHost, proxyPort));
            
            // 如果需要账号密码认证，需要设置Authenticator
            /*
            Authenticator.setDefault(new Authenticator() {
                @Override
                protected PasswordAuthentication getPasswordAuthentication() {
                    return new PasswordAuthentication("账号", "密码".toCharArray());
                }
            });
            */
            
            // 创建连接
            URL url = new URL("http://myip.ipip.net");
            HttpURLConnection connection = (HttpURLConnection) url.openConnection(proxy);
            connection.setConnectTimeout(10000);
            connection.setReadTimeout(10000);
            
            // 记录开始时间
            long startTime = System.currentTimeMillis();
            
            // 发送请求
            int responseCode = connection.getResponseCode();
            
            // 读取响应
            BufferedReader reader = new BufferedReader(new InputStreamReader(connection.getInputStream()));
            String line;
            StringBuilder response = new StringBuilder();
            while ((line = reader.readLine()) != null) {
                response.append(line);
            }
            reader.close();
            
            // 计算耗时
            long endTime = System.currentTimeMillis();
            
            System.out.println(response.toString());
            System.out.println("耗时: " + (endTime - startTime) + " ms");
            
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

import okhttp3.OkHttpClient
import okhttp3.Request
import java.net.InetSocketAddress
import java.net.Proxy
import java.util.concurrent.TimeUnit

fun main() {
    // 设置代理服务器
    val proxyHost = "代理IP"
    val proxyPort = 代理端口  // 替换为实际端口
    
    // 创建代理对象
    val proxy = Proxy(Proxy.Type.HTTP, InetSocketAddress(proxyHost, proxyPort))
    
    // 创建OkHttpClient
    val client = OkHttpClient.Builder()
        .proxy(proxy)
        .connectTimeout(10, TimeUnit.SECONDS)
        .readTimeout(10, TimeUnit.SECONDS)
        .build()
    
    // 如果需要账号密码认证
    /*
    val client = OkHttpClient.Builder()
        .proxy(proxy)
        .proxyAuthenticator { route, response ->
            val credential = Credentials.basic("账号", "密码")
            response.request().newBuilder()
                .header("Proxy-Authorization", credential)
                .build()
        }
        .connectTimeout(10, TimeUnit.SECONDS)
        .readTimeout(10, TimeUnit.SECONDS)
        .build()
    */
    
    // 创建请求
    val request = Request.Builder()
        .url("http://myip.ipip.net")
        .build()
    
    // 记录开始时间
    val startTime = System.currentTimeMillis()
    
    // 发送请求
    try {
        client.newCall(request).execute().use { response ->
            val bodyText = response.body()?.string() ?: "No response body"
            val endTime = System.currentTimeMillis()
            
            println(bodyText)
            println("耗时: ${endTime - startTime} ms")
        }
    } catch (e: Exception) {
        println("请求发生错误: ${e.message}")
    }
}

<?php
// API请求地址
$apiUrl = 'http://apitest.jianyunip.com:8200/api/getshortipurl';

// 请求参数
$params = [
    'po' => 'A17421991409711421',    // 订单编号
    'count' => '100',               // 单次提取数量
    'posecret' => 'b8f8a3f54d',     // 订单密钥
    'formattype' => 'json',         // 返回格式(text或json)
    'proxytype' => '2',             // 代理类型(1=http, 2=socks)
    'net' => '0',                     // 网络类型(0=不筛选, 1=电信, 2=移动, 3=联通)
    'filter' => '1',                  // 是否去重(1=是, 0=否)
    'province' => '110000',           // 省份编号
    'city' => '110100',               // 城市编号
    'separator' => '\r\n'           // 分隔符
];

// 构建完整URL
$fullUrl = $apiUrl . '?' . http_build_query($params);

// 创建CURL请求
$ch = curl_init();
curl_setopt($ch, CURLOPT_URL, $fullUrl);
curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
curl_setopt($ch, CURLOPT_TIMEOUT, 10);

// 记录开始时间
$startTime = microtime(true);

// 执行请求
$response = curl_exec($ch);
$httpCode = curl_getinfo($ch, CURLINFO_HTTP_CODE);
$error = curl_error($ch);

// 计算耗时
$endTime = microtime(true);
$duration = round(($endTime - $startTime) * 1000, 2);

if (!$error && $httpCode == 200) {
    // 解析JSON响应
    $result = json_decode($response, true);
    
    if ($result !== null) {
        // 打印结果
        echo "提取状态: " . ($result['status'] ?? '未知') . "\n";
        echo "提取数量: " . ($result['count'] ?? '0') . "\n";
        
        // 打印IP列表
        if (isset($result['list']) && count($result['list']) > 0) {
            echo "\n代理IP列表:\n";
            
            foreach ($result['list'] as $index => $proxy) {
                $sever = $proxy['sever'] ?? '';
                $port = $proxy['port'] ?? '';
                $username = $proxy['username'] ?? '';
                $password = $proxy['password'] ?? '';
                $netType = $proxy['net_type'] ?? '';
                
                echo "代理 " . ($index + 1) . ": {$sever}:{$port} 用户名:{$username} 密码:{$password} 网络:{$netType}\n";
            }
        }
    } else {
        echo "解析JSON响应失败\n";
        echo "原始响应: {$response}\n";
    }
} else {
    echo "请求失败，HTTP状态码: {$httpCode}\n";
    if ($error) {
        echo "错误信息: {$error}\n";
    }
}

// 输出耗时
echo "\n耗时: {$duration} ms";

// 关闭CURL连接
curl_close($ch);
?>