Tutorial zur Java-Crawler-Anwendung, praktische Datenerfassung und -analyse

Java-Crawler-Anwendungs-Tutorial, praktische Datenerfassung und -analyse

Mit dem Aufkommen des Internetzeitalters sind Daten für Unternehmen und Einzelpersonen der einzige Weg zum Erfolg geworden, sodass auch die Bedeutung von Daten zunimmt. Als leistungsstarkes Werkzeug zur Datenerfassung ist die Crawler-Technologie in allen Lebensbereichen weit verbreitet. In diesem Artikel wird erläutert, wie Sie mithilfe der Java-Sprache einen Crawler zum Erfassen und Analysieren von Daten schreiben.

1. Vorkenntnisse

Bevor Sie Java Crawler lernen, müssen Sie die folgenden Grundkenntnisse beherrschen:

1. Java-Sprachgrundlagen: Zumindest müssen Sie grundlegende Konzepte wie Klassen, Methoden, Variablen usw. in Java verstehen. sowie objektorientierter Programmiergedanke.
2. HTML-Grundlagen: Verstehen Sie die Grundstruktur und Tags der HTML-Sprache und können Sie einfache CSS-Stile und JavaScript-Codes verwenden.
3. HTTP-Grundlagen: Verstehen Sie die Grundprinzipien der GET- und POST-Methoden im HTTP-Protokoll und verfügen Sie über ein gewisses Verständnis für HTTP-Header-Informationen wie Cookie, User-Agent usw.
4. Reguläre Ausdrücke: Verstehen Sie die grundlegende Syntax und Verwendung regulärer Ausdrücke.
5. Datenbankoperationen: Beherrschen Sie die Grundkenntnisse von Java-Datenbankoperationen wie JDBC, Hibernate, MyBatis usw.

2. Grundlagen des Java-Crawlers

Ein Webcrawler ist ein automatisiertes Programm, das menschliches Verhalten simulieren kann, um auf das Internet zuzugreifen, Informationen aus Webseiten zu extrahieren und diese zu verarbeiten. Die Java-Sprache verfügt über gute Netzwerkprogrammierfunktionen und leistungsstarke objektorientierte Funktionen und eignet sich daher sehr gut zum Schreiben von Crawler-Programmen.

Java-Crawler sind im Allgemeinen in drei Teile unterteilt: URL-Manager, Webseiten-Downloader und Webseiten-Parser.

1. URL-Manager

URL-Manager verwaltet die URL-Adressen, die Crawler crawlen müssen, und zeichnet auf, welche URLs gecrawlt wurden und welche URLs noch gecrawlt werden müssen. Es gibt im Allgemeinen zwei Möglichkeiten, URL-Manager zu implementieren:

(1) In-Memory-URL-Manager: Verwenden Sie einen Satz oder eine Warteschlange, um die gecrawlten URLs und die zu crawlenden URLs aufzuzeichnen.

(2) Datenbankbasierter URL-Manager: Speichern Sie gecrawlte und noch zu crawlende URLs in der Datenbank.

2. Webpage Downloader

Webpage Downloader ist der Kernbestandteil des Crawlers und für das Herunterladen von Webseiten aus dem Internet verantwortlich. Java-Crawler verfügen im Allgemeinen über zwei Implementierungsmethoden:

(1) URLConnection: implementiert mithilfe der URLConnection-Klasse, die relativ einfach zu verwenden ist. Der Kerncode lautet wie folgt:

URL url = new URL("http://www.example.com");
HttpURLConnection conn = (HttpURLConnection) url.openConnection();
InputStream in = conn.getInputStream();
BufferedReader reader = new BufferedReader(new InputStreamReader(in));
String line = reader.readLine();
while (line != null) {
    System.out.println(line);
    line = reader.readLine();
}

(2) HttpClient: implementiert mithilfe des HttpClient-Frameworks ist leistungsfähiger als URLConnection und kann HTTP-Header-Informationen wie Cookies und benutzerdefinierten Benutzeragenten verarbeiten. Der Kerncode lautet wie folgt:

HttpClient httpClient = new HttpClient();
GetMethod getMethod = new GetMethod("http://www.example.com");
int status = httpClient.executeMethod(getMethod);
if (status == HttpStatus.SC_OK) {
    InputStream in = getMethod.getResponseBodyAsStream();
    BufferedReader reader = new BufferedReader(new InputStreamReader(in));
    String line = reader.readLine();
    while (line != null) {
        System.out.println(line);
        line = reader.readLine();
    }
}

3. Webseiten-Parser

Nachdem die Webseite heruntergeladen wurde, müssen Sie a verwenden Webseiten-Parser zum Extrahieren der Daten. Es gibt im Allgemeinen zwei Möglichkeiten, Java-Crawler zu implementieren:

(1) Regulärer Ausdruck: Verwenden Sie reguläre Ausdrücke, um Daten in Webseiten abzugleichen. Der Kerncode lautet wie folgt:

String pattern = "<title>(.*?)</title>";
Pattern r = Pattern.compile(pattern);
Matcher m = r.matcher(html);
if (m.find()) {
    System.out.println(m.group(1));
}

