shiguangScrapy: 该项目是用于实际业务爬虫, 用于将一个系统的数据导入另一个系统中,主要分享爬虫技术和思路,

# shiguangScrapy

## 0. 项目介绍
    1.本项目用于实际项目爬取,项目中的地址不便于公开请各位多担待,本项目主要用于分享爬虫技术和爬虫思路,由于干掉了地址项目无法启动
    2.luo_shan爬虫
        2.1: start_requests函数 用于初始页面进入,因为是个人账号登录所以要用cookies 其中callback是用于回调传递给下一个函数parse
        2.2: parse函数 用于组装列表上的数据,作用二取列表上的详情页地址回调给下一个函数care_details
        2.3: care_details函数 用于将详情页的数据进行组装 放入管道中pipelines.py中的LuoShanPipeline函数
        2.4: LuoShanPipeline函数 用于将组装的数据进行接口请求放到清洗项目中
    3.shi爬虫
        3.1: 用于爬取实际项目,项目中的地址不便于公开请各位多担待
    4.wk爬虫
        4.1: 用于爬取实际项目,该项目写的比较详细,主要是看爬虫逻辑,组装数据不用细看

### 1、创建项目

在目标文件夹里点击文件夹路径、输入[CMD]并回车、进入命令行

输入命令：

```python
scrapy startproject **Spider
```

### 2、创建[爬虫]

cd 进入项目文件

输入命令：

```python
scrapy genspider demo "demo.cn"
```

### 3、项目[根目录]建立main.py文件

main.py文件输入以下内容

```python
from scrapy.cmdline import execute
 
execute(['scrapy', 'crawl', 'demo'])
```

## 1. pipelines 管道的使用

### 1.1 管道json的使用

```python
class KePipeline(ImagesPipeline):
	def process_item(self, item, spider):
        """
        :title: 处理上传类型和案例
        :param item:
        :param spider:
        :return:
        """
        if isinstance(item, ShiguangTypeItem):  # 处理案例类型数据
            req = requests.post(url='http://xxxx.com',  # 上传类型接口
                                data=json.dumps(dict(item)),
                                headers={
                                    'Content-Type': 'application/json'
                                })
           class wkPipeline:
    # 悟空系统的客资导入

def __init__(self):
        self.a = 0
        self.b = 0
        self.mistake_list = []  # 失败
        self.success_list = []  # 成功

def open_spider(self, spider):
        print('请求开始')

def process_item(self, item, spider):
        """
        :title: 处理上传类型和案例
        :param item:
        :param spider:
        :return: http://xxxx.com
        """
        req = requests.post(url='http://xxxx.com',  # 上传接口
                            data=json.dumps(dict(item)),
                            headers={
                                'Content-Type': 'application/json',
                                # 'Blade-Auth':'bearer ',
                                'Blade-Auth': 'bearer ',
                                'Authorization': 'Basic YXBwY2xpZW50OmFwcGNsaWVudDEyMzQ=',
                                'Tenant-Id': '322307'
                            })
        if req.status_code == 200:
            self.success_list.append(item['page']['contract_number'])
            self.a = self.a + 1
            print('{}存储成功，第{}条数据,合同编号:{}'.format(time.strftime("%Y-%m-%d %H:%M:%S", time.localtime()), self.a,
                                                 item['page']['contract_number']))
            logging.warning(item['page'])
            return '客资存储成功'
        else:
            self.mistake_list.append(item['page']['contract_number'])
            self.b = self.b + 1
            print('{}存储失败，第{}条数据,合同编号:{}'.format(time.strftime("%Y-%m-%d %H:%M:%S", time.localtime()), self.b,
                                                 item['page']['contract_number']))
            logging.warning(item['page'])
            return '客资存储失败'

def close_spider(self, spider):
        print('存储结束,共进入管道{}条'.format(self.a + self.b))
        logging.warning('失败数据')
        logging.warning(self.mistake_list)
        logging.warning(list(set(self.mistake_list)))
        logging.warning('成功数据')
        logging.warning(self.success_list)
        logging.warning(list(set(self.success_list))) if req.status_code == 200:
                self.typeId = eval(req.text)['data']
                print('typeId 类型存储完成---{}'.format(self.typeId))
            else:
                print('类型接口返回失败---{}'.format(item))
        else:  # 处理案例详情页数据
            # print(self.typeId[item['page']['dic_series_category']['id']])
            item['page']['typeId'] = self.typeId[item['page']['dic_series_category']['id']]
            req = requests.post(url='http://xxxx.com',  # 上传案例接口
                                data=json.dumps(dict(item)),
                                headers={
                                    'Content-Type': 'application/json'
                                })
            if req.status_code == 200:
                print('案例存储完成---{}'.format(item['page']['title']))
            else:
                print('案例存储失败---{}'.format(item['page']['title']))
```

