Parsowanie HTMLa / wielowątkowość na przykładzie EmailScrapingu JAVA8

Cześć,
wiem, wiem że są święta i raczej powinienem jeść karpia niż pisać na blogu, ale chciałem pokazać jak łatwo można, przy użyciu pewnej biblioteki, napisać prosty program do zbierania po internecie adresów email.
Zasada działania jest bardzo prosta. Podajemy do programu adres strony oznaczonej jako root czyli korzeń drzewa które będzie się budować podczas przeszukiwania stron.
Odwiedzamy podany adres, pobieramy z niego wszystkie emaile i zapisujemy do pliku (dopisujemy), następnie pobieramy wszystkie linki ze strony, sprawdzamy czy są poprawne i jeśli tak, to każdy z nich zostaje w taki sposób odwiedzony jak root.

Jako że sam proces znajdowania dzieci oraz wyszukiwania maili może być dość długi (tj. relatywnie długi, w porównaniu do innych, standardowych operacji w Javie) warto tutaj rozwiązać to nieco bardziej współbieżnie. Łatwo zauważyć iż analizowanie każdej strony jest operacją całkowicie autonomiczną, a więc może wykonywać się spokojnie w oddzielnym wątku. Niestety jest to mimo wszystko dość kłopotliwe, gdyż zrealizowanie tego w taki sposób po kilkunastu sekundach mocno spowolni komputer, taka ilość wątków nie przyspieszy procesu a go spowolni, jest to związane z kosztem jaki system musi przeznaczyć na zarządzanie taką ilością wątków, tj. np. przełączaniem kontekstu.
Optymalnym rozwiązaniem jest ograniczenie ilości wątków do np. 2 * ilość procesorów. Uzyskamy wtedy faktyczną współbieżność.

Możemy to uzyskać stosując mechanizm zarządców, tj. Executors.
Użyjemy zarządcy typu FixedThreadPool który działa jak kolejka. Ilość możliwych do utworzenia wątków jest parametrem konstruktora, jeśli zadań jest więcej niż dostępnych wątków to są one kolejkowane. Jeśli jakieś zadanie się wykona – kolejne zadanie z kolejki jest wykonywane przez ten zwolniony wątek.
Myślę że mnożnik 2 użyty do określenia ilości wątków w tej puli jest jak najbardziej modyfikowalny.

Nie wiem czy wychwyciłeś pewien problem, aktualnie nasz pomysł nie ma warunku końca. Tzn można za warunek końca uznać moment kiedy każda z przetworzonych stron nie będzie miała dzieci. Ale niestety średnio to możliwe ;) dlatego można ograniczyć ilość przeanalizowanych stron lub przetworzonych poziomów drzewa.

Zerknijmy na kod…

Może jednak przed kodem, zerknij na pom.xml:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>
    <groupId>com.mycompany</groupId>
    <artifactId>EmailScraper</artifactId>
    <version>1.0-SNAPSHOT</version>
    <packaging>jar</packaging>
    <properties>
        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
        <maven.compiler.source>1.8</maven.compiler.source>
        <maven.compiler.target>1.8</maven.compiler.target>
    </properties>
    <dependencies>
        <dependency>
            <groupId>org.codehaus.mojo</groupId>
            <artifactId>exec-maven-plugin</artifactId>
            <version>1.2.1</version>
        </dependency>
        <dependency>
            <groupId>org.apache.httpcomponents</groupId>
            <artifactId>httpclient</artifactId>
            <version>4.3</version>
        </dependency>
        <dependency>
            <groupId>org.jsoup</groupId>
            <artifactId>jsoup</artifactId>
            <version>1.7.2</version>
        </dependency>
        <dependency>
            <groupId>commons-io</groupId>
            <artifactId>commons-io</artifactId>
            <version>2.4</version>
        </dependency>
        <dependency>
                <groupId>com.google.guava</groupId>
                <artifactId>guava</artifactId>
                <version>18.0</version>
        </dependency>

    </dependencies>
</project>

A więc mamy od Apache dwie biblioteki – Commons IO oraz Httpclient. Pierwsza to zestaw klas do pracy na kolekcjach, dałoby radę bez niej się obejść, ale bardzo ją lubię. Httpclient jest do wysyłania GETów do stron i pobierania odpowiedzi. Mamy jeszcze Jsoup – parsowanie HTMLa i Guavę – bibliotekę od Google. Bez Guavy można by się obejść również ;)

A wracając.. Zaimplementujmy klasę EmailScraper:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
/*
 * To change this license header, choose License Headers in Project Properties.
 * To change this template file, choose Tools | Templates
 * and open the template in the editor.
 */

package com.mycompany.emailscraper;

import com.google.common.collect.Sets;
import java.util.Set;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

/**
 *
 * @author Matt
 */

