// 设置IP，格式  ip:port
            $proxyServer = "ip:port";
            
            $ch = curl_init();
            // 设置请求地址
            curl_setopt($ch, CURLOPT_URL, "https://api.ip.cc");
            // 设置IP，格式  http://ip:port
            curl_setopt($ch, CURLOPT_PROXY, "http://$proxyServer");
            // https请求 不验证证书和hosts
            curl_setopt($ch, CURLOPT_SSL_VERIFYPEER, FALSE);
            
            $output = curl_exec($ch);
            if ($output === FALSE) {
                echo "CURL Error:" . curl_error($ch);
            } else {
                echo $output;
            }
            curl_close($ch);
                                
                            

                                

                    package main
                    
                    import (
                    	"fmt"
                    	"golang.org/x/net/proxy"
                    	"io/ioutil"
                    	"net/http"
                    	"net/url"
                    	"os"
                    )
                    
                    func httpProxy(targetUrlString, httpProxyServer string) {
                    
                    	targetUrl := url.URL{}
                    	//配置IP服务器
                    	proxyServer, _ := targetUrl.Parse("http://" + httpProxyServer)
                    	//设置一个http客户端
                    	client := &http.Client{
                    		Transport: &http.Transport{
                    			//设置IP服务器
                    			Proxy: http.ProxyURL(proxyServer),
                    		},
                    	}
                    
                    	//访问地址
                    	rqt, err := http.NewRequest("GET", targetUrlString, nil)
                    	if err != nil {
                    		println("请求网站失败")
                    		return
                    	}
                    	//处理返回结果
                    	response, _ := client.Do(rqt)
                    	defer response.Body.Close()
                    	//读取内容
                    	body, err := ioutil.ReadAll(response.Body)
                    	if err != nil {
                    		return
                    	}
                    	//输入响应结果
                    	fmt.Println("socket5 请求结果:", string(body))
                    }
                    
                    func socket5Proxy(targetUrlString, httpProxyServer string) {
                    
                    	dialer, err := proxy.SOCKS5("tcp", httpProxyServer, nil, proxy.Direct)
                    	if err != nil {
                    		fmt.Println(os.Stderr, "can't connect to the proxy:", err)
                    		os.Exit(1)
                    	}
                    
                    	// setup a http client
                    	httpTransport := &http.Transport{}
                    	client := &http.Client{Transport: httpTransport}
                    	// set our socks5 as the dialer
                    	httpTransport.Dial = dialer.Dial
                    
                    	//访问地址
                    	rqt, err := http.NewRequest("GET", targetUrlString, nil)
                    	if err != nil {
                    		println("请求网站失败")
                    		return
                    	}
                    	//处理返回结果
                    	response, _ := client.Do(rqt)
                    	defer response.Body.Close()
                    	//读取内容
                    	body, err := ioutil.ReadAll(response.Body)
                    	if err != nil {
                    		return
                    	}
                    	//输入响应结果
                    	fmt.Println("http 请求结果:", string(body))
                    }
                    
                    func main() {
                    
                    	httpProxy("https://api.ip.cc", "服务器ip:服务器http端口")
                    
                    	socket5Proxy("https://api.ip.cc", "服务器ip:服务器socket5端口")
                    }
                
                                
                            

                                


                using System;
                using System.IO;
                using System.IO.Compression;
                using System.Net;
                
                namespace ConsoleApp1
                {
                    class Program
                    {
                        static void Main(string[] args)
                        {
                            // 要访问的目标网页
                            string page_url = "https://api.ip.cc";
                
                            // 构造请求
                            HttpWebRequest request = (HttpWebRequest)WebRequest.Create(page_url);
                            request.Method = "GET";
                
                            // 代理服务器
                            string proxy_ip = "代理服务器ip";
                            int proxy_port = 代理服务器端口;
                
                
                            // 设置代理 (私密/独享代理&未添加白名单)
                            WebProxy proxy = new WebProxy();
                            proxy.Address = new Uri(String.Format("http://{0}:{1}", proxy_ip, proxy_port));
                
                            request.Proxy = proxy;
                
                            // 请求目标网页
                            HttpWebResponse response = (HttpWebResponse)request.GetResponse();
                
                            Console.WriteLine((int)response.StatusCode);  // 获取状态码
                                                                          // 解压缩读取返回内容
                            Stream responseStream = response.GetResponseStream();
                            byte[] bArr = new byte[1024];
                            try
                            {
                                int size = responseStream.Read(bArr, 0, (int)bArr.Length);
                                Console.Write(System.Text.Encoding.Default.GetString(bArr));
                            }
                            catch (Exception ex)
                            {
                                Console.WriteLine("下载出错");
                                return;
                            }
                
                            responseStream.Close();
                            return;
                        }
                    }
                }
                                
                            

                                

                import okhttp3.*;
                import java.io.IOException;
                import java.net.InetSocketAddress;
                import java.net.Proxy;
                public class DemoProxy {
                
                    public static void main(String[] args) throws IOException {
                        String targetUrl = "https://api.ip.cc";
                
                        String ip = "代理服务器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)
                                     .build();
                
                        Response response = client.newCall(request).execute();
                        System.out.println(response.body().string());
                    }
                }
                
                
                                
                            

                                

                import kotlin.Throws
                import java.io.IOException
                import kotlin.jvm.JvmStatic
                import java.net.InetSocketAddress
                import okhttp3.OkHttpClient
                import okhttp3.Request
                import java.net.Proxy
                
                object DemoProxy {
                    @Throws(IOException::class)
                    @JvmStatic
                    fun main(args: Array) {
                        val targetUrl = "https://api.ip.cc"
                        val ip = "代理服务器IP" // 代理服务器IP
                        val port = 代理服务器端口
                        val proxy = Proxy(Proxy.Type.HTTP, InetSocketAddress(ip, port))
                        val client = OkHttpClient.Builder()
                                .proxy(proxy)
                                .build()
                        val request = Request.Builder()
                                .url(targetUrl)
                                .build()
                        val response = client.newCall(request).execute()
                        println(response.body().string())
                    }
                }