如何自己实现一个scrapy框架（一）

一、了解框架

1、首先明确一下，什么是框架：

框架是为了为解决一类问题而开发的程序，框架两个字可以分开理解，框：表示指定解决问题的边界，明确要解决的问题；架：表达的是能够提供一定的支撑性和可扩展性；从而实现解决这类问题达到快速开发的目的。

2、实现框架的好处是什么

2.1现成开源第三方框架的局限性
现成开源第三方框架是为了尽可能满足大部分的需求，不可能做到面面俱到，以及第三方框架的调试相对复杂
2.2解决特定的工作需求
工作中会有很多特殊的需求，会经常使用某种套路去实现这些需求，那么为了提高效率可以专门把这种套路封装成一个框架
比如专门针对电商网站、新闻资讯写一个爬虫框架；再比如针对断点续爬、增量抓取等需求写一个框架
2.3提高自己的技术能力
不一定需要亲自造轮子，但是应该知道如何造轮子

二、框架设计思路

1、正常爬虫的流程

（1）构建请求信息(url、method、headers、params、data)
（2）发起HTTP/HTTPS请求，获取HTTP/HTTPS响应
（3）解析响应，分析响应数据的数据结构或者页面结构
提取数据
提取请求的地址
（4）对数据进行存储/对新的请求地址重复前面的步骤

2、scrapy爬虫的流程

从上图可以看出，scrapy分为：
（1）三个内置对象
请求对象(Request)
响应对象(Response)
数据对象(Item)
（2）五个核心组件
爬虫组件
构建请求信息(初始的)，也就是生成请求对象(Request)
解析响应对象，返回数据对象(Item)或者新的请求对象(Request)
调度器组件
缓存请求对象(Request)，并为下载器提供请求对象，实现请求的调度
对请求对象进行去重判断
下载器组件
根据请求对象(Request)，发起HTTP、HTTPS网络请求，
拿到HTTP、HTTPS响应，构建响应对象(Response)并返回
管道组件
负责处理数据对象(Item)
引擎组件
负责驱动各大组件，通过调用各自对外提供的API接口，实现它们之间的交互和协作
提供整个框架的启动入口
（3）两个中间件
爬虫中间件
对请求对象和数据对象进行预处理
下载器中间件
对请求对象和响应对象进行预处理

三、代码实现分析

1、明确模块之间的逻辑关系

五个核心模块和三个内置的对象是关键模块，需要优先实现，先抛开中间件，分析下它们之间的逻辑关系是：
构造spider中start_urls中的请求
传递给调取器进行保存，之后从中取出
取出的request对象交给下载的进行下载，返回response
response交给爬虫模块进行解析，提取结果
如果结果是request对象，重新交给调度器，如果结果是item对象，交给管道处理

2、设计代码结构

框架名字起名为scrapy_plus
继续对模块进行解耦和分类：
把核心模块放置在一起
请求对象模块和响应对象模块统一作为http模块
数据对象单独作为一个分类
暂定代码结构为

markdown最近才开始使用，画的不是太好请见谅

四、框架雏形

1、实现http模块和item模块

创建http模块包
（1）request模块的封装
对HTTP基本的请求属性进行简单封装，实现一个Request对象

# scrapy/http/request.py
'''封装Request对象'''

class Request(object):
    '''框架内置请求对象，设置请求信息'''

    def __init__(self, url, method='GET',\
              headers=None, params=None, data=None):
        self.url = url    # 请求地址
        self.method = method    # 请求方法
        self.headers = headers    # 请求头
        self.params = params    # 请求参数
        self.data = data    # 请求体

（2）response对象的封装
对HTTP基本的响应属性进行简单封装，实现一个Response对象

# scrapy/http/response.py
'''封装Response对象'''

class Response(object):
    '''框架内置Response对象'''
    def __init__(self, url, status_code, headers, body):
        self.url = url    # 响应url
        self.status_code = status_code    # 响应状态码
        self.headers = headers    # 响应头
        self.body = body    # 响应体

（3）item对象的封装
对数据进行简单封装，实现Item对象

# scrapy/item.py
'''item对象'''

class Item(object):
    '''框架内置Item对象'''
    def __init__(self, data):
        # data表示传入的数据
        self._data = data    # 设置为简单的私有属性

    @property
    def data(self):
      '''对外提供data进行访问，一定程度达到保护的作用'''
      return self._data

其中property的理解：

property 能够让调用一个方法和调用一个属性一样容易，即不用打括号

property 能够让这个属性的值是只读的，即不能够对其进行重新赋值，达到一定的保护的目的

2、核心模块的实现

（1）spider模块的封装
1.1 爬虫组件功能：
构建请求信息(初始的)，也就是生成请求对象(Request)
解析响应对象，返回数据对象(Item)或者新的请求对象(Request)
1.2 实现方案：
实现start_requests方法，返回请求对象
实现parse方法，返回Item对象或者新的请求对象
具体实现
创建core模块包