### 1.2 scrapy管道自带的图片下载管道使用

```python
class KePipeline(ImagesPipeline):
    # 通过重写get_media_requests，将item和每个request联系起来
    def get_media_requests(self, item, info):
        headers = DEFAULT_REQUEST_HEADERS
        # print('{},{}'.format(self.type_name,self.name))
        celebrationSimplePageList = item['celebrationSimplePageList']
        for cele in celebrationSimplePageList:
            if cele['type'] == 4:
                item['image_urls'] = []
                for url in cele['celebrationSimplePageValueList']:
                    # self.type_name = item['type_name']
                    # self.name = item['name']
                    img_url = url['value'].split('?')[0]
                    item['image_urls'].append(img_url)
        for li in item['image_urls']:
            yield scrapy.Request(
                li,
                headers=headers,
                meta={'type_name': item['type_name'], 'name': item['name']}
            )

def file_path(self, request, response=None, info=None):
        img = (request.url).split('/')[-1]
        type_name = request.meta['type_name']
        name = request.meta['name']
        # print(type_name+'/'+name+'/'+img)
        return type_name + '/' + name + '/' + img  # 返回路径
```

### 1.3 scrapy管道自带的视频下载管道使用

```python

# 自定义一个类，继承FilesPipeline这个父类
class VideoDownloadPipeline(FilesPipeline):
 
    def get_media_requests(self, item, info):
        # 依次对视频地址发送请求，meta用于传递视频的文件名
        yield scrapy.Request(url=item['url'], meta={'name': item['name']})
 
    def file_path(self, request, response=None, info=None, *, item=None):
        filename = request.meta['name']  # 获取视频文件名
        return filename  # 返回下载的视频文件名(可以是路径)
 	
```

### 1.4 scrapy管道自带保存json文件的使用(**数据量少时**)

```python
from scrapy.exporters import JsonItemExporter  # scrapy的导出器，最后json文件里[{},{},{}...{}]
 
 
class XicispiderPipeline:
    def __init__(self):
        # 这个函数是自己加的
        self.file = open("ips.json", "wb")  # 这里得用byte类型数据
        self.exporter = JsonItemExporter(self.file, ensure_ascii=False, encoding="utf-8")
        self.exporter.start_exporting()
 
    def open_spider(self, spider):
        # 这个函数是自己加的
        print('执行了pipelines.py的open_spider函数')
 
    def process_item(self, item, spider):
        # 这个函数是默认生成的 接收spiders扔过来的dict
        self.exporter.export_item(item)
        return item
 
    def close_spider(self, spider):
        # 这个函数是自己加的
        self.exporter.finish_exporting()
        self.file.close()
        print('执行了pipelines.py的close_spider函数')
```

### 1.5scrapy管道自带保存json文件的使用(**数据量多时**)

