import requests

proxy_ip = "ip:port"

# 白名单方式（需提前设置白名单）
proxies = {
    "http": "http://%(proxy)s/" % {"proxy": proxy_ip},
    "https": "http://%(proxy)s/" % {"proxy": proxy_ip}
}

# 要访问的目标网页
target_url = "http://www.xx.com"

# 使用代理IP发送请求
response = requests.get(target_url, proxies=proxies)

# 获取页面内容
if response.status_code == 200:
    print(response.text)

import urllib.request
import ssl

# 全局取消证书验证，避免访问https网页报错
ssl._create_default_https_context = ssl._create_unverified_context
proxy_ip = "ip:port"

# 白名单方式（需提前设置白名单）
proxies = {
    "http": "http://%(proxy)s/" % {"proxy": proxy_ip},
    "https": "http://%(proxy)s/" % {"proxy": proxy_ip}
}

# 要访问的目标网页
target_url = "http://www.xx.com"

# 使用代理IP发送请求
proxy_support = urllib.request.ProxyHandler(proxies)
opener = urllib.request.build_opener(proxy_support)
# urllib.request.install_opener(opener)  注意此处是全局设置代理，如用这种写法进程内之后的所有urllib请求都会使用代理
# response = urllib.request.urlopen(target_url)
response = opener.open(target_url)

# 获取页面内容
if response.code == 200:
    print(response.read().decode('utf-8'))

import aiohttp
import asyncio
# asyncio.set_event_loop_policy(asyncio.WindowsSelectorEventLoopPolicy()) windows系统请求https网站报错时调用此方法

page_url = "http://www.xx.com/"  # 要访问的目标网页

# API接口返回的proxy_list
proxy_ip = "ip:port"

async def fetch(url):
    async with aiohttp.ClientSession() as session:
        async with session.get(url, proxy="http://" + proxy_ip) as resp:
            content = await resp.read()
            print(f"status_code: {resp.status}, content: {content}")


def run():
    loop = asyncio.get_event_loop()
    # 异步发出2次请求
    tasks = [fetch(page_url) for _ in range(2)]
    loop.run_until_complete(asyncio.wait(tasks))


if __name__ == '__main__':
    run()

import asyncio
import httpx

page_url = "http://www.xx.com/"  # 要访问的目标网页


proxy_ip = "ip:port"

async def fetch(url):
    proxies = httpx.Proxy(
        url=f"http://{proxy_ip}",
    )
    async with httpx.AsyncClient(proxies=proxies, timeout=10) as client:
        resp = await client.get(url)
        print(f"status_code: {resp.status_code}, content: {resp.content}")


def run():
    loop = asyncio.get_event_loop()
    # 异步发出2次请求
    tasks = [fetch(page_url) for _ in range(2)]
    loop.run_until_complete(asyncio.wait(tasks))

if __name__ == '__main__':
    run()

import http.client

# 访问目标网址
target_host = "www.xx.com"

# 创建连接对象
conn = http.client.HTTPSConnection("ip:port")

# 设置代理信息
conn.set_tunnel(target_host)

# 发送请求
conn.request("GET", "/")

# 获取响应
response = conn.getresponse()

# 打印响应状态和内容
print(response.status, response.reason)
print(response.read().decode('utf-8'))

# 关闭连接
conn.close()

import ssl
import websocket


def on_message(ws, message):
    print(message)


def on_error(ws, error):
    print(error)


def on_open(ws):
    data = '{"type":"web"}'  # 此处填入您需要传给目标网站的json格式参数，如{"type":"web","data":{"_id":"xxxx"}}
    ws.send(data)


def on_close(*args):
    print("### closed ###")


proxies = {
    "http_proxy_host": "ip",
    "http_proxy_port": port,
    # "http_proxy_auth": ("username", "password"),
    "proxy_type": "http",
}


