go语言爬虫项目架构（记录一次练习）

go语言爬虫项目架构（记录一次练习）

总体介绍

以一个初学的练习为例：一个简单的项目需要构建的包有engine、fetcher、model、parse等（go-internationalization和golang.org这两个包是从github上下的，不需要自己写）

在engine包下包含两个文件：engine（用来存放Run函数是代码运行的关键）、type（存放各种结构体）
fetcher包中包涵两个函数：Fetch和determiEncoding。用来获取网页信息
model包下主要包含数据模板。
parse包用来获取我们想要的数据。

（1）main函数

package main

import (
	"engine"
	"parse"
)

func main() {
	engine.Run(engine.Request{
		Url: "www.biquok.com",
		ParseFunc: parse.ParseBookList,
	})
}

main函数实现了engine包下Run函数的调用

以下为Run函数的代码：

func Run(seeds...Request){
	var requests []Request
	for _,e:=range seeds {
		requests = append(requests,e)
	}
	for len(requests)>0{
		r:= requests[0]
		requests = requests[1:]
		log.Printf("Fetching mainurl:%s", r.Url)
		body,err := fetcher.Fetch(r.Url)

		if err != nil{
			log.Printf("Fetch Error: %s",r.Url)
		}

		parseresult := r.ParseFunc(body)

		requests = append(requests,parseresult.Requesrts...)

		for _,item := range parseresult.Items{
			fmt.Printf("Got item:%s",item)
		}
	}
}

Run函数引入的参数Url为需要爬取的网页、ParseFunc则是一个记录爬取方式的函数。

（2）engine包

engine包下包含两个go文件：engine和type

（2.1）engine

调用项目程序的关键函数

package engine

import (
	"fetcher"
	"fmt"
	"log"
)

func Run(seeds...Request){
	var requests []Request
	for _,e:=range seeds {
		requests = append(requests,e)
	}
	for len(requests)>0{
		r:= requests[0]
		requests = requests[1:]
		log.Printf("Fetching mainurl:%s", r.Url)
		body,err := fetcher.Fetch(r.Url)

		if err != nil{
			log.Printf("Fetch Error: %s",r.Url)
		}

		parseresult := r.ParseFunc(body)

		requests = append(requests,parseresult.Requesrts...)

		for _,item := range parseresult.Items{
			fmt.Printf("Got item:%s",item)
		}
	}
}

（2.2）type

储存需要使用的结构体

package engine

type ParseResult struct {
	Requesrts []Request
	Items []interface{}
}

type Request struct {
	Url string
	ParseFunc func([]byte) ParseResult
}

func NilParse([]byte) ParseResult{
	return ParseResult{}
}

fetch包

使用原生的方式，获取网页信息

package fetcher

import (
	"bufio"
	"fmt"
	"golang.org/x/net/html/charset"
	"golang.org/x/text/encoding"
	"golang.org/x/text/encoding/unicode"
	"golang.org/x/text/transform"
	"io/ioutil"
	"log"
	"net/http"
)

//非原生的方式获取网页信息，此函数在本次练习并没有用到
func Fetch1(url string) ([]byte , error){
	resp, err := http.Get(url)
	if err != nil {
		fmt.Println(err)
	}
	//使用get后必须使用close关闭，
	defer resp.Body.Close()

	//判断网页是否响应成功，defer后面的语句不会马上调用, 而是延迟到函数结束时调用
	//defer 语句正好是在函数退出时执行的语句，所以使用 defer 能非常方便地处理资源释放问题。
	if resp.StatusCode != http.StatusOK {
		fmt.Printf("Error status Code :%d", resp.StatusCode)
	}

	//获取响应体
	bodyReader := bufio.NewReader(resp.Body)

	//使用determiEncoding函数对获取的信息进行解析
	e := determiEncoding(bodyReader)
	utf8Reader := transform.NewReader(bodyReader,e.NewDecoder())

	//读取并打印获取的信息
	result, err := ioutil.ReadAll(utf8Reader)

	return result,nil

}

//原生的方式,模拟浏览器的访问方式
func Fetch(url string) ([]byte , error){
	client := &http.Client{}
	req,err := http.NewRequest("GET",url,nil)
	if err!=nil{
		return nil , fmt.Errorf("ERROR:get mainurl:%s",url)
	}

	//第二个数据是用户密钥，用来模拟用户上网
	req.Header.Set("User-Agent","Mozilla/5.0 (Linux; Android 6.0; Nexus 5 Build/MRA58N) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/92.0.4515.131 Mobile Safari/537.36 Edg/92.0.902.67")
	resp,err:= client.Do(req)
	//获取响应体
	bodyReader := bufio.NewReader(resp.Body)

	//使用determiEncoding函数对获取的信息进行解析
	e := determiEncoding(bodyReader)
	utf8Reader := transform.NewReader(bodyReader,e.NewDecoder())

	//读取并打印获取的信息
	result, err := ioutil.ReadAll(utf8Reader)

	return result,nil

}



//处理获取的数据,解决乱码问题
func determiEncoding (r * bufio.Reader) encoding.Encoding {//Encoding编码是一种字符集编码，可以在 UTF-8 和 UTF-8 之间进行转换
	//获取数据,Peek返回输入流的下n个字节
	bytes, err := r.Peek(1024)
	if err != nil {
		log.Printf("fetch error :%v", err)
		return unicode.UTF8
	}

	//调用DEtermineEncoding函数，确定编码通过检查最多前 1024 个字节的内容和声明的内容类型来确定 HTML 文档的编码。
	e,_, _:= charset.DetermineEncoding(bytes,"")
	return e
}

parse包

使用正则表达式来获取指定的信息。

package parse

import (
	"engine"
	"regexp"
)
const regexStr = `<a href="([^"]+)">([^"]+)</a>`
//获取指定格式的数据并返回
func ParseContent(content []byte) engine.ParseResult{
	//设置匹配规则。
	//[^"]+表示以冒号结尾的字符全部拿到
	re := regexp.MustCompile(regexStr)

	//返回表达式的所有连续匹配的切片,match为切片
	matches := re.FindAllSubmatch(content,-1)

	//收纳信息
	result := engine.ParseResult{}

	for _,m := range matches{
		result.Items = append(result.Items,m[2])
		result.Requesrts = append(result.Requesrts,engine.Request{
			Url:"你想得到的数据是"+"---->"+string(m[2]),
			ParseFunc: engine.NilParse,
		})
	}
	return result
}

使用正则验证，实现数据的筛选，然将数据返回到切片中，使用PaeseResult结构体收纳信息，再使用range函数对数据进行遍历。