go网站爬虫

公司有需求爬取全国所有城市的楼盘，解析出经纬度，这种大范围的爬取一般用scrapy框架比较合适，但是刚好最近学完了go语言，go语言的http库用起来也很方便，因此尝试用go语言完成

一，程序支持根据用户输入城市进行爬取，使用flag方法可以解析用户数据，定义好要爬取的城市、爬取翻页时等待时长（慢速爬取更友好）和是否打印爬取结果

func init() {
	flag.StringVar(&p, "p", "湖北", "省份")
	flag.StringVar(&c, "c", "武汉", "城市")
	flag.IntVar(&t, "t", 5, "翻页间隔")
	flag.BoolVar(&r, "r", true, "打印记录")
	flag.Parse()
}

二，判断用户输入的省份城市是否合法（是否在该网站中存在记录），在进行元素定位时用到了htmlquery库，采用xpath语法定位

func CheckCityExist() bool {
	rsp, err := engine.GetRsp("https://www.ke.com/city/")
	if err != nil {
		log.Fatalln("请求查询城市失败: ", err)
	}
	defer rsp.Body.Close()
	doc, _ := htmlquery.Parse(rsp.Body)
	retLis := htmlquery.Find(doc, `//div[@class="city_province"]`)
	for _, i := range retLis {
		pr := strings.TrimSpace(htmlquery.InnerText(htmlquery.FindOne(i, `./div[@class="city_list_tit c_b"]`)))
		if p == pr {
			ct := htmlquery.FindOne(i, fmt.Sprintf(`./ul/li[@class="CLICKDATA"]/a[text()="%s"]`, c))
			if ct != nil {
				ctURL = htmlquery.SelectAttr(ct, "href")
				if ctURL != "" {
					ctURL = "https:" + ctURL
					return true
				}
			}
		}
	}
	return false
}

　

三，每个城市会存在楼盘（新房）和小区（旧房）两个爬取源，GetCityURL方法找到楼盘和小区的根路径，并将其存入结构体pp中

func GetCityURL(u string) {
	rsp, err := engine.GetRsp(u)
	if err != nil {
		log.Fatalln("请求查询城市失败: ", err)
	}
	defer rsp.Body.Close()
	doc, _ := htmlquery.Parse(rsp.Body)
	louPan := htmlquery.FindOne(doc, `//li[@class="CLICKDATA"]/a[text()="新房"]`) // 新房
	xiaoQu := htmlquery.FindOne(doc, `//li[@class="CLICKDATA"]/a[text()="小区"]`) // 旧房
	lp := htmlquery.SelectAttr(louPan, "href")
	if lp == "" {
		louPan2 := htmlquery.FindOne(doc, `//li[@class="new-link-list"]/a[text()="新房"]`) // 新房
		lp = htmlquery.SelectAttr(louPan2, "href")
		lp = strings.TrimRight(lp, "/")
	}
	if !strings.HasPrefix(lp, "http") {
		lp = "https:" + lp
	}
	pp.Loupan = lp
	pp.Xiaoqu = htmlquery.SelectAttr(xiaoQu, "href")
	pp.Province = p
	pp.City = c
}

四，爬取楼盘，解析字段，该网站请求楼盘返回的数据是json格式，每次返回10条记录，解析很方便，注意该网站在爬到一定页数后，每次会返回200条记录，并且都是重复数据，因此程序对此作了判断并结束循环

func ProcessLoupanData(data *utils.JData, pp *utils.CityMeta, r bool) {
	// 提取出数据库需要的字段
	for _, item := range data.Data.List {
		item.CityName = pp.City
		item.Province = pp.Province
		db.InsertRow(&item, true)
		if !r {
			continue
		}
		fmt.Println("封面", item.CoverPic)
		fmt.Println("省份", item.Province)
		fmt.Println("城市", item.CityName)
		fmt.Println("区域", item.District)
		fmt.Println("地址", item.Address)
		fmt.Println("商圈", item.CircleName)
		fmt.Println("小区名", item.Loupan)
		fmt.Println("均价", item.AvePrice)
		fmt.Println("价格单位", item.PriceUnit)
		fmt.Println("销售状态", item.Status)
		fmt.Println("面积", item.Area)
		fmt.Println("房型", item.RoomType)
		fmt.Println("经度", item.LNG)
		fmt.Println("纬度", item.LAT)
		fmt.Println(strings.Repeat("#", 50))
	}
}