def start():
    websocket.enableTrace(True)
    target_url = 'ws://echo.websocket.events/'  # 此处替换您的目标网站
    ws = websocket.WebSocketApp(
        url = target_url,
        header = [
            "User-Agent: Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_1) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/85.0.4183.102 Safari/537.36"
        ],
        on_message=on_message,
        on_error=on_error,
        on_close=on_close,
    )
    ws.on_open = on_open
    ws.run_forever(sslopt={"cert_reqs": ssl.CERT_NONE}, **proxies)


if __name__ == "__main__":
    start()

import asyncio
from pyppeteer import launch

proxy_ip = "ip:port"
proxy = "http://" + proxy_ip


def accounts():
    # 用户名密码认证(私密代理/独享代理)
    username = "username"
    password = "password"
    account = {"username": username, "password": password}
    return account

async def main():
    # 要访问的目标网页
    target_url = "http://www.xx.com"

    browser = await launch({
        'headless': False,
        'executablePath':r"C:\chrome.exe",
        'ignorehttpserrrors':True,
        'args': ['--disable-infobars', '--proxy-server=' + proxy]})
    page = await browser.newPage()
    # await page.authenticate(accounts())  # 白名单方式，注释本行（需提前设置白名单）
    await page.setViewport({'width': 1920, 'height': 1080})
    # 使用代理IP发送请求
    await page.goto(target_url)
    await asyncio.sleep(209)
    await browser.close()

asyncio.get_event_loop().run_until_complete(main())

import requests
from playwright.sync_api import sync_playwright

proxy_ip = "ip:port"

# 用户名密码方式
username = "username"
password = "password"

# 要访问的目标网页
url = "http://www.xx.com"

# proxies = {
#    "server": proxy_ip,
#    "username": username,
#    "password": password,
# }

# 白名单方式（需提前设置白名单）
proxies = {
    "server": proxy_ip,
}

with sync_playwright() as playwright:
    # headless=True 无头模式，不显示浏览器窗口
    browser = playwright.chromium.launch(headless=False, proxy=proxies, executable_path='C:\\chrome.exe')
    context = browser.new_context()
    page = context.new_page()
    page.goto(url)
    content = page.content()
    print(content)
    # other actions...
    browser.close()

import requests

proxy_ip = "IP代理地址:端口号"
proxies = {
    "http": "http://%(proxy)s/" % {"proxy": proxy_ip},
    "https": "http://%(proxy)s/" % {"proxy": proxy_ip}
}

target_url = "http://www.xx.com"

response = requests.get(target_url, proxies=proxies)

if response.status_code == 200:
    print response.text

import urllib2

proxy_ip = "IP代理地址:端口号"

proxies = {
    "http": "http://%(proxy)s/" % {"proxy": proxy_ip},
}

target_url = "http://www.xx.com"
# 使用代理IP发送请求
proxy_support = urllib2.ProxyHandler(proxies)
opener = urllib2.build_opener(proxy_support)
response = opener.open(target_url)

if response.code == 200:
    print response.read()

from selenium import webdriver
import time

chrome_options = webdriver.ChromeOptions()
chrome_options.add_argument('--proxy-server=http://ip:port')  # IP地址:端口号
# selenium 4.6及以上
driver = webdriver.Chrome(options=chrome_options)
# executable_path： chromedriver驱动存放路径
# driver = webdriver.Chrome(executable_path="C:\\chromedriver.exe", options=chrome_options)
driver.get("http://www.xx.com")

# 获取页面内容
print(driver.page_source)

# 延迟3秒后关闭当前窗口，如果是最后一个窗口则退出
time.sleep(3)
driver.close()

from selenium import webdriver
import time

# 先下载phantomjs包文件,再填入phantomjs.exe的路径 (路径不要包含中文)
executable_path = 'C:\\phantomjs.exe'
service_args=[
    '--proxy=ip:port',
    '--proxy-type=http'
    #'--proxy-auth=username:password'
]
driver=webdriver.PhantomJS(service_args=service_args, executable_path=executable_path)
driver.get('http://www.xx.com')

print(driver.page_source)
time.sleep(3)
driver.close()

import time

from seleniumwire import webdriver