public class EmailScraper {
    public static int maxViewedPages;
    private final String root;
    public static final ExecutorService es = Executors.newFixedThreadPool(2*Runtime.getRuntime().availableProcessors());
    public static Set<String> viewed = Sets.newConcurrentHashSet();

    public EmailScraper(String root, int max) {
        this.root = root;
        EmailScraper.maxViewedPages = max;
    }
   
    public void run(){
        EmailScraperCrawler esc = new EmailScraperCrawler(root);
        es.submit(esc);
    }
   
}

EmailScraper odpala cały proces, czyli dodaje do kolejki zadań, zadanie przetworzenia pierwszej strony.
Zerknijmy na EmailScraperCrawler

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
package com.mycompany.emailscraper;

import java.io.File;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.PrintWriter;
import java.net.MalformedURLException;
import java.net.URISyntaxException;
import java.net.URL;
import java.util.HashSet;
import java.util.Set;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.logging.Level;
import java.util.logging.Logger;
import java.util.regex.Matcher;
import java.util.regex.Pattern;
import org.apache.commons.io.IOUtils;
import org.apache.http.HttpEntity;
import org.apache.http.client.methods.CloseableHttpResponse;
import org.apache.http.client.methods.HttpGet;
import org.apache.http.impl.client.CloseableHttpClient;
import org.apache.http.impl.client.HttpClients;
import org.jsoup.Jsoup;
import org.jsoup.nodes.Document;
import org.jsoup.select.Elements;

/**
 *
 * @author Matt
 */

public class EmailScraperCrawler extends Thread{
    private final String root;
    private static final Logger LOG = Logger.getLogger(EmailScraperCrawler.class.getName());
    public EmailScraperCrawler(String root) {
        this.root = root;
    }

    @Override
    public void run() {
        LOG.log(Level.INFO, Thread.currentThread().getName());
        try {
            CloseableHttpClient hc = HttpClients.createDefault();
            EmailScraper.viewed.add(root);
            HttpGet httpGet = new HttpGet(root);
            CloseableHttpResponse chp = hc.execute(httpGet);
            HttpEntity he = chp.getEntity();
            String content = IOUtils.toString(he.getContent(), "UTF-8");
            chp.close();
            Set<Email> emails = findEmails(content, root);
            appendToFile(emails);
            runChildren(content);
            shutDownScrapingIfNecessary();
        } catch (IOException ex) {
            Logger.getLogger(EmailScraperCrawler.class.getName()).log(Level.SEVERE, null, ex);
        }

    }
   
    private void runChildren(String content){
       
        Document d = Jsoup.parse(content);
        Elements links = d.getElementsByTag("a");
        links.stream().map((link) -> link.attr("href")).filter((stringLink) -> (isValid(stringLink) && !EmailScraper.viewed.contains(stringLink))).map((stringLink) -> new EmailScraperCrawler(stringLink)).forEach((esc) -> {
            EmailScraper.es.submit(esc);
        });
    }
   
    private void shutDownScrapingIfNecessary(){
        if(EmailScraper.viewed.size() > EmailScraper.maxViewedPages){
            EmailScraper.es.shutdownNow();
        }
    }
   
    private boolean isValid(String url) {
        URL u;
        try {
            u = new URL(url);
        } catch (MalformedURLException e) {
            return false;
        }
        try {
            u.toURI();
        } catch (URISyntaxException e) {
            return false;
        }
        return true;
    }
   
    private Set<Email> findEmails(String content, String source){
        Pattern p = Pattern.compile("\\b[A-Z0-9._%+-][email protected][A-Z0-9.-]+\\.[A-Z]{2,4}\\b", Pattern.CASE_INSENSITIVE);
        Matcher matcher = p.matcher(content);
        Set<Email> emails = new HashSet<>();
        while(matcher.find()) {
            emails.add(new Email(matcher.group(), source));
        }
       
        return emails;
    }
   
    private static void appendToFile(Set<Email> emails){
        if(emails.isEmpty()) return;
        StringBuilder sb = new StringBuilder();
        for(Email email : emails){
            sb.append(email.getEmail());
            sb.append('\n');
        }
       
        try (PrintWriter out = new PrintWriter(new FileOutputStream(new File("emails.txt"),true))) {
                out.write(sb.toString());
                out.close();

        } catch (FileNotFoundException ex) {
            Logger.getLogger(EmailScraperCrawler.class.getName()).log(Level.SEVERE, null, ex);
        }
       
       
    }
   
}

Mamy tutaj kilka metod. Przeciążone „run” skleja wszystko w całość. Pierw łączymy się ze stroną i zapisujemy jej HTMLa do zmiennej content, która jest przekazywana do metod odpowiedzialnych za odnalezienie adresów email oraz znalezienia dzieci aktualnie przetwarzanego URLa. Znalezione maile dopisujemy do pliku. Zapisujemy odwiedzoną stronę i podczas szukania dzieci sprawdzamy czy dziecko nie zostało już odwiedzone, np. linki „wstecz” odfiltrujemy dzięki temu.

