using System;

using System.Net;
using System.Net.Http;
using System.Collections.Generic;

namespace ClientProxyDemo
{
    class TestProxy
    {
        static void Main(string[] args)
        {
            String proxyServer = "http://xxx:xxx"; // http://host:port, 例(http://1.2.3.4:7777), host可以是域名或者ip,port是代理端口号
            var proxy = new WebProxy(proxyServer);
            HttpClientHandler httpClientHandler = new HttpClientHandler()
            {
                Proxy = proxy
            };
            var httpCient = new HttpClient(httpClientHandler);
            // 增加头部
            httpCient.DefaultRequestHeaders.Add("Header-Key", "header-vaule");

            TestProxy testProxy = new TestProxy();
            testProxy.testGet(httpCient);
            // testProxy.testPost(httpCient);
        }


        // 测试get请求
        public void testGet(HttpClient httpClient)
        {
            String targetUrl = "http://httpbin.org/get";
            var httpResult = httpClient.GetStringAsync(targetUrl).Result;
        }

        // 测试post请求
        public void testPost(HttpClient httpClient)
        {
            String targetUrl = "http://httpbin.org/post";
            List> formData = new List>();
            formData.Add(new KeyValuePair("key1", "vaule1"));
            formData.Add(new KeyValuePair("key2", "vaule2"));
            var formContent = new FormUrlEncodedContent(formData.ToArray());
            var responseMsg = httpClient.PostAsync(targetUrl, formContent).Result;
            var httpResult = responseMsg.Content.ReadAsStringAsync().Result;
        }
    }
}

package main

import (
    "fmt"
    "io/ioutil"
    "net/http"
    "net/url"
)

//sock5代理
func socksproxy() {
    urli := url.URL{}
    urlproxy, _ := urli.Parse("http://测试ip:端口")
    client := &http.Client{
        Transport: &http.Transport{
            Proxy: http.ProxyURL(urlproxy),
        },
    }
    rqt, err := http.NewRequest("GET", "http://myip.top", nil)
    if err != nil {
        println("接口获取IP失败!")
        return
    }

    rqt.Header.Add("User-Agent", "Lingjiang")
    //处理返回结果
    response, _ := client.Do(rqt)
    defer response.Body.Close()
    body, err := ioutil.ReadAll(response.Body)
    if err != nil {
        return
    }

    fmt.Println("socks5:", string(body))
    return

}

//http代理
func httpproxy() {
    urli := url.URL{}
    urlproxy, _ := urli.Parse("http://测试ip:端口")
    client := &http.Client{
        Transport: &http.Transport{
            Proxy: http.ProxyURL(urlproxy),
        },
    }
    rqt, err := http.NewRequest("GET", "http://myip.top", nil)
    if err != nil {
        println("接口获取IP失败!")
        return
    }

    rqt.Header.Add("User-Agent", "Lingjiang")
    //处理返回结果
    response, _ := client.Do(rqt)
    defer response.Body.Close()
    body, err := ioutil.ReadAll(response.Body)
    if err != nil {
        return
    }

    fmt.Println("http:", string(body))
    return

}

//本机IP
func httplocal() {
    client := &http.Client{}
    rqt, err := http.NewRequest("GET", "http://myip.top", nil)
    if err != nil {
        println("接口获取IP失败!")
        return
    }

    rqt.Header.Add("User-Agent", "Lingjiang")
    //处理返回结果
    response, _ := client.Do(rqt)
    defer response.Body.Close()
    body, err := ioutil.ReadAll(response.Body)
    if err != nil {
        return
    }

    fmt.Println("本机:", string(body))
    return

}
func main() {
    httplocal()
    httpproxy()
    socksproxy()
}

Phantomjs http/socks5:

phantomjs --proxy=ip:port --proxy-type=[http|socks5|none] demo.js