proxy_ip = 'ip:port'
options = {
        'proxy': {
            'http': "http://%(proxy)s/" % {"proxy": proxy_ip},
            'https': "http://%(proxy)s/" % {"proxy": proxy_ip}
        }
    }

driver = webdriver.Firefox(seleniumwire_options=options)

driver.get('http://www.xx.com')

# 获取页面内容
print(driver.page_source)

# 延迟3秒后关闭当前窗口，如果是最后一个窗口则退出
time.sleep(3)
driver.close()

from DrissionPage import WebPage, ChromiumOptions
import time

co = ChromiumOptions()
co.set_proxy("http://ip:port")

page = WebPage(chromium_options=co)
page.get("http://www.xx.com")  # 要访问的目标网页

# 获取页面内容
print(page.html)

# 等待3秒后关闭页面
time.sleep(3)
page.quit()

import okhttp3.*;
import java.io.IOException;
import java.net.InetSocketAddress;
import java.net.Proxy;
public class OkHttpTunnel {
	public static void main(String args[]) throws IOException {
		// 目标网站
		String targetUrl = "http://www.xx.com";

		String ip = "IP代理地址";
		int port = 端口号;

		Proxy proxy = new Proxy(Proxy.Type.HTTP, new InetSocketAddress(ip, port));

		OkHttpClient client = new OkHttpClient.Builder()
				.proxy(proxy)
				.build();
		
		Request request = new Request.Builder()
				.url(targetUrl)
				.addHeader("Connection","close")
				.build();
		
		Response response = client.newCall(request).execute();
		System.out.println(response.body().string());
		
	}
}

import java.net.URL;
import org.apache.http.HttpHost;
import org.apache.http.auth.AuthScope;
import org.apache.http.auth.UsernamePasswordCredentials;
import org.apache.http.client.CredentialsProvider;
import org.apache.http.client.config.RequestConfig;
import org.apache.http.client.methods.CloseableHttpResponse;
import org.apache.http.client.methods.HttpGet;
import org.apache.http.impl.client.BasicCredentialsProvider;
import org.apache.http.impl.client.CloseableHttpClient;
import org.apache.http.impl.client.HttpClients;
import org.apache.http.util.EntityUtils;
public class HTTPClientTunnel {


        /**
         * 使用httpclient请求服务器 http和https网页均适用
         */
        private static String pageUrl = "http://www.xx.com"; // 要访问的目标网页
        private static String proxyIp = "IP代理地址";
        private static int proxyPort = 端口号;
        
        public static void main(String[] args) throws Exception {
            // JDK 8u111版本后，目标页面为HTTPS协议，启用proxy用户密码鉴权
            System.setProperty("jdk.http.auth.tunneling.disabledSchemes", "");

            CredentialsProvider credsProvider = new BasicCredentialsProvider();
            credsProvider.setCredentials(new AuthScope(proxyIp, proxyPort), new UsernamePasswordCredentials("", ""));
            
            CloseableHttpClient httpclient = HttpClients.custom().setDefaultCredentialsProvider(credsProvider).build();
            try {
                URL url = new URL(pageUrl);
                HttpHost target = new HttpHost(url.getHost(), url.getDefaultPort(), url.getProtocol());
                HttpHost proxy = new HttpHost(proxyIp, proxyPort);

	            /*
	            setConnectTimeout：设置连接超时时间
	            setConnectionRequestTimeout：设置从connect Manager获取Connection 超时时间
	            setSocketTimeout：请求获取数据的超时时间
	            */
                RequestConfig config = RequestConfig.custom().setProxy(proxy).setConnectTimeout(6000)
                        .setConnectionRequestTimeout(2000).setSocketTimeout(6000).build();
                HttpGet httpget = new HttpGet(url.getPath());
                httpget.setConfig(config);
                httpget.addHeader("Accept-Encoding", "gzip"); // 使用gzip压缩传输数据让访问更快
                httpget.addHeader("Connection", "close");
                httpget.addHeader("User-Agent", "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/87.0.4280.66 Safari/537.36");
                CloseableHttpResponse response = httpclient.execute(target, httpget);
                try {
                    System.out.println(response.getStatusLine());
                    System.out.println(response.toString());
                } finally {
                    response.close();
                }
            } finally {
                httpclient.close();
            }
        }

}

