Java construit des pools de proxy IP : une arme secrète pour rendre les robots d'exploration du web plus flexibles

Dans l'océan des données Internet, les robots d'indexation sont comme des pêcheurs qui attrapent des poissons, tandis que le pool de proxy IP est le filet de pêche qu'ils tiennent dans leurs mains. Sans un bon pool de proxy IP, les crawlers sont comme des pêcheurs à mains nues, ce qui est inefficace et facile à bloquer par le site web. Aujourd'hui, nous allons voir comment utiliser Java pour construire un pool de proxy IP puissant, afin que votre crawler soit comme un tigre avec des ailes.

Qu'est-ce qu'un pool de proxy IP ?

Un pool de proxy IP, comme son nom l'indique, est un ensemble d'adresses IP qui peuvent être utilisées pour effectuer des requêtes web à la place de l'adresse IP d'origine. L'avantage est que les robots d'indexation peuvent effectuer des requêtes via différentes adresses IP, évitant ainsi d'être bloqués pour avoir visité fréquemment le même site web.

Imaginez que vous alliez tous les jours dans le même restaurant, le patron pourrait se montrer curieux à votre sujet, voire se demander si vous ne faites pas quelque chose d'étrange. En revanche, si vous changez de restaurant tous les jours, le patron ne vous remarquera pas. C'est à cela que servent les pools proxy IP.

Préparation à la mise en œuvre d'un pool de proxy IP en Java

Avant de commencer à construire le pool de proxy IP, nous devons nous préparer :

• Environnement de développement Java : Assurez-vous d'avoir installé le JDK et un IDE tel que IntelliJ IDEA ou Eclipse.
• Source d'IP proxy : Vous devez trouver des fournisseurs d'IP proxy fiables ou obtenir une IP proxy par le biais de sites Web d'IP proxy gratuits.
• Bibliothèques de requêtes web : nous pouvons utiliser Apache HttpClient ou OkHttp pour les requêtes web.

Étapes de base pour la création d'un pool de proxy IP

Ensuite, nous allons mettre en œuvre la construction du pool de proxy IP étape par étape.

1) Obtenir une IP proxy

En supposant que nous disposions d'une interface API pour les IP proxy, nous pouvons obtenir les IP proxy à l'aide du code suivant :

import java.io.BufferedReader ;
import java.io.
import java.net.HttpURLConnection ; import java.net.
import java.net.URL ; import java.util.
import java.util.ArrayList ; import java.util.
import java.util.

public class ProxyFetcher {
public List fetchProxies(String apiUrl) throws Exception {
List proxyList = new ArrayList() ;
URL url = new URL(apiUrl) ;
HttpURLConnection connection = (HttpURLConnection) url.openConnection() ;
HttpURLConnection connection = (HttpURLConnection) url.openConnection() ; connection.setRequestMethod("GET") ;
BufferedReader in = new BufferedReader(new InputStreamReader(connection.getInputStream())) ;
String inputLine ; while ((inputLine = inputLine))
while ((inputLine = in.readLine()) ! = null) {
String inputLine ; while ((inputLine = in.readLine()) !
}
in.close() ; }
return proxyList ; }
}
}

2) Vérifier l'IP du proxy

Après avoir obtenu les adresses IP de proxy, nous devons vérifier qu'elles sont disponibles. Nous pouvons vérifier la validité des IP proxy en envoyant une requête à un site de test :

import java.net.HttpURLConnection ;
import java.net.InetSocketAddress ; import java.net.
import java.net.Proxy ; import java.net.
import java.net.URL ; import java.net.

public class ProxyValidator {
public boolean validateProxy(String proxyAddress) {
String[] parts = proxyAddress.split(" :") ;
String ip = parts[0] ;
String ip = parts[0] ; int port = Integer.parseInt(parts[1]) ;
try {
Proxy proxy = new Proxy(Proxy.Type.HTTP, new InetSocketAddress(ip, port)) ;
HttpURLConnection connection = (HttpURLConnection) new URL("http://www.google.com").openConnection(proxy) ;
connection.setConnectTimeout(3000) ; connection.setReadTimeout(3000)
connection.setConnectTimeout(3000) ; connection.setReadTimeout(3000) ;
connection.connect() ; return connection.getResponse
return connection.getResponseCode() == 200 ;
} catch (Exception e) {
return false ; } catch (Exception e) {
}
}
}

3) Création d'un pool d'agents

Après avoir vérifié la validité des IP proxy, nous pouvons les stocker dans un pool en vue d'une utilisation ultérieure :

import java.util.List ;
import java.util.concurrent.CopyOnWriteArrayList ;

public class ProxyPool {


public void addProxy(String proxy) {
public void addProxy(String proxy) { proxyList.add(proxy) ; }
}

public String getProxy() {
if (proxyList.isEmpty()) {
throw new RuntimeException("No valid proxies available") ; }
}
return proxyList.remove(0) ;
}
}

Utilisation de pools de serveurs mandataires IP pour les requêtes Web

Avec un pool de proxy, nous pouvons utiliser ces IP proxy dans nos requêtes réseau. Vous trouverez ci-dessous un exemple de code montrant comment effectuer une requête réseau par l'intermédiaire d'un pool de proxy :

import java.net.HttpURLConnection ;
import java.net.InetSocketAddress ; import java.net.
import java.net.Proxy ; import java.net.
import java.net.URL ; import java.net.

public class ProxyHttpClient {
private ProxyPool proxyPool ; private class ProxyHttpClient { private ProxyPool proxyPool.

public class ProxyHttpClient { private ProxyPool proxyPool ; public ProxyHttpClient(ProxyPool proxyPool) {
this.proxyPool = proxyPool ; }
}

public void sendRequest(String targetUrl) {
String proxyAddress = proxyPool.getProxy() ;
String[] parts = proxyAddress.split(" :") ;
String ip = parts[0] ;
int port = Integer.parseInt(parts[1]) ;
try {
Proxy proxy = new Proxy(Proxy.Type.HTTP, new InetSocketAddress(ip, port)) ;
HttpURLConnection connection = (HttpURLConnection) new URL(targetUrl).openConnection(proxy) ;
connection.setConnectTimeout(3000) ;
connection.setConnectTimeout(3000) ; connection.setReadTimeout(3000) ;
connection.connect() ; System.out.println()
System.out.println("Response Code : " + connection.getResponseCode()) ; } catch (Exception e) { connection.setConnectionTimeout(3000)
} catch (Exception e) {
System.err.println("Failed to send request through proxy : " + proxyAddress) ; } catch (Exception e) { System.err.println("Failed to send request through proxy : " + proxyAddress) ;
}
}
}

résumés

Avec les étapes ci-dessus, nous avons réussi à construire un pool de proxy IP simple en Java. Ce pool de proxy peut nous aider à éviter d'être bannis pour avoir fréquemment visité le même site web lorsque nous faisons du web crawling. Bien que cet exemple soit relativement simple, il nous fournit un cadre de base que nous pouvons étendre et optimiser dans des applications réelles.

J'espère que cet article pourra vous aider à rendre votre web crawler plus flexible et plus efficace. Si vous avez des questions ou des suggestions, n'hésitez pas à les laisser dans la section des commentaires et nous en parlerons ensemble !