Comment écrire un robot en Golang

Avec la popularité d'Internet, nous avons besoin d'obtenir une grande quantité d'informations, et une grande partie de celles-ci nous oblige à les explorer à partir du site Web. Il existe de nombreuses méthodes d'exploration, parmi lesquelles les robots écrits en Golang peuvent nous aider à obtenir ces informations plus efficacement.

golang est un langage de programmation intuitif, concis et efficace, adapté aux scénarios d'application à haute concurrence et hautes performances, et les robots d'exploration sont une tâche à haute concurrence et hautes performances, donc écrire des robots d'exploration en golang est très approprié. Dans cet article, nous présenterons le processus de base, les bibliothèques couramment utilisées et les technologies de base pour écrire des robots d'exploration dans Golang afin d'aider les débutants à maîtriser rapidement les méthodes de base des robots d'exploration Golang.

1. Étapes de base pour écrire des robots d'exploration en golang

Avant de présenter les étapes de base pour écrire des robots d'exploration en golang, nous devons comprendre la structure HTML de base.

1. Requête HTTP

Dans la bibliothèque standard de Golang, les fonctions associées aux requêtes HTTP ont été fournies. Il nous suffit de définir l'URL et la requête Avec. informations de base telles que les en-têtes, les cookies et les paramètres de requête, vous pouvez créer la requête HTTP dont vous avez besoin. Le code principal est le suivant :

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))
}

Ce code utilise la fonction http.Get pour lancer une requête HTTP et lire le corps de la réponse à partir de la réponse. Le point clé est l'instruction defer, qui sera exécutée à la fin de la fonction pour fermer le corps de la réponse et éviter les fuites de ressources.

2. Analyser la page HTML

Les données de réponse obtenues par la requête HTTP sont un document HTML, et nous devons l'analyser afin d'obtenir les données requises. En Golang, nous pouvons utiliser la bibliothèque GoQuery pour analyser des documents HTML. Cette bibliothèque est basée sur la syntaxe de jQuery et est facile à utiliser.

Les principales fonctions d'analyse fournies par GoQuery sont : Rechercher, Filtrer, Chacun, Attr, etc. La fonction Rechercher est utilisée pour rechercher les sous-éléments qui répondent aux critères, et la fonction Filtre est utilisée pour filtrer les éléments qui répondent aux critères. La fonction Each est utilisée pour parcourir tous les éléments qui remplissent les conditions, tandis que la fonction Attr est utilisée pour obtenir les attributs de l'élément. En prenant l'analyse de la page d'accueil de Baidu comme exemple, le code est le suivant :

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())
    })
}

Dans le code ci-dessus, la fonction goquery.NewDocumentFromReader est utilisée pour construire l'objet document, puis l'élément titre est trouvé via la méthode Find, et tous les éléments qualificatifs sont parcourus via la méthode Each pour afficher son texte.

3. Stockage des données

La dernière étape consiste à enregistrer les données obtenues. Pour le stockage des données, nous avons le choix entre de nombreuses méthodes, telles que des bases de données, des fichiers, des caches, etc.

Par exemple, nous souhaitons enregistrer les données analysées dans un fichier CSV. Les étapes sont les suivantes :

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"})
}

Le code ci-dessus utilise la fonction os.Create pour créer un. fichier nommé data csv, puis créez un écrivain CSV via la fonction csv.NewWriter. Enfin, nous écrivons les données à enregistrer dans le fichier CSV via la méthodewriter.Write.

2. Bibliothèques couramment utilisées pour écrire des robots d'exploration dans Golang

L'écriture de robots d'exploration dans Golang ne nécessite pas que vous écriviez vous-même beaucoup de code sous-jacent. Les bibliothèques de robots d'exploration courantes sont les suivantes :

# 🎜🎜#Gocolly

