Wie schreibe ich einen Crawler in Golang?

Angesichts der Popularität des Internets müssen wir eine große Menge an Informationen beschaffen, und ein großer Teil davon erfordert, dass wir sie von der Website aus crawlen. Es gibt viele Crawling-Methoden, unter denen in Golang geschriebene Crawler uns dabei helfen können, diese Informationen effizienter zu erhalten.

golang ist eine intuitive, prägnante und effiziente Programmiersprache, die sich für Anwendungsszenarien mit hoher Parallelität und hoher Leistung eignet. Crawler sind Aufgaben mit hoher Parallelität und hoher Leistung. Daher eignet sie sich sehr gut zum Schreiben von Crawlern in Golang. In diesem Artikel stellen wir den grundlegenden Prozess, häufig verwendete Bibliotheken und Kerntechnologien zum Schreiben von Crawlern in Golang vor, um Anfängern dabei zu helfen, die grundlegenden Methoden von Golang-Crawlern schnell zu erlernen.

1. Die grundlegenden Schritte zum Schreiben eines Crawlers in Golang

Bevor wir die grundlegenden Schritte zum Schreiben eines Crawlers in Golang vorstellen, müssen wir die grundlegende HTML-Struktur verstehen.

1. HTTP-Anfrage

In der Standardbibliothek von Golang wurden verwandte Funktionen für HTTP-Anfragen bereitgestellt. Wir müssen nur die grundlegenden Informationen wie URL, Anforderungsheader, Cookies, Anforderungsparameter usw. festlegen, um das von uns benötigte HTTP zu erstellen . fragen. Der Hauptcode lautet wie folgt:

package main

import (
    "fmt"
    "io/ioutil"
    "net/http"
)

func main() {
    resp, err := http.Get("http://www.baidu.com")
    if err != nil {
        fmt.Println(err)
        return
    }
    defer resp.Body.Close()
    
    body, _ := ioutil.ReadAll(resp.Body)
    fmt.Println(string(body))
}

Dieser Code verwendet die http.Get-Funktion, um eine HTTP-Anfrage zu initiieren und den Antworttext aus der Antwort zu lesen. Der entscheidende Punkt ist die Defer-Anweisung, die am Ende der Funktion ausgeführt wird, um den Antworttext zu schließen und Ressourcenlecks zu vermeiden.

2. HTML-Seite analysieren

Die durch die HTTP-Anfrage erhaltenen Antwortdaten sind ein HTML-Dokument, das wir analysieren müssen, um die erforderlichen Daten zu erhalten. In Golang können wir die GoQuery-Bibliothek verwenden, um HTML-Dokumente zu analysieren. Diese Bibliothek basiert auf der Syntax von jQuery und ist einfach zu verwenden.

Die wichtigsten von GoQuery bereitgestellten Parsing-Funktionen sind: Suchen, Filtern, Jeder, Attr usw. Mit der Suchfunktion werden Unterelemente gefunden, die Bedingungen erfüllen, und mit der Filterfunktion werden Elemente gefiltert, die Bedingungen erfüllen. Die Each-Funktion wird verwendet, um alle Elemente zu durchlaufen, die die Bedingungen erfüllen, während die Attr-Funktion verwendet wird, um die Attribute des Elements abzurufen. Am Beispiel der Analyse der Baidu-Homepage lautet der Code wie folgt:

package main

import (
    "fmt"
    "github.com/PuerkitoBio/goquery"
    "log"
)

func main() {
    resp, err := http.Get("http://www.baidu.com")
    if err != nil {
        log.Fatal(err)
    }
    body := resp.Body
    defer body.Close()

    doc, err := goquery.NewDocumentFromReader(body)
    if err != nil {
        log.Fatal(err)
    }

    doc.Find("title").Each(func(i int, s *goquery.Selection) {
        fmt.Println(s.Text())
    })
}

Der obige Code verwendet die Funktion goquery.NewDocumentFromReader, um das Dokumentobjekt zu erstellen, findet dann das Titelelement über die Find-Methode und durchläuft alle qualifizierten Elemente über Each Methode zur Ausgabe des Textes.

3. Daten speichern

