登录
目录
当前位置： 首页 > 文档资料 > Pholcus 使用手册 >

采集规则 - 添加一条简单规则

优质
小牛编辑
132浏览
2023-12-01

3.4 运行规则分析

本节会给大家提供一个参考实例，用于告诉大家如何根据具体的业务实现自己的爬虫框架。

我们以公共规则中“阿里巴巴产品搜索”为例（这些公共的规则都在github.com/pholcus下面包含，大家可以参考下）。

  1. package spider_lib
  3. // 基础包
  4. import (
  5.     "github.com/PuerkitoBio/goquery"                        //DOM解析
  6.     "github.com/henrylee2cn/pholcus/app/downloader/context" //必需
  7.     . "github.com/henrylee2cn/pholcus/app/spider"           //必需
  8.     . "github.com/henrylee2cn/pholcus/app/spider/common"    //选用
  9.     "github.com/henrylee2cn/pholcus/logs"                   //信息输出
  11.     // net包
  12.     "net/http" //设置http.Header
  13.     // "net/url"
  15.     // 编码包
  16.     // "encoding/xml"
  17.     // "encoding/json"
  19.     // 字符串处理包
  20.     // "regexp"
  21.     "strconv"
  22.     "strings"
  24.     // 其他包
  25.     // "fmt"
  26.     // "math"
  27.     // "time"
  28. )
  30. func init() {
  31.     AlibabaProduct.Register()
  32. }
  34. var AlibabaProduct = &Spider{
  35.     Name:        "阿里巴巴产品搜索",
  36.     Description: "阿里巴巴产品搜索 [s.1688.com/selloffer/offer_search.htm]",
  37.     // Pausetime: 300,
  38.     Keyword:      KEYWORD,
  39.     MaxPage:      MAXPAGE,
  40.     EnableCookie: false,
  41.     RuleTree: &RuleTree{
  42.         Root: func(ctx *Context) {
  43.             ctx.Aid(map[string]interface{}{"loop": [2]int{0, 1}, "Rule": "生成请求"}, "生成请求")
  44.         },
  46.         Trunk: map[string]*Rule{
  48.             "生成请求": {
  49.                 AidFunc: func(ctx *Context, aid map[string]interface{}) interface{} {
  50.                     keyword := EncodeString(ctx.GetKeyword(), "GBK")
  51.                     for loop := aid["loop"].([2]int); loop[0] < loop[1]; loop[0]++ {
  52.                         ctx.AddQueue(&context.Request{
  53.                             Url:    "http://s.1688.com/selloffer/offer_search.htm?enableAsync=false&earseDirect=false&button_click=top&pageSize=60&n=y&offset=3&uniqfield=pic_tag_id&keywords=" + keyword + "&beginPage=" + strconv.Itoa(loop[0]+1),
  54.                             Rule:   aid["Rule"].(string),
  55.                             Header: http.Header{"Content-Type": []string{"text/html", "charset=GBK"}},
  56.                         })
  57.                     }
  58.                     return nil
  59.                 },
  60.                 ParseFunc: func(ctx *Context) {
  61.                     query := ctx.GetDom()
  62.                     pageTag := query.Find("#sm-pagination div[data-total-page]")
  63.                     // 跳转
  64.                     if len(pageTag.Nodes) == 0 {
  65.                         logs.Log.Critical("[消息提示：| 任务：%v | 关键词：%v | 规则：%v] 由于跳转AJAX问题，目前只能每个子类抓取 1 页……\n", ctx.GetName(), ctx.GetKeyword(), ctx.GetRuleName())
  66.                         query.Find(".sm-floorhead-typemore a").Each(func(i int, s *goquery.Selection) {
  67.                             if href, ok := s.Attr("href"); ok {
  68.                                 ctx.AddQueue(&context.Request{
  69.                                     Url:    href,
  70.                                     Header: http.Header{"Content-Type": []string{"text/html", "charset=GBK"}},
  71.                                     Rule:   "搜索结果",
  72.                                 })
  73.                             }
  74.                         })
  75.                         return
  76.                     }
  77.                     total1, _ := pageTag.First().Attr("data-total-page")
  78.                     total1 = strings.Trim(total1, " \t\n")
  79.                     total, _ := strconv.Atoi(total1)
  80.                     if total > ctx.GetMaxPage() {
  81.                         total = ctx.GetMaxPage()
  82.                     } else if total == 0 {
  83.                         logs.Log.Critical("[消息提示：| 任务：%v | 关键词：%v | 规则：%v] 没有抓取到任何数据！！！\n", ctx.GetName(), ctx.GetKeyword(), ctx.GetRuleName())
  84.                         return
  85.                     }
  87.                     // 调用指定规则下辅助函数
  88.                     ctx.Aid(map[string]interface{}{"loop": [2]int{1, total}, "Rule": "搜索结果"})
  89.                     // 用指定规则解析响应流
  90.                     ctx.Parse("搜索结果")
  91.                 },
  92.             },
  94.             "搜索结果": {
  95.                 //注意：有无字段语义和是否输出数据必须保持一致
  96.                 ItemFields: []string{
  97.                     "公司",
  98.                     "标题",
  99.                     "价格",
  100.                     "销量",
  101.                     "星级",
  102.                     "地址",
  103.                     "链接",
  104.                 },
  105.                 ParseFunc: func(ctx *Context) {
  106.                     query := ctx.GetDom()
  108.                     query.Find("#sm-offer-list > li").Each(func(i int, s *goquery.Selection) {
  110.                         // 获取公司
  111.                         company, _ := s.Find("a.sm-offer-companyName").First().Attr("title")
  113.                         // 获取标题
  114.                         t := s.Find(".sm-offer-title > a:nth-child(1)")
  115.                         title, _ := t.Attr("title")
  117.                         // 获取URL
  118.                         url, _ := t.Attr("href")
  120.                         // 获取价格
  121.                         price := s.Find(".sm-offer-priceNum").First().Text()
  123.                         // 获取成交量
  124.                         sales := s.Find("span.sm-offer-trade > em").First().Text()
  126.                         // 获取地址
  127.                         address, _ := s.Find(".sm-offer-location").First().Attr("title")
  129.                         // 获取信用年限
  130.                         level := s.Find("span.sm-offer-companyTag > a.sw-ui-flaticon-cxt16x16").First().Text()
  132.                         // 结果存入Response中转
  133.                         ctx.Output(map[int]interface{}{
  134.                             0: company,
  135.                             1: title,
  136.                             2: price,
  137.                             3: sales,
  138.                             4: level,
  139.                             5: address,
  140.                             6: url,
  141.                         })
  142.                     })
  143.                 },
  144.             },
  145.         },
  146.     },
  147. }

