|
|
Publié sur 30/11/2014 16:56:56
|
|
|
|
[mw_shl_code=java,true]/**
* @author Jack.Wang
*
*/
importer java.io.BufferedReader ;
importer java.io.InputStreamReader ;
importez java.net.URL ;
import java.util.ArrayList ;
importer java.util.HashMap ;
importer java.util.HashSet ;
importer java.util.LinkedHashSet ;
import java.util.regex.Matcher ;
importer java.util.regex.Pattern ;
Recherche de robots d’indexation web
Public Class SearchCrawler implémente Runnable {
/*
* disallowListCache cache robot n’autorise pas les URL recherchées. Le protocole Robot place un fichier robots.txt dans le répertoire racine du site web,
* Spécifie quelles pages du site sont consultables pour une recherche restreinte.
* Le programme de recherche doit sauter ces zones pendant la recherche, voici un exemple de robots.txt :
* # robots.txt pour http://somehost.com/ User-agent :
* Refuser : /cgi-bin/
* Interautoriser : /registration # Interpermettre les robots sur la page d’inscription
* Refuser : /login
*/
private HashMap<String, ArrayList<String>> disallowListCache = new HashMap<String, <String>ArrayList>() ;
<String> ArrayList errorList = new ArrayList<String>() ; Message d’erreur
<String> Résultat ArrayList = new <String>ArrayList() ; Résultats recherchés
String startUrl ; Un point de départ pour commencer votre recherche
int maxUrl ; Le nombre maximal d’URL traitées
Recherche de chaînesChaîne ; Sources à rechercher
booléenSensible à la casse = faux ; Savoir s’il faut ou non être sensible à la casse
limitHôte booléen = faux ; Savoir s’il faut chercher dans un hôte restreint
public SearchCrawler(String startUrl, int maxUrl, String searchString) {
this.startUrl = startUrl ;
this.maxUrl = maxUrl ;
this.searchString = searchString ;
}
public ArrayList<String> getResult() {
résultat de retour ;
}
public void run() { // Lancer le fil de recherche
crawl(startUrl, maxUrl, searchString, limitHost, case sensitive) ;
}
Détecter la mise en forme d’URL
private URL verifyUrl(String url) {
Seules les URL HTTP sont traitées.
if ( !url.url.toLowerCase().startsWith(« http:// »))
retourner nul ;
URL vérifiéeUrl = null ;
try {
verifiedUrl = nouvelle URL(URL) ;
} catch (Exception e) {
retourner nul ;
}
return verifiedUrl ;
}
Détecte si le robot permet d’accéder à l’URL donnée.
private boolean isRobotAllowed(URL urlToCheck) {
Chaîne hôte = urlToCheck.getHost().toLowerCase() ; Prends l’hôte qui donne le RUL
System.out.println(« host="+host) ;
Obtenez un cache d’URL que votre hébergeur ne permet pas de rechercher
ArrayList<String> disallowList = disallowListCache.get(host) ;
Si vous n’avez pas déjà de cache, téléchargez-le et mettez-le en cache.
if (disallowList == null) {
disallowList = nouvelle <String>ArrayList() ;
try {
URL robotsFileUrl = nouvelle URL (« http:// » + hôte + « /robots.txt ») ;
Lecteur Tamponné = nouveau LecteurDeTamponné (
le nouveau InputStreamReader(robotsFileUrl.openStream()) ;
Lisez le fichier robot pour créer une liste de chemins qui ne sont pas autorisés à accéder.
Ligne de cordes ;
tandis que ((ligne = lecteur.readLine()) != null) {
if (line.indexOf(« Disallow : ») == 0) {// Contienne-t-elle « Disallow » :
String disallowPath = line.substring(« Disallow : »
.longueur()) ; Obtenez le chemin vers l’accès interdit
Vérifiez les annotations.
int commentIndex = disallowPath.indexOf(« # ») ;
if (commentIndex != -1) {
disallowPath = disallowPath.sous-string(0,
commentaireIndex) ; Supprimer le commentaire
}
disallowPath = disallowPath.trim() ;
disallowList.add(disallowPath) ;
}
}
Des chemins de cache auxquels cet hôte n’est pas autorisé à accéder.
disallowListCache.put (host, disallowList) ;
} catch (Exception e) {
retour fidèle ; Il n’y a pas de fichiers robots.txt dans le répertoire racine du site, et il retourne true
}
}
Chaîne de fichiers = urlToCheck.getFile() ;
System.out.println (« File getFile()="+file) ;
pour (int i = 0 ; i < disallist.size() ; i++) {
Chaîne disallow = disallowList.get(i) ;
if (file.startsWith(disallow)) {
return false ;
}
}
retour fidèle ;
}
private String downloadPage(URL pageUrl) {
try {
Connexion ouverte vers l’URL pour la lecture.
Lecteur Lecteur Tamponné = nouveau LecteurLecteur Tamponné (nouveau LecteurStreamInput(
pageUrl.openStream()) ;
Lisez la page dans le tampon.
Ligne de cordes ;
StringBuffer pageBuffer = nouveau StringBuffer() ;
tandis que ((ligne = lecteur.readLine()) != null) {
pageBuffer.append(ligne) ;
}
return pageBuffer.toString() ;
} catch (Exception e) {
}
retourner nul ;
}
Supprimez « www » de l’URL
private String removeWwwFromUrl(String url) {
int index = url.indexOf(« ://www. ») ;
si (index != -1) {
return url.sous-string(0, index + 3) + url.sous-string(index + 7) ;
}
retour (URL) ;
}
Analysez la page et trouvez le lien
ArrayList privé<String> retrieveLinks(URL pageUrl, Chaîne pageContenus,
HashSet crawledList, boolean limitHost) {
Compiler le motif correspondant du lien avec des expressions régulières.
Pattern p = Pattern.compile(« <a\\s+href\\s*=\\s*\ » ?(. *?) [\"|>]",
Pattern.CASE_INSENSITIVE) ;
Matcher m = p.matcher(pageContents) ;
<String> ArrayList linkList = new <String>ArrayList() ;
tandis que (m.find()) {
Lien de chaîne = m.group(1).trim() ;
si (link.length() < 1) {
continuer ;
}
Passez le lien vers cette page.
if (link.charAt(0) == '#') {
continuer ;
}
if (link.indexOf(« mailto : ») != -1) {
continuer ;
}
if (link.toLowerCase().indexOf(« javascript ») != -1) {
continuer ;
}
if (link.indexOf(« :// ») == -1) {
if (link.charAt(0) == '/') {// gère absolument
lien = « http:// » + pageUrl.getHost() + « : »
+ pageUrl.getPort() + lien ;
} else {
Fichier chaîne = pageUrl.getFile() ;
if (file.indexOf('/') == -1) {// gère les adresses relatives
lien = « http:// » + pageUrl.getHost() + « : »
+ pageUrl.getPort() + « / » + lien ;
} else {
Chemin de chaîne = fichier.sous-chaîne(0,
file.lastIndexOf('/') + 1) ;
lien = « http:// » + pageUrl.getHost() + « : »
+ pageUrl.getPort() + chemin + lien ;
}
}
}
int index = link.indexOf('#') ;
si (index != -1) {
lien = lien.sous-string(0, index) ;
}
lien = removeWwwFromUrl(lien) ;
URL vérifiéeLink = verifyUrl(lien) ;
if (verifiedLink == null) {
continuer ;
}
/* Si vous restreignez les hôtes, excluez les URL qui ne remplissent pas les critères */
if (limitHost
&& !pageUrl.getHost().toLowerCase().equals(
verifiedLink.getHost().toLowerCase())) {
continuer ;
}
Ignorez les liens déjà traités.
if (crawledList.contains(link)) {
continuer ;
}
linkList.add(lien) ;
}
return (lienList) ;
}
Recherchez le contenu d’une page web téléchargée pour déterminer s’il existe une chaîne de recherche spécifiée dans la page
recherche booléenne privéeStringMatches(String pageContents,
String searchString, boolean caseSensitive) {
Recherche de chaîne Contenus = pageContenu ;
if ( !casSensible) {// si insensible à la casse
rechercheContenusT= pageContenus.versMinuscule() ;
}
Pattern p = Pattern.compile(« [\\s]+ ») ;
Termes String[] = p.split(searchString) ;
pour (int i = 0 ; J’ai < termes. Longueur ; i++) {
if (majusculeSensible) {
if (searchContents.indexOf(termes) == -1) {
return false ;
}
} else {
if (searchContents.indexOf(termes.toLowerCase()) == -1) {
return false ;
}
}
}
retour fidèle ;
}
Effectuer l’opération de recherche proprement dite
public<String> ArrayList crawl(String startUrl, int maxUrls,
String searchString, boolean limithost, boolean caseSensitive) {
HashSet<String> crawledList = nouveau <String>HashSet() ;
LinkedHashSet<String> toCrawlList = nouveau <String>LinkedHashSet() ;
if (maxUrls < 1) {
errorList.add (« Invalid Max URLs value. ») ;
System.out.println (« Valeur des URL Max invalides. ») ;
}
if (searchString.length() < 1) {
errorList.add (« Chaîne de recherche manquante. ») ;
System.out.println (« Chaîne de recherche manquante ») ;
}
if (errorList.size() > 0) {
System.out.println(« err !! ») ;
return errorList ;
}
Déplacer www depuis le début de l’URL
startUrl = removeWwwFromUrl(startUrl) ;
toCrawlList.add(startUrl) ;
tandis que (toCrawlList.size() > 0) {
if (maxUrls != -1) {
if (crawledList.size() == maxUrls) {
pause ;
}
}
Obtenez l’URL en bas de la liste.
URL de chaîne = toCrawlList.iterator().next() ;
Supprime l’URL de la liste de recherche.
toCrawlList.remove(url) ;
Convertir l’URL de chaîne en objet URL.
URL vérifiéeURL = verifyUrl(url) ;
Passez l’URL si les robots ne sont pas autorisés à y accéder.
if ( !isRobotAllowed(verifiedUrl)) {
continuer ;
}
Ajouter les URL traitées à crawledList
crawledList.add(url) ;
Chaîne de pagesContenu = downloadPage(verifiedUrl) ;
if (pageContents != null && pageContents.length() > 0) {
Obtenez un lien valide depuis la page
<String> ArrayList liens = retrieveLinks(verifiedUrl,
pageContents, crawledList, limitHost) ;
toCrawlList.addAll(liens) ;
si (searchStringMatches(pageContents, searchString,
Majusculessensible)) {
résult.add(url) ;
System.out.println(url) ;
}
}
}
résultat de retour ;
}
Fonction principale
public static void main(String[] args) {
SearchCrawler crawler = nouveau SearchCrawler (« http://www.itsvse.com/ », 100,"Delver_Si ») ;
Recherche de fils = nouveau Fil (crawler) ;
System.out.println (« Commencer la recherche... ») ;
System.out.println (« résultat : ») ;
recherche.start() ;
try {
recherche.join() ;
} catch (InterruptedException e) {
TODO Bloc de capture auto-généré
e.printStackTrace() ;
}
}
}
[/mw_shl_code]
|
-
1.png
(100.02 KB, Nombre de téléchargements: 591)
-
2.png
(72.18 KB, Nombre de téléchargements: 596)
-
3.png
(188.46 KB, Nombre de téléchargements: 606)
Précédent:PHP représente 82,2 % des sites 100W les plus populairesProchain:Visualiseur de code source Web Java Edition
|
Propriétaire|
Publié sur 30/11/2014 18:28:24
|
Publié sur 30/11/2014 17:40:16
|
