Golang实现简单爬虫框架（3）——简单并发版

原创

小城里OL 2023-01-12 01:54:26 博主文章分类：golang ©著作权

文章标签 golang 爬虫任务调度 github 单任务 文章分类 Hadoop 大数据

©著作权归作者所有：来自51CTO博客作者小城里OL的原创作品，请联系作者获取转载授权，否则将追究法律责任

在上篇文章Golang实现简单爬虫框架（2）——单任务版爬虫中我们实现了一个简单的单任务版爬虫，对于单任务版爬虫，每次都要请求页面，然后解析数据，然后才能请求下一个页面。整个过程中，获取网页数据速度比较慢，那么我们就把获取数据模块做成并发执行。在项目的基础上，实现多任务并发版爬虫。

项目github地址：https://github.com/NovemberChopin/golang-crawler 回滚到相应记录食用，效果更佳。

1、项目架构

首先我们把但任务版爬虫架构中的Fetcher模块和Parser模块合并成一个Worker模块，然后并发执行Worker模块

Golang实现简单爬虫框架（3）——简单并发版_golang

然后得到并发版的架构图：

Golang实现简单爬虫框架（3）——简单并发版_爬虫_02

在并发版爬虫中，会同时执行多个Worker，每个Worker任务接受一个Request请求，然后请求页面解析数据，输出解析出的Requests和Item
因为又很多Request和Worker，所以还需要Scheduler模块，负责对请求任务的调度处理
Engine模块接受Worker发送的Requests和Items，当前我们先把Items打印出，把解析出的Request发送给调度器
其中Engine和Scheduler是一个goroutine，Worker包含多个goroutine，各个模块之间都是用channel进行连接
先放上重构后的项目文件结构：

Golang实现简单爬虫框架（3）——简单并发版_github_03

2、Worker实现

我们从engine.go中提取下面功能作为Worker模块，同时把engine.go 更名为simple.go。修改后的simple.go文件请自行调整，或者去github项目源代码回滚查看。

engine/worker.go

package engine

import (
  "crawler/fetcher"
  "log"
)

// 输入 Request， 返回 ParseResult
func worker(request Request) (ParseResult, error) {
  log.Printf("Fetching %s\n", request.Url)
  content, err := fetcher.Fetch(request.Url)
  if err != nil {
    log.Printf("Fetch error, Url: %s %v\n", request.Url, err)
    return ParseResult{}, err
  }
  return request.ParseFunc(content), nil
}

对于每一个Worker接受一个请求，然后返回解析出的内容

3、并发引擎Concurrent实现

请大家根据架构图来看，效果会更好。

package engine

import "log"

// 并发引擎
type ConcurrendEngine struct {
   Scheduler   Scheduler   // 任务调度器
   WorkerCount int         // 任务并发数量
}

// 任务调度器
type Scheduler interface {
   Submit(request Request) // 提交任务
   ConfigMasterWorkerChan(chan Request)   // 配置初始请求任务
}

func (e *ConcurrendEngine) Run(seeds ...Request) {

   in := make(chan Request)         // scheduler的输入
   out := make(chan ParseResult) // worker的输出
   e.Scheduler.ConfigMasterWorkerChan(in) // 把初始请求提交给scheduler

   // 创建 goruntine
   for i := 0; i < e.WorkerCount; i++ {
      createWorker(in, out)
   }

   // engine把请求任务提交给 Scheduler
   for _, request := range seeds {
      e.Scheduler.Submit(request)
   }

   itemCount := 0
   for {
      // 接受 Worker 的解析结果
      result := <-out
      for _, item := range result.Items {
         log.Printf("Got item: #%d: %v\n", itemCount, item)
         itemCount++
      }

      // 然后把 Worker 解析出的 Request 送给 Scheduler
      for _, request := range result.Requests {
         e.Scheduler.Submit(request)
      }
   }
}

// 创建任务，调用worker，分发goroutine
func createWorker(in chan Request, out chan ParseResult) {
   go func() {
      for {
         request := <-in
         result, err := worker(request)
         if err != nil {
            continue
         }
         out <- result
      }
   }()
}

4、任务调度器Scheduler实现

scheduler/scheduler.go

package scheduler

import "crawler/engine"

type SimpleScheduler struct {
  workerChan chan engine.Request
}

func (s *SimpleScheduler) Submit(request engine.Request) {
  // send request down to worker chan
  go func() {
    s.workerChan <- request
  }()
}

// 把初始请求发送给 Scheduler
func (s *SimpleScheduler) ConfigMasterWorkerChan(in chan engine.Request) {
  s.workerChan = in
}

5、main函数

package main

import (
  "crawler/engine"
  "crawler/scheduler"
  "crawler/zhenai/parser"
)

func main() {
  e := engine.ConcurrendEngine{ // 配置爬虫引擎
    Scheduler:   &scheduler.SimpleScheduler{},
    WorkerCount: 50,
  }
  e.Run(engine.Request{   // 配置爬虫目标信息
    Url:       "http://www.zhenai.com/zhenghun",
    ParseFunc: parser.ParseCityList,
  })
}