Pembangunan Golang: membina perangkak web yang menyokong konkurensi

Pembangunan Golang: Membina perangkak web yang menyokong concurrency

Dengan perkembangan pesat Internet, mendapatkan data rangkaian telah menjadi keperluan utama dalam banyak senario aplikasi. Sebagai alat untuk mendapatkan data rangkaian secara automatik, perangkak web telah meningkat dengan pesat. Untuk mengatasi jumlah data rangkaian yang semakin besar, membangunkan perangkak yang menyokong concurrency telah menjadi pilihan yang perlu. Artikel ini akan memperkenalkan cara menggunakan Golang untuk menulis perangkak web yang menyokong konkurensi dan memberikan contoh kod khusus.

1. Buat struktur asas crawler

Sebelum kita mula, kita perlu mencipta struktur crawler asas. Struktur ini akan mengandungi beberapa sifat asas dan kaedah yang diperlukan untuk perangkak.

type Spider struct {
    baseURL  string
    maxDepth int
    queue    chan string
    visited  map[string]bool
}

func NewSpider(baseURL string, maxDepth int) *Spider {
    spider := &Spider{
        baseURL:  baseURL,
        maxDepth: maxDepth,
        queue:    make(chan string),
        visited:  make(map[string]bool),
    }
    return spider
}

func (s *Spider) Run() {
    // 实现爬虫的逻辑
}

Dalam kod di atas, kami mentakrifkan struktur Spider, yang mengandungi sifat dan kaedah asas. baseURL mewakili URL permulaan perangkak, maxDepth mewakili kedalaman rangkak maksimum, baris gilir ialah saluran yang digunakan untuk menyimpan URL untuk dirangkak dan yang dilawati ialah peta yang digunakan untuk merekodkan URL yang dilawati.

2. Laksanakan logik crawler

Seterusnya, kami akan melaksanakan logik crawler. Dalam logik ini, kami akan menggunakan goroutine yang disediakan oleh Golang untuk melaksanakan operasi serentak crawler. Langkah-langkah khusus adalah seperti berikut:

• Dapatkan URL untuk dirangkak dari baris gilir
• Tentukan sama ada URL telah dilawati, jika tidak, tambahkannya pada yang dilawati
• Mulakan permintaan HTTP, dapatkan respons
• Parse the kandungan tindak balas, dan ekstrak Data yang diperlukan
• Tambahkan URL yang dihuraikan pada baris gilir
• Ulangi langkah di atas sehingga kedalaman maksimum yang ditetapkan dicapai

func (s *Spider) Run() {
    // 将baseURL添加到queue中
    s.queue <- s.baseURL

    for i := 0; i < s.maxDepth; i++ {
        // 循环直到queue为空
        for len(s.queue) > 0 {
            // 从queue中获取URL
            url := <-s.queue

            // 判断URL是否已经访问过
            if s.visited[url] {
                continue
            }
            // 将URL添加到visited中
            s.visited[url] = true

            // 发起HTTP请求，获取响应
            resp, err := http.Get(url)
            if err != nil {
                // 处理错误
                continue
            }

            defer resp.Body.Close()

            // 解析响应内容，提取需要的数据
            body, err := ioutil.ReadAll(resp.Body)
            if err != nil {
                // 处理错误
                continue
            }

            // 提取URL
            urls := extractURLs(string(body))

            // 将提取出来的URL添加到queue中
            for _, u := range urls {
                s.queue <- u
            }
        }
    }
}

Dalam kod di atas, kami menggunakan gelung for untuk mengawal kedalaman merangkak , dan gunakan gelung The for yang lain merangkak apabila baris gilir tidak kosong. Dan pengendalian ralat yang diperlukan dilakukan sebelum mendapatkan respons, menghuraikan kandungan, mengekstrak URL dan operasi lain.

3. Menguji perangkak

Kini kita boleh menggunakan contoh perangkak di atas untuk ujian. Anggapkan bahawa tapak web yang ingin kami rangkak ialah https://example.com dan tetapkan kedalaman maksimum kepada 2. Kami boleh memanggil perangkak seperti ini:

func main() {
    baseURL := "https://example.com"
    maxDepth := 2

    spider := NewSpider(baseURL, maxDepth)
    spider.Run()
}

Dalam penggunaan sebenar, anda boleh membuat pengubahsuaian dan sambungan yang sepadan mengikut keperluan anda sendiri. Contohnya, memproses data dalam kandungan respons, menambah lebih banyak pengendalian ralat, dsb.

Ringkasan:

Artikel ini memperkenalkan cara menggunakan Golang untuk menulis perangkak web yang menyokong concurrency dan memberikan contoh kod khusus. Dengan menggunakan goroutine untuk melaksanakan operasi serentak, kami boleh meningkatkan kecekapan merangkak. Pada masa yang sama, menggunakan pustaka standard kaya yang disediakan oleh Golang, kami boleh melakukan operasi dengan lebih mudah seperti permintaan HTTP dan penghuraian kandungan. Saya berharap kandungan artikel ini akan membantu anda untuk memahami dan mempelajari perangkak web Golang.

Atas ialah kandungan terperinci Pembangunan Golang: membina perangkak web yang menyokong konkurensi. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!