Go分布式爬虫(二十四)_go语言实现分布式爬虫pdf

最新推荐文章于 2024-08-23 16:53:34 发布

2401_84140463

最新推荐文章于 2024-08-23 16:53:34 发布

阅读量697

点赞数 19

分类专栏：程序员文章标签： python 学习面试

本文链接：https://blog.csdn.net/2401_84140463/article/details/138906622

版权

程序员专栏收录该内容

136 篇文章 2 订阅

订阅专栏

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

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

二、Python必备开发工具

工具都帮大家整理好了，安装就可直接上手！

三、最新Python学习笔记

当我学到一定基础，有自己的理解能力的时候，会去阅读一些前辈整理的书籍或者手写的笔记资料，这些笔记详细记载了他们对一些技术点的理解，这些理解是比较独到，可以学到不一样的思路。

四、Python视频合集

观看全面零基础学习视频，看视频学习是最快捷也是最有效果的方式，跟着视频中老师的思路，从基础到深入，还是很容易入门的。

五、实战案例

纸上得来终觉浅，要学会跟着视频一起敲，要动手实操，才能将自己的所学运用到实际当中去，这时候可以搞点实战案例来学习。

六、面试宝典

在这里插入图片描述

简历模板

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

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

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

}
t.data[key] = value
return nil
}


### step3 获取图书详情


最后，点击图书的详情页，可以看到图书的作者、出版社、页数、定价、得分、价格、简介等信息。


