爬虫是数据搜集系统中的一个重要工具,主要用于从Web上搜集数据。一般一个爬虫的流程如下:

func Crawler(seed_url):
Q = Queue()
Q.append(seed_url)
while !Q.empty() :
link = Q.pop()
html = download(link)
sub_links = extract_links(html)
for link in sub_links:
Q.append(link)

如果我们要设计一个分布式爬虫,可以将上述程序分成3个部分:

downloader : 输入一个url,返回这个url对应的HTML
link extractor : 输入一个HTML,返回这个HTML中的链接
redirector : 负责接收link extractor提取的链接,并且将这些链接转发给downloader

不过,因为downloader主要消耗网络资源,而link extractor主要消耗CPU资源,因此我们可以将1,2部分合并在一个程序中。我们把合并后的程序也称为downloader。downloader集群通过nginx做负载均衡和外面通信。而downloader集群的鲁棒性可以通过nginx的health check实现。
Downloader

downloader的任务就是 1. 给定一个url,将他对应的HTML下载下来,写到磁盘上 2. 从HTML中提取链接,并将提取出来的链接发送给redirector

下载网页这一步是需要解决一下的问题: 1. 如何通过HTTP GET下载网页(这个是最简单的) 2. 如何使用HTTP 代理 3. 如何通过HTTP POST下载网页,这个涉及到表单的自动post 4. 如何处理页面的Javascript,获得Ajax的调用内容 5. 如何处理非HTML网页,比如PDF,Excel等等
Redirector

redirector的任务是 1. 控制每个不同网站的爬取速率 2. 控制网站爬取的优先级 3. 控制网页的更新速率(同一个网页,什么时候再爬一次)

所以,redirector从downloader接受到新的链接后,要对链接进行排序,整理,再发送给downloader下载。从而redirector和downloader之间形成闭环。
Golang

golang在实现上述逻辑时,可以充分发挥它强大的channel特性。

比如,如何控制不同网站的爬取速率?

可以给每个域名建立一个channel,每个域名的网页都进入到各自的channel。然后channel的消费者按照一定的速率从channel中取出链接进行消费。

不过使用channel也有一个问题。就是channel是阻塞的,如果channel满了,一定要消费者消费一个才能往里面放东西。而因为我们整个系统是一个环状系统:

downloader 有一个input的queue A
redirector 有一个input的queue B
redirector将B中的链接放入A
download消费A中的链接,得到新链接,放入到B

这时候,如果A,B都满了,redirector和downloader就会出现死锁,因为他们都需要别人先动一下,自己才能动。

因此,我们就需要设计一个逻辑,让所有的queue都不可能满。这样就只能利用文件系统了。

如果queue满了,将链接写文件
如果queue没有满,将链接写入queue中
如果queue空闲了,将文件中的链接写入queue

管道(Channel)是Go语言中比较重要的部分,经常在Go中的并发中使用。今天尝试对Go语言的管道来做以下总结。总结的形式采用问答式的方法,让答案更有目的性。

Q1.管道是什么?
管道是Go语言在语言级别上提供的goroutine间的通讯方式,我们可以使用channel在多个goroutine之间传递消息。channel是进程内的通讯方式,是不支持跨进程通信的,如果需要进程间通讯的话,可以使用Socket等网络方式。

以上是管道的概念,下面我们就看下管道的语法。

Q2.管道的语法?

整个Go语言的语法都比较简洁,管道也不例外,其语法如下所示:

在此应当注意,管道是类型相关的,即一个管道只能传递一种类型的值。管道中的数据是先进先出的。

 1 // 声明方式,在此ElemType是指此管道所传递的类型
 2 var chanName chan ElemType
 3 // 声明一个传递类型为int的管道
 4 var ch chan int
 5 // 声明一个map,元素是bool型的channel
 6 var m map[string] chan bool
 7 
 8 // 定义语法,定义需要使用内置函数make()即可,下面这行代码是声明+定义一个整型管道
 9 ch := make(chan int)
