使用动态代理池做数据采集的时候，要注意哪些问题?
数据采集，信息洪流中的“富矿开采”，对于许多企业和开发者来说，通过动态代理池采集数据已成为实现多样化数据流的基础。然而，这条数据之路并非一路平坦，我们需要深入了解动用动态代理池时的诸多注意事项。
#### 1. 选择优质的代理服务
首先，选择优质的代理服务提供商至关重要。代理IP的质量直接决定了数据采集的效率和效果。
- **高可用性**：确保代理池内的IP可用率足够高，避免因为失效IP导致数据采集中断。青果网络提供的代理服务可用率高达99.9%，是您坚实的后盾。
- **覆盖广泛**：采集不同区域的数据时，需要代理服务能提供私网覆盖全球的IP范围，以保证数据收集的各国、各地区适用性。
#### 2. 管理IP切换的频率
动态代理池的本质就是频繁更换IP，这有助于防止被目标网站识别为异常请求。
- **合理设定切换间隔**：IP切换频率需要与目标网站的访问限制相匹配，太频繁可能导致目标站点响应变慢或请求失败。
- **平衡频率与有效性**：既要保护IP不被封禁，也要确保切换频率不会过于频繁影响数据采集的连续性。
#### 3. 监控代理池运行状态
动态代理池的维护需要实时监控其使用状态，以保证高成功率的运行。
- **故障排查**：实时检测代理池中的IP是否运行正常，及时排查异常情况，例如IP被封或响应速度过慢。
- **调整策略**：通过采集过程中的反馈（如响应时间、成功率），动态调整使用的IP池策略，以提高数据采集的效率。
#### 4. 合法合规的数据采集
在使用代理IP进行数据采集时，合法合规是每位采集者必须时刻牢记的准则。
- **遵守当地法规**：不同国家和地区的数据使用政策差异显著，确保数据采集项目符合相关法律规定，防止触碰法律红线。
- **尊重网站协议**：使用时尽量遵循目标网站的robots.txt文件与用户协议，避免过载目标网站服务器和引起法律问题。
在复杂多变的数据采集中，青果网络提供了优质的动态代理解决方案，助您以最高的安全性与效能获得所需数据，采用企业分池技术，业务成功率高于竞品30%。
### 总结
在利用动态代理池进行数据采集过程中，遵循可靠性、有规有序地操作是提升采集项目效率的金钥匙。希望本文所提供的详细建议，能为您的数据采集带来更为流畅和成功的体验。
欢迎随时与青果网络联络，我们致力于成为您可靠、持久的数据采集助手。
优质的动态代理一定是速度快的代理吗？
在互联网蓬勃发展的时代，动态代理已经成为众多应用场景下的重要工具。关于优质动态代理的衡量标准，不少人将“速度”视为首要标准。但事实上，速度仅是名列其中的一项。本文将详细分析优质动态代理的多重品质，揭示速度背后的更多考量。
#### 动态代理的本质
动态代理是指在一定时间或请求间隔内，自动更换IP地址的代理技术。它能够通过频繁变换IP来增强客户端请求的多样性和分布性。
- **速度**：自然是影响用户体验的重要因素之一。高速度意味着响应时间短，更快的页面加载，更流畅的数据传输。
- **IP更换频率**：与速度相得益彰，高频率的IP更替是动态代理的核心特性，其能够大幅减少被目标服务器频次检测的风险。
#### 优质动态代理的多重标准
1. **稳定性**：一个优质的动态代理，必须首先确保连接的稳定。即便速度再快，如果频繁掉线或连接不稳定，同样无法满足业务需要。
2. **覆盖范围**：拥有广泛的IP资源覆盖，特别是在需要全球数据访问时，优质的动态代理应该能够提供多地域、多国家的IP选择。
3. **数据安全**：保障数据传输安全性。而且不止传输快，数据传输更安全。
4. **业务成功率**：青果网络的经验显示，优质动态代理应该达到高业务成功率。青果的动态代理提供的业务成功率高于竞品30%，说明了可靠的操作性。
#### 速度不是唯一的标准
- **负载能力**：优质动态代理在面对高并发请求时，需具备良好的负载能力。一个速度快但不能承载并发的代理，很可能在实际应用中失去优势。
- **服务质量**：全天候的稳定服务，技术支持与故障排除，也是评判优质动态代理的重要标准之一。
### 真实场景中的选择
在明确了优质动态代理的多重标准后，如何选择适合自己的代理更显得至关重要：
- 针对需频繁更换IP且对安全性要求高的任务，优选支持HTTPS/HTTP协议的代理资源。
- 若需在时效性上占优势，业界顶尖如青果网络，凭借600+万IP库存，提供快速且稳定的连接。
### 结语
速度固然是优质动态代理的魅力所在，但我们不能只看表象而忽略其背后的宽泛属性。衡量动态代理的优质与否，应当从稳定性、安全性、IP覆盖与业务成功等全面出发。综合考虑这些要素，方能在数字竞争的浪潮中寻得长青之道。
期待本文能为您在选择动态代理时，提供启迪与帮助。
为什么要选择优质的短效IP池来进行抓取？
在数据抓取领域，代理IP池的选择对于任务的效率和安全性至关重要。优质的短效IP池因其独特的优势，在数据采集、市场分析和网络安全等多个领域中展现出强大的功能。本文将探讨选择优质短效IP池进行数据抓取的重要性。
## 短效IP池的优势
### **1. 提高代理IP切换频率**
短效IP池的本质之一是其高频的IP切换特性。这种动态频繁的优势在于：
- **降低IP检测风险**：频繁的IP切换让目标网站很难进行有效的IP拉黑或跟踪，减少了采集被阻止的概率。
- **多个请求的分散减负**：尤其在进行大量短期请求时，高切换频次极大程度上减轻了单个IP的负担，提高访问成功率。
### **2. 增强数据采集效率**
短效IP池在短期内可提供丰富的IP资源支持，是大规模数据采集的极佳选择：
- **适应临时高峰需求**：适合突发的高并发请求，按需分配IP资源，避免因流量过大导致的不可用。
- **灵活应对反爬策略**：很多目标网站设计了复杂的反爬机制，快速切换IP能有效突破此类限制。
### **3. 优化市场活动效果**
在开展市场活动和在线推广时，短效IP池能够提供快速的方案支持：
- **广告效果分析**：通过更换不同的IP检测广告在不同地区或人群中的曝光效果。
- **多点营销策略**：短期内执行多点位市场操作，灵活调整策略应对各种市场环境变化。
### **4. 提高用户访问体验**
对某些依赖于复杂访问路径的应用，短效IP池让用户访问体验更为流畅：
- **减少用户刷新等待**：通过代理池快速响应用户请求，降低网页刷新等待时间。
- **提升访问速度**：尤其在远程或者国际访问时，有效减少网络延迟。青果网络的短效IP池服务，IP覆盖国内200多个城市，采用三大运营商宽带资源，自研代理服务技术，延迟＜100ms，支持HTTP/HTTPS/SOCKS5三大协议，使用方式灵活，赋能企业大数据转型。
**总结**
选择优质的短效IP池对于数据抓取任务至关重要。它不仅能够提高代理IP切换频率，降低被封禁的风险，还能增强数据采集效率，优化市场活动效果，并提高用户访问体验。青果网络作为国内领先的企业级代理IP服务商，以其全球覆盖、高可用率和强大的技术支持，为用户提供了优质的短效IP池服务，是数据抓取任务的理想选择。
HTTP代理IP是什么？使用HTTP代理有什么好处？
在互联网技术变得日趋复杂的今天，HTTP代理IP作为一种基础而又重要的网络技术，为各类互联网应用提供了多重便利。本文将详细解析HTTP代理IP的概念，以及使用它所能带来的多重好处。
#### 什么是HTTP代理IP？
简单来讲，HTTP代理IP是一种充当用户与互联网之间中间节点的技术。它主要用于处理HTTP协议的请求和响应。
- **技术原理**：HTTP代理IP接收到用户的请求后会转发到目标服务器，再将获取到的响应返回给用户。这样，用户对外展示的IP地址就变成了代理IP的地址。
- **类型多样**：HTTP代理可以是透明代理、匿名代理，也可以是更高安全性的高匿名代理。根据应用场景的不同，可以选择适合的代理类型。
#### 使用HTTP代理的好处
商用价值和个人用途都推动了HTTP代理的广泛使用。以下是它的几个主要好处：
- **数据安全保护**：通过代理IP做数据采集的时候，能为用户提供了额外的保护层，保障使用者的数据安全。
- **访问受限内容**：某些内容因为地域限制可能无法访问，HTTP代理可以提供在不同国家的IP地址，使用户能够突破地域限制，真正做到全球视角。
- **提升访问速度**：一些HTTP代理提供缓存功能，可以在请求中为常用内容直接返回缓存结果，显著缩短加载时间，提高访问速度。
- **负载均衡与安全检测**：许多企业使用HTTP代理来均衡负载，把请求分散到多个服务器，降低单点故障风险。同时，代理还可以监测流量，辅助企业进行安全检测。
#### HTTP代理的具体应用场景
在实际应用中，HTTP代理被广泛应用于不同的领域，涵盖从个人上网体验到企业级应用解决方案。
- **数据采集与分析**：企业依赖HTTP代理进行数据采集，尤其是在分析市场趋势和用户行为时，它为抓取提供了稳定而高效的支持。青果网络作为国内领先的企业级代理IP服务商，提供优质的HTTP代理服务，达到业务成功率高于竞品30%的表现。
- **测试与开发环境**：开发人员利用代理进行各种环境的模拟测试，可以快速调试和优化应用程序。
### 结语
HTTP代理IP在现代互联网中的角色，可谓既真实又无形。它不仅仅是一个技术工具，更象征着用户对安全、高效、灵活网络体验的追求。无论是从个人角度还是商业角度来看，充分利用HTTP代理的优势，始终是迈向数字未来的一项睿智选择。
在数据抓取的时候，短效IP比长效IP有哪些优势？
在数据抓取领域，代理IP的选择对于任务的成功率和效率至关重要。短效IP和长效IP各有其特点和适用场景，但在数据抓取过程中，短效IP因其独特的优势而受到青睐。本文将和大家一起探讨短效IP在数据抓取中相比长效IP的优势。
### 短效IP的定义与特点
短效IP是指有效期较短的代理IP，通常从几分钟到几小时不等。这种IP的特点是频繁更换，为用户提供了较高的匿名性和灵活性。
### **数据抓取中短效IP的优势**
**1. 提高业务成功率**
在数据抓取过程中，频繁更换IP地址可以降低被目标网站识别为爬虫的风险。短效IP由于其生命周期短，可以更有效地模拟正常用户行为，从而提高业务成功率。青果网络提供的短效IP服务，通过业务分池技术，确保业务成功率平均高于竞品30%。
**2. 降低封禁风险**
长效IP由于长时间使用同一IP地址，容易被目标网站识别并封禁。相比之下，短效IP由于其不稳定性，更难被追踪和封锁，从而降低了封禁风险。
**3. 提升数据采集效率**
在进行大规模数据采集时，短效IP可以快速适应网络环境的变化，尤其是在面对动态网站防护系统时，短效IP能够提供更稳定的数据流。
**4. 保护用户隐私**
短效IP由于其匿名性更高，可以更好地保护用户隐私，尤其是在涉及敏感数据抓取时，短效IP提供了额外的安全层。
**5. 灵活性和可扩展性**
短效IP服务可以根据用户的需求快速扩展或缩减，适应不同的业务需求。这种灵活性使得短效IP在处理突发的大规模数据采集任务时更为有效。
### **青果网络的短效IP服务**
青果网络是国内领先的企业级代理IP服务商，其短效IP节点覆盖全球200多个城市，采用三大运营商宽带资源，构建日更600+万的纯净IP资源池。采用业务分池技术，业务成功率平均高于竞品30%。
**技术细节**
在实际应用中，短效IP的更换可以通过编程实现自动化管理。以下是一个简单的Python代码示例，展示如何使用短效IP进行数据抓取：
```python
import requests
import random
# 假设这是你的短效代理IP列表
short_lived_proxies = [
'http://IP1:端口',
'http://IP2:端口',
# 更多短效IP...
]
# 随机选择一个代理IP
proxy = random.choice(short_lived_proxies)
# 发送请求
response = requests.get('目标URL', proxies={'http': proxy, 'https': proxy})
# 检查响应状态码
if response.status_code == 200:
print("数据抓取成功")
else:
print("数据抓取失败")
```
**总结**
在数据抓取的过程中，短效IP因其高安全性、低封禁风险和灵活性，相比长效IP展现出了明显的优势。青果网络的短效IP服务，以其高业务成功率和全球覆盖的优势，为数据抓取任务提供了强有力的支持。选择合适的代理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();
}
}
}
```