![image](https://img-blog.csdnimg.cn/img_convert/753fe11fd4703e1a864809afe3a5c39e.png)

var autoRe = regexp.MustCompile( 作者:[\d\D]\*?<a.\*?>([^<]+)</a>)
var public = regexp.MustCompile(出版社:([^<]+) )
var pageRe = regexp.MustCompile(页数: ([^<]+) )
var priceRe = regexp.MustCompile(定价:([^<]+) )
var scoreRe = regexp.MustCompile(([^<]+))
var intoRe = regexp.MustCompile(<div class="intro">[\d\D]\*?([^<]+)</div>)

func ParseBookDetail(ctx *collect.Context) (collect.ParseResult, error) {
bookName := ctx.Req.TmpData.Get(“book_name”)
page, _ := strconv.Atoi(ExtraString(ctx.Body, pageRe))

book := map[string]interface{}{
“书名”: bookName,
“作者”: ExtraString(ctx.Body, autoRe),
“页数”: page,
“出版社”: ExtraString(ctx.Body, public),
“得分”: ExtraString(ctx.Body, scoreRe),
“价格”: ExtraString(ctx.Body, priceRe),
“简介”: ExtraString(ctx.Body, intoRe),
}
data := ctx.Output(book)

result := collect.ParseResult{
Items: []interface{}{data},
}

return result, nil
}

func ExtraString(contents []byte, re *regexp.Regexp) string {

match := re.FindSubmatch(contents)

if len(match) >= 2 {
return string(match[1])
} else {
return “”
}
}


其中，书名是从缓存中得到的。这里仍然使用了正则表达式作为演示，你也可以改为使用更合适的 CSS 选择器。


### 完整规则

var DoubanBookTask = &collect.Task{
Property: collect.Property{
Name: “douban_book_list”,
WaitTime: 1 * time.Second,
MaxDepth: 5,
Cookie: “xxx”
},
Rule: collect.RuleTree{
Root: func() ([]*collect.Request, error) {
roots := []*collect.Request{
&collect.Request{
Priority: 1,
Url: “https://book.douban.com”,
Method: “GET”,
RuleName: “数据tag”,
},
}
return roots, nil
},
Trunk: map[string]*collect.Rule{
“数据tag”: &collect.Rule{ParseFunc: ParseTag},
“书籍列表”: &collect.Rule{ParseFunc: ParseBookList},
“书籍简介”: &collect.Rule{
ItemFields: []string{
“书名”,
“作者”,
“页数”,
“出版社”,
“得分”,
“价格”,
“简介”,
},
ParseFunc: ParseBookDetail,
},
},
},
}


‍


## 存储到MySQL


### 数据抽象


这里将数据抽象成DataCell, 其key定义如下


* Task: 存储当前任务名
* Rule: 存储当前的规则名
* Url: 存储当前网址
* Time: 存储当前时间
* Data: 存储当前核心数据,即书籍详细信息


	+ Data对应的数据结构又是一个哈希表 map[string]interface{}。
	+ 在这个哈希表中，Key 为“书名”“评分”等字段名，Value 为字段对应的值。
	+ Data 对应的 Value 不一定需要是 map[string]interface{}，只要我们在后面能够灵活地处理不同的类型就可以了。

type DataCell struct {
Data map[string]interface{}
}


输出方法

func (c *Context) Output(data interface{}) *collector.DataCell {
res := &collector.DataCell{}
res.Data = make(map[string]interface{})
res.Data[“Task”] = c.Req.Task.Name
res.Data[“Rule”] = c.Req.RuleName
res.Data[“Data”] = data
res.Data[“Url”] = c.Req.Url
res.Data[“Time”] = time.Now().Format(“2006-01-02 15:04:05”)
return res
}


### 数据存储


然后在 HandleResult 方法中对解析后的数据进行存储。


循环遍历 Items，判断其中的数据类型，如果数据类型为 DataCell，我们就要用专门的存储引擎将这些数据存储起来。（存储引擎是和每一个爬虫任务绑定在一起的，不同的爬虫任务可能会有不同的存储引擎。）

func (s *Crawler) HandleResult() {
for {
select {
case result := <-s.out:
for _, item := range result.Items {
switch d := item.(type) {
case *collector.DataCell:
name := d.GetTaskName()
task := Store.Hash[name]
task.Storage.Save(d)
}
s.Logger.Sugar().Info("get result: ", item)
}
}
}
}


这里选择使用比较常见的 MySQL 数据库作为这个示例的存储引擎。


创建了一个接口 Storage 作为数据存储的接口，Storage 中包含了 Save 方法，任何实现了 Save 方法的后端引擎都可以存储数据。

type Storage interface {
Save(datas …*DataCell) error
}


不过我们还需要完成一轮抽象，因为后端引擎会处理的事务比较繁琐，它不仅仅包含了存储，还包含了缓存、对表头的拼接、数据的处理等。所以，我们要创建一个更加底层的模块，只进行数据的存储。


这个底层抽象的好处在于，我们可以比较灵活地替换底层的存储模块，我在这个例子中使用了原生的 MySQL 语句来与数据库交互。你也可以使用 Xorm 与 Gorm 这样的库来操作数据库。


新建一个文件夹 mysqldb，设置操作数据库的接口 DBer，里面的两个核心函数分别是 CreateTable（创建表）以及 Insert（插入数据）。

type DBer interface {
CreateTable(t TableData) error //TableData 包含了表的元数据
Insert(t TableData) error
}
type Field struct {
Title string
Type string
}
type TableData struct {
TableName string // 表名
ColumnNames []Field // 字段名和字段的属性
Args []interface{} // 数据
DataCount int // 插入数据的数量
AutoKey bool // 标识是否为表创建自增主键
}


下面这段代码，我们使用 option 模式生成了 SqlDB 结构体，实现了 DBer 接口。Sqldb.OpenDB 方法用于与数据库建立连接，需要从外部传入远程 MySQL 数据库的连接地址。

type MySQLDb struct {
options
db *sql.DB
}

func New(opts …Option) (*MySQLDb, error) {
options := defaultOptions
for _, opt := range opts {
opt(&options)
}
d := &MySQLDb{}
d.options = options
if err := d.OpenDB(); err != nil {
return nil, err
}
return d, nil
}

func (d *MySQLDb) OpenDB() error {
db, err := sql.Open(“mysql”, d.sqlUrl)
if err != nil {
return err
}
db.SetMaxOpenConns(2048)
db.SetMaxIdleConns(2048)
if err = db.Ping(); err != nil {
return err
}
d.db = db
return nil
}

// 创建表
func (d *MySQLDb) CreateTable(t TableData) error {
if len(t.ColumnNames) == 0 {
return errors.New(“Column can not be empty”)
}
sql := CREATE TABLE IF NOT EXISTS + t.TableName + " ("
if t.AutoKey {
sql += id INT(12) NOT NULL PRIMARY KEY AUTO\_INCREMENT,
}
for _, t := range t.ColumnNames {
sql += t.Title + + t.Type + ,
}
sql = sql[:len(sql)-1] + ) ENGINE=MyISAM DEFAULT CHARSET=utf8;

d.logger.Debug("crate table", zap.String("sql", sql))

\_, err := d.db.Exec(sql)
return err

}