Php http/sock5:

    // 要访问的目标页面
    $targetUrl = "http://baidu.com";

    // 代理服务器
    $proxyServer = "http://ip:port";

    // 隧道身份信息
    $ch = curl_init();

    curl_setopt($ch, CURLOPT_URL, $targetUrl);

    curl_setopt($ch, CURLOPT_HTTPPROXYTUNNEL, false);

    curl_setopt($ch, CURLOPT_SSL_VERIFYPEER, false);

    // 设置代理服务器
    // curl_setopt($ch, CURLOPT_PROXYTYPE, 0); //http

    curl_setopt($ch, CURLOPT_PROXYTYPE, 5); //sock5

    curl_setopt($ch, CURLOPT_PROXY, $proxyServer);

    // 设置隧道验证信息
    curl_setopt($ch, CURLOPT_PROXYAUTH, CURLAUTH_BASIC);

    curl_setopt($ch, CURLOPT_USERAGENT, "Mozilla/4.0 (compatible; MSIE 6.0; Windows NT 5.1; SV1; .NET CLR 2.0.50727;)");

    curl_setopt($ch, CURLOPT_CONNECTTIMEOUT, 3);

    curl_setopt($ch, CURLOPT_TIMEOUT, 5);

    curl_setopt($ch, CURLOPT_HEADER, true);

    curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);

    $result = curl_exec($ch);

    curl_close($ch);

    var_dump($result);

import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.Map.Entry;

import org.apache.http.HttpEntity;
import org.apache.http.HttpHost;
import org.apache.http.NameValuePair;
import org.apache.http.client.config.RequestConfig;
import org.apache.http.client.entity.UrlEncodedFormEntity;
import org.apache.http.client.methods.CloseableHttpResponse;
import org.apache.http.client.methods.HttpGet;
import org.apache.http.client.methods.HttpPost;
import org.apache.http.client.methods.HttpRequestBase;
import org.apache.http.impl.client.CloseableHttpClient;
import org.apache.http.impl.client.HttpClients;
import org.apache.http.message.BasicNameValuePair;
import org.apache.http.util.EntityUtils;

public class ClientProxyHttpClientHttp {
    // 代理服务器
    final static String proxyHost = "xxx";
    final static Integer proxyPort = 0;

    private static HttpHost proxy = null;

    private static RequestConfig reqConfig = null;

    static {
        proxy = new HttpHost(proxyHost, proxyPort, "http");
        reqConfig = RequestConfig.custom().setConnectionRequestTimeout(5000).setConnectTimeout(10000) // 设置连接超时时间
                .setSocketTimeout(10000) // 设置读取超时时间
                .setExpectContinueEnabled(false).setProxy(new HttpHost(proxyHost, proxyPort))
                .setCircularRedirectsAllowed(true) // 允许多次重定向
                .build();
    }

    public static void main(String[] args) {
        doGetRequest();
        doPostRequest();
    }

