Obtenha acesso a dados da Web com proxies confiáveis

													
													package main
													
													import (
														"context"
														"fmt"
														"io/ioutil"
														"net"
														"net/http"
														"net/url"
														"strings"
														"time"
													
														"golang.org/x/net/proxy"
													)
													
													// Proxy setting
													var ip = "proxy server"   //Example:192.168.0.1
													var port = "port" //Example:2333
													// Proxy server
													var proxyServer = "http://" + ip + ":" + port
													
													// Test link
													var testApi = "https://ipinfo.pyproxy.io"
													
													func main() {
														var proxyIP = proxyServer
														go httpProxy(proxyIP, "", "")
														go Socks5Proxy(proxyIP, "", "")
														time.Sleep(time.Minute)
													}
													
													// http proxy
													func httpProxy(proxyUrl, user, pass string) {
														defer func() {
															if err := recover(); err != nil {
																fmt.Println(time.Now().Format("2006-01-02 15:04:05 07"), "http", "response:", err)
															}
														}()
														urli := url.URL{}
													
														if !strings.Contains(proxyUrl, "http") {
															proxyUrl = fmt.Sprintf("http://%s", proxyUrl)
														}
													
														urlProxy, _ := urli.Parse(proxyUrl)
														if user != "" && pass != "" {
															urlProxy.User = url.UserPassword(user, pass)
														}
													
														client := &http.Client{
															Transport: &http.Transport{
																Proxy: http.ProxyURL(urlProxy),
															},
														}
														rqt, err := http.NewRequest("GET", testApi, nil)
														if err != nil {
															panic(err)
															return
														}
														response, err := client.Do(rqt)
														if err != nil {
															panic(err)
															return
														}
													
														defer response.Body.Close()
														body, _ := ioutil.ReadAll(response.Body)
														fmt.Println(time.Now().Format("2006-01-02 15:04:05 07"), proxyUrl, "[http success]", "response:", response.Status, string(body))
													
														return
													}
													
													// socks5 proxy
													func Socks5Proxy(proxyUrl, user, pass string) {
													
														defer func() {
															if err := recover(); err != nil {
																fmt.Println(time.Now().Format("2006-01-02 15:04:05 07"), proxyUrl, "response:", err)
															}
														}()
													
														var userAuth proxy.Auth
														if user != "" && pass != "" {
															userAuth.User = user
															userAuth.Password = pass
														}
														dialer, err := proxy.SOCKS5("tcp", proxyUrl, &userAuth, proxy.Direct)
														if err != nil {
															panic(err)
														}
														httpClient := &http.Client{
															Transport: &http.Transport{
																DialContext: func(ctx context.Context, network, addr string) (conn net.Conn, err error) {
																	return dialer.Dial(network, addr)
																},
															},
															Timeout: time.Second * 10,
														}
													
														if resp, err := httpClient.Get(testApi); err != nil {
															panic(err)
														} else {
															defer resp.Body.Close()
															body, _ := ioutil.ReadAll(resp.Body)
															fmt.Println(time.Now().Format("2006-01-02 15:04:05 07"), proxyUrl, "[socks5 success]", "response:", string(body))
														}
													}														
												

													
													#!/usr/bin/env node
													require('request-promise')({
														url: 'https://pyproxy.com',//Request URL
														proxy: 'http://ip:port',//Proxy server IP: port
														})
													.then(function(data){ console.log(data); },
														function(err){ console.error(err); });													
												

													
													<?php
													//Proxy setting
													$ip = "Proxy server IP";//Example:192.168.0.1
													$port = "Port";//Example:2333
													// Target URL
													$targetUrl = "http://google.com";
													// Proxy server
													$proxyServer = "http://$ip:$port";
																										
													// Tunnel verification
													$ch = curl_init();
													curl_setopt($ch, CURLOPT_URL, $targetUrl);
													curl_setopt($ch, CURLOPT_HTTPPROXYTUNNEL, false);
													curl_setopt($ch, CURLOPT_SSL_VERIFYPEER, false);
																										
													// Proxy server setting
													curl_setopt($ch, CURLOPT_PROXYTYPE, 0); //http
													// curl_setopt($ch, CURLOPT_PROXYTYPE, 5); //sock5
													curl_setopt($ch, CURLOPT_PROXY, $proxyServer);
																										
													// Tunnel verification setting
													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);
													$err = curl_error($ch);
																										
													curl_close($ch);
																										
													var_dump($err);
													var_dump($result);
																										
																										
												

													
													package demo;
													
													import okhttp3.OkHttpClient;
													import okhttp3.Request;
													
													import java.io.IOException;
													import java.net.InetSocketAddress;
													import java.net.Proxy;
													
													/**
													 * compile 'com.squareup.okhttp3:okhttp:4.9.3'
													 */
													class ApiProxyJava {
														public static void main(String[] args) throws IOException {
															testHttpWithOkHttp();
															testSocks5WithOkHttp();
														}
													
														/**
														 * http proxy
														 */
														public static void testHttpWithOkHttp() throws IOException {
															//Set the URL you want to visit
															String url = "https://ipinfo.pyproxy.io";
															//Create an HTTP proxy object and set IP and port for the proxy server
															Proxy proxy = new Proxy(Proxy.Type.HTTP, new InetSocketAddress("ip", "port"));//The "ip" and "port" here should be replaced with proxy server IP and port.
															//Build an OkHttpClient instance and configure the HTTP proxy
															OkHttpClient client = new OkHttpClient().newBuilder().proxy(proxy).build();
															//Send GET Request and get response
															Request request = new Request.Builder().url(url).build();
															okhttp3.Response response = client.newCall(request).execute();
															//Get and print response
															String responseString = response.body().string();
															System.out.println(responseString);
														}
													
														/**
														 * SOCKS5 Proxy
														 */
														public static void testSocks5WithOkHttp() throws IOException {
															//Set the URL you want to visit
															String url = "https://ipinfo.pyproxy.io";
															//Create a SOCKS proxy object and set IP and port for the proxy server
															Proxy proxy = new Proxy(Proxy.Type.SOCKS, new InetSocketAddress("ip", "port"));//The "ip" and "port" here should be replaced with proxy server IP and port.
															//Build an OkHttpClient instance and configure the SOCKS proxy
															//A SOCKS proxy is used here, which means that all network traffic (including TCP connections) will be forwarded through this SOCKS proxy.
															OkHttpClient client = new OkHttpClient().newBuilder().proxy(proxy).build();
															//Send GET Request and get response
															Request request = new Request.Builder().url(url).build();
															okhttp3.Response response = client.newCall(request).execute();
															//Get and print response
															String responseString = response.body().string();
															System.out.println(responseString);
														}
													}
													
																										
												

													
													# coding=utf-8
													# ！/usr/bin/env python
													import json
													import threading
													import time
													import requests as rq
													
													# Set head of request
													headers = {
														"User-Agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:85.0) Gecko/20100101 Firefox/85.0",
														"Accept": "text/html,application/xhtml+xml,application/xml;q=0.9,image/webp,*/*;q=0.8",
														"Accept-Language": "zh-CN,zh;q=0.8,zh-TW;q=0.7,zh-HK;q=0.5,en-US;q=0.3,en;q=0.2",
														"Accept-Encoding": "gzip, deflate, br"
													}
													# Test URL
													testUrl = 'https://ipinfo.pyproxy.io'
													
													
													# Main business
													def testPost(host, port):
														# Configure IP and port you get
														proxies = {
															# Proxy server IP you get by API
															# Port you get by API
															'http': 'http://{}:{}'.format(host, port),
															'https': 'http://{}:{}'.format(host, port),
														}
														while True:
															try:
																# Test after configuring proxies
																res = rq.get(testUrl, proxies=proxies, timeout=5)
																# print(res.status_code)
																# Print the result of request
																print(res.status_code, "***", res.text)
																break
															except Exception as e:
																print(e)
																break
														return
													
													
													class ThreadFactory(threading.Thread):
														def __init__(self, host, port):
															threading.Thread.__init__(self)
															self.host = host
															self.port = port
													
														def run(self):
															testPost(self.host, self.port)
													
													
													# Link for getting proxies  Return is in json type
													tiqu = 'Get proxy link'
													
													while 1 == 1:
														# Get 10 at a time, and put in thread
														resp = rq.get(url=tiqu, timeout=5)
														try:
															if resp.status_code == 200:
																dataBean = json.loads(resp.text)
															else:
																print("Fail to get")
																time.sleep(1)
																continue
														except ValueError:
															print("fail to get")
															time.sleep(1)
															continue
														else:
															# Parse json array and get ip and port
															print("code=", dataBean["code"])
															code = dataBean["code"]
															if code == 0:
																threads = []
																for proxy in dataBean["data"]:
																	threads.append(ThreadFactory(proxy["ip"], proxy["port"]))
																for t in threads:  # Turn on thread
																	t.start()
																	time.sleep(0.01)
																for t in threads:  # Block thread
																	t.join()
														# break
														time.sleep(1)