// 插入操作
func (d *MySQLDb) Insert(t TableData) error {
if len(t.ColumnNames) == 0 {
return errors.New(“empty column”)
}
sql := INSERT INTO + t.TableName + (

for \_, v := range t.ColumnNames {
	sql += v.Title + ","
}

sql = sql[:len(sql)-1] + `) VALUES `

blank := ",(" + strings.Repeat(",?", len(t.ColumnNames))[1:] + ")"
sql += strings.Repeat(blank, t.DataCount)[1:] + `;`
d.logger.Debug("insert table", zap.String("sql", sql))
\_, err := d.db.Exec(sql, t.Args...)
return err

}


### 存储引擎实现

package sqlstorage

import (
“encoding/json”
“github.com/funbinary/crawler/collector”
“github.com/funbinary/crawler/engine”
“github.com/funbinary/crawler/mysqldb”
“go.uber.org/zap”
)

// 实现 Storage 接口的实现

type MySQLStore struct {
dataDocker []*collector.DataCell //分批输出结果缓存
columnNames []mysqldb.Field // 标题字段
db mysqldb.DBer
Table map[string]struct{}
options // 选项
}

func New(opts …Option) (*MySQLStore, error) {
options := defaultOptions
for _, opt := range opts {
opt(&options)
}
s := &MySQLStore{}
s.options = options
s.Table = make(map[string]struct{})
var err error
s.db, err = mysqldb.New(
mysqldb.WithConnUrl(s.sqlUrl),
mysqldb.WithLogger(s.logger),
)
if err != nil {
return nil, err
}

return s, nil

}

func (s *MySQLStore) Save(dataCells …*collector.DataCell) error {
// 循环遍历要存储的 DataCell，并判断当前 DataCell 对应的数据库表是否已经被创建。
for _, cell := range dataCells {
name := cell.GetTableName()
if _, ok := s.Table[name]; !ok {
// 创建表
columnNames := getFields(cell)
err := s.db.CreateTable(mysqldb.TableData{
TableName: name,
ColumnNames: columnNames,
AutoKey: true,
})
if err != nil {
s.logger.Error(“create table falied”, zap.Error(err))
}
s.Table[name] = struct{}{}
}
// 如果当前的数据小于 s.BatchCount，则将数据放入到缓存中直接返回（使用缓冲区批量插入数据库可以提高程序的性能）。
if len(s.dataDocker) >= s.BatchCount {
s.Flush()
}
// 如果缓冲区已经满了，则调用 SqlStore.Flush() 方法批量插入数据。
s.dataDocker = append(s.dataDocker, cell)
}
return nil
}

// getFields 用于获取当前数据的表字段与字段类型，这是从采集规则节点的 ItemFields 数组中获得的。
// 为什么不直接用 DataCell 中 Data 对应的哈希表中的 Key 生成字段名呢？
// 这一方面是因为它的速度太慢，另外一方面是因为 Go 中的哈希表在遍历时的顺序是随机的，而生成的字段列表需要顺序固定。
func getFields(cell *collector.DataCell) []mysqldb.Field {
taskName := cell.Data[“Task”].(string)
ruleName := cell.Data[“Rule”].(string)
fields := engine.GetFields(taskName, ruleName)

var columnNames []mysqldb.Field
for \_, field := range fields {
	columnNames = append(columnNames, mysqldb.Field{
		Title: field,
		Type:  "MEDIUMTEXT",
	})
}
columnNames = append(columnNames,
	mysqldb.Field{Title: "Url", Type: "VARCHAR(255)"},
	mysqldb.Field{Title: "Time", Type: "VARCHAR(255)"},
)
return columnNames

}

// Flush 核心是遍历缓冲区，解析每一个 DataCell 中的数据，将扩展后的字段值批量放入 args 参数中，
// 并调用底层 DBer.Insert 方法批量插入数据
func (s *MySQLStore) Flush() error {
if len(s.dataDocker) == 0 {
return nil
}
args := make([]interface{}, 0)
for _, datacell := range s.dataDocker {
ruleName := datacell.Data[“Rule”].(string)
taskName := datacell.Data[“Task”].(string)
fields := engine.GetFields(taskName, ruleName)
data := datacell.Data[“Data”].(map[string]interface{})
value := []string{}
for _, field := range fields {
v := data[field]
switch v.(type) {
case nil:
value = append(value, “”)
case string:
value = append(value, v.(string))
default:
j, err := json.Marshal(v)
if err != nil {
value = append(value, “”)
} else {
value = append(value, string(j))
}
}
}
value = append(value, datacell.Data[“Url”].(string), datacell.Data[“Time”].(string))
for _, v := range value {
args = append(args, v)
}
}

return s.db.Insert(mysqldb.TableData{
	TableName:   s.dataDocker[0].GetTableName(),
	ColumnNames: getFields(s.dataDocker[0]),
	Args:        args,
	DataCount:   len(s.dataDocker),
})

}


### 存储引擎验证


接下来我们使用运行MySQL, 下面给出两种运行方式:




文末有福利领取哦~
---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------

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

Python所有方向的技术点做的整理，形成各个领域的知识点汇总，它的用处就在于，你可以按照上面的知识点去找对应的学习资源，保证自己学得较为全面。![img](https://img-blog.csdnimg.cn/c67c0f87cf9343879a1278dfb067f802.png)

👉**二、Python必备开发工具**

![img](https://img-blog.csdnimg.cn/757ca3f717df4825b7d90a11cad93bc7.png)  
👉**三、Python视频合集**

观看零基础学习视频，看视频学习是最快捷也是最有效果的方式，跟着视频中老师的思路，从基础到深入，还是很容易入门的。  
![img](https://img-blog.csdnimg.cn/31066dd7f1d245159f21623d9efafa68.png)

👉 **四、实战案例**

光学理论是没用的，要学会跟着一起敲，要动手实操，才能将自己的所学运用到实际当中去，这时候可以搞点实战案例来学习。**（文末领读者福利）**  
![img](https://img-blog.csdnimg.cn/e78afb3dcb8e4da3bae5b6ffb9c07ec7.png)

👉**五、Python练习题**

检查学习结果。  
![img](https://img-blog.csdnimg.cn/280da06969e54cf180f4904270636b8e.png)

👉**六、面试资料**

我们学习Python必然是为了找到高薪的工作，下面这些面试题是来自阿里、腾讯、字节等一线互联网大厂最新的面试资料，并且有阿里大佬给出了权威的解答，刷完这一套面试资料相信大家都能找到满意的工作。  
![img](https://img-blog.csdnimg.cn/a9d7c35e6919437a988883d84dcc5e58.png)

![img](https://img-blog.csdnimg.cn/5db8141418d544d3a8e9da4805b1a3f9.png)

👉因篇幅有限，仅展示部分资料，这份完整版的Python全套学习资料已经上传




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

**[需要这份系统化学习资料的朋友，可以戳这里获取](https://bbs.csdn.net/topics/618317507)**

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

2401_84140463

关注

19
点赞
踩
21

收藏

觉得还不错? 一键收藏
0
评论
Go分布式爬虫(二十四)_go语言实现分布式爬虫pdf

当我学到一定基础，有自己的理解能力的时候，会去阅读一些前辈整理的书籍或者手写的笔记资料，这些笔记详细记载了他们对一些技术点的理解，这些理解是比较独到，可以学到不一样的思路。Python所有方向的技术点做的整理，形成各个领域的知识点汇总，它的用处就在于，你可以按照下面的知识点去找对应的学习资源，保证自己学得较为全面。// 这一方面是因为它的速度太慢，另外一方面是因为 Go 中的哈希表在遍历时的顺序是随机的，而生成的字段列表需要顺序固定。
复制链接

扫一扫