    public static void doGetRequest() {
        // 目标地址
        String targetUrl = "http://httpbin.org/get";

        try {
            // 设置url参数 (可选)
            Map urlParams = new HashMap<>();
            urlParams.put("uid", "1234567");
            String paramStr = EntityUtils.toString(new UrlEncodedFormEntity(paramsAdapter(urlParams), "UTF-8"));
            HttpGet httpGet = new HttpGet(targetUrl + "?" + paramStr);
            String result = doRequest(httpGet);
            System.out.println(result);
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

    public static void doPostRequest() {
        try {
            // 要访问的目标页面
            HttpPost httpPost = new HttpPost("http://httpbin.org/post");

            // 设置表单参数
            Map formParams = new HashMap<>();
            formParams.put("uid", "1234567");
            UrlEncodedFormEntity uefEntity = new UrlEncodedFormEntity(paramsAdapter(formParams), "utf-8");
            httpPost.setEntity(uefEntity);
            String result = doRequest(httpPost);
            System.out.println(result);
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

    /**
     * 设置请求头
     *
     * @param httpReq
     */
    private static void setHeaders(HttpRequestBase httpReq) {
        httpReq.setHeader("User-Agent",
                "Mozilla/5.0 (Windows NT 6.1; WOW64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/49.0.2623.110 Safari/537.36");
        httpReq.addHeader("xxx", "xxx");
    }

    /**
     * 执行请求
     *
     * @param httpReq
     * @return
     */
    public static String doRequest(HttpRequestBase httpReq) {
        String result = new String();
        httpReq.setConfig(reqConfig);
        try {
            // 设置请求头
            setHeaders(httpReq);

            CloseableHttpClient httpClient = HttpClients.createDefault();
            // 执行请求
            CloseableHttpResponse httpResp = httpClient.execute(httpReq);

            // 保存Cookie

            // 获取http code
            int statusCode = httpResp.getStatusLine().getStatusCode();
            System.out.println(statusCode);

            HttpEntity entity = httpResp.getEntity();
            if (entity != null) {
                result = EntityUtils.toString(entity, "utf-8");
            }

            httpResp.close();
            httpClient.close();
            httpReq.abort();
        } catch (Exception e) {
            e.printStackTrace();
            return null;
        }
        return result;
    }

    /**
     * 参数适配器，将系统定义的请求参数转换成HttpClient能够接受的参数类型
     *
     * @param params
     *            系统定义的请求参数
     * @return HttpClient要求的参数类型
     */
    private static List paramsAdapter(Map map) {
        List nvps = new ArrayList();

        for (Entry entry : map.entrySet()) {
            nvps.add(new BasicNameValuePair(entry.getKey(), entry.getValue()));
        }
        return nvps;
    }

}

import java.io.ByteArrayOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.net.Authenticator;
import java.net.InetSocketAddress;
import java.net.PasswordAuthentication;
import java.net.Proxy;
import java.net.URL;
import java.net.URLConnection;
import java.nio.charset.StandardCharsets;

/**
 *
 * @author librabin
 *
 */
public class ClientProxyBasicHttp {

    public static void main(String args[]) throws Exception {
        // 目标地址
        String targetUrl = "http://httpbin.org/get";

        // 代理服务器
        String proxyHost = "xxx";
        int proxyPort = 0;

        // http代理: Proxy.Type.HTTP, socks代理: Proxy.Type.SOCKS
        Proxy.Type proxyType = Proxy.Type.HTTP;

        // 代理验证
        String proxyUser = "xxx";
        String proxyPwd = "xxx";

        try {
            // 设置验证
            Authenticator.setDefault(new ProxyAuthenticator(proxyUser, proxyPwd));

            // 创建代理服务器
            InetSocketAddress addr = new InetSocketAddress(proxyHost, proxyPort);
            Proxy proxy = new Proxy(proxyType, addr);
            // 访问目标网页
            URL url = new URL(targetUrl);
            URLConnection conn = url.openConnection(proxy);
            // 读取返回数据
            InputStream in = conn.getInputStream();
            // 将返回数据转换成字符串
            System.out.println(IO2String(in));

        } catch (Exception e) {
            e.printStackTrace();
        }

    }

    /**
     * 将输入流转换成字符串
     *
     * @param inStream
     * @return
     * @throws IOException
     */
    public static String IO2String(InputStream inStream) throws IOException {
        ByteArrayOutputStream result = new ByteArrayOutputStream();
        byte[] buffer = new byte[1024];
        int len;
        while ((len = inStream.read(buffer)) != -1) {
            result.write(buffer, 0, len);
        }
        String str = result.toString(StandardCharsets.UTF_8.name());
        return str;
    }

    static class ProxyAuthenticator extends Authenticator {
        private String authUser, authPwd;

        public ProxyAuthenticator(String authUser, String authPwd) {
            this.authUser = authUser;
            this.authPwd = authPwd;
        }

        public PasswordAuthentication getPasswordAuthentication() {
            return (new PasswordAuthentication(authUser, authPwd.toCharArray()));
        }
    }
}

import java.io.ByteArrayOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.net.InetSocketAddress;
import java.net.Proxy;
import java.net.URL;
import java.net.URLConnection;
import java.nio.charset.StandardCharsets;

/**
 *
 * @author librabin
 *
 */
public class ClientProxyBasicSocks {

    public static void main(String args[]) throws Exception {
        // 目标地址
        String targetUrl = "http://httpbin.org/get";

        // 代理服务器
        String proxyHost = "xxx";
        int proxyPort = 0;

        // http代理: Proxy.Type.HTTP, socks代理: Proxy.Type.SOCKS
        Proxy.Type proxyType = Proxy.Type.SOCKS;
        try {
            // 创建代理服务器
            InetSocketAddress addr = new InetSocketAddress(proxyHost, proxyPort);
            Proxy proxy = new Proxy(proxyType, addr);
            // 访问目标网页
            URL url = new URL(targetUrl);
            URLConnection conn = url.openConnection(proxy);
            // 读取返回数据
            InputStream in = conn.getInputStream();
            // 将返回数据转换成字符串
            System.out.println(IO2String(in));

        } catch (Exception e) {
            e.printStackTrace();
        }

    }

    /**
     * 将输入流转换成字符串
     *
     * @param inStream
     * @return
     * @throws IOException
     */
    public static String IO2String(InputStream inStream) throws IOException {
        ByteArrayOutputStream result = new ByteArrayOutputStream();
        byte[] buffer = new byte[1024];
        int len;
        while ((len = inStream.read(buffer)) != -1) {
            result.write(buffer, 0, len);
        }
        String str = result.toString(StandardCharsets.UTF_8.name());
        return str;
    }

}

Python http/sock5:

#coding=utf-8
import requests

#请求地址
targetUrl = "http://baidu.com"

#代理服务器
proxyHost = "ip"
proxyPort = "port"

proxyMeta = "http://%(host)s:%(port)s" % {
    "host" : proxyHost,
    "port" : proxyPort,
}

#pip install -U requests[socks]  socks5代理
# proxyMeta = "socks5://%(host)s:%(port)s" % {
#     "host" : proxyHost,
#     "port" : proxyPort,
# }

proxies = {
    "http"  : proxyMeta,
}

resp = requests.get(targetUrl, proxies=proxies)
print resp.status_code
print resp.text

Python selenium http/socks5:

#coding=utf-8
from selenium import webdriver

# 代理服务器
proxyHost = "ip"
proxyPort = "port"
proxyType='http' #socks5

# 代理隧道验证信息
service_args = [
    "--proxy-type=%s" % proxyType,
    "--proxy=%(host)s:%(port)s" % {
        "host" : proxyHost,
        "port" : proxyPort,
    }
]

# 要访问的目标页面
targetUrl = "http://baidu.com"
driver = webdriver.PhantomJS(service_args=service_args)
driver.get(targetUrl)

print driver.title
print driver.page_source.encode("utf-8")
driver.quit()

安装易语言并选择打开对应demo文件进行接入。

//node代理请求http
var http = require('http')
var opt = {
    host: 'tunnel.alicloudecs.com',//这里放代理服务器的ip或者域名
    port: '500',//这里放代理服务器的端口号
    method: 'GET',//这里是发送的方法
    path: 'http://www.sdip.321174.com/',   //这里是访问的路径
}
//以下是接收数据的代码
var body = '';
var req = http.request(opt, function (res) {
    console.log("Got response: " + res.statusCode);
    res.on('data', function (d) {
        body += d;
    }).on('end', function () {
        console.log(res.headers)
        console.log(body)
    });

}).on('error', function (e) {
    console.log("Got error: " + e.message);
})
req.end();



//node代理请求http/https
const fetch = require("node-fetch");
const HttpsProxyAgent = require('https-proxy-agent');
 //这里是访问的路径
let url="https://www.baidu.com/s?cl=3&tn=baidutop10&fr=top1000&wd=%E9%AB%98%E8%80%83&rsv_idx=2&rsv_dl=fyb_n_homepage&hisfilter=1";
//这是代理服务器地址
let ip='58.218.205.48';
//这是端口号
let port='500';
fetch(url, {
    method: 'GET',
    // body: null,
    agent: new HttpsProxyAgent("http://" + ip + ":" + port) //<==注意是 `http://`
}).then(function (res) {
    console.log("Response Headers ============ ");
    res.headers.forEach(function(v,i,a) {
        console.log(i+" : "+v);
    });
    return res.text();
}).then(function (res) {
    console.log("Response Body ============ ");
    console.log(res);
});