# scrapy_plus/core/spider.py
'''爬虫组件封装'''
from scrapy_plus.item import Item    # 导入Item对象
from scrapy_plus.http.request import Request    # 导入Request对象

class Spider(object):
    '''
    1. 构建请求信息(初始的)，也就是生成请求对象(Request)
    2. 解析响应对象，返回数据对象(Item)或者新的请求对象(Request)
    '''

    start_url = 'http://www.baidu.com'    # 默认初始请求地址   

    def start_requests(self):
        '''构建初始请求对象并返回'''
        return Request(self.start_url)

    def parse(self, response):
        '''解析请求
        并返回新的请求对象、或者数据对象
        '''
        return Item(response.body)   # 返回item对象

(2) 调度器模块的封装
2.1 调度器功能：
缓存请求对象(Request)，并为下载器提供请求对象，实现请求的调度：
对请求对象进行去重判断：实现去重方法_filter_request，该方法对内提供，因此设置为私有方法
2.2 实现方案：
利用队列FIFO存储请求；
实现add_request方法添加请求，接收请求对象作为参数；
实现get_request方法对外提供从队列取出的请求对象

# scrapy_plus/core/scheduler.py
'''调度器模块封住'''
# 利用six模块实现py2和py3兼容
from six.moves.queue import Queue


class Scheduler(object):
    '''
    1. 缓存请求对象(Request)，并为下载器提供请求对象，实现请求的调度
    2. 对请求对象进行去重判断
    '''
    def __init__(self):
        self.queue = Queue()

    def add_request(self, request):
        '''添加请求对象'''
        self.queue.put(request)

    def get_request(self):
        '''获取一个请求对象并返回'''
        request = self.queue.get()
        return request

    def _filter_request(self):
        '''请求去重'''
        # 暂时不实现
        pass

这里queue的导入在pycharm中会报错，不用管它，这是pycharm的问题，代码的OK的

(3)下载器模块的封装
3.1 下载器功能：
根据请求对象(Request)，发起HTTP、HTTPS网络请求，拿到HTTP、HTTPS响应，构建响应对象(Response)并返回
3.1 实现方案：
利用requests、urllib2等模块发请求，这里使用requests模块
实现get_response方法，接收request请求对象作为参数，发起请求，获取响应

# scrapy_plus/core/downloader.py
'''下载器组件'''
import requests
from scrapy_plus.http.response import Response

class Downloader(object):
    '''根据请求对象(Request)，发起HTTP、HTTPS网络请求，拿到HTTP、HTTPS响应，构建响应对象(Response)并返回'''

    def get_response(self, request):
        '''发起请求获取响应的方法'''
        # 1. 根据请求对象，发起请求，获取响应
        #    判断请求方法：
        if request.method.upper() == 'GET':
            resp = requests.get(request.url, headers=request.headers,\
                          params=request.params)
        elif request.method.upper() == 'POST':
            resp = requests.post(request.url,headers=request.headers,\
                      params=request.params,data=request.data)
        else:
            # 如果方法不是get或者post，抛出一个异常
            raise Exception("不支持的请求方法")
        # 2. 构建响应对象,并返回
        return Response(resp.url, resp.status_code, resp.headers, resp.content)

(4)管道模块的封装
4.1 管道组件功能：
负责处理数据对象
4.2 实现方案：
实现process_item方法，接收数据对象作为参数

# scrapy_plus/core/pipeline.py
'''管道组件封装'''


class Pipeline(object):
    '''负责处理数据对象(Item)'''

    def process_item(self, item):
        '''处理item对象'''
        print("item: ", item)

(5)引擎模块的封装
5.1 引擎组件功能：
对外提供整个的程序的入口
依次调用其他组件对外提供的接口，实现整个框架的运作(驱动)
5.2 实现方案：
利用init方法初始化其他组件对象，在内部使用
实现start方法，由外部调用，启动引擎
实现_start_engine方法，完成整个框架的运行逻辑
具体参考上一小节中雏形结构引擎的逻辑

# scrapy_plus/core/engine.py
'''引擎组件'''
from scrapy_plus.http.request import Request    # 导入Request对象

from .scheduler import Scheduler
from .downloader import Downloader
from .pipeline import Pipeline
from .spider import Spider