func ParseCityLoupan(r bool, t int, pp *utils.CityMeta) {
	// 爬取楼盘信息
	if pp.Loupan == "" {
		log.Printf("%s-%s 无新房记录", pp.Province, pp.City)
		return
	}
	url := pp.Loupan + "/pg1/?_t=1"

	b, err := engine.Download(url)
	if err != nil {
		log.Printf("首页新房请求失败", err)
		return
	}
	var data utils.JData
	err = json.Unmarshal(*b, &data)
	if err != nil {
		log.Printf("解析新房第1页失败:%v
", err)
		return
	}
	total, err := strconv.Atoi(data.Data.Total)
	if err != nil {
		log.Fatalln("无法获取新房总页数", data.Data.Total, err)
	}
	ProcessLoupanData(&data, pp, r)
	pages := int(math.Ceil(float64(total)/ 10)) + 1
	count := 0
	for page := 2; page < pages; page++ {
		var data utils.JData
		time.Sleep(time.Second * time.Duration(t))
		url := fmt.Sprintf("%s/pg%d/?_t=1", pp.Loupan, page)
		b, err := engine.Download(url)
		if err != nil {
			log.Printf("请求第%d页失败
", page)
			continue
		}
		err = json.Unmarshal(*b, &data)
		if err != nil {
			log.Printf("解析第%d页失败
", page)
			continue
		}
		if len(data.Data.List) > 10 {
			count ++
		}
		if count == 2 {
			fmt.Println("结束重复值")
			break
		}
		ProcessLoupanData(&data, pp, r)
	}
}

　

五，爬取小区，解析字段，该网站请求小区返回的是html格式内容，需要用htmlquery库xpath，方便解析字段

func ParsePageRegionXiaoqu(r bool, url string, areaName string, p string, c string) {
	rsp, err := engine.GetRsp(url)
	if err != nil {
		log.Printf("爬取链接%s失败
", url)
		return
	}
	defer rsp.Body.Close()
	doc, _ := htmlquery.Parse(rsp.Body)
	items := htmlquery.Find(doc, `//li[contains(@class, "xiaoquListItem")]`)
	for _, item := range items {
		var data utils.MData
		titleNode := htmlquery.FindOne(item, `.//a[@class="maidian-detail"]`)
		title := htmlquery.SelectAttr(titleNode, "title")
		if title == "" {
			continue
		}
		circleNode := htmlquery.FindOne(item, `//a[@class="bizcircle"]`)
		circle := strings.TrimSpace(htmlquery.InnerText(circleNode))
		if circle == "" {
			continue
		}
		lng, lat := engine.BaiduAPI(c, areaName+" "+title)
		if lng == 0 || lat == 0 {
			continue
		}
		data.Province = p
		data.CityName = c
		data.Loupan = title
		data.District = areaName
		data.CircleName = circle
		data.Address = circle + title
		data.LNG = strconv.FormatFloat(lng, 'f', 6, 64)
		data.LAT = strconv.FormatFloat(lat, 'f', 6, 64)
		if r {
			fmt.Println("封面", data.CoverPic)
			fmt.Println("省份", data.Province)
			fmt.Println("城市", data.CityName)
			fmt.Println("区域", data.District)
			fmt.Println("地址", data.Address)
			fmt.Println("商圈", data.CircleName)
			fmt.Println("小区名", data.Loupan)
			fmt.Println("均价", data.AvePrice)
			fmt.Println("价格单位", data.PriceUnit)
			fmt.Println("销售状态", data.Status)
			fmt.Println("面积", data.Area)
			fmt.Println("房型", data.RoomType)
			fmt.Println("经度", data.LNG)
			fmt.Println("纬度", data.LAT)
			fmt.Println(strings.Repeat("#", 50))
		}
		db.InsertRow(&data, false)
	}
}

func ParseRegionXiaoqu(r bool, t int, baseURL string, areaName string, p string, c string) {
	page := 1
	url := baseURL + strconv.Itoa(page)
	rsp, err := engine.GetRsp(url)
	if err != nil {
		log.Printf("爬取链接%s失败
", url)
		return
	}
	defer rsp.Body.Close()
	doc, _ := htmlquery.Parse(rsp.Body)
	totalNode := htmlquery.FindOne(doc, `//h2[contains(@class, "total")]/span`)
	total, err := strconv.Atoi(strings.TrimSpace(htmlquery.InnerText(totalNode)))
	if err != nil {
		log.Printf("非有效数字", total)
		return
	}
	pages := int(math.Ceil(float64(total) / 30))
	for page:=1;page<=pages;page++{
		time.Sleep(time.Second * time.Duration(t))
		url := baseURL + strconv.Itoa(page)
		ParsePageRegionXiaoqu(r, url, areaName, p, c)
	}
}

// 爬取旧房信息
func ParseCityXiaoqu(r bool, t int, pp *utils.CityMeta) {
	if !strings.HasSuffix(pp.Xiaoqu, "xiaoqu/") {
		log.Printf("%s-%s 无小区记录", pp.Province, pp.City)
		return
	}

	url := pp.Xiaoqu + "pg1/"
	b, err := engine.Download(url)
	if err != nil {
		log.Printf("首页新房请求失败:%v", err)
		return
	}
	pt, _ := regexp.Compile(`href="/xiaoqu/([a-z0-9]{2,20}/pg)1".*?>(.*?)</a>`)
	retLis := pt.FindAllStringSubmatch(string(*b), -1)
	mp := make(map[string]string) // 去重后的区域url
	for _, v := range retLis {
		mp[pp.Xiaoqu+v[1]] = v[2]
	}
	for aURL, aName := range mp {
		fmt.Println("打印当前", aURL, aName)
		ParseRegionXiaoqu(r, t, aURL, aName, pp.Province, pp.City)
	}
}

　　

六，无论是爬取楼盘还是小区都有可能返回数据中没有经纬度，这里需要调用百度api获取地址对应的经纬度（需要申请百度开发者账号）

func BaiduAPI(city string, addr string) (lng, lat float64) {
	// 调用百度api，获取地理位置
	if useIdx == len(utils.AK) {
		log.Fatalln("无可用ak")
	}
	params := url.Values{}
	params.Set("address", addr)
	params.Set("output", "json")
	params.Set("city", city)
	params.Set("ak", utils.AK[useIdx])
	toURL := apiURL + "?" + params.Encode()
	req, err = http.NewRequest("GET", toURL, nil)
	if err != nil {
		return 0, 0
	}
	req.Header.Set("User-Agent", "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/84.0.4147.135 Safari/537.36")
	rsp, err = client.Do(req)
	if err != nil {
		return 0, 0
	}
	defer rsp.Body.Close()
	b, _ := ioutil.ReadAll(rsp.Body)
	var ret apiRet
	err = json.Unmarshal(b, &ret)
	if err != nil {
		return 0, 0
	}
	if ret.Msg == "天配额超限，限制访问" {
		log.Println(utils.AK[useIdx], ret.Msg)
		useIdx += 1
		return BaiduAPI(city, addr)
	}
	return ret.Result.Location.LNG, ret.Result.Location.LAT
}

　　

七，将数据存入mysql，使用经纬度md5值去重

func generateID(data *utils.MData) string {
	md := md5.New()
	md.Write([]byte(strings.Join([]string{data.LNG, data.LAT}, "")))
	ret := md.Sum([]byte(""))
	return fmt.Sprintf("%x", ret)
}

// InsertRow ...
func InsertRow(data *utils.MData, checkGeo bool) {
	// 若经纬度任意为空，则根据地址，调用百度api获取经纬度
	if data.LNG == "" || data.LAT == "" {
		if !checkGeo {
			return
		}
		if data.CityName == "" || data.Address == "" || data.Loupan == "" {
			return
		}
		lng, lat := engine.BaiduAPI(data.CityName, fmt.Sprintf("%s %s", data.Address, data.Loupan))
		if lng == 0 || lat == 0 {
			return
		}
		data.LNG = strconv.FormatFloat(lng, 'f', 6, 64)
		data.LAT = strconv.FormatFloat(lat, 'f', 6, 64)
	}
	iid = generateID(data)
	if _, ok := mp[iid]; ok {
		// 过滤重复坐标
		return
	}
	mp[iid] = ""
	sqlStr := "insert into lbs(id, province, city, region, avenue, community_name, community_addr, longitude, dimension, status) values (?,?,?,?,?,?,?,?,?,?)"
	_, err := sdb.Exec(sqlStr, iid, data.Province, data.CityName, data.District, data.CircleName, data.Loupan, data.Address, data.LNG, data.LAT, 0)
	if err != nil {
		fmt.Printf("insert failed, err:%v
", err)
		return
	}
}

编译后执行后效果如下：

完整代码参考github项目地址：https://github.com/Tarantiner/golang_beike