从代码中可以看到，总体上，我们实例化一个Spider类型的对象，如之前所讲，对象的Name是必须要有的：

  1.     Name:        "阿里巴巴产品搜索",
  2.     Description: "阿里巴巴产品搜索 [s.1688.com/selloffer/offer_search.htm]",
  3.     // Pausetime: 300,
  4.     Keyword:      KEYWORD,
  5.     MaxPage:      MAXPAGE,
  6.     EnableCookie: false,

这个结构的各种配置之前已经讲过，这里不赘述，如果需要调整，可以在这里赋值。

RuleTree正是我们的规则端的入口。Root: func可以认为程序在装载好任务后，首先执行的程序入口

  1.     RuleTree: &RuleTree{
  2.         Root: func(ctx *Context) {
  3.             ctx.Aid(map[string]interface{}{"loop": [2]int{0, 1}, "Rule": "生成请求"}, "生成请求")
  4.         },

这里我们看到，我们通过ctx.Aid函数给规则添加了第一个任务，就是执行key为”生成请求”的AidFunc: func函数，顺着代码，我们可以找到这个函数的代码：

  1.             "生成请求": {
  2.                 AidFunc: func(ctx *Context, aid map[string]interface{}) interface{} {
  3.                     keyword := EncodeString(ctx.GetKeyword(), "GBK")
  4.                     for loop := aid["loop"].([2]int); loop[0] < loop[1]; loop[0]++ {
  5.                         ctx.AddQueue(&context.Request{
  6.                             Url:    "http://s.1688.com/selloffer/offer_search.htm?enableAsync=false&earseDirect=false&button_click=top&pageSize=60&n=y&offset=3&uniqfield=pic_tag_id&keywords=" + keyword + "&beginPage=" + strconv.Itoa(loop[0]+1),
  7.                             Rule:   aid["Rule"].(string),
  8.                             Header: http.Header{"Content-Type": []string{"text/html", "charset=GBK"}},
  9.                         })
  10.                     }
  11.                     return nil
  12.                 },
  13.                 ParseFunc: func(ctx *Context) {
  14.                     query := ctx.GetDom()
  15.                     pageTag := query.Find("#sm-pagination div[data-total-page]")
  16.                     // 跳转
  17.                     if len(pageTag.Nodes) == 0 {
  18.                         logs.Log.Critical("[消息提示：| 任务：%v | 关键词：%v | 规则：%v] 由于跳转AJAX问题，目前只能每个子类抓取 1 页……\n", ctx.GetName(), ctx.GetKeyword(), ctx.GetRuleName())
  19.                         query.Find(".sm-floorhead-typemore a").Each(func(i int, s *goquery.Selection) {
  20.                             if href, ok := s.Attr("href"); ok {
  21.                                 ctx.AddQueue(&context.Request{
  22.                                     Url:    href,
  23.                                     Header: http.Header{"Content-Type": []string{"text/html", "charset=GBK"}},
  24.                                     Rule:   "搜索结果",
  25.                                 })
  26.                             }
  27.                         })
  28.                         return
  29.                     }
  30.                     total1, _ := pageTag.First().Attr("data-total-page")
  31.                     total1 = strings.Trim(total1, " \t\n")
  32.                     total, _ := strconv.Atoi(total1)
  33.                     if total > ctx.GetMaxPage() {
  34.                         total = ctx.GetMaxPage()
  35.                     } else if total == 0 {
  36.                         logs.Log.Critical("[消息提示：| 任务：%v | 关键词：%v | 规则：%v] 没有抓取到任何数据！！！\n", ctx.GetName(), ctx.GetKeyword(), ctx.GetRuleName())
  37.                         return
  38.                     }
  40.                     // 调用指定规则下辅助函数
  41.                     ctx.Aid(map[string]interface{}{"loop": [2]int{1, total}, "Rule": "搜索结果"})
  42.                     // 用指定规则解析响应流
  43.                     ctx.Parse("搜索结果")
  44.                 },
  45.             },

可以看到，”生成请求”这个成员变量内部包含了两个函数AidFunc和ParseFunc，如之前的文章介绍的，通过Aid添加的任务由AidFunc解析，通过Addqueue函数添加的任务由ParseFunc负责解析，不同的是程序在执行ParseFunc之前会默认抓取Addqueue添加的的request请求，并把response添加到ctx中去。
这就是为什么我们没有明显的看到URL请求，却能直接通过ctx.GetDom来获取Dom树了。此外，这里调用了Parse函数，执行过程是不解析url直接用当先的ctx执行ParseFunc函数。此外，代码中还有一些goquery的语法（建议参考W3c jquery相关语法）及golang本身的语法，这些大家可以自己研究下。

另外，我们可以看到一些关于输出的语句：

  1.                     ctx.Output(map[int]interface{}{
  2.                         0: title,
  3.                         1: ctx.GetTemp("description", ""),
  4.                         2: infoStr,
  5.                         3: ctx.GetTemp("releaseTime", ""),
  6.                         4: ctx.GetTemp("src", ""),
  7.                         5: ctx.GetTemp("author", ""),
  8.                     })

pholcus目前支持csv,mongo,mysql和excel四种数据存储方式，这些都可以在见面上手动设置。存储的方式统一都是已Key-Value数据的方式存储。

免责声明： 以上内容版权归原作者所有，如有侵犯您的原创版权请告知，我们将尽快删除相关内容。感谢每一位辛勤著写的作者，感谢每一位的分享。
@小牛知识库 xnip.cn