```python
from scrapy.exporters import JsonLinesItemExporter  # scrapy的导出器，1行行的存
 
class XicispiderPipeline:
    def __init__(self):
        # 这个函数是自己加的
        self.file = open("ips.json", "wb")  # 这里得用byte类型数据
        self.exporter = JsonLinesItemExporter(self.file, ensure_ascii=False, encoding="utf-8")
 
    def open_spider(self, spider):
        # 这个函数是自己加的
        print('执行了pipelines.py的open_spider函数')
 
    def process_item(self, item, spider):
        # 这个函数是默认生成的 接收spiders扔过来的dict
        self.exporter.export_item(item)
        return item
 
    def close_spider(self, spider):
        # 这个函数是自己加的
        self.file.close()
        print('执行了pipelines.py的close_spider函数')
```

### 1.6 scrapy管道保存exel文件的使用

```python
from openpyxl import Workbook

class TuniuPipeline(object):  # 设置工序一
    self.wb = Workbook()
    self.ws = self.wb.active
    self.ws.append(['新闻标题', '新闻链接', '来源网站', '发布时间', '相似新闻', '是否含有网站名'])  # 设置表头

def process_item(self, item, spider):  # 工序具体内容
    line = [item['title'], item['link'], item['source'], item['pub_date'], item['similar'], item['in_title']]  # 把数据中每一项整理出来
    self.ws.append(line)  # 将数据以行的形式添加到xlsx中
    self.wb.save('/home/alexkh/tuniu.xlsx')  # 保存xlsx文件
    return item
```

### 1.7 注意

- 使用管道之前一定要在settings中去开启：ITEM_PIPELINES 参数并设置优先级
- 有多个pipeline的时候，process_item的方法必须return item ，否则后一个pipeline取到的数据为None值
- pipeline中的process_item方法必须有，否则item没有办法接受和处理
- process_item方法接收item和spider，其中spider表示当前传递item过来的spider
- open_spider表示：能够在爬虫开启时执行一次
- close_spider表示：能够在爬虫关闭时执行一次

## 2. Middleware下载器中间件

激活中间件

```python
DOWNLOADER_MIDDLEWARES = {
    'projectName.middlewares.sDownloaderMiddleware': 543,  # 这个是默认自带的，543序号越大，优先级越低
    'projectName.middlewares.ProxyMiddleware': 544,
}
```

### 2.1 selenium中间件的使用反爬机制处理

作用:将页面上动态渲染的参数渲染出来,返回给spiders

```python
from selenium import webdriver
import time
from scrapy.http import HtmlResponse

class seleniumMiddleware(object):

def process_request(self, request, spider):
        if 'case' in request.url:
            chrome = webdriver.Chrome()  # 创建chrome对象
            chrome.get(request.url)  # 请求网页
            time.sleep(1)
            data = chrome.page_source  # 获取网页加载过后的element对象
            # chrome.close()  # 关闭窗口
            # 创建响应对象
            res = HtmlResponse(url=request.url, body=data, encoding='utf-8', request=request)
            return res
```

### 2.2 随机请求头的使用反爬机制处理

```python
import random
class RandomUserAgentMiddleWare(object):
    # ua池
    USER_AGENT_LIST = [
        'Mozilla/5.0 (Windows NT 6.1; WOW64) AppleWebKit/535.1 (KHTML, like Gecko) Chrome/14.0.835.163 Safari/535.1',
        'Mozilla/5.0 (Windows NT 6.1; WOW64; rv:6.0) Gecko/20100101 Firefox/6.0',
        'Mozilla/4.0 (compatible; MSIE 7.0; Windows NT 5.1)',
        'Mozilla/4.0 (compatible; MSIE 6.0; Windows NT 5.1; SV1)'
    ]

def process_request(self, request, spider):
        user_agent = random.choice(self.USER_AGENT_LIST) #随机取请求头
        request.headers.setdefault('User-Agent', user_agent)  #设置请求头
```

### 2.3 使用selenium获取cookies