import java.io.IOException;
import java.net.Authenticator;
import java.net.InetSocketAddress;
import java.net.PasswordAuthentication;
import java.net.Proxy;
import org.jsoup.Jsoup;
import org.jsoup.nodes.Document;
public class JsoupProxy {
    
    // 用户名密码, 若已添加白名单则不需要添加
    final static String ProxyUser = "username";
    final static String ProxyPass = "password";
    final static String ProxyHost = "IP地址";
    final static Integer ProxyPort = 端口号;

    public static String getUrlProxyContent(String url) {
        Authenticator.setDefault(new Authenticator() {
            public PasswordAuthentication getPasswordAuthentication() {
                return new PasswordAuthentication(ProxyUser, ProxyPass.toCharArray());
            }
        });

        Proxy proxy = new Proxy(Proxy.Type.HTTP, new InetSocketAddress(ProxyHost, ProxyPort));

        try {
            // 此处自己处理异常、其他参数等
            Document doc = Jsoup.connect(url).followRedirects(true).timeout(3000).proxy(proxy).get();
            if (doc != null) {
                System.out.println(doc.body().html());
            }
        } catch (IOException e) {
            e.printStackTrace();
        }

        return null;
    }

    public static void main(String[] args) throws Exception {
        // 目标网站
        String targetUrl = "http://www.xx.com";

        // JDK 8u111版本后，目标页面为HTTPS协议，启用proxy用户密码鉴权
        System.setProperty("jdk.http.auth.tunneling.disabledSchemes", "");

        getUrlProxyContent(targetUrl);
    }
}

import java.net.Authenticator;
import java.net.PasswordAuthentication;
import cn.hutool.http.HttpResponse;
import cn.hutool.http.HttpRequest;

public class HuToolProxy {
        // 用户名密码, 若已添加白名单则不需要添加
        final static String ProxyUser = "username";
        final static String ProxyPass = "password";
        final static String ProxyHost = "IP地址";
        final static Integer ProxyPort = 端口号;

        public static void main(String[] args) {
            // 目标网站
            String url = "https://www.xx.com";
            // JDK 8u111版本后，目标页面为HTTPS协议，启用proxy用户密码鉴权
            System.setProperty("jdk.http.auth.tunneling.disabledSchemes", "");
            // 设置请求验证信息
            Authenticator.setDefault(new ProxyAuthenticator(ProxyUser, ProxyPass));

            // 发送请求
            HttpResponse result = HttpRequest.get(url)
                    .setHttpProxy(ProxyHost, ProxyPort)
                    .timeout(6000)//设置超时，毫秒
                    .execute();
            System.out.println(result.body());
        }
}
// 代理验证信息
class ProxyAuthenticator extends Authenticator {
    private String user, password;

    public ProxyAuthenticator(String user, String password) {
        this.user     = user;
        this.password = password;
    }

    protected PasswordAuthentication getPasswordAuthentication() {
        return new PasswordAuthentication(user, password.toCharArray());
    }
}

import org.openqa.selenium.By;
import org.openqa.selenium.Proxy;
import org.openqa.selenium.WebDriver;
import org.openqa.selenium.WebElement;
import org.openqa.selenium.chrome.ChromeDriver;
import org.openqa.selenium.chrome.ChromeOptions;

public class seleniumJava {
    public static void main(String[] args) throws InterruptedException {
        String url = "http://www.xx.com";
        String proxyip = "ip:port";
        System.setProperty("webdriver.chrome.driver","C:\\chromedriver.exe");
        Proxy proxy = new Proxy().setHttpProxy(proxyip).setSslProxy(proxyip);
        ChromeOptions ch = new ChromeOptions();
        ch.addArguments("--remote-allow-origins=*");
        ch.setProxy(proxy);
        WebDriver w = new ChromeDriver(ch);

        w.get(url);
        WebElement we = w.findElement(By.xpath("/html"));
        String res = we.getText().toString();
        System.out.println(res);
        Thread.sleep(3000);
        w.quit();

    }
}

