Go分布式爬虫笔记(二十二)_extensions randomua

ParseFunc func([]byte, *Request) ParseResult
}

那在异步爬取的情况下，我们怎么知道当前网站的深度呢？最好的时机是在采集引擎采集并解析爬虫数据，并将下一层的请求放到队列中的时候。以我们之前写好的 ParseURL 函数为例，在添加下一层的 URL 时，我们将 Depth 加 1，这样就标识了下一层的深度。

func ParseURL(contents []byte, req *collect.Request) collect.ParseResult {
re := regexp.MustCompile(urlListRe)

matches := re.FindAllSubmatch(contents, -1)
result := collect.ParseResult{}

for _, m := range matches {
u := string(m[1])
result.Requesrts = append(
result.Requesrts, &collect.Request{
Url: u,
WaitTime: req.WaitTime,
Cookie: req.Cookie,
Depth: req.Depth + 1,
MaxDepth: req.MaxDepth,
ParseFunc: func(c []byte, request *collect.Request) collect.ParseResult {
return GetContent(c, u)
},
})
}
return result
}

最后一步，我们在爬取新的网页之前，判断最大深度。如果当前深度超过了最大深度，那就不再进行爬取。

func (r *Request) Check() error {
if r.Depth > r.MaxDepth {
return errors.New(“Max depth limit reached”)
}
return nil
}

func (s *Schedule) CreateWork() {
for {
r := <-s.workerCh
if err := r.Check(); err != nil {
s.Logger.Error(“check failed”,
zap.Error(err),
)
continue
}
…
}
}

## 避免请求重复


目的:


* 避免死循环
* 无效爬取


考虑点:


* 用什么数据结构来存储数据才能保证快速地查找到请求的记录？  
哈希表
* 如何保证并发查找与写入时，不出现并发冲突问题？  
 锁, sync.Map
* 在什么条件下，我们才能确认请求是重复的，从而停止爬取？  
 任务进行前检查


在解决上面的三个问题之前，我们先优化一下代码。我们之前的 Request 结构体会在每一次请求时发生变化，但是我们希望有一个字段能够表示一整个网站的爬取任务，因此我们需要抽离出一个新的结构 **Task ​**作为一个**爬虫任务**，而 Request 则作为单独的请求存在。有些参数是整个任务共有的，例如 Task 中的 Cookie、MaxDepth（最大深度）、WaitTime（默认等待时间）和 RootReq（任务中的第一个请求）。

type Task struct {
Url string
Cookie string
WaitTime time.Duration
MaxDepth int
RootReq *Request
Fetcher Fetcher
}

// 单个请求
type Request struct {
Task *Task
Url string
Depth int
ParseFunc func([]byte, *Request) ParseResult
}

由于抽象出了 Task，代码需要做对应的修改，例如我们需要把初始的 Seed 种子任务替换为 Task 结构。

for i := 0; i <= 0; i += 25 {
str := fmt.Sprintf(“https://www.douban.com/group/szsh/discussion?start=%d”, i)
seeds = append(seeds, &collect.Task{
…
Url: str,
RootReq: &collect.Request{
ParseFunc: doubangroup.ParseURL,
},
})
}

同时，在深度检查时，每一个请求的最大深度需要从 Task 字段中获取。

func (r *Request) Check() error {
if r.Depth > r.Task.MaxDepth {
return errors.New(“Max depth limit reached”)
}
return nil
}

接下来，我们继续用一个哈希表结构来存储历史请求。  
 由于我们希望随时访问哈希表中的历史请求，所以把它放在 Request、Task 中都不合适。 放在调度引擎中也不合适，因为调度引擎从功能上讲，应该只负责调度才对。所以，我们还需要完成一轮抽象，**将调度引擎抽离出来作为一个接口，让它只做调度的工作，不用负责存储全局变量等任务。**

type Crawler struct {
out chan collect.ParseResult //负责处理爬取后的数据，完成下一步的存储操作。schedule 函数会创建调度程序，负责的是调度的核心逻辑。
Visited map[string]bool //存储请求访问信息
VisitedLock sync.Mutex
options
}

type Scheduler interface {
Schedule() //启动调度器
Push(…*collect.Request) //将请求放入到调度器中
Pull() *collect.Request //从调度器中获取请求
}

type Schedule struct {
requestCh chan *collect.Request //负责接收请求
workerCh chan *collect.Request //负责分配任务给 worker
reqQueue []*collect.Request
Logger *zap.Logger
}

Visited 中的 Key 是请求的唯一标识，我们现在先将唯一标识设置为 URL + method 方法，并使用 MD5 生成唯一键。后面我们还会为唯一标识加上当前请求的规则条件。

// 请求的唯一识别码
func (r *Request) Unique() string {
block := md5.Sum([]byte(r.Url + r.Method))
return hex.EncodeToString(block[:])
}

接着，编写 HasVisited 方法，判断当前请求是否已经被访问过。StoreVisited 方法用于将请求存储到 Visited 哈希表中。

func (e *Crawler) HasVisited(r *collect.Request) bool {
e.VisitedLock.Lock()
defer e.VisitedLock.Unlock()
unique := r.Unique()
return e.Visited[unique]
}

func (e *Crawler) StoreVisited(reqs …*collect.Request) {
e.VisitedLock.Lock()
defer e.VisitedLock.Unlock()

for _, r := range reqs {
unique := r.Unique()
e.Visited[unique] = true
}
}

最后在 Worker 中，在执行 request 前，判断当前请求是否已被访问。如果请求没有被访问过，将 request 放入 Visited 哈希表中。

func (s *Crawler) CreateWork() {
for {

一、Python所有方向的学习路线

Python所有方向路线就是把Python常用的技术点做整理，形成各个领域的知识点汇总，它的用处就在于，你可以按照上面的知识点去找对应的学习资源，保证自己学得较为全面。

二、学习软件

工欲善其事必先利其器。学习Python常用的开发软件都在这里了，给大家节省了很多时间。

三、入门学习视频

我们在看视频学习的时候，不能光动眼动脑不动手，比较科学的学习方法是在理解之后运用它们，这时候练手项目就很适合了。

网上学习资料一大堆，但如果学到的知识不成体系，遇到问题时只是浅尝辄止，不再深入研究，那么很难做到真正的技术提升。

需要这份系统化学习资料的朋友，可以戳这里无偿获取

一个人可以走的很快，但一群人才能走的更远！不论你是正从事IT行业的老鸟或是对IT行业感兴趣的新人，都欢迎加入我们的的圈子（技术交流、学习资源、职场吐槽、大厂内推、面试辅导），让我们一起学习成长！