10 // 事先定义好管道的size,下面这行代码定义管道的size为100
11 ch := make(chan int, 100)
12 
13 // 由管道中读写数据,<-操作符是与最左边的chan优先结合的
14 // 向管道中写入一个数据,在此需要注意:向管道中写入数据通常会导致程序阻塞,直到有
15 // 其他goroutine从这个管道中读取数据
16 ch<- value
17 // 读取数据,注意:如果管道中没有数据,那么从管道中读取数据会导致程序阻塞,直到有数据
18 value := <-ch
19 
20 // 单向管道
21 var ch1 chan<- float64     // 只能向里面写入float64的数据,不能读取
22 var ch2 <-chan int         // 只能读取int型数据
23 
24 // 关闭channel,直接调用close()即可
25 close(ch)
26 // 判断ch是否关闭,判断ok的值,如果是false,则说明已经关闭(关闭的话读取是不会阻塞的)
27 x, ok := <-ch

Q3.管道的使用场景?

在第一个问题中,我们已经知道管道可以做进程间通讯,Go中自带了对协程的支持(关键字go),而管道就是各个协程间通讯的一个方法。这里我们举些简单的小例子来说明一下管道如何在协程中使用。

 1 package main
 2 import "fmt"
 3 
 4 func print() {
 5     fmt.Println("Hello world")
 6 }
 7 
 8 func main() {
 9     for i := 0; i < 10; i++ {
10         go print()
11     }
12 }

上面的代码意思大致是:使用协程来并行输出10次 "Hello world", 但是大家运行上面代码的时候,会发现不会有输出。这是因为虽然使用go关键字进行了协程的创建,但是还没有等到执行的时候,main函数已经退出来了,进程已经关闭,所以起来的协程也不会被执行。

如果你有C相关的多线程经验时,可已经将协程改为线程,之后调用线程的join方法,让主线程等待子线程执行完毕后再退出。而在Go语言中,我们可以利用管道的写入阻塞和读取阻塞来完成类似线程join的行为。代码如下所示:

 1 package main
 2 import "fmt"
 3 
 4 func print(ch chan int) {
 5     fmt.Println("Hello world")
 6     ch<- 1
 7 }
 8 
 9 func main() {
10     chs := make([]chan int)
11     for i := 0; i < 10; i++ {
12         chs[i] = make(chan int)
13         go print(chs[i])
14     }
15     
16     for _, ch := range(chs){
17         <-ch
18     }
19 }

通过以上代码,我们就可以完成了并行输出10此Hello world 的效果。

有一个问题留给大家,如果将 print改为

func print(ch chan int){
     ch<- 1
     fmt.Println("Hello world")
}

会打印出什么呢?

由于水平有限,难免会有错误,请大家指正。
谢谢。

Channel是什么

在Go语言中,Channel即指通道类型。有时也用它来直接指代可以传递某种类型的值的通道。

类型表示法

chan T

关键字chan代表了通道类型的关键字,T则代表了该通道类型的元素类型。

例如:type IntChan chan int 别名类型IntChan代表了元素类型为int的通道类型。我们可以直接声明一个chan int类型的变量:var IntChan chan int,在被初始化后,变量IntChan就可以被用来传递int类型的元素值了。

chan<- T

只能被用来发送值, <-表示发送操作符

<-chan T

接收通道值, <-表示接收操作符

值表示法

属性和基本操作

  • 基于通道的通讯是在多个Goroutine之间进行同步的重要手段。而针对通道的操作本身也是同步的。
  • 在同一时刻,仅有一个Goroutine能向一个通道发送元素值
  • 同时也仅有一个Goroutine能从它那里接收元素值。
  • 通道相当于一个FIFO先进先出的消息队列。
  • 通道中的元素值都具有原子性。它们是不可被分割的。通道中的每一个元素都只可能被某一个Goroutine接收。已被接收的元素值会立刻被从通道中删除。

初始化通道

make(chan int, 10)

~ 表达式初始化了一个通道类型的值。传递给make函数的第一个参数表明此值的具体类型是元素类型为int的通道类型,而第二个参数则指该值在同一时刻最多可以容纳10个元素值。

package main
import (
    "fmt"
)

type Person struct {
    Name string
    Age  uint8
    Address Addr
}

type Addr struct{
    city string
    district string
}

func main(){
    persionChan := make(chan Person,1)

    p1 := Person{"Harry",32,Addr{"Shanxi","Xian"}}
    fmt.Printf("P1 (1): %v\n",p1)

    persionChan <- p1

    p1.Address.district = "shijingshan"
    fmt.Printf("P2 (2): %v\n",p1)

    p1_copy := <-persionChan
    fmt.Printf("p1_copy: %v\n",p1_copy)
}

go test.go 运行结果

P1 (1): {Harry 32 {Shanxi Xian}}
P2 (2): {Harry 32 {Shanxi shijingshan}}
p1_copy: {Harry 32 {Shanxi Xian}}