import org.apache.http.HttpHost;
import org.apache.http.auth.AuthScope;
import org.apache.http.auth.UsernamePasswordCredentials;
import org.apache.http.client.CredentialsProvider;
import org.apache.http.impl.client.BasicCredentialsProvider;
import org.apache.http.impl.client.CloseableHttpClient;
import org.apache.http.impl.client.HttpClientBuilder;
import org.apache.http.impl.client.ProxyAuthenticationStrategy;
import org.springframework.http.client.HttpComponentsClientHttpRequestFactory;
import org.springframework.web.client.RestTemplate;
public class ResTempTunnel {
        // 目标网站
        private static String pageUrl = "http://www.xx.com";
        private static String proxyHost = "IP地址";
        private static Integer proxyPort = 端口号;
        // 用户名密码, 若已添加白名单则不需要添加
        private static String ProxyUser = "name";
        private static String Proxypass = "password";

        public static void main(String[] args) {
            CredentialsProvider credsProvider = new BasicCredentialsProvider();
            credsProvider.setCredentials(
                    new AuthScope(proxyHost, proxyPort),
                    new UsernamePasswordCredentials(ProxyUser, Proxypass)
            );

            HttpHost proxy = new HttpHost(proxyHost, proxyPort);
            HttpClientBuilder clientBuilder = HttpClientBuilder.create();
            clientBuilder.useSystemProperties();
            clientBuilder.setProxy(proxy);
            clientBuilder.setDefaultCredentialsProvider(credsProvider);
            clientBuilder.setProxyAuthenticationStrategy(new ProxyAuthenticationStrategy());

            CloseableHttpClient client = clientBuilder.build();
            HttpComponentsClientHttpRequestFactory factory = new HttpComponentsClientHttpRequestFactory();
            factory.setHttpClient(client);

            RestTemplate restTemplate = new RestTemplate();
            restTemplate.setRequestFactory(factory);
            String result = restTemplate.getForObject(pageUrl, String.class);
            System.out.println(result);
        }

}

package main

import (
	"compress/gzip"
	"fmt"
	"io"
	"io/ioutil"
	"net/http"
	"net/url"
	"os"
)

// 请求代理服务器
// http和https网页均适用

func main() {

	// 代理服务器
	proxy_raw := "服务器地址:端口号"
	proxy_str := fmt.Sprintf("http://%s", proxy_raw)
	proxy, err := url.Parse(proxy_str)

	// 目标网页
	page_url := "http://www.xx.com"

	//  请求目标网页
	client := &http.Client{Transport: &http.Transport{Proxy: http.ProxyURL(proxy)}}
	req, _ := http.NewRequest("GET", page_url, nil)
	req.Header.Add("Accept-Encoding", "gzip") // 使用gzip压缩传输数据让访问更快
	res, err := client.Do(req)

	if err != nil {
		// 请求发生异常
		fmt.Println(err.Error())
	} else {
		defer res.Body.Close() // 保证最后关闭Body

		fmt.Println("status code:", res.StatusCode) // 获取状态码

		// 有gzip压缩时,需要解压缩读取返回内容
		if res.Header.Get("Content-Encoding") == "gzip" {
			reader, _ := gzip.NewReader(res.Body) // gzip解压缩
			defer reader.Close()
			io.Copy(os.Stdout, reader)
			os.Exit(0) // 正常退出
		}

		// 无gzip压缩, 读取返回内容
		body, _ := ioutil.ReadAll(res.Body)
		fmt.Println(string(body))
	}
}                              

using System.IO.Compression;
using System.Net;
using System.Text;

namespace Sample
{
    internal class Program
    {

        static void Main(string[] args)
        {
            //HTTP代理
            HttpWebRequestTest();
            Console.ReadKey();
        }