(2) HTML-Parser: Implementiert mit dem Jsoup-Framework. Sie können Webseiten in eine DOM-Struktur konvertieren und dann Daten über CSS-Selektoren oder XPath-ähnliche Methoden abrufen. Der Kerncode lautet wie folgt:

Document doc = Jsoup.connect("http://www.example.com").get();
Elements links = doc.select("a[href]");
for (Element link : links) {
    String text = link.text();
    String href = link.attr("href");
    System.out.println(text + " " + href);
}

3. Java-Crawler-Praxis

Nachdem Sie die grundlegenden Ideen und Implementierungsmethoden von verstanden haben Mit Java-Crawlern können wir versuchen, ein einfaches Crawler-Programm zu schreiben, um Daten von einer Website abzurufen und zu analysieren.

1. Crawling-Daten

Wir haben uns entschieden, die Daten der Douban-Filmrankings zu crawlen. Zuerst müssen wir die URL-Adresse der Douban-Filmrankings abrufen, wie unten gezeigt:

https://movie.douban.com/chart

Dann können wir das Jsoup-Framework verwenden, um die Webseite herunterzuladen und die darin enthaltenen Daten zu extrahieren. Der Code lautet wie folgt:

Document doc = Jsoup.connect("https://movie.douban.com/chart").get();
Elements items = doc.select("div.item");
List<Movie> movieList = new ArrayList<>();
for (Element item : items) {
    Elements title = item.select("div.info div.hd a");
    Elements rating = item.select("div.info div.bd div.star span.rating_num");
    Elements director = item.select("div.info div.bd p").eq(0);
    Elements actor = item.select("div.info div.bd p").eq(1);
    Movie movie = new Movie();
    movie.setTitle(title.text());
    movie.setRating(Double.valueOf(rating.text()));
    movie.setDirector(director.text().replace("导演: ", ""));
    movie.setActor(actor.text().replace("主演: ", ""));
    movieList.add(movie);
}

Hier verwenden wir eine Movie-Klasse zum Speichern von Filminformationen.

2. Speicherdaten

Speichern Sie die erhaltenen Filmdaten in der Datenbank, um die spätere Analyse zu erleichtern. Hier verwenden wir JDBC, um die Datenbank zu betreiben. Der Code lautet wie folgt:

public class DBHelper {
    private static final String JDBC_DRIVER = "com.mysql.jdbc.Driver";
    private static final String DB_URL = "jdbc:mysql://localhost:3306/db";
    private static final String USER = "root";
    private static final String PASS = "password";

    public static Connection getConnection() {
        Connection conn = null;
        try {
            Class.forName(JDBC_DRIVER);
            conn = DriverManager.getConnection(DB_URL, USER, PASS);
        } catch (Exception e) {
            e.printStackTrace();
        }
        return conn;
    }

    public static void saveMovies(List<Movie> movieList) {
        try (Connection conn = getConnection();
             PreparedStatement stmt = conn.prepareStatement(
                     "INSERT INTO movie(title,rating,director,actor) VALUES (?,?,?,?)"
             )) {
            for (Movie movie : movieList) {
                stmt.setString(1, movie.getTitle());
                stmt.setDouble(2, movie.getRating());
                stmt.setString(3, movie.getDirector());
                stmt.setString(4, movie.getActor());
                stmt.addBatch();
            }
            stmt.executeBatch();
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

3. Daten analysieren

Nachdem wir die Daten haben, können wir sie analysieren. Hier zählen wir die Anzahl der Filme und die durchschnittlichen Bewertungen jedes Regisseurs. Der Code lautet wie folgt:

public class MovieAnalyzer {
    public static void analyzeMovies() {
        try (Connection conn = DBHelper.getConnection();
             Statement stmt = conn.createStatement()) {
            String sql = "SELECT director, COUNT(*) AS cnt, AVG(rating) AS avg_rating " +
                    "FROM movie " +
                    "GROUP BY director " +
                    "HAVING cnt > 1 " +
                    "ORDER BY avg_rating DESC";
            ResultSet rs = stmt.executeQuery(sql);
            while (rs.next()) {
                String director = rs.getString("director");
                int cnt = rs.getInt("cnt");
                double avgRating = rs.getDouble("avg_rating");
                System.out.printf("%-20s %5d %7.2f%n", director, cnt, avgRating);
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

Speichern Sie die erhaltenen Filminformationen in der Datenbank und analysieren Sie sie. Wir haben die praktische Anwendung des Java-Crawlers abgeschlossen.

4. Zusammenfassung

Dieser Artikel stellt die Grundkenntnisse und praktischen Anwendungen von Java-Crawlern vor und soll den Lesern helfen, die Crawler-Technologie und die Java-Programmierung besser zu verstehen. In der Praxis müssen Sie auf rechtliche und ethische Normen achten und davon absehen, sich illegal die Privatsphäre anderer Menschen zu verschaffen und Urheberrechte zu verletzen. Gleichzeitig müssen Sie auch die Anti-Crawler-Technologie beherrschen, um zu verhindern, dass sie von gecrawlten Websites blockiert oder IP-Adressen gesperrt werden.

Das obige ist der detaillierte Inhalt vonTutorial zur Java-Crawler-Anwendung, praktische Datenerfassung und -analyse. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!