```python
import time
from selenium import webdriver

def getCookies():
    # 使用selenium模拟登陆，获取并返回cookie
    username = input('输入github账号:')
    password = input('输入github密码:')
    options = webdriver.ChromeOptions()
    options.add_argument('--headless') # 无窗口启动
    options.add_argument('--disable-gpu') #谷歌文档提到需要加上这个属性来规避bug
    options.add_argument('disable-infobars')#隐藏"Chrome正在受到自动软件的控制"
    options.add_argument('lang=zh_CN.UTF-8') # 设置中文
    driver = webdriver.Chrome(chrome_options=options)
    driver.get('https://github.com/login')
    time.sleep(1)
    driver.find_element_by_xpath('//*[@id="login_field"]').send_keys(username)
    time.sleep(1)
    driver.find_element_by_xpath('//*[@id="password"]').send_keys(password)
    time.sleep(1)
    driver.find_element_by_xpath('//*[@id="login"]/form/div[3]/input[3]').click()
    time.sleep(2)
    cookies_dict = {cookie['name']: cookie['value'] for cookie in driver.get_cookies()}
    driver.quit()
    return cookies_dict

class LoginDownloaderMiddleware(object):

def process_request(self, request, spider):
        if 'case' in request.url:
        cookies_dict = getCookies()
        print(cookies_dict)
        request.cookies = cookies_dict # 对请求对象的cookies属性进行替换
```

### 2.4 添加ip代理的使用反爬机制处理

```python
class ProxyMiddleware(object):
	
    def __init__(self):
        # 构建request请求
        res = request.post()
        res = json.lodoms(res)
        self.res['proxy']
    #PROXIES = [
        #'https://36.249.118.13:9999',
        #'https://175.44.108.65:9999',
        #'http://117.69.12.82:9999']

def process_request(self, request, spider):
        proxy = random.choice('PROXIES')
        request.meta['proxy'] = self.res['proxy']
        
    def process_response(self, request, response, spider):   
        """ 对返回的 response 处理"""
        # 如果返回的 response 状态不是 200， 重新生成当前的 request对象
        if response.status != 200:
            proxy = RedisClient().pop_proxy().decode('utf-8')
            print('this is response ip:'+ proxy)
            # 对当前 request 加上代理
            return request

return response 
```

### 2.5 Scrapy设置时间间隔反爬机制
```python
import time
import logging
 
# 设置随机延时
class RandomDelayMiddleware(object):
    def __init__(self, delay):
        self.delay = delay
 
    @classmethod
    def from_crawler(cls, crawler):
        delay = crawler.spider.settings.get("DOWNLOAD_DELAY", 1) #setting里设置的时间，注释默认为1s
        if not isinstance(delay, int):
            raise ValueError("RANDOM_DELAY need a int")
        return cls(delay)
 
    def process_request(self, request, spider):
        # delay = random.randint(0, self.delay)
        delay = random.uniform(0, self.delay)
        delay = float("%.1f" % delay)
        logging.debug("### time is random delay: %s s ###" % delay)
        time.sleep(delay)
```

***Downloader Middleware:
    下载器中间件是介于Scrapy的request/response处理的钩子框架。 是用于全局修改Scrapy request和response的一个轻量、底层的系统。
    用容易理解的话表述就是：更换代理IP，更换Cookies，更换User-Agent，自动重试 等。

#### 特技

1.  使用 Readme\_XXX.md 来支持不同的语言，例如 Readme\_en.md, Readme\_zh.md
2.  Gitee 官方博客 [blog.gitee.com](https://blog.gitee.com)
3.  你可以 [https://gitee.com/explore](https://gitee.com/explore) 这个地址来了解 Gitee 上的优秀开源项目
4.  [GVP](https://gitee.com/gvp) 全称是 Gitee 最有价值开源项目，是综合评定出的优秀开源项目
5.  Gitee 官方提供的使用手册 [https://gitee.com/help](https://gitee.com/help)
6.  Gitee 封面人物是一档用来展示 Gitee 会员风采的栏目 [https://gitee.com/gitee-stars/](https://gitee.com/gitee-stars/)

Einstar/shiguangScrapy

简介

发行版

贡献者

近期动态

Einstar/shiguangScrapy .gitee-modal { width: 500px !important; }

简介

发行版

贡献者

近期动态

搜索帮助

Einstar/shiguangScrapy