Gocolly est un framework d'exploration léger basé sur Golang, qui fournit de nombreuses méthodes pratiques pour aider à explorer les données. Il peut gérer automatiquement des problèmes tels que la redirection, les cookies, les proxys, les limites de vitesse, etc., nous permettant ainsi de nous concentrer davantage sur la définition des règles d'extraction des données. Le code suivant montre comment utiliser Gocolly pour obtenir le titre de Baidu :

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

beautifulsoup4go est un analyseur HTML basé sur Golang, et The la même célèbre bibliothèque Python BeautifulSoup4 peut analyser différentes pages HTML sur Internet. Le code suivant montre comment utiliser beautifulsoup4go pour obtenir le titre de Baidu :

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

La bibliothèque goquery a été introduite plus tôt, c'est un Basé sur CSS L'analyseur HTML du sélecteur prend en charge les opérations en chaîne et constitue une bibliothèque très pratique. Le code suivant montre comment utiliser goquery pour obtenir des titres Baidu :

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)
}

Chacune des trois bibliothèques ci-dessus a ses propres caractéristiques. En choisissant la bibliothèque qui vous convient, vous pouvez compléter le robot plus efficacement.

3. Technologie de base Golang pour l'écriture de robots d'exploration

Concurrency

Dans le processus d'implémentation d'un robot d'exploration, un est très important. La fonctionnalité unique est la simultanéité, c'est-à-dire l'accès à plusieurs sites Web ou à plusieurs URL en même temps. Dans Golang, nous pouvons effectuer des tâches simultanément via des coroutines, par exemple :

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)
    }
}

Dans le code ci-dessus, nous utilisons des coroutines pour obtenir un accès simultané à plusieurs URL, et à partir de la balise head de chaque site Web Extraire les informations d'en-tête et imprimez-le.

mécanisme anti-crawler

Comme nous le savons tous, afin de limiter l'accès des robots, de nombreux sites Web adopteront des mécanismes anti-crawler, tels que comme limiter la fréquence des demandes et ajouter du code de vérification, identifier les outils d'exploration courants, etc. Pour ces mécanismes anti-crawler, nous devons utiliser certains moyens techniques pour éviter d'être banni du site Web. Voici deux moyens techniques :

(1) Contrôle de la fréquence d'accès

Afin d'éviter d'être restreint par le site Web, nous pouvons définir l'intervalle d'accès, utiliser une IP proxy et utiliser des méthodes de distribution et d’autres moyens pour éviter d’être reconnu par le mécanisme anti-reptile.

Par exemple, dans le framework Gocolly, nous pouvons utiliser des méthodes telles que WaitTime, RandomDelay et Limit pour définir la fréquence d'exploration et les limites de requêtes :

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")
}

Le nombre d'accès simultanés défini dans le code ci-dessus est 2. L'intervalle de requête est de 5 secondes, ce qui peut effectivement éviter d'être restreint par le site Web. Bien entendu, dans la pratique, nous devons également définir des intervalles d’accès raisonnables en fonction des différents sites Web.

(2) Exploration distribuée

L'exploration distribuée peut efficacement éviter d'être restreinte par les sites Web et améliorer l'efficacité de l'exploration. L'idée de base est d'attribuer différentes tâches à différents nœuds ou machines, de les traiter indépendamment et de résumer les résultats ensemble. L'exploration distribuée nécessite une planification, une communication et d'autres technologies, ce qui est relativement complexe. Dans les robots d'exploration réels, nous pouvons utiliser des bibliothèques tierces ou des services cloud pour mettre en œuvre une exploration distribuée.

Conclusion

Cet article explique comment utiliser Golang pour écrire un robot d'exploration, y compris les étapes de base, les bibliothèques communes et les technologies de base. Golang est un langage performant, concis et clair qui peut bien répondre aux besoins des robots. Cependant, dans la pratique de l'exploration, nous devons encore comprendre davantage de technologies et apprendre constamment de nouvelles technologies anti-exploration afin de mener à bien la tâche d'exploration.

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!