        static void HttpWebRequestTest()
        {
            // 设置代理服务器地址和端口号
            // WebProxy proxy = new WebProxy("http://代理服务器地址:代理服务器端口号/");
            WebProxy proxy = new WebProxy("http://xx:xx/");
            // 创建Web请求对象
            HttpWebRequest request = (HttpWebRequest)WebRequest.Create("http://www.xx.com");

            // 将代理服务器设置到请求中
            request.Proxy = proxy;

            // 发送HTTP GET请求
            HttpWebResponse response = (HttpWebResponse)request.GetResponse();

            // 获取响应内容
            string content = new StreamReader(response.GetResponseStream(), Encoding.UTF8).ReadToEnd();

            // 输出响应内容
            Console.WriteLine(content);

            // 关闭响应对象
            response.Close();
        }
    }
}

const http = require("http");  // 引入内置http模块
const url = require("url");

// 要访问的目标页面
const targetUrl = "http://www.xx.com";
const urlParsed = url.parse(targetUrl);

const proxyIp = "IP地址";
const proxyPort = 端口号;

// 用户名密码, 若已添加白名单则不需要添加
//const username = "username";
//const password = "password";

//const base64 = new Buffer.from(username + ":" + password).toString("base64");
const options = {
    host: proxyIp,
    port: proxyPort,
    path: targetUrl,
    method: "GET",
    headers: {
        "Host": urlParsed.hostname,
        //"Proxy-Authorization": "Basic " + base64
    }
};

http.request(options, (res) => {
    console.log("got response: " + res.statusCode);
    // 输出返回内容(使用了gzip压缩)
    if (res.headers['content-encoding'] && res.headers['content-encoding'].indexOf('gzip') != -1) {
        let zlib = require('zlib');
        let unzip = zlib.createGunzip();
        res.pipe(unzip).pipe(process.stdout);
    } else {
        // 输出返回内容(未使用gzip压缩)
        res.pipe(process.stdout);
    }
})
    .on("error", (err) => {
        console.log(err);
    })
    .end()
    ;

let http = require('http'); // 引入内置http模块
let tls = require('tls'); // 引入内置tls模块
let util = require('util');

// 代理服务器ip和端口
let proxy_ip = 'tunnelhost';
let proxy_port = port;

// 要访问的主机和路径
let remote_host = 'www.xx.com';
let remote_path = '/';


// 发起CONNECT请求
let req = http.request({
    host: proxy_ip,
    port: proxy_port,
    method: 'CONNECT',
    path: remote_host,
    headers: {
        "Host": remote_host,
        "User-Agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/60.0.3100.0 Safari/537.36",
        "Accept-Encoding": "gzip"   // 使用gzip压缩让数据传输更快
    },
    rejectUnauthorized: false
});

req.on('connect', function (res, socket, head) {
    console.log('状态码:', res.statusCode);
    // TLS握手
    let tlsConnection = tls.connect({
        host: remote_host,
        socket: socket
    }, function () {
        // 发起GET请求
        tlsConnection.write(util.format('GET %s HTTP/1.1\r\nHost: %s\r\n\r\n', remote_path, remote_host));
    });

    tlsConnection.on('data', function (data) {
        // 输出响应结果(完整的响应报文串)
        console.log(data.toString());
    });
});

req.end();

let request = require('request'); // 引入第三方request库
let util = require('util');
let zlib = require('zlib');

// 用户名密码, 若已添加白名单则不需要添加
//const username = 'username';
//const password = 'password';

// 要访问的目标地址
let page_url = 'http://www.xx.com'

let tunnelhost = 'IP地址';
let tunnelport = 端口号;

// 用户名密码完整url
//let proxy = util.format('http://%s:%s@%s:%d', username, password, tunnelhost, tunnelport);
//// 白名单完整url
let proxy = util.format('http://%s:%d', tunnelhost, tunnelport);