Der letzte Schritt besteht darin, die erfassten Daten zu speichern. Für die Datenspeicherung stehen uns viele Möglichkeiten zur Auswahl, wie Datenbanken, Dateien, Caches usw.

Zum Beispiel möchten wir die gecrawlten Daten in einer CSV-Datei speichern. Die Schritte sind wie folgt:

package main

import (
    "encoding/csv"
    "log"
    "os"
)

func main() {
    file, err := os.Create("data.csv")
    if err != nil {
        log.Fatal(err)
    }
    defer file.Close()

    writer := csv.NewWriter(file)
    defer writer.Flush()
    
    writer.Write([]string{"name", "address", "tel"})
    writer.Write([]string{"John Smith", "123 Main St, Los Angeles, CA 90012", "123-456-7890"})
    writer.Write([]string{"Jane Smith", "456 Oak Ave, San Francisco, CA 94107", "123-456-7891"})
}

Im obigen Code verwenden wir die Funktion os.Create, um eine Datei mit dem Namen data.csv zu erstellen, und erstellen dann eine Datei mit dem Namen data.csv über die CSV-Writer-Funktion. Abschließend schreiben wir die zu speichernden Daten über die Methode write.Write in die CSV-Datei.

2. Häufig verwendete Bibliotheken zum Schreiben von Crawlern in Golang. Für das Schreiben von Crawlern in Golang müssen Sie nicht viel zugrunde liegenden Code schreiben:

Gocolly

1. Gocolly ist ein leichter Crawler Ein auf Golang basierendes Framework, das viele praktische Methoden zum Crawlen von Daten bereitstellt. Es kann Probleme wie Umleitung, Cookies, Proxys, Geschwindigkeitsbegrenzungen usw. automatisch behandeln, sodass wir uns mehr auf die Definition von Datenextraktionsregeln konzentrieren können. Der folgende Code zeigt, wie man Gocolly verwendet, um Baidu-Titel zu erhalten:

package main

import (
    "fmt"
    "github.com/gocolly/colly"
)

func main() {
    c := colly.NewCollector()
    
    c.OnHTML("head", func(e *colly.HTMLElement) {
        title := e.ChildText("title")
        fmt.Println(title)
    })
    
    c.Visit("http://www.baidu.com")
}

beautifulsoup4go

2. beautifulsoup4go ist ein Golang-basierter HTML-Parser, genau wie die berühmte Python-Bibliothek BeautifulSoup4, die verschiedene HTML-Seiten aus dem Internet analysieren kann. Der folgende Code zeigt, wie man beautifulsoup4go verwendet, um Baidu-Titel zu erhalten:

package main

import (
    "fmt"
    "github.com/sundy-li/go_commons/crawler"
)

func main() {
    html := crawler.FetchHTML("http://www.baidu.com", "GET", nil, "")

    bs := crawler.NewSoup(html)

    title := bs.Find("title").Text()
    
    fmt.Println(title)
}

goquery

3. Die Goquery-Bibliothek wurde bereits eingeführt und ist ein auf CSS-Selektoren basierender HTML-Parser, der Kettenoperationen unterstützt. Bibliothek. Der folgende Code zeigt, wie Sie mit goquery Baidu-Titel erhalten:

package main

import (
    "fmt"
    "github.com/PuerkitoBio/goquery"
    "log"
)

func main() {
    resp, err := http.Get("http://www.baidu.com")
    if err != nil {
        log.Fatal(err)
    }
    body := resp.Body
    defer body.Close()

    doc, err := goquery.NewDocumentFromReader(body)
    if err != nil {
        log.Fatal(err)
    }

    title := doc.Find("title").Text()
    
    fmt.Println(title)
}

Die oben genannten drei Bibliotheken haben jeweils ihre eigenen Eigenschaften, um den Crawler effizienter zu vervollständigen.

3. Golang-Kerntechnologie zum Schreiben von Crawlern

Parallelität

1. Bei der Implementierung von Crawlern ist die Parallelität eine sehr wichtige Funktion, d. h. der gleichzeitige Zugriff auf mehrere Websites oder mehrere URLs. In Golang können wir Aufgaben gleichzeitig über Coroutinen ausführen, zum Beispiel:

package main

import (
    "fmt"
    "github.com/gocolly/colly"
)

func main() {
    urls := []string{
        "http://www.baidu.com",
        "http://www.sogou.com",
        "http://www.google.com",
    }

    ch := make(chan string, len(urls))

    for _, url := range urls {
        go func(url string) {
            c := colly.NewCollector()

            c.OnHTML("head", func(e *colly.HTMLElement) {
                title := e.ChildText("title")
                ch <- title
            })

            c.Visit(url)
        }(url)
    }

    for range urls {
        title := <-ch
        fmt.Println(title)
    }
}

Im obigen Code verwenden wir Coroutinen, um gleichzeitig auf mehrere URLs zuzugreifen, die Titelinformationen aus dem Head-Tag jeder Website zu extrahieren und auszudrucken.

Anti-Crawler-Mechanismus

2. Wie wir alle wissen, verwenden viele Websites Anti-Crawler-Mechanismen, um den Crawler-Zugriff einzuschränken, z. B. die Begrenzung der Anforderungshäufigkeit, das Hinzufügen von Bestätigungscodes, die Identifizierung gängiger Crawler-Tools usw. Für diese Anti-Crawler-Mechanismen müssen wir einige technische Mittel einsetzen, um zu verhindern, dass wir von der Website ausgeschlossen werden. Hier sind zwei technische Mittel:

(1) Kontrolle der Zugriffshäufigkeit

Um eine Einschränkung durch die Website zu vermeiden, können wir Zugriffsintervalle festlegen, Proxy-IPs verwenden, verteilte Methoden verwenden usw., um eine Blockierung durch die Anti- Crawler-Mechanismus Identifizieren.

Zum Beispiel können wir im Gocolly-Framework Methoden wie WaitTime, RandomDelay und Limit verwenden, um die Crawling-Häufigkeit und Anforderungslimits festzulegen:

package main

import (
    "fmt"
    "github.com/gocolly/colly"
    "time"
)

func main() {
    c := colly.NewCollector()

    c.Limit(&colly.LimitRule{
        DomainGlob:  "*",
        Parallelism: 2,
        RandomDelay: 5 * time.Second,
    })

    c.OnHTML("head", func(e *colly.HTMLElement) {
        title := e.ChildText("title")
        fmt.Println(title)
    })

    c.Visit("http://www.baidu.com")
}

Im obigen Code ist die Anzahl gleichzeitiger Zugriffe auf 2 und das Anforderungsintervall festgelegt beträgt 5 Sekunden, wodurch eine Einschränkung durch die Website effektiv vermieden werden kann. Natürlich müssen wir im tatsächlichen Gebrauch auch angemessene Zugriffsintervalle für verschiedene Websites festlegen.

(2) Verteiltes Crawlen

Verteiltes Crawlen kann die Einschränkung durch Websites effektiv vermeiden und die Crawling-Effizienz verbessern. Die Grundidee besteht darin, verschiedenen Knoten oder Maschinen unterschiedliche Aufgaben zuzuweisen, diese unabhängig voneinander zu bearbeiten und die Ergebnisse zusammenzufassen. Verteiltes Crawlen erfordert Planung, Kommunikation und andere Technologien, was relativ komplex ist. Bei tatsächlichen Crawlern können wir Bibliotheken oder Cloud-Dienste von Drittanbietern verwenden, um verteiltes Crawlen zu implementieren.

Fazit

In diesem Artikel wird erläutert, wie Sie mit Golang einen Crawler schreiben, einschließlich grundlegender Schritte, häufig verwendeter Bibliotheken und Kerntechnologien. Golang ist eine leistungsstarke, prägnante und klare Sprache, die den Anforderungen von Crawlern gut gerecht wird. In der Praxis des Crawlens müssen wir jedoch noch mehr Technologien verstehen und ständig neuere Anti-Crawling-Technologien erlernen, um die Crawling-Aufgabe erfolgreich abzuschließen.

Das obige ist der detaillierte Inhalt vonWie schreibe ich einen Crawler in Golang?. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!