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

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

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

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

24 存储引擎

爬虫项目的一个重要的环节就是把最终的数据持久化存储起来，数据可能会被存储到 MySQL、MongoDB、Kafka、Excel 等多种数据库、中间件或者是文件中。

之前我们爬取的案例比较简单，像是租房网站的信息等。但是实际情况下，我们的爬虫任务通常需要获取结构化的数据。例如一本书的信息就包含书名、价格、出版社、简介、评分等。为了生成结构化的数据，这里豆瓣图书为例书写我们的任务规则。

爬取结构化数据

step1 从首页获取热门标签信息

​​

const regexpStr = `<a href="([^"]+)" class="tag">([^<]+)</a>`
func ParseTag(ctx \*collect.Context) (collect.ParseResult, error) {
  re := regexp.MustCompile(regexpStr)

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

  for \_, m := range matches {
    result.Requesrts = append(
      result.Requesrts, &collect.Request{
        Method:   "GET",
        Task:     ctx.Req.Task,
        Url:      "<https://book.douban.com>" + string(m[1]),
        Depth:    ctx.Req.Depth + 1,
        RuleName: "书籍列表",
      })
  }
  return result, nil
}

step2 获取图书列表

​​

const BooklistRe = `<a.\*?href="([^"]+)" title="([^"]+)"`

func ParseBookList(ctx \*collect.Context) (collect.ParseResult, error) {
  re := regexp.MustCompile(BooklistRe)
  matches := re.FindAllSubmatch(ctx.Body, -1)
  result := collect.ParseResult{}
  for \_, m := range matches {
    req := &collect.Request{
      Method:   "GET",
      Task:     ctx.Req.Task,
      Url:      string(m[1]),
      Depth:    ctx.Req.Depth + 1,
      RuleName: "书籍简介",
    }
    //获取到书名之后，将书名缓存到了临时的 tmp 结构中供下一个阶段读取。
    //这是因为我们希望得到的某些信息是在之前的阶段获得的。
    req.TmpData = &collect.Temp{}
    req.TmpData.Set("book\_name", string(m[2]))
    result.Requesrts = append(result.Requesrts, req)
  }

  return result, nil
}

// 缓存结构定义为了一个哈希表，并封装了 Get 与 Set 两个函数来获取和设置请求中的缓存。
type Temp struct {
  data map[string]interface{}
}

// 返回临时缓存数据
func (t \*Temp) Get(key string) interface{} {
  return t.data[key]
}

func (t \*Temp) Set(key string, value interface{}) error {
  if t.data == nil {
    t.data = make(map[string]interface{}, 8)
  }
  t.data[key] = value
  return nil
}

step3 获取图书详情

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

​​

var autoRe = regexp.MustCompile(`<span class="pl"> 作者</span>:[\d\D]\*?<a.\*?>([^<]+)</a>`)
var public = regexp.MustCompile(`<span class="pl">出版社:</span>([^<]+)<br/>`)
var pageRe = regexp.MustCompile(`<span class="pl">页数:</span> ([^<]+)<br/>`)
var priceRe = regexp.MustCompile(`<span class="pl">定价:</span>([^<]+)<br/>`)
var scoreRe = regexp.MustCompile(`<strong class="ll rating\_num " property="v:average">([^<]+)</strong>`)
var intoRe = regexp.MustCompile(`<div class="intro">[\d\D]\*?<p>([^<]+)</p></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 {
			// 创建表


**（1）Python所有方向的学习路线（新版）**  

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

最近我才对这些路线做了一下新的更新，知识体系更全面了。



![在这里插入图片描述](https://img-blog.csdnimg.cn/1f807758e039481fa866130abf71d796.png#pic_center)



**（2）Python学习视频**



包含了Python入门、爬虫、数据分析和web开发的学习视频，总共100多个，虽然没有那么全面，但是对于入门来说是没问题的，学完这些之后，你可以按照我上面的学习路线去网上找其他的知识资源进行进阶。

![在这里插入图片描述](https://img-blog.csdnimg.cn/d66e3ad5592f4cdcb197de0dc0438ec5.png#pic_center)



**（3）100多个练手项目**

我们在看视频学习的时候，不能光动眼动脑不动手，比较科学的学习方法是在理解之后运用它们，这时候练手项目就很适合了，只是里面的项目比较多，水平也是参差不齐，大家可以挑自己能做的项目去练练。

![在这里插入图片描述](https://img-blog.csdnimg.cn/f5aeb4050ab547cf90b1a028d1aacb1d.png#pic_center)




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

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

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