// 发起请求
request({
    url: page_url,
    method: 'GET',
    proxy: proxy,
    headers: {
        "User-Agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/60.0.3100.0 Safari/537.36",
        "Accept-Encoding": "gzip"   // 使用gzip压缩让数据传输更快
    },
    encoding: null,  // 方便解压缩返回的数据
}, function (error, res, body) {
    if (!error && res.statusCode == 200) {
        // 输出返回内容(使用了gzip压缩)
        if (res.headers['content-encoding'] && res.headers['content-encoding'].indexOf('gzip') != -1) {
            zlib.gunzip(body, function (err, dezipped) {
                console.log(dezipped.toString());
            });
        } else {
            // 输出返回内容(没有使用gzip压缩)
            console.log(body);
        }
    } else {
        console.log(error);
    }
});

// 引入puppeteer模块
const puppeteer = require('puppeteer');

// 要访问的目标网页
const url = 'http://www.xx.com';

// 添加headers
const headers = {
    'Accept-Encoding': 'gzip' // 使用gzip压缩让数据传输更快
};

(async () => {
    // 新建一个浏览器实例
    const browser = await puppeteer.launch({
        headless: false,  // 是否不显示窗口, 默认为true, 设为false便于调试
        args: [
            '--proxy-server=tunnelHost:port',
            '--no-sandbox',
            '--disable-setuid-sandbox'
        ],
        executablePath: "C:\\chrome.exe"
    });

    // 打开一个新页面
    const page = await browser.newPage();

    // 设置headers
    await page.setExtraHTTPHeaders(headers);

    // 访问目标网页
    await page.goto(url);

})();

const axios = require('axios');
const { HttpsProxyAgent } = require("https-proxy-agent");

let tunnelHost = 'IP地址'
let tunnelPort = 端口号

// 配置用户名和密码
let username = 'username'
let password = 'password.'

axios({
    url: 'http://www.xx.com',
    method: "get",
    httpAgent: new HttpsProxyAgent(`http://${username}:${password}@${tunnelHost}:${tunnelPort}`),
    httpsAgent: new HttpsProxyAgent(`http://${username}:${password}@${tunnelHost}:${tunnelPort}`),
}).then(
    res => {
        console.log(res.data);
    }
).catch(err => {
    console.log(err);
})

const WebSocket = require('ws');
const { HttpsProxyAgent } = require("https-proxy-agent");

let tunnelHost = 'IP地址'
let tunnelPort = 端口号

// 配置用户名和密码
let username = 'username'
let password = 'password'
const target = 'ws://echo.websocket.org/';
const agent = new HttpsProxyAgent(`http://${username}:${password}@${tunnelHost}:${tunnelPort}`);
const socket = new WebSocket(target, { agent });

socket.on('open', function () {
    console.log('"open" event!');
    socket.send('hello world!!!');
});

socket.on('message', function (data, flags) {
    console.log('"message" event!', data, flags);
    socket.close();
});

function sendRequest($url, $proxy_ip)
{
    $ch = curl_init();
    curl_setopt($ch, CURLOPT_URL, $url);
    curl_setopt($ch, CURLOPT_PROXY, $proxy_ip);
    curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
    $response = curl_exec($ch);
    curl_close($ch);
    return $response;
}
$proxy_ip = "ip:port";
$url = "www.xx.com";
$response = sendRequest($url, $proxy_ip);
echo 'Response: ' . $response;

.子程序 _启动子程序, 整数型
.局部变量 请求地址, 文本型
.局部变量 代理IP, 文本型
.局部变量 代理端口, 文本型
.局部变量 响应内容, 文本型

' 设置代理IP和端口（请替换为您的实际代理信息）
代理IP ＝ “您的代理IP”
代理端口 ＝ “您的代理端口”

' 要访问的网址
请求地址 ＝ “http://www.xx.com”

' 使用易语言的网络请求函数，设置代理
' 注意：易语言本身不直接支持HTTP代理，需使用第三方库或API调用系统命令
' 此处仅为示意，请根据实际情况调整

' 示例：使用系统命令调用curl（需确保易语言环境支持）
' 如果您有更具体的易语言网络库，请参考文档中的样例