Golang ne dirige pas les robots d'exploration

1. Avant-propos

Avec le développement d'Internet, le champ d'application des robots d'exploration Web devient de plus en plus large. Dans la vie quotidienne, nous pouvons obtenir diverses informations grâce aux robots d'exploration Web, telles que les actualités, les actions, la météo, les films, la musique, etc. Les robots d’exploration du Web jouent un rôle important, notamment dans les domaines de l’analyse des Big Data et de l’intelligence artificielle. Cet article explique principalement comment utiliser le langage Golang pour écrire un robot d'exploration non directionnel (c'est-à-dire sans site Web cible spécifique) afin d'obtenir des informations sur Internet.

2. Introduction à golang

golang est un langage de programmation développé par Google En raison de sa concurrence, de ses hautes performances, de sa simplicité et de sa facilité d'apprentissage, il est de plus en plus privilégié par les programmeurs. . service. La version Golang utilisée dans cet article est la 1.14.2.

3. Idées d'implémentation

Ce robot est principalement divisé selon les étapes suivantes :

1. Obtenir l'URL de départ

L'URL de départ peut être obtenue en saisissant manuellement l'URL, en lisant l'URL à partir d'un fichier, en lisant l'URL à partir de la base de données, etc.

2. Envoyer une requête http

Envoyez une requête http via Get ou Post pour obtenir les données de réponse.

3. Analyser les données de réponse

Utilisez des expressions régulières ou des bibliothèques tierces pour analyser les données en fonction du format des données de réponse.

4. Stockage des données

Vous pouvez stocker des données dans des fichiers, dans des bases de données ou utiliser d'autres méthodes de stockage, selon vos besoins.

5. Résoudre la nouvelle URL

Selon le lien hypertexte et d'autres informations contenues dans les données de réponse, analysez la nouvelle URL comme la suivante URL explorée.

6. Répétez les étapes ci-dessus

Selon la nouvelle URL, renvoyez la requête http, analysez les données de réponse, stockez les données, analysez la nouvelle URL, répétez Continuer jusqu’à ce qu’il n’y ait plus de nouvelles URL.

4. Implémentation du code

Dans Golang, utilisez le package net/http pour envoyer des requêtes http et utilisez le package regexp ou une bibliothèque tierce pour analyser les données de réponse. Cet article utilise C'est la bibliothèque goquery.

1. Fonction d'initialisation

Tout d'abord, nous devons définir une fonction initiale, qui est chargée d'obtenir l'URL de départ, de configurer le client http et autres opérations.

func init() {
    // 获取起始网址
    flag.StringVar(&startUrl, "url", "", "请输入起始网址")
    flag.Parse()

    // 设置http客户端
    client = &http.Client{
        Timeout: 30 * time.Second,
        CheckRedirect: func(req *http.Request, via []*http.Request) error {
            return http.ErrUseLastResponse
        },
    }
}

2. Envoyer la fonction de requête http

Définir une fonction chargée d'envoyer des requêtes http et d'obtenir des données de réponse.

func GetHtml(url string) (string, error) {
    resp, err := client.Get(url)
    if err != nil {
        log.Println(err)
        return "", err
    }
    defer resp.Body.Close()

    body, err := ioutil.ReadAll(resp.Body)
    if err != nil {
        log.Println(err)
        return "", err
    }

    return string(body), nil
}

3. Fonction d'analyse des données de réponse

Utilisez la bibliothèque goquery pour analyser les données de réponse L'implémentation spécifique est la suivante :

func ParseSingleHTML(html string, query string) []string {
    doc, err := goquery.NewDocumentFromReader(strings.NewReader(html))
    if err != nil {
        log.Println(err)
        return nil
    }

    result := make([]string, 0)
    doc.Find(query).Each(func(i int, selection *goquery.Selection) {
        href, ok := selection.Attr("href")
        if ok {
            result = append(result, href)
        }
    })

    return result
}

#. 🎜🎜#

Fonction de stockage des données

Définir une fonction chargée de stocker les données dans un fichier.

func SaveData(data []string) error {
    file, err := os.OpenFile("data.txt", os.O_APPEND|os.O_CREATE|os.O_WRONLY, 0644)
    if err != nil {
        log.Println(err)
        return err
    }
    defer file.Close()

    writer := bufio.NewWriter(file)
    for _, line := range data {
        _, err := writer.WriteString(line + "
")
        if err != nil {
            log.Println(err)
            return err
        }
    }
    writer.Flush()

    return nil
}

Analyser la nouvelle fonction d'URL

Utilisez des expressions régulières pour analyser les nouvelles URL dans les hyperliens.

func ParseHref(url, html string) []string {
    re := regexp.MustCompile(`<a[sS]+?href="(.*?)"[sS]*?>`)
    matches := re.FindAllStringSubmatch(html, -1)

    result := make([]string, 0)
    for _, match := range matches {
        href := match[1]
        if strings.HasPrefix(href, "//") {
            href = "http:" + href
        } else if strings.HasPrefix(href, "/") {
            href = strings.TrimSuffix(url, "/") + href
        } else if strings.HasPrefix(href, "http://") || strings.HasPrefix(href, "https://") {
            // do nothing
        } else {
            href = url + "/" + href
        }
        result = append(result, href)
    }

    return result
}

Fonction principale

Enfin, nous devons définir une fonction principale pour implémenter l'ensemble du processus du robot.

func main() {
    // 确认起始网址是否为空
    if startUrl == "" {
        fmt.Println("请指定起始网址")
        return
    }

    // 初始化待访问队列
    queue := list.New()
    queue.PushBack(startUrl)

    // 初始化已访问集合
    visited := make(map[string]bool)

    // 循环爬取
    for queue.Len() > 0 {
        // 从队列中弹出一个网址
        elem := queue.Front()
        queue.Remove(elem)
        url, ok := elem.Value.(string)
        if !ok {
            log.Println("网址格式错误")
            continue
        }

        // 确认该网址是否已经访问过
        if visited[url] {
            continue
        }
        visited[url] = true

        // 发送http请求，获取响应数据
        html, err := GetHtml(url)
        if err != nil {
            continue
        }

        // 解析响应数据，获取新的网址
        hrefs := ParseHref(url, html)
        queue.PushBackList(list.New().Init())
        for _, href := range hrefs {
            if !visited[href] {
                hrefHtml, err := GetHtml(href)
                if err != nil {
                    continue
                }
                hrefUrls := ParseSingleHTML(hrefHtml, "a")

                // 将新的网址加入队列
                queue.PushBackList(list.New().Init())
                for _, hrefUrl := range hrefUrls {
                    queue.PushBack(hrefUrl)
                }
            }
        }

        // 存储数据到文件
        data := ParseSingleHTML(html, "title")
        err = SaveData(data)
        if err != nil {
            continue
        }
    }
}

5. Résumé

Ce qui précède est le processus de base et la méthode de mise en œuvre de l'utilisation de Golang pour écrire des robots d'exploration non dirigés. Bien sûr, ce n'est qu'un exemple simple. Dans le développement réel, les stratégies anti-crawler, la sécurité des threads et d'autres problèmes doivent également être pris en compte. J'espère que cela pourra être utile aux lecteurs.

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!