Zerknijmy na wyjście tego programu:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
gru 26, 2014 3:49:20 PM com.mycompany.emailscraper.EmailScraperCrawler run
INFO: pool-1-thread-1
gru 26, 2014 3:49:22 PM com.mycompany.emailscraper.EmailScraperCrawler run
INFO: pool-1-thread-2
gru 26, 2014 3:49:22 PM com.mycompany.emailscraper.EmailScraperCrawler run
INFO: pool-1-thread-3
gru 26, 2014 3:49:22 PM com.mycompany.emailscraper.EmailScraperCrawler run
INFO: pool-1-thread-4
gru 26, 2014 3:49:22 PM com.mycompany.emailscraper.EmailScraperCrawler run
INFO: pool-1-thread-5
gru 26, 2014 3:49:22 PM com.mycompany.emailscraper.EmailScraperCrawler run
INFO: pool-1-thread-8
gru 26, 2014 3:49:22 PM com.mycompany.emailscraper.EmailScraperCrawler run
INFO: pool-1-thread-1
gru 26, 2014 3:49:22 PM com.mycompany.emailscraper.EmailScraperCrawler run
INFO: pool-1-thread-6
gru 26, 2014 3:49:22 PM com.mycompany.emailscraper.EmailScraperCrawler run
INFO: pool-1-thread-7
gru 26, 2014 3:49:22 PM com.mycompany.emailscraper.EmailScraperCrawler run
INFO: pool-1-thread-4
gru 26, 2014 3:49:22 PM com.mycompany.emailscraper.EmailScraperCrawler run
INFO: pool-1-thread-2
gru 26, 2014 3:49:22 PM com.mycompany.emailscraper.EmailScraperCrawler run
INFO: pool-1-thread-3
gru 26, 2014 3:49:22 PM com.mycompany.emailscraper.EmailScraperCrawler run
INFO: pool-1-thread-1
gru 26, 2014 3:49:22 PM com.mycompany.emailscraper.EmailScraperCrawler run
INFO: pool-1-thread-7
gru 26, 2014 3:49:23 PM com.mycompany.emailscraper.EmailScraperCrawler run
INFO: pool-1-thread-5
gru 26, 2014 3:49:23 PM com.mycompany.emailscraper.EmailScraperCrawler run
INFO: pool-1-thread-3
gru 26, 2014 3:49:23 PM com.mycompany.emailscraper.EmailScraperCrawler run
INFO: pool-1-thread-8
gru 26, 2014 3:49:23 PM com.mycompany.emailscraper.EmailScraperCrawler run
INFO: pool-1-thread-3
gru 26, 2014 3:49:23 PM com.mycompany.emailscraper.EmailScraperCrawler run
INFO: pool-1-thread-5
gru 26, 2014 3:49:23 PM com.mycompany.emailscraper.EmailScraperCrawler run
INFO: pool-1-thread-7
gru 26, 2014 3:49:23 PM com.mycompany.emailscraper.EmailScraperCrawler run
INFO: pool-1-thread-3
gru 26, 2014 3:49:23 PM com.mycompany.emailscraper.EmailScraperCrawler run
INFO: pool-1-thread-5
gru 26, 2014 3:49:23 PM com.mycompany.emailscraper.EmailScraperCrawler run
INFO: pool-1-thread-6
gru 26, 2014 3:49:23 PM com.mycompany.emailscraper.EmailScraperCrawler run
INFO: pool-1-thread-8
gru 26, 2014 3:49:23 PM com.mycompany.emailscraper.EmailScraperCrawler run

Można łatwo zauważyć tutaj że wątki się przeplatają, widać że jest faktycznie 2 * ilość procesorów (dla mojego komputera to 8).

Takie rozwiązanie współbieżności daje więcej wytchnienia odpytywanym serwerom, co nie zmienia faktu że tyle zapytań w tak krótkim czasie może zabić serwer.

Może masz pomysł jak sprytnie zrealizować to inaczej? Napisz w komentarzu ;)

Dzięki za wizytę,
Mateusz Mazurek
Podziel się na:
    Facebook email PDF Wykop Twitter

2
Dodaj komentarz

avatar
1 Wątki
1 Odpowiedzi
0 Śledzący
 
Komentarz z największą liczbą reakcji
Najczęściej komentowany wątek
2 Komentarze autora
Mateusz M.Piotrek Ostatnie komentarze autora

This site uses Akismet to reduce spam. Learn how your comment data is processed.

  Subskrybuj  
Powiadom o
Piotrek
Gość
Piotrek

Cześć! dla potomnych, brakuje jednej klasy aby poprawnie skompilować kod,: 123456789101112131415161718public class Email {         String email;         String root;         public Email(String email, String root) {             this.email = email;             this.root = root;         }         public String getEmail() {             return email;         }         public void setEmail(String email) {             this.email = email;    … Czytaj więcej »