package main

import (
    "fmt"
    "github.com/zhshch2002/goribot"
)

func main() {
    s := goribot.NewSpider()
    s.NewTask(
        goribot.MustNewGetReq("https://httpbin.org/get?Goribot%20test=hello%20world"),
        func(ctx *goribot.Context) {
            fmt.Println("got resp data", ctx.Text)
        })
    s.Run()
}

s := goribot.NewSpider()

s := NewSpider(RandomUserAgent)

req:=goribot.MustNewGetReq("https://httpbin.org/get?Goribot%20test=hello")
// 或者 req,err := goribot.NewGetReq("https://httpbin.org/get?Goribot%20test=hello")

// 配置请求
req.Header.Set("test", "test") // 设置请求头部
req.Cookie = append(req.Cookie, &http.Cookie{ // 添加Cookie
    Name:  "test",
    Value: "test",
})
req.Proxy = "http://127.0.0.1:1080" // 配置代理

var thirdHandler func(*goribot.Context) // 可选的创建方式
thirdHandler= func(ctx *goribot.Context) {
    //bu la bu la,do sth
}

s.NewTask(
    req, // 上文创建的请求
    func(ctx *goribot.Context) {
        // first handler
        fmt.Println("got resp data", ctx.Text)
    },
    func(ctx *goribot.Context) { // 此处可以为一个请求设置多个处理回调函数，或者数个请求共用一个函数
    // second handler
        fmt.Println("got resp data", ctx.Text)
    },
    thirdHandler,
)

type Context struct {
    Text string // 收到的数据转换为字符串类型
    Html *goquery.Document // 自动尝试将收到的内容解析为Html
    Json map[string]interface{} // 自动尝试将收到的内容解析为Json

    Request  *Request // 上文中创建的请求
    Response *Response // 蜘蛛收到的网络响应，包含响应码、响应头、字节码原始数据等

    Tasks []*Task // 执行结束后将要提交给蜘蛛的新任务
    Items []interface{} // 执行结束后将要提交给蜘蛛的结果数据，用作数据持久化设计
    Meta  map[string]interface{} // 使用 NewTaskWithMeta 函数添加的任务可以携带一个Key-Val对应的数据

    drop bool // 在多个handler回调函数中可以调用ctx.Drop()函数来中断处理队列，使之后的回调函数不再执行
}

s.NewTaskWithMeta(MustNewGetReq("https://httpbin.org/get"), map[string]interface{}{
    "test": 1,
}, func(ctx *Context) {
    fmt.Println(ctx.Meta["test"]) // 内层函数可以使用外层提供的数据
    
    // 在Handler内创建新的任务，注意这里是ctx.NewTaskWithMeta而非外层的s.NewTaskWithMeta
    ctx.NewTaskWithMeta(MustNewGetReq("https://httpbin.org/get"), map[string]interface{}{
        "test": 2,
    }, func(ctx *Context) {
        fmt.Println(ctx.Meta["test"]) // 内层函数可以使用外层提供的数据
    })
})

package main

import (
    "github.com/PuerkitoBio/goquery"
    "github.com/zhshch2002/goribot"
    "log"
    "strings"
)

type BiliVideoItem struct {
    Title, Url string
}

func main() {
    s := goribot.NewSpider(goribot.HostFilter("www.bilibili.com"), goribot.RandomUserAgent)
    s.DepthFirst = false
    s.ThreadPoolSize = 1

    var biliVideoHandler, getNewLinkHandler func(ctx *goribot.Context)
    getNewLinkHandler = func(ctx *goribot.Context) {
        ctx.Html.Find("a[href]").Each(func(i int, selection *goquery.Selection) {
            rawurl, _ := selection.Attr("href")
            if !strings.HasPrefix(rawurl, "/video/av") {
                return
            }
            u, err := ctx.Request.Url.Parse(rawurl)
            if err != nil {
                return
            }
            u.RawQuery = ""
            if strings.HasSuffix(u.Path, "/") {
                u.Path = u.Path[0 : len(u.Path)-1]
            }
            //log.Println(u.String())
            if r, err := goribot.NewGetReq(u.String()); err == nil {
                ctx.NewTask(r, getNewLinkHandler, biliVideoHandler)
            }
        })
    }
    biliVideoHandler = func(ctx *goribot.Context) {
        ctx.AddItem(BiliVideoItem{
            Title: ctx.Html.Find("title").Text(),
            Url:   ctx.Request.Url.String(),
        })
    }

    s.NewTask(goribot.MustNewGetReq("https://www.bilibili.com/video/av66703342"), getNewLinkHandler, biliVideoHandler)
    s.OnItem(func(ctx *goribot.Context, i interface{}) interface{} {
        log.Println(i) // 可以做一些数据存储工作
        return i
    })

    s.Run()
}