So verwenden Sie die Go-Sprache und Redis, um verteilte Crawler zu entwickeln

So verwenden Sie die Go-Sprache und Redis, um verteilte Crawler zu entwickeln

Einführung:
Mit der rasanten Entwicklung der Internettechnologie werden Webcrawler zunehmend in Bereichen wie Data Mining, Suchmaschinenoptimierung und Informationssammlung eingesetzt. Unter anderem können verteilte Crawler die Clusterressourcen voll ausnutzen und die Crawling-Effizienz und -Stabilität verbessern. In diesem Artikel wird vorgestellt, wie man mit der Go-Sprache und Redis einen einfachen verteilten Crawler entwickelt, um den Lesern zu helfen, verwandte Technologien besser zu verstehen und anzuwenden.

1. Vorbereitung
Bevor wir mit dem Beispiel dieses Artikels beginnen, müssen wir die folgenden Vorbereitungen abschließen:

1. Installieren Sie die Go-Sprachentwicklungsumgebung: Bitte stellen Sie sicher, dass Ihr Computer die Go-Sprachentwicklungsumgebung korrekt installiert und die entsprechende Umgebung konfiguriert hat Variablen.
2. Redis installieren: Redis ist eine Open-Source-In-Memory-Datenbank, die zum Speichern von Informationen wie der Aufgabenwarteschlange und Ergebnissen des Crawler-Programms verwendet werden kann. Bitte installieren Sie Redis entsprechend Ihrem Betriebssystemtyp und Ihrer Betriebssystemversion und starten Sie den Redis-Dienst.

2. Projektstruktur und Codebeispiele
Wir werden die Go-Sprache verwenden, um ein einfaches verteiltes Crawler-Programm zu schreiben. Das Folgende ist die grundlegende Verzeichnisstruktur des Projekts:

• crawler

  • main.go
  • worker. go
  • conn.go

1. main.go
   Erstellen Sie eine Datei namens main.go und schreiben Sie den folgenden Code:

package main

import (
    "fmt"
    "net/http"
    "strconv"
)

func main() {
    // 创建一个任务队列，用来存储待爬取的URL
    taskQueue := make(chan string)
    go func() {
        // 将待爬取的URL加入到任务队列中
        for i := 1; i <= 10; i++ {
            url := "http://example.com/page" + strconv.Itoa(i)
            taskQueue <- url
        }
        close(taskQueue)
    }()

    // 创建一定数量的爬虫协程，并从任务队列中获取URL进行爬取
    for i := 0; i < 5; i++ {
        go func() {
            for url := range taskQueue {
                resp, err := http.Get(url)
                if err != nil {
                    fmt.Println("Failed to crawl", url)
                } else {
                    fmt.Println("Crawled", url)
                    // TODO: 解析和处理网页内容
                }
            }
        }()
    }

    // 阻塞主进程
    select {}
}

In main.go haben wir eine Aufgabenwarteschlange taskQueue erstellt und in eine Add-Datei eingefügt die URL, die in eine separate Goroutine gecrawlt werden soll. Anschließend haben wir mehrere Crawler-Coroutinen (hier 5) zum Crawlen erstellt, indem wir die URL aus der Aufgabenwarteschlange abgerufen haben.

2. worker.go
   Als nächstes erstellen wir eine Datei mit dem Namen worker.go und schreiben den folgenden Code:

package main

import (
    "fmt"
    "github.com/go-redis/redis"
)

func main() {
    // 连接Redis数据库
    client := redis.NewClient(&redis.Options{
        Addr:     "localhost:6379",
        Password: "",
        DB:       0,
    })

    // 创建一个爬虫任务队列
    taskQueue := make(chan string)

    // 监听Redis的任务队列，并将任务URL加入到爬虫任务队列中
    go func() {
        for {
            task, err := client.BLPop(0, "task_queue").Result()
            if err == nil {
                url := task[1]
                taskQueue <- url
            }
        }
    }()

    // 创建一定数量的爬虫协程，并从爬虫任务队列中获取URL进行爬取
    for i := 0; i < 5; i++ {
        go func() {
            for url := range taskQueue {
                fmt.Println("Crawling", url)
                // TODO: 真正的爬虫逻辑
                // 将爬取结果保存到Redis或其他存储介质中
            }
        }()
    }

    // 阻塞主进程
    select {}
}

In worker.go stellen wir eine Verbindung zur Redis-Datenbank her und erstellen eine Crawler-Aufgabenwarteschlange taskQueue. Dann hören wir die Redis-Aufgabenwarteschlange in einer Goroutine ab und fügen die Aufgaben-URL zur Crawler-Aufgabenwarteschlange hinzu. Schließlich haben wir mehrere Crawler-Coroutinen (hier 5) zum Crawlen erstellt, indem wir die URL aus der Crawler-Aufgabenwarteschlange abgerufen haben.

3. conn.go
   Erstellen Sie eine Datei mit dem Namen conn.go und schreiben Sie den folgenden Code:

package main

import (
    "github.com/go-redis/redis"
)

// NewRedisClient 创建一个Redis客户端连接
func NewRedisClient() *redis.Client {
    client := redis.NewClient(&redis.Options{
        Addr:     "localhost:6379",
        Password: "",
        DB:       0,
    })
    return client
}

// AddTask 将任务URL加入到Redis的任务队列中
func AddTask(client *redis.Client, url string) error {
    err := client.RPush("task_queue", url).Err()
    if err != nil {
        return err
    }
    return nil
}

In conn.go kapseln wir die Methode NewRedisClient(), um eine Verbindung zur Redis-Datenbank herzustellen und die Aufgaben-URL zu Redis hinzuzufügen Methode AddTask() in der Aufgabenwarteschlange.

3. Führen Sie das Programm aus
Nach Abschluss des obigen Codeschreibens können wir das Programm ausführen. Öffnen Sie zunächst ein Terminalfenster, geben Sie das Projektstammverzeichnis ein und führen Sie den folgenden Befehl aus, um die Crawler-Coroutine zu starten:

go run main.go

Öffnen Sie dann ein neues Terminalfenster, geben Sie ebenfalls das Projektstammverzeichnis ein und führen Sie den folgenden Befehl aus, um die funktionierende Coroutine zu starten :

go run worker.go

4. Zusammenfassung
Durch die obigen Codebeispiele haben wir gelernt, wie man mit der Go-Sprache und Redis einen einfachen verteilten Crawler entwickelt. Zu den Hauptschritten gehören: Erstellen einer Aufgabenwarteschlange, Erstellen mehrerer Crawler-Coroutinen, Überwachen der Aufgabenwarteschlange, Abrufen von URLs aus der Aufgabenwarteschlange zum Crawlen usw. Gleichzeitig haben wir auch gelernt, wie man Redis als Tool zur Implementierung von Aufgabenwarteschlangen verwendet und über den BLPop-Befehl von Redis Aufgaben aus der Aufgabenwarteschlange erhält. Ich hoffe, dieser Artikel kann Ihnen helfen, verteilte Crawler zu verstehen und zu üben.

Das obige ist der detaillierte Inhalt vonSo verwenden Sie die Go-Sprache und Redis, um verteilte Crawler zu entwickeln. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!