如何利用IP代理池提升数据采集的效率
在数据采集的海洋中，代理IP池就像是一艘装备精良的快艇，能够帮助我们快速、高效地搜集信息。那么，如何利用这个强大的工具来提高数据采集的效率呢？今天，我们就来探讨一下这个话题。
## **选择合适的代理IP池**
首先，选择合适的代理IP池是提高数据采集效率的关键。一个好的代理IP池应该具备广泛的IP覆盖、快速的响应时间和稳定的连接。这样，无论是进行市场调研、用户行为分析还是竞争情报收集，你都能确保数据采集的连续性和准确性。
## **分散请求，降低风险**
使用代理IP池可以分散请求，降低单一IP被目标网站识别和封禁的风险。通过从不同的IP地址发起请求，你可以模拟真实用户的访问行为，减少被网站反爬虫机制检测到的可能性。
## 提高请求速度
代理IP池可以同时处理多个请求，这意味着你可以在短时间内从多个来源收集数据。这种并行处理能力显著提高了数据采集的速度，让你能够快速响应市场变化。
## **灵活应对变化**
在数据采集过程中，目标网站可能会改变其结构或策略。拥有一个灵活的代理IP池可以让你迅速适应这些变化，继续高效地进行数据采集。
## **总结**
通过这篇文章，我们不仅分享了如何利用IP代理池提高数据采集效率的实用技巧，知道了如何利用IP代理池提高数据采集效率，需要从选择合适的代理服务、分散请求、提高请求速度和灵活应对变化等方面入手。希望这篇文章能够帮助你在数据采集项目中实现更高的效率，取得更好的成果。
如何提高代理IP的并发能力
在数据采集的领域，时间就是金钱，效率就是生命。代理IP的并发能力直接关系到我们能否快速、高效地获取数据。那么，如何提高代理IP的并发能力呢？今天，我们就来聊聊这个话题，为你的数据采集项目提速。
并发，简而言之，就是同时进行多个操作的能力。在代理IP的使用中，高并发意味着我们可以同时从多个IP地址发起请求，这样可以大大提高数据采集的速度和效率。
### **1. 选择合适的代理IP服务**
提高并发能力的第一步是选择合适的代理IP服务。不同的服务提供商提供的IP数量和质量各不相同。选择一个提供大量、高质量IP的服务提供商，比如青果网络，可以为你的高并发需求打下坚实的基础。
### **2. 优化请求逻辑**
优化你的请求逻辑也是提高并发能力的关键。这包括合理设置请求间隔，避免过快的请求导致目标网站的反爬虫机制触发，以及实现请求的动态分配，确保每个代理IP都能得到充分利用。
### **3. 使用高效的编程框架**
使用高效的编程框架和库可以大幅提升并发处理能力。例如，Python中的`asyncio`库可以让你轻松实现异步请求，从而提高并发量。
### **4. 分布式爬虫系统**
对于大规模的数据采集项目，考虑构建分布式爬虫系统。通过在多台服务器上部署爬虫，可以显著提高并发量，实现更高效的数据采集。
### **5. 监控和调整**
监控代理IP的使用情况，包括响应时间和成功率，根据实际情况调整并发策略。及时发现并解决可能的问题，比如某个IP被封禁，可以保证并发请求的稳定性。
### **总结**
提高代理IP的并发能力，需要从选择合适的服务提供商、优化请求逻辑、使用高效的编程框架、构建分布式爬虫系统，以及进行实时监控和调整等多方面入手。青果网络作为你的合作伙伴，将为你提供稳定、高效的代理IP服务，帮助你在数据采集的赛道上加速前进。希望这篇文章能够帮助你在数据采集项目中实现更高的并发量，提高工作效率。
代理IP是什么，有什么用？
在这个信息爆炸的时代，数据采集已经成为许多行业不可或缺的一部分。而在这个过程中，代理IP扮演了一个非常重要的角色。那么，代理IP究竟是什么？它在数据采集中又有什么用呢？让我们一起来揭开代理IP的神秘面纱。
## **代理IP是什么？**
代理IP，简单来说，就是一个中间人，它位于你的计算机和目标服务器之间。当你通过代理IP发送请求时，实际上是代理服务器代替你的计算机向目标服务器发起请求，并将获取的数据返回给你。
## **代理IP在数据采集中的作用**
1. **突破地域限制**
代理IP可以帮助我们突破地域限制，访问那些可能因为地理位置而无法直接访问的数据。这对于需要从全球范围内收集数据的企业和研究者来说尤为重要。
2. **提高数据采集效率**
使用代理IP可以同时从多个不同的地点发起请求，这大大提高了数据采集的效率，尤其是在需要从多个数据源收集数据的情况下。
3. **保护数据采集的稳定性**
由于代理IP可以分散请求，这有助于避免因频繁访问同一服务器而被限制或封禁的风险，从而保护数据采集过程的稳定性。
4. **提升数据的多样性**
代理IP通常覆盖全球多个国家和地区，这使得数据采集可以覆盖更广泛的地区，提升收集数据的多样性。
在代理IP服务领域，青果网络以其专业的技术和优质的服务赢得了广泛的信赖。我们提供日更600W+纯净IP资源池，代理IP服务不仅覆盖全球多个国家和地区，还支持多种协议，满足不同用户的需求。
## **总结**
代理IP是数据采集中的重要工具，它帮助我们突破地域限制，提高数据采集效率，保护数据采集的稳定性，并提升数据的多样性。
通过这篇文章，我们介绍了代理IP的概念和它在数据采集中的重要作用，希望这篇文章能够帮助您更好地理解代理IP，并在您的数据采集项目中发挥其最大的潜力。青果网络作为您的合作伙伴，将为您提供高质量的代理IP服务，助力您的数据采集项目顺利进行。
如何判断自己的数据采集项目，要多少代理IP？
在数据采集的世界里，代理IP就像是我们的侦察兵，帮助我们从互联网的海洋中获取宝贵的信息。但是，如何判断自己的项目需要多少这样的侦察兵呢？今天，我们就来聊聊如何为您的数据采集项目选择合适的代理IP数量。
---
## **项目规模与数据量**
首先，考虑您的项目规模和所需收集的数据量。如果您的目标是收集大量数据，比如进行市场趋势分析或用户行为研究，那么您可能需要更多的代理IP来提高数据采集的效率和覆盖面。
## **目标网站的反爬虫策略**
不同的网站有不同的反爬虫策略。一些网站对频繁的请求非常敏感，可能会限制或封禁那些看起来可疑的IP地址。在这种情况下，您可能需要尽可能多的代理IP来分散请求，降低被封禁的风险。
## **数据采集的速度要求**
如果您的项目需要快速获取数据，比如实时监控社交媒体趋势或股票市场动态，这些都需要我们需使用更多的代理IP来并行处理多个请求，以满足速度要求。
### **预算限制**
代理IP的数量也受到预算的限制。高质量的代理IP往往成本较高，因此您需要根据自己的预算来决定可以购买多少代理IP。
在决定代理IP数量时，青果网络可以为您提供灵活的解决方案。我们提供日更超600W+的纯净IP资源池，代理IP服务覆盖全球多个国家和地区，支持多种协议，能够满足您在数据采集过程中的不同需求。无论是小规模的精准采集还是大规模的数据收集，青果网络都能为您提供合适的代理IP数量。
## **总结**
判断数据采集项目需要多少代理IP，需要综合考虑项目规模、目标网站的反爬虫策略、数据采集速度要求以及预算限制。青果网络作为您的合作伙伴，将为您提供稳定、高效的代理IP服务，帮助您在数据采集的道路上更加顺畅。希望这篇文章能够帮助您更好地理解代理IP的选择，并在数据采集中做出更合适的决策。
如何挑选靠谱的IP代理池?
嘿，寻觅一个靠谱的IP代理池就好比找到一双合脚的跑鞋，舒适性和耐用性缺一不可。IP代理池同样要支撑您在网络世界中“跑”得更快更远。所以，别急，我们来看看有哪些小妙招，教您挑选出最合适的IP代理池吧！
#### 看速度——像猎豹一样迅捷
谁不想拥有“风驰电掣”的浏览速度呢？在选择代理池时，速度是一定要试试的要素！
- **快速响应**：优质代理通常能提供小于100毫秒的响应时间，快速响应意味着您使用的体验更流畅。青果网络就提供了这种极速飞驰的快感哦。
- **延迟低**：谁想在数据采集中盯着屏幕等“原地踏步”？低延迟保证了您秒开网页，迅捷完成采集。
#### 可靠性——像老朋友般稳定
找到靠谱的代理服务，就如同找到一位稳妥的朋友，怎么依靠都不会掉链子。
- **高可用率**：出色的代理池，应该具备超过99%的可用率，这样您就不必担心掉链子的情况。青果网络在这一点上可是小有名气！
- **故障排除快速**：好的代理服务总能在IP不可用时，立刻调度补齐，确保不中断您的业务。
#### 覆盖广——像地图般全面
当您需要大数据支持，全球化覆盖的代理服务能让您获取不同区域的信息，成就“全景”视角。
- **全球覆盖**：理想的代理池要支持来自多个国家或地区的IP，让您随时获取广泛信息。比如，青果网络提供的全球200多个城市的覆盖。
- **多协议支持**：不仅仅是HTTP，支持HTTPS、SOCKS5这些额外协议，更能灵活适应不同需求场合。
#### 安全性——切忌“数据泄露”
在各种可能的网络风险前，安全性是您需要时刻关心的“保护盾”。
- **安全保护**：确保代理池提供数据加密，让您的业务数据在采集和传输中安全无虞。
- **评价和口碑**：寻找有良好安全记录和较好客户反馈的服务商，了解过去用户的体验和满意度。
### 结语
在挑选靠谱IP代理池的过程中，最重要的是明确人工智能工具的实际需求，通过多样性和适配性来选定最佳方案。希望这些活泼小知识能如同深夜的星光，照亮你的网路选择之旅！
如果您还有任何疑问或者需要了解更多，青果网络永远欢迎您的光临和咨询。祝您从此开启畅快的互联网真我之旅！
Node语言代码示例
## nodejs http
```javascript
const http = require("http");
const url = require("url");
const targetURL = url.parse("https://test.ipw.cn");
// 如果上面目标站不可用，请使用ip.sb、ipinfo.io、ip-api.com、64.ipcheck.ing
const proxyIp = "您的代理IP";
const proxyPort = 端口号;
const authKey = "请改成您的Key";
const password = "请改成您的AuthPwd";
const base64 = new Buffer.from(authKey + ":" + password).toString("base64");
const options = {
host: proxyIp,
port: proxyPort,
path: targetURL,
method: "GET",
headers: {
"Host": urlParsed.hostname,
"Proxy-Authorization": "Basic " + base64
}
};
http.request(options, function (resp) {
console.log("response status code: " + resp.statusCode);
resp.pipe(process.stdout);
}).on("error", function (err) {
console.log("request failed: " + err);
}).end();
```
## nodejs request
```javascript
const request = require("https://test.ipw.cn");
// 如果上面目标站不可用，请使用ip.sb、ipinfo.io、ip-api.com、64.ipcheck.ing
const targetUrl = "https://api.ipify.org";
const proxyIp = "您的代理IP";
const proxyPort = 端口号;
const authKey = "请改成您的Key";
const password = "请改成您的AuthPwd";
const proxyUrl = "http://" + authKey + ":" + password + "@" + proxyIp + ":" + proxyPort;
const req = request.defaults({'proxy': proxyUrl});
const options = {
url: targetUrl,
headers: {}
};
req.get(options, function (err, resp, body) {
if (err) {
return console.log(err);
}
console.log("response status code: " + resp.statusCode);
console.log("response body: " + body);
}).on("error", function (err) {
console.log("request failed: " + err);
});
```
## nodejs superagent
```javascript
const request = require("superagent");
require("superagent-proxy")(request);
const targetUrl = "https://test.ipw.cn";
// 如果上面目标站不可用，请使用ip.sb、ipinfo.io、ip-api.com、64.ipcheck.ing
const proxyIp = "您的代理IP";
const proxyPort = 端口号;
const authKey = "请改成您的Key";
const password = "请改成您的AuthPwd";
const proxyUrl = "http://" + authKey + ":" + password + "@" + proxyIp + ":" + proxyPort;
request.get(targetUrl).proxy(proxyUrl).end(function onResponse(err, resp) {
if (err) {
return console.log(err);
}
console.log("response status code: " + resp.statusCode);
console.log("response body: " + resp.text);
});
```
## nodejs axios
```javascript
const axios = require("axios")
const {HttpsProxyAgent} = require("https-proxy-agent")
const targetUrl = "https://test.ipw.cn"
// 如果上面目标站不可用，请使用ip.sb、ipinfo.io、ip-api.com、64.ipcheck.ing
const proxyIp = "您的代理IP"
const proxyPort = 端口号
const authKey = "请改成您的Key"
const password = "请改成您的AuthPwd"
const proxy = new HttpsProxyAgent(`http://${authKey}:${password}@${proxyIp}:${proxyPort}`)
axios.get(targetUrl, {
httpAgent: proxy,
httpsAgent: proxy,
}).then(function (response) {
console.log("response body: " + response.data)
}).catch(function (error) {
console.log("request failed: " + error)
}).finally(function () {
console.log("request finished.")
})
// 如果目标站是HTTPS，则需要使用下面的代码进行代理请求
let httpsProxyAgent = require('https-proxy-agent');
var agent = new HttpsProxyAgent(`http://${authKey}:${password}@${proxyIp}:${proxyPort}`);
var config = {
url: "https://api.ipify.org",
httpsAgent: agent
}
axios.request(config)
.then(function(response) {
console.log("response body: " + response.data)
}).catch(function(error) {
console.log("request failed: " + error)
})
```
隧道代理 Go 语言接入指南
## 概述
本文档将指引你进行隧道代理的接入，在此文档中使用到的术语将会在下方进行列出。
| 术语 | 解释 |
| :------- | :----------------------------------------- |
| 隧道 | 自动更换代理 IP 的代理服务 |
| 固定时长 | 服务器将在固定时长后自动切换IP，例如1分钟 |
| 通道 | 使用多个通道同时发起请求，每个通道的IP不同 |
隧道代理有多种使用方式，具体行为取决于套餐及模式。
- 普通模式
每次请求都自动切换IP
- 普通模式打标记
普通模式下，希望多个HTTP请求保证代理IP相同，可以给多个请求的代理协议打上相同的标记，并标记这个代理IP的存活时间（不主动设置存活时间则默认为10秒）
- 固定时长多通道模式
服务器定时切换IP，可同时使用多个通道发起请求，即可以同时使用多个IP
## 前置知识
在 go 语言中，通常使用 http.Client 进行 http/s 代理的设定与请求的发送，使用 http.NewRequest 进行请求的构建。
### Proxy Url Scheme
由协议、用户名、密码、域名、端口几部分组成
例如 http 协议的代理 url
```
http://[user:password@]hostname:port
```
## 使用 GO 接入
**以下内容假设读者具备基本的 Go 语言编程能力和对网络协议具有一定的了解。**
### 生成 url
普通模式
```go
link := fmt.Sprintf("http://%s:%s@%s", authKey, password, proxyServer)
proxyURL, _ := url.Parse(link)
```
普通模式打标记
```go
link := fmt.Sprintf("http://%s:%s:%s:%d@%s", authKey, password, "channel-1", 20, proxyServer)
proxyURL, _ := url.Parse(link)
```
固定时长多通道模式
```go
link := fmt.Sprintf("http://%s:%s:%s@%s", authKey, password, "channel-1", proxyServer)
proxyURL, _ := url.Parse(link)
```
### 构建 Client
后续将使用该 client 发起 request
```go
client := http.Client{
Transport: &http.Transport{
Proxy: http.ProxyURL(proxyURL),
},
}
```
### 构建 HTTP/s GET 请求
以 https://api.ipify.org 为例。
因为已确认参数合法，因此构建不会发生错误，无需处理错误。
```
request, _ := http.NewRequest("GET", "https://test.ipw.cn", nil)
// 如果上面目标站不可用，请使用ip.sb、ipinfo.io、ip-api.com、64.ipcheck.ing
```
### 执行已构建的 HTTP/s 请求
```go
response, err := client.Do(request)
if err != nil {
panic(err)
}
defer response.Body.Close()
```
### 读取响应实体
response.Body 是 io.Reader 类型，需要手动进行读取
```go
body, err := io.ReadAll(response.Body)
if err != nil {
panic(err)
}
fmt.Println(string(body))
```
## 示例代码
```go
package main
import (
"fmt"
"io"
"log"
"net/http"
"net/url"
)
const (
authKey = ""
password = ""
server = ""
channel = "channel-1"
)
func main() {
var link string
if channel == "" {
link = fmt.Sprintf("http://%s:%s@%s", authKey, password, server)
} else {
link = fmt.Sprintf("http://%s:%s:%s@%s", authKey, password, channel, server)
}
proxyURL, _ := url.Parse(link)
client := http.Client{
Transport: &http.Transport{
Proxy: http.ProxyURL(proxyURL),
},
}
request, _ := http.NewRequest("GET", "https://test.ipw.cn", nil)
// 如果上面目标站不可用，请使用ip.sb、ipinfo.io、ip-api.com、64.ipcheck.ing
response, err := client.Do(request)
if err != nil {
panic(err)
}
defer response.Body.Close()
body, err := io.ReadAll(response.Body)
if err != nil {
panic(err)
}
log.Println("response body", string(body))
}
```
C#语言代码示例
```c#
string targetUrl = "https://test.ipw.cn";
// 如果上面目标站不可用，请使用ip.sb、ipinfo.io、ip-api.com、64.ipcheck.ing
string proxyIp = "您的代理IP";
string proxyPort = "端口号";
string authKey = "请改成您的Key";
string password = "请改成您的AuthPwd";
WebProxy proxy = new WebProxy(string.Format("{0}:{1}", proxyIp, proxyPort), true);
proxy.Credentials = new NetworkCredential(authKey, password);
ServicePointManager.Expect100Continue = false;
var request = WebRequest.Create(targetUrl) as HttpWebRequest;
request.AllowAutoRedirect = true;
request.KeepAlive = true;
request.Method = "GET";
request.Proxy = proxy;
request.Timeout = 10000;
request.ServicePoint.ConnectionLimit = 16;
using (var resp = request.GetResponse() as HttpWebResponse)
using (var reader = new StreamReader(resp.GetResponseStream(), Encoding.UTF8)){
string htmlStr = reader.ReadToEnd();
}
```
Shell语言代码示例
```shell
#!/bin/bash
targetURL="https://test.ipw.cn"
# 如果上面目标站不可用，请使用ip.sb、ipinfo.io、ip-api.com、64.ipcheck.ing
proxyAddr="您的代理IP:端口号"
authKey="请改成您的Key"
password="请改成您的AuthPwd"
curl -x ${authKey}:${password}@${proxyAddr} ${targetURL} -vvvv
```
Java语言代码示例
## Java HttpURLConnection
```java
package com.qgproxy;
import java.io.ByteArrayOutputStream;
import java.io.InputStream;
import java.net.Authenticator;
import java.net.HttpURLConnection;
import java.net.InetSocketAddress;
import java.net.PasswordAuthentication;
import java.net.Proxy;
import java.net.URL;
class QGProxyAuthenticator extends Authenticator {
private String user, password;
public QGProxyAuthenticator(String user, String password) {
this.user = user;
this.password = password;
}
protected PasswordAuthentication getPasswordAuthentication() {
return new PasswordAuthentication(user, password.toCharArray());
}
}
class QGProxy {
public static void main(String args[]) {
// 如果您的本地jdk版本在Java 8 Update 111以上，需要增加以下代码
// System.setProperty("jdk.http.auth.tunneling.disabledSchemes", "false");
// System.setProperty("jdk.http.auth.proxying.disabledSchemes", "false");
String targetUrl = "https://test.ipw.cn";
// 如果上面目标站不可用，请使用ip.sb、ipinfo.io、ip-api.com、64.ipcheck.ing
String proxyIp = "您的代理IP";
int proxyPort = 端口号;
String authKey = "请改成您的Key";
String password = "请改成您的AuthPwd";
try {
URL url = new URL(targetUrl);
Authenticator.setDefault(new QGProxyAuthenticator(authKey, password));
InetSocketAddress socketAddress = new InetSocketAddress(proxyIp, proxyPort);
Proxy proxy = new Proxy(Proxy.Type.HTTP, socketAddress);
HttpURLConnection connection = (HttpURLConnection) url.openConnection(proxy);
byte[] response = readStream(connection.getInputStream());
System.out.println(new String(response));
} catch (Exception e) {
System.out.println(e.getLocalizedMessage());
}
}
public static byte[] readStream(InputStream inStream) throws Exception {
ByteArrayOutputStream outSteam = new ByteArrayOutputStream();
byte[] buffer = new byte[1024];
int len = -1;
while ((len = inStream.read(buffer)) != -1) {
outSteam.write(buffer, 0, len);
}
outSteam.close();
inStream.close();
return outSteam.toByteArray();
}
}
```
## Java okhttp(4.10.0版本以上)
```java
package com.qgproxy;
import okhttp3.*;
import java.io.IOException;
import java.net.InetSocketAddress;
import java.net.Proxy;
import java.util.concurrent.TimeUnit;
public class QGProxy {
final static String proxyIp = "您的代理IP";
final static Integer proxyPort = 端口号;
final static String authKey = "请改成您的Key";
final static String password = "请改成您的AuthPwd";
public Response request() throws IOException {
Proxy proxy = new Proxy(Proxy.Type.HTTP, new InetSocketAddress(proxyIp, proxyPort));
OkHttpClient client = new OkHttpClient.Builder()
.proxy(proxy)
.proxyAuthenticator((route, response) -> {
String credential = Credentials.basic(authKey, password);
return response.request().newBuilder().header("Proxy-Authorization", credential).build();
}).
build();
Request request = new Request.Builder().url("https://api.ipify.org").get().build();
return client.newCall(request).execute();
}
public static void main(String[] args) {
QGProxy qgProxy = new QGProxy();
try {
Response resp = qgProxy.request();
System.out.println(resp.body().string());
} catch (Exception e) {
System.out.printf("failed to proxy: %s\n", e.getMessage());
}
}
}
```
## Java jsoup
```java
package com.qgproxy;
import org.jsoup.Jsoup;
import org.jsoup.nodes.Document;
import java.io.IOException;
import java.net.Authenticator;
import java.net.InetSocketAddress;
import java.net.PasswordAuthentication;
import java.net.Proxy;
public class QGProxy {
final static String proxyIp = "您的代理IP";
final static Integer proxyPort = 端口号;
final static String authKey = "请改成您的Key";
final static String password = "请改成您的AuthPwd";
public static void main(String[] args) throws Exception {
String targetUrl = "https://test.ipw.cn";
// 如果上面目标站不可用，请使用ip.sb、ipinfo.io、ip-api.com、64.ipcheck.ing
Authenticator.setDefault(new Authenticator() {
public PasswordAuthentication getPasswordAuthentication() {
return new PasswordAuthentication(authKey, password.toCharArray());
}
});
// 如果您的本地jdk版本在Java 8 Update 111以上，需要增加以下代码
// System.setProperty("jdk.http.auth.tunneling.disabledSchemes", "false");
// System.setProperty("jdk.http.auth.proxying.disabledSchemes", "false");
Proxy proxy = new Proxy(Proxy.Type.HTTP, new InetSocketAddress(proxyIp, proxyPort));
try {
Document doc = Jsoup.connect(targetUrl).ignoreContentType(true).timeout(10000).proxy(proxy).get();
if (doc != null) {
System.out.println(doc.body().html());
}
} catch (IOException e) {
e.printStackTrace();
}
}
}
```
## Java HttpClient 3.X
```java
package com.qgproxy;
import java.io.IOException;
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;
public class QGProxy {
public static void main(String[] args) {
String targetUrl = "https://test.ipw.cn"; // 访问的目标站点
// 如果上面目标站不可用，请使用ip.sb、ipinfo.io、ip-api.com、64.ipcheck.ing
String proxyIp = "您的代理IP";
int proxyPort = 端口号;
String authKey = "请改成您的Key";
String password = "请改成您的AuthPwd";
try {
HttpHost proxy = new HttpHost(proxyIp, proxyPort, "http");
HttpHost target = new HttpHost(targetUrl, 80);
// 设置认证
CredentialsProvider provider = new BasicCredentialsProvider();
provider.setCredentials(new AuthScope(proxy), new UsernamePasswordCredentials(authKey, password));
CloseableHttpClient httpClient = HttpClients.custom().setDefaultCredentialsProvider(provider).build();
RequestConfig config = RequestConfig.custom().setProxy(proxy).build();
HttpGet httpGet = new HttpGet("/ip");
httpGet.setConfig(config);
CloseableHttpResponse resp = null;
resp = httpClient.execute(target, httpGet);
if (resp.getStatusLine().getStatusCode() == 200) {
System.out.println("OK");
}
System.out.println(resp.getStatusLine());
} catch (IOException e) {
e.printStackTrace();
}
}
}
```
## Java HttpClient 4.X
```java
package com.qgproxy
import java.io.BufferedReader;
import java.io.InputStreamReader;
import java.io.IOException;
import java.net.URI;
import java.util.Arrays;
import java.util.ArrayList;
import java.util.HashSet;
import java.util.List;
import java.util.Set;
import org.apache.http.Header;
import org.apache.http.HeaderElement;
import org.apache.http.HttpHost;
import org.apache.http.auth.AuthScope;
import org.apache.http.auth.UsernamePasswordCredentials;
import org.apache.http.client.AuthCache;
import org.apache.http.client.CredentialsProvider;
import org.apache.http.client.HttpRequestRetryHandler;
import org.apache.http.client.config.RequestConfig;
import org.apache.http.client.config.AuthSchemes;
import org.apache.http.client.entity.GzipDecompressingEntity;
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.client.protocol.HttpClientContext;
import org.apache.http.config.Registry;
import org.apache.http.config.RegistryBuilder;
import org.apache.http.conn.socket.ConnectionSocketFactory;
import org.apache.http.conn.socket.LayeredConnectionSocketFactory;
import org.apache.http.conn.socket.PlainConnectionSocketFactory;
import org.apache.http.conn.ssl.SSLConnectionSocketFactory;
import org.apache.http.impl.auth.BasicScheme;
import org.apache.http.impl.client.BasicAuthCache;
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.impl.client.ProxyAuthenticationStrategy;
import org.apache.http.impl.conn.PoolingHttpClientConnectionManager;
import org.apache.http.message.BasicHeader;
import org.apache.http.message.BasicNameValuePair;
import org.apache.http.NameValuePair;
import org.apache.http.util.EntityUtils;
public class QGProxy {
final static String proxyHost = "您的代理IP";
final static Integer proxyPort = 端口号;
final static String proxyUser = "请改成您的key";
final static String proxyPass = "请改成您的password";
private static PoolingHttpClientConnectionManager cm = null;
private static HttpRequestRetryHandler httpRequestRetryHandler = null;
private static HttpHost proxy = null;
private static CredentialsProvider credsProvider = null;
private static RequestConfig reqConfig = null;
static {
ConnectionSocketFactory plainsf = PlainConnectionSocketFactory.getSocketFactory();
LayeredConnectionSocketFactory sslsf = SSLConnectionSocketFactory.getSocketFactory();
Registry registry = RegistryBuilder.create()
.register("http", plainsf)
.register("https", sslsf)
.build();
cm = new PoolingHttpClientConnectionManager(registry);
cm.setMaxTotal(10);
cm.setDefaultMaxPerRoute(5);
proxy = new HttpHost(proxyHost, proxyPort, "http");
credsProvider = new BasicCredentialsProvider();
credsProvider.setCredentials(AuthScope.ANY, new UsernamePasswordCredentials(proxyUser, proxyPass));
reqConfig = RequestConfig.custom()
.setExpectContinueEnabled(false)
.setProxy(new HttpHost(proxyHost, proxyPort))
.build();
}
public static void doRequest(HttpRequestBase httpReq) {
CloseableHttpResponse httpResp = null;
try {
httpReq.setConfig(reqConfig);
CloseableHttpClient httpClient = HttpClients.custom()
.setConnectionManager(cm)
.setDefaultCredentialsProvider(credsProvider)
.build();
AuthCache authCache = new BasicAuthCache();
authCache.put(proxy, new BasicScheme());
authCache.put(proxy, new BasicScheme(ChallengeState.PROXY));
HttpClientContext localContext = HttpClientContext.create();
localContext.setAuthCache(authCache);
httpResp = httpClient.execute(httpReq, localContext);
System.out.println(httpResp.getStatusLine().getStatusCode(););
BufferedReader rd = new BufferedReader(new InputStreamReader(httpResp.getEntity().getContent()));
String line = "";
while((line = rd.readLine()) != null) {
System.out.println(line);
}
} catch (Exception e) {
e.printStackTrace();
} finally {
try {
if (httpResp != null) {
httpResp.close();
}
} catch (IOException e) {
e.printStackTrace();
}
}
}
public static void main(String[] args) {
String targetUrl = "https://api.ipify.org";
try {
HttpGet httpGet = new HttpGet(targetUrl);
doRequest(httpGet);
} catch (Exception e) {
e.printStackTrace();
}
}
}
```
