Golang leitet keine Crawler

1. Einleitung

Mit der Entwicklung des Internets wird der Anwendungsbereich von Webcrawlern immer größer. Im täglichen Leben können wir über Webcrawler verschiedene Informationen abrufen, z. B. Nachrichten, Aktien, Wetter, Filme, Musik usw. Gerade in den Bereichen Big-Data-Analyse und künstliche Intelligenz spielen Webcrawler eine wichtige Rolle. In diesem Artikel wird hauptsächlich erläutert, wie Sie mithilfe der Golang-Sprache einen ungerichteten Crawler (dh keine bestimmte Zielwebsite) schreiben, um Informationen im Internet abzurufen.

2. Einführung in Golang

Golang ist eine von Google entwickelte Programmiersprache, die aufgrund ihrer Parallelität, hohen Leistung, Einfachheit und einfachen Erlernbarkeit immer beliebter wird. Die in diesem Artikel verwendete Golang-Version ist 1.14.2.

3. Implementierungsideen

Dieser Crawler ist hauptsächlich in die folgenden Schritte unterteilt:

1. Start-URL abrufen

Sie können die URL manuell eingeben, die URL aus der Datei lesen und die URL aus der Datei lesen Datenbank usw. Start-URL.

2. HTTP-Anfrage senden

HTTP-Anfrage über Get oder Post senden, um die Antwortdaten zu erhalten.

3. Antwortdaten analysieren

Verwenden Sie reguläre Ausdrücke oder Bibliotheken von Drittanbietern, um die Daten entsprechend dem Format der Antwortdaten zu analysieren.

4. Speichern von Daten

Sie können Daten je nach Bedarf in Dateien, in Datenbanken speichern oder andere Speichermethoden verwenden.

5. Parsen Sie die neue URL

Parsen Sie die neue URL entsprechend dem Hyperlink und anderen Informationen in den Antwortdaten als nächste zu crawlende URL.

6. Wiederholen Sie die obigen Schritte

Entsprechend der neuen URL senden Sie die http-Anfrage erneut, analysieren Sie die Antwortdaten, speichern Sie die Daten, analysieren Sie die neue URL und wiederholen Sie den Vorgang, bis keine neue URL mehr vorhanden ist.

4. Code-Implementierung

Verwenden Sie in Golang das Paket net/http, um http-Anfragen zu senden, und verwenden Sie das Paket regexp oder eine Bibliothek eines Drittanbieters, um die Antwortdaten zu analysieren.

1. Initialisierungsfunktion

Zunächst müssen wir eine Anfangsfunktion definieren, die für den Erhalt der Start-URL, die Einrichtung des http-Clients und andere Vorgänge verantwortlich ist.

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. HTTP-Anfragefunktion senden

Definieren Sie eine Funktion, die für das Senden von http-Anfragen und das Erhalten von Antwortdaten verantwortlich ist.

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. Antwortdatenfunktion analysieren

Goquery-Bibliothek zum Parsen von Antwortdaten verwenden. Die spezifische Implementierung lautet wie folgt:

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
}

4. Speicherdatenfunktion

Definieren Sie eine Funktion, die für das Speichern von Daten in einer Datei verantwortlich ist.

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
}

5. Funktion zum Parsen neuer URLs

Verwenden Sie reguläre Ausdrücke, um neue URLs in Hyperlinks zu analysieren.

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
}

6. Hauptfunktion

Schließlich müssen wir eine Hauptfunktion definieren, um den gesamten Crawler-Prozess zu implementieren.

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. Zusammenfassung

Das Obige ist der grundlegende Prozess und die Implementierungsmethode für die Verwendung von Golang zum Schreiben ungerichteter Crawler. Dies ist natürlich nur ein einfaches Beispiel. Bei der tatsächlichen Entwicklung müssen auch Anti-Crawler-Strategien, Thread-Sicherheit und andere Probleme berücksichtigt werden. Ich hoffe, es kann den Lesern hilfreich sein.

Das obige ist der detaillierte Inhalt vonGolang leitet keine Crawler. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!