class Engine(object):
    '''
    a. 对外提供整个的程序的入口
    b. 依次调用其他组件对外提供的接口，实现整个框架的运作(驱动)
    '''

    def __init__(self):
        self.spider = Spider()    # 接收爬虫对象
        self.scheduler = Scheduler()    # 初始化调度器对象
        self.downloader = Downloader()    # 初始化下载器对象
        self.pipeline = Pipeline()    # 初始化管道对象

    def start(self):
        '''启动整个引擎'''
        self._start_engine()

    def _start_engine(self):
        '''依次调用其他组件对外提供的接口，实现整个框架的运作(驱动)'''
        # 1. 爬虫模块发出初始请求
        start_request = self.spider.start_requests()
        # 2. 把初始请求添加给调度器
        self.scheduler.add_request(start_request)
        # 3. 从调度器获取请求对象，交给下载器发起请求，获取一个响应对象
        request = self.scheduler.get_request()
        # 4. 利用下载器发起请求
        response = self.downloader.get_response(request)
        # 5. 利用爬虫的解析响应的方法，处理响应，得到结果
        result = self.spider.parse(response)
        # 6. 判断结果对象
        # 6.1 如果是请求对象，那么就再交给调度器
        if isinstance(result, Request):
            self.scheduler.add_request(result)
        # 6.2 否则，就交给管道处理
        else:
            self.pipeline.process_item(result)

五、框架安装

1 安装框架的目的

利用setup.py将框架安装到python环境中，在编写爬虫时候，作为第三方模块来调用

2 框架安装第一步：完成setup.py的编写

以下代码相当于一个模板，只用更改name字段出，改为对应的需要安装的模块名称就可以，比如这里是：scrapy_plus
将setup.py文件放到scrapy_plus的同级目录下

from os.path import dirname, join
# from pip.req import parse_requirements

from setuptools import (
    find_packages,
    setup,
)

def parse_requirements(filename):
    """ load requirements from a pip requirements file """
    lineiter = (line.strip() for line in open(filename))
    return [line for line in lineiter if line and not line.startswith("#")]

with open(join(dirname(__file__), './VERSION.txt'), 'rb') as f:
    version = f.read().decode('ascii').strip()

setup(
    name='scrapy-plus',  # 模块名称
    version=version,
    description='A mini spider framework, like Scrapy',  # 描述
    packages=find_packages(exclude=[]),
    author='itcast',
    author_email='[email protected]',
    license='Apache License v2',
    package_data={'': ['*.*']},
    url='#',
    install_requires=parse_requirements("requirements.txt"),  # 所需的运行环境
    zip_safe=False,
    classifiers=[
        'Programming Language :: Python',
        'Operating System :: Microsoft :: Windows',
        'Operating System :: Unix',
        'Programming Language :: Python :: 2.7',
        'Programming Language :: Python :: 3.4',
        'Programming Language :: Python :: 3.5',
        'Programming Language :: Python :: 3.6',
    ],
)

注意： 上面代码中可能会报错需要额外安装packaging模块，更新setuptools

pip install packaging
pip install --upgrade setuptools

pip.req可能不存在，对应的可以：

def parse_requirements(filename):
    """ load requirements from a pip requirements file """
    lineiter = (line.strip() for line in open(filename))
    return [line for line in lineiter if line and not line.startswith("#")]

3、 框架安装第二步：完成requirements.txt的编写

功能：
写明依赖环境所支持的模块及其版本
使用：
在setup.py中使用
放置在setup.py同级目录下

requests>=2.18.4
six>=1.11.0

4 框架安装第三步：完成VERSION.txt的编写

功能：
标明当前版本，一个合格的模块，应当具备相应的版本号
使用：
在setup.py中使用
放置在setup.py同级目录下

1.0

5 框架安装第四步：执行安装命令

步骤：
切换到setup.py所在目录
切换到对应需要python虚拟环境下
在终端执行python setup.py install
显示结果：

Adding chardet 3.0.4 to easy-install.pth file
Installing chardetect-script.py script to C:\Users\Star Platinum\AppData\Local\Programs\Python\Python35\Scripts
Installing chardetect.exe script to C:\Users\Star Platinum\AppData\Local\Programs\Python\Python35\Scripts

Using c:\users\star platinum\appdata\local\programs\python\python35\lib\site-packages
Finished processing dependencies for scrapy-plus==1.0

六、框架运行

1 编写main.py

在其他路径下创建一个项目文件夹 project_dir

# project_dir/main.py

from scrapy_plus.core.engine import Engine    # 导入引擎

if __name__ == '__main__':
    engine = Engine()    # 创建引擎对象
    engine.start()    # 启动引擎

运行结果：管道中打印的item对象
报错：

File "C:\Users\Star Platinum\AppData\Local\Programs\Python\Python35\lib\site-packages\urllib3\packages\six.py", line 82, in _import_module
    __import__(name)
ImportError: No module named 'http.client'

这里的问题是window下导入包的时候路径优先找本项目下的http包，所以没有找到client，解决方法是：
修改http文件夹的名字，改为htttp（自定义），同时路径也跟着修改

再不行就看看这些库是否下载，版本不对也无所谓，不要低就好
requests==2.11.1
gcloud==0.17.0
oauth2client==3.0.0
requests-toolbelt==0.7.0
python-jwt==2.0.1
pycrypto==2.6.1
运行成功之后显示结果：

item对象:<scrapy_plus.item.Item object at 0x10759eef0>