|
|
Veröffentlicht am 30.11.2014 16:56:56
|
|
|
|
[mw_shl_code=java, wahr]/**
* @author Jack.Wang
*
*/
import java.io.BufferedReader;
java.io.InputStreamReader importieren;
java.net.URL importieren;
import java.util.ArrayList;
java.util.HashMap importieren;
import java.util.HashSet;
import java.util.LinkedHashSet;
import java.util.regex.Matcher;
import java.util.regex.Pattern;
Suche nach Webcrawlern
öffentliche Klasse SearchCrawler implementiert Runnable {
/*
* disallowListCache-Cache-Roboter erlaubt keine gesuchten URLs. Das Robot-Protokoll legt eine robots.txt-Datei im Root-Verzeichnis der Website fest,
* Gibt an, welche Seiten auf der Seite für eingeschränkte Suche durchsuchbar sind.
* Das Suchprogramm sollte diese Bereiche während der Suche überspringen, hier ist ein Beispiel für robots.txt:
* # robots.txt für http://somehost.com/ User-Agent:
* Nicht erlauben: /cgi-bin/
* Nicht erlauben: /Registrierung # Roboter auf der Registrierungsseite nicht erlauben
* Nicht erlauben: /login
*/
private HashMap<String, ArrayList<String>> disallowListCache = neuer HashMap<String, ArrayList<String>>();
ArrayList<String> errorList = neue ArrayList<String>(); Fehlermeldung
ArrayList-Ergebnis<String> = neuer ArrayList<String>(); Durchsuchte Ergebnisse
String startUrl; Ein Ausgangspunkt, um Ihre Suche zu beginnen
int maxUrl; Die maximale Anzahl der verarbeiteten URLs
String searchString; Zeichenketten, nach denen man suchen sollte
boolesche FallSensitive = falsch; Ob man groß- und kleinschreibungssensitiv sein soll oder nicht
boolesche LimitHost = falsch; Ob man innerhalb eines eingeschränkten Hosts suchen sollte
public SearchCrawler(String startUrl, int maxUrl, String searchString) {
this.startUrl = startUrl;
this.maxUrl = maxUrl;
this.searchString = searchString;
}
public ArrayList<String> getResult() {
Rückgabeergebnis;
}
public void run() { // Starte den Suchthread
crawl(startUrl, maxUrl, searchString, limitHost, caseSensitive);
}
URL-Formatierung erkennen
private URL verifyUrl(String url) {
Es werden nur HTTP-URLs verarbeitet.
if (!url.toLowerCase().startsWith("http://"))
Null zurück;
URL verifiedUrl = null;
versuchen {
verifiedUrl = neue URL(URL);
} catch (Ausnahme e) {
Null zurück;
}
return verifiziertUrl;
}
Erkennt, ob der Roboter Zugriff auf die angegebene URL erlaubt.
private boolean isRobotAllowed(URL urlToCheck) {
String host = urlToCheck.getHost().toLowerCase(); Hol dir den Host, der das RUL gibt
System.out.println("host="+host);
Hol dir einen Cache mit URLs, die dein Host nicht durchsuchen erlaubt
ArrayList<String> disallowList = disallowListCache.get(host);
Wenn du noch keinen Cache hast, lade ihn herunter und cache ihn.
wenn (disallowList == null) {
disallowList = neuer ArrayList<String>();
versuchen {
URL robotsFileUrl = neue URL ("http://" + Host + "/robots.txt");
BufferedReader Reader = neuer BufferedReader(
neuer InputStreamReader (robotsFileUrl.openStream()));
Lesen Sie die Roboterdatei, um eine Liste von Pfaden zu erstellen, auf die nicht zugegriffen werden darf.
Stringline;
während ((Line = reader.readLine()) != null) {
wenn (line.indexOf("Disallow:") == 0) {// Enthält es "Disallow:"
String disallowPath = line.substring("Disallow:"
.length()); Erhalte den Weg zum verbotenen Zugriff
Prüfe auf Anmerkungen.
int commentIndex = disallowPath.indexOf("#");
if (commentIndex != -1) {
disallowPath = disallowPath.substring(0,
commentIndex); Entfernen Sie den Kommentar
}
disallowPath = disallowPath.trim();
disallowList.add (disallowPath);
}
}
Cache-Pfade, auf die dieser Host keinen Zugriff haben darf.
disallowListCache.put(host, disallowList);
} catch (Ausnahme e) {
Return true; Im Root-Verzeichnis der Website gibt es keine robots.txt Dateien, und es gibt true zurück
}
}
String-Datei = urlToCheck.getFile();
System.out.println("Datei getFile()="+file);
für (int i = 0; i < disallowList.size(); i++) {
String disallow = disallowList.get(i);
if (file.startsWith(disallow)) {
return false;
}
}
Return true;
}
private String DownloadPage(URL pageUrl) {
versuchen {
Öffnen Sie die Verbindung zur URL zum Lesen.
BufferedReader Reader = neuer BufferedReader (neuer InputStreamReader(
pageUrl.openStream()));
Lese die Seite in den Puffer.
Stringline;
StringBuffer pageBuffer = neuer StringBuffer();
während ((Line = reader.readLine()) != null) {
pageBuffer.append(zeile);
}
return pageBuffer.toString();
} catch (Ausnahme e) {
}
Null zurück;
}
Entfernen Sie "www" aus der URL
private String removeWwwFromUrl(String url) {
int index = url.indexOf("://www.");
wenn (Index != -1) {
return url.substring(0, index + 3) + url.substring(index + 7);
}
return (URL);
}
Analysieren Sie die Seite und finden Sie den Link
private ArrayList<String> retrieveLinks(URL pageUrl, String pageContents,
HashSet crawledList, boolean limitHost) {
Kompiliere das Matching-Muster des Links mit regulären Ausdrücken.
Muster p = Pattern.compile("<a\\s+href\\s*=\\s*\"?(. *?) [\"|>]",
Pattern.CASE_INSENSITIVE);
Matcher m = p.matcher(seiteInhalt);
ArrayList<String> linkList = neuer ArrayList<String>();
während (m.find()) {
Stringlink = m.group(1).trim();
if (link.length() < 1) {
Fahren Sie fort;
}
Überspringen Sie den Link zu dieser Seite.
if (link.charAt(0) == '#') {
Fahren Sie fort;
}
if (link.indexOf("mailto:") != -1) {
Fahren Sie fort;
}
if (link.toLowerCase().indexOf("javascript") != -1) {
Fahren Sie fort;
}
wenn (link.indexOf("://") == -1) {
if (link.charAt(0) == '/') {// verarbeitet absolut
Link = "http://" + pageUrl.getHost() + ":"
+ pageUrl.getPort() + Link;
} sonst {
String-Datei = pageUrl.getFile();
wenn (file.indexOf('/') == -1) {// relative Adressen behandelt
Link = "http://" + pageUrl.getHost() + ":"
+ pageUrl.getPort() + "/" + Link;
} sonst {
Stringpath = file.substring(0,
file.lastIndexOf('/') + 1);
Link = "http://" + pageUrl.getHost() + ":"
+ pageUrl.getPort() + Pfad + Link;
}
}
}
int index = link.indexOf('#');
wenn (Index != -1) {
link = link.substring(0, Index);
}
Link = entfernenWwwFromUrl(Link);
URL verifiedLink = verifyUrl(Link);
wenn (verififiedLink == null) {
Fahren Sie fort;
}
/* Wenn du Hosts einschränkst, schließe die URLs aus, die die Kriterien nicht erfüllen */
wenn (limitHost)
&& !pageUrl.getHost().toLowerCase().equals(
verifiedLink.getHost().toLowerCase())) {
Fahren Sie fort;
}
Überspringe die bereits bearbeiteten Links.
if (crawledList.contains(link)) {
Fahren Sie fort;
}
linkList.add (Link);
}
Rückkehr (linkList);
}
Durchsuchen Sie den Inhalt einer heruntergeladenen Webseite, um festzustellen, ob eine bestimmte Suchfolge auf der Seite vorhanden ist
private boolesche Suche StringMatches (String pageContents,
String searchString, boolean caseSensitive) {
String searchContents = pageContents;
if (!caseSensitive) {// if case insensitive
searchContents = pageContents.toLowerCase();
}
Muster p = Pattern.compile("[\\s]+");
String[]-Begriffe = p.split(searchString);
für (int i = 0; Ich < Begriffe. Länge; i++) {
if (caseSensitive) {
wenn (searchContents.indexOf(terms) == -1) {
return false;
}
} sonst {
wenn (searchContents.indexOf(terms.toLowerCase()) == -1) {
return false;
}
}
}
Return true;
}
Führen Sie die eigentliche Suchoperation durch
public ArrayList<String> crawl(String startUrl, int maxUrls,
String searchString, boolean limithost, boolean caseSensitive) {
HashSet<String> crawledList = neuer HashSet<String>();
LinkedHashSet<String> toCrawlList = neuer LinkedHashSet<String>();
if (maxUrls < 1) {
errorList.add ("Ungültige maximale URLs-Wert.");
System.out.println("Ungültige maximale URLs-Wert.");
}
if (searchString.length() < 1) {
errorList.add ("fehlende Suchzeichenfolge.");
System.out.println ("Fehlender Suchstring");
}
if (errorList.size() > 0) {
System.out.println("err!!");
return errorList;
}
Flytt www aus der Start-URL
startUrl = entfernenWwwFromUrl(startUrl);
toCrawlList.add (startUrl);
während (toCrawlList.size() > 0) {
if (maxUrls != -1) {
if (crawledList.size() == maxUrls) {
Unterbrechung;
}
}
Holen Sie sich die URL unten auf der Liste.
String-URL = toCrawlList.iterator().next();
Entfernen Sie die URL aus der Crawl-Liste.
toCrawlList.remove(URL);
Konvertiere die String-URL in ein URL-Objekt.
URL verifiedUrl = verifyUrl(url);
Überspringe die URL, wenn Roboter nicht darauf zugreifen dürfen.
if (!isRobotAllowed(verifiedUrl)) {
Fahren Sie fort;
}
Fügen Sie bearbeitete URLs zur gecrawlten Liste hinzu
crawledList.add(URL);
String pageContents = downloadPage(verifiedUrl);
if (pageContents != null && pageContents.length() > 0) {
Holen Sie sich einen gültigen Link von der Seite
ArrayList-Links<String> = retrieveLinks(verifiedUrl,
pageContents, crawledList, limitHost);
toCrawlList.addAll(links);
if (searchStringMatches(pageContents, searchString,
caseSensitive)) {
result.add(url);
System.out.println(url);
}
}
}
Rückgabeergebnis;
}
Hauptfunktion
public static void main(String[] args) {
SearchCrawler Crawler = neuer SearchCrawler ("http://www.itsvse.com/", 100,"Delver_Si");
Thread-Suche = neuer Thread (Crawler);
System.out.println ("Such starten...");
System.out.println("result:");
search.start();
versuchen {
search.join();
} catch (InterruptedException e) {
TODO Autogenerierter Fangblock
e.printStackTrace();
}
}
}
[/mw_shl_code]
|
-
1.png
(100.02 KB, Anzahl der Downloads: 591)
-
2.png
(72.18 KB, Anzahl der Downloads: 596)
-
3.png
(188.46 KB, Anzahl der Downloads: 606)
Vorhergehend:PHP macht 82,2 % der größten 100W-Websites ausNächster:Java Edition Web-Quellcode-Viewer
|
Vermieter|
Veröffentlicht am 30.11.2014 18:28:24
|
Veröffentlicht am 30.11.2014 17:40:16
|