通道中的元素值丝毫没有受到外界的影响。这说明了,在发送过程中进行的元素值属于完全复制。这也保证了我们使用通道传递的值的不变性。

关闭通道

close(strChan)

我们应该先明确一点:无论怎么样都不应该在接收端关闭通道。因为在那里我们无法判断发送端是否还会向该通道发送元素值。

package main

import (
    "fmt"
    "time"
)

func main(){
    ch := make(chan int, 5)
    sign := make(chan int, 2)

    go func() {
        for i :=0;i<5;i++ {
            ch <- i
            time.Sleep(1 * time.Second)
        }
        close(ch)
        fmt.Println("The channel is closed.")
        sign <- 0
    }()

    go func() {
        for {
            e, ok := <-ch
            fmt.Printf("%d (%v)\n", e,ok)
            if !ok {
                break
            }
            time.Sleep(2 * time.Second)
        }
        fmt.Println("Done.")
        sign <- 1
    }()
    <- sign
    <- sign
}

    运行结果:
    0 (true)
    1 (true)
    2 (true)
    The channel is closed.
    3 (true)
    4 (true)
    0 (false)
    Done.

运行时系统并没有在通道ch被关闭之后立即把false作为相应接收操作的第二个结果,而是等到接收端把已在通道中的所有元素值都接收到之后才这样做。这确保了在发送端关闭通道的安全性。

爬虫系统的要求

基本要求

  • 遍历链接,并获取网页
  • 网页解析,分析
  • 数据存储
  • 日志: 错误日志, 运行日志

分布式要求

  • 并行爬取: 效率高, 可以设定爬虫的数目
  • 任务管理: 任务队列, 出错了可以重新爬取
  • 代理: 考虑到爬取太多,可能会触发拦截,因此需要通过代理。
  • 策略: 可以灵活的设定策略, 爬取频率, 爬取数量, 使用不同的网管,使用不同的header

爬虫管理

  • 不同的网站,爬虫的规则是不一样的,因此爬虫可以自定义规则
  • 脚本: 有些网站可能需要登录认证。

循序渐进

v0.1 http请求

    baseUrl := "http://www.xxx.cn"
    req,_  := http.NewRequest("GET",baseUrl,nil)
    req.Header.Set("User-Agent", GetRandomUserAgent())
    client := http.DefaultClient
    res, e := client.Do(req)

    if e !=nil {
        fmt.Print(e)
        return
    }

    if res.StatusCode == 200 {
        body := res.Body
        defer body.Close()
        bodyByte,_ := ioutil.ReadAll(body)
        resStr := string(bodyByte)
        print(resStr)
    }

序言

看过很多方面的编码规范,可能每一家公司都有不同的规范,这份编码规范是写给我自己的,同时希望我们公司内部同事也能遵循这个规范来写Go代码。

如果你的代码没有办法找到下面的规范,那么就遵循标准库的规范,多阅读标准库的源码,标准库的代码可以说是我们写代码参考的标杆。
格式化规范

go默认已经有了gofmt工具,但是我们强烈建议使用goimport工具,这个在gofmt的基础上增加了自动删除和引入包.

go get golang.org/x/tools/cmd/goimports

不同的编辑器有不同的配置, sublime的配置教程:http://michaelwhatcott.com/gosublime-goimports/

LiteIDE默认已经支持了goimports,如果你的不支持请点击属性配置->golangfmt->勾选goimports

保存之前自动fmt你的代码。
行长约定

一行最长不超过80个字符,超过的请使用换行展示,尽量保持格式优雅。
go vet

vet工具可以帮我们静态分析我们的源码存在的各种问题,例如多余的代码,提前return的逻辑,struct的tag是否符合标准等。

go get golang.org/x/tools/cmd/vet

使用如下:

go vet .

package名字

保持package的名字和目录保持一致,尽量采取有意义的包名,简短,有意义,尽量和标准库不要冲突。
import 规范

import在多行的情况下,goimports会自动帮你格式化,但是我们这里还是规范一下import的一些规范,如果你在一个文件里面引入了一个package,还是建议采用如下格式:

import (
"fmt"
)

如果你的包引入了三种类型的包,标准库包,程序内部包,第三方包,建议采用如下方式进行组织你的包:

import (
"encoding/json"
"strings"

"myproject/models"
"myproject/controller"
"myproject/utils"

"github.com/astaxie/beego"
"github.com/go-sql-driver/mysql"

)

有顺序的引入包,不同的类型采用空格分离,第一种实标准库,第二是项目包,第三是第三方包。

在项目中不要使用相对路径引入包:

// 这是不好的导入
import “../net”

// 这是正确的做法
import “github.com/repo/proj/src/net”

变量申明

变量名采用驼峰标准,不要使用_来命名变量名,多个变量申明放在一起

var (
Found bool
count int
)

在函数外部申明必须使用var,不要采用:=,容易踩到变量的作用域的问题。
自定义类型的string循环问题

如果自定义的类型定义了String方法,那么在打印的时候会产生隐藏的一些bug

type MyInt int
func (m MyInt) String() string {
return fmt.Sprint(m) //BUG:死循环
}

func(m MyInt) String() string {
return fmt.Sprint(int(m)) //这是安全的,因为我们内部进行了类型转换
}

避免返回命名的参数

如果你的函数很短小,少于10行代码,那么可以使用,不然请直接使用类型,因为如果使用命名变量很
容易引起隐藏的bug

func Foo(a int, b int) (string, ok){

}

当然如果是有多个相同类型的参数返回,那么命名参数可能更清晰:

func (f *Foo) Location() (float64, float64, error)

下面的代码就更清晰了:

// Location returns f's latitude and longitude.
// Negative values mean south and west, respectively.
func (f *Foo) Location() (lat, long float64, err error)

错误处理

错误处理的原则就是不能丢弃任何有返回err的调用,不要采用_丢弃,必须全部处理。接收到错误,要么返回err,要么实在不行就panic,或者使用log记录下来
error 信息

error的信息不要采用大写字母,尽量保持你的错误简短,但是要足够表达你的错误的意思。
长句子打印或者调用,使用参数进行格式化分行

我们在调用fmt.Sprint或者log.Sprint之类的函数时,有时候会遇到很长的句子,我们需要在参数调用处进行多行分割:

下面是错误的方式:

log.Printf(“A long format string: %s %d %d %s”, myStringParameter, len(a),
expected.Size, defrobnicate(“Anotherlongstringparameter”,
expected.Growth.Nanoseconds() /1e6))

应该是如下的方式:

log.Printf(
“A long format string: %s %d %d %s”,
myStringParameter,
len(a),
expected.Size,
defrobnicate(
“Anotherlongstringparameter”,
expected.Growth.Nanoseconds()/1e6,
),

注意闭包的调用

在循环中调用函数或者goroutine方法,一定要采用显示的变量调用,不要再闭包函数里面调用循环的参数

fori:=0;i<limit;i++{
go func(){ DoSomething(i) }() //错误的做法
go func(i int){ DoSomething(i) }(i)//正确的做法
}

http://golang.org/doc/articles/race_detector.html#Race_on_loop_counter
在逻辑处理中禁用panic

在main包中只有当实在不可运行的情况采用panic,例如文件无法打开,数据库无法连接导致程序无法
正常运行,但是对于其他的package对外的接口不能有panic,只能在包内采用。

强烈建议在main包中使用log.Fatal来记录错误,这样就可以由log来结束程序。
注释规范

注释可以帮我们很好的完成文档的工作,写得好的注释可以方便我们以后的维护。详细的如何写注释可以
参考:http://golang.org/doc/effective_go.html#commentary
bug注释

针对代码中出现的bug,可以采用如下教程使用特殊的注释,在godocs可以做到注释高亮:

// BUG(astaxie):This divides by zero.
var i float = 1/0

http://blog.golang.org/2011/03/godoc­documenting­go­code.html
struct规范
struct申明和初始化格式采用多行:

定义如下:

type User struct{
Username string
Email string
}

初始化如下:

u := User{
Username: "astaxie",
Email: "[email protected]",
}

recieved是值类型还是指针类型

到底是采用值类型还是指针类型主要参考如下原则:

func(w Win) Tally(playerPlayer)int //w不会有任何改变
func(w *Win) Tally(playerPlayer)int //w会改变数据

更多的请参考:https://code.google.com/p/go-wiki/wiki/CodeReviewComments#Receiver_Type
带mutex的struct必须是指针receivers

如果你定义的struct中带有mutex,那么你的receivers必须是指针
参考资料

https://code.google.com/p/go-wiki/wiki/CodeReviewComments
http://golang.org/doc/effective_go.html