实现动态模块导入

# 动态导入模块

# 学习目标

掌握模块的动态导入的方法
完成对现有代码的重构

# 1 目前代码存在的问题

通过前面的代码编写，我们已经能够完成大部分的任务，但是在main.py 中的代码非常臃肿，对应的我们可以再settings.py 配置哪些爬虫，管道，中间件需要开启，能够让整个代码的逻辑更加清晰

# 2 模块动态导入的方法

利用importlib.import_modle能够传入模块的路径，即可即可实现根据模块的位置的字符串，导入该模块的功能

# 3 在settings中设置SPIDER，MIDDLEWARES

# 3.1 利用在配置文件中设置需要启用的爬虫类、管道类、中间件类

项目路径/settings.py

# 项目中的settings.py

......

# 增加以下信息：
# 启用的爬虫类
SPIDERS = [
    'spiders.baidu.BaiduSpider',
    'spiders.douban.DoubanSpider'
]

# 启用的管道类
PIPELINES = [
    'pipelines.BaiduPipeline',
    'pipelines.DoubanPipeline'
]

# 启用的爬虫中间件类
SPIDER_MIDDLEWARES = []

# 启用的下载器中间件类
DOWNLOADER_MIDDLEWARES = []

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22

# 3.2 利用importlib模块，在引擎中动态导入并实例化

scrapy_plus/core/engine.py

....
import importlib
from scrapy_plus.conf.settings import SPIDERS, PIPELINES, SPIDER_MIDDLEWARES, DOWNLOADER_MIDDLEWARES

class Engine:
    '''完成对引擎模块的封装'''

def __init__(self): # 此处修改

    self.spiders = self._auto_import_instances(SPIDERS,isspider=True)   # 接收爬虫字典 # 此处修改
    self.scheduler = Scheduler()    # 初始化调度器对象
    self.downloader = Downloader()    # 初始化下载器对象

    # 此处修改
    self.pipelines = self._auto_import_instances(PIPELINES) # 管道
    self.spider_mids = self._auto_import_instances(SPIDER_MIDDLEWARES) # 爬虫中间件
    self.downloader_mids = self._auto_import_instances(DOWNLOADER_MIDDLEWARES) # 下载中间件

    self.total_request_nums = 0
    self.total_response_nums = 0

# 此处新增函数 
def _auto_import_instances(self, path=[], isspider=False):
    '''通过配置文件，动态导入类并实例化
    path: 表示配置文件中配置的导入类的路径
    isspider: 由于爬虫需要返回的是一个字典，因此对其做对应的判断和处理
    '''
    instances = {} if isspider else []
    for p in path:
        module_name = p.rsplit(".", 1)[0]  # 取出模块名称
        cls_name = p.rsplit(".", 1)[1]  # 取出类名称
        ret = importlib.import_module(module_name)  # 动态导入爬虫模块
        cls = getattr(ret, cls_name)  # 根据类名称获取类对象

        if isspider:
            instances[cls.name] = cls()  # 组装成爬虫字典{spider_name:spider(),}
        else:
            instances.append(cls())  # 实例化类对象
            # 把管道中间件分别组装成 管道列表=[管道类1(),管道类2()] / 中间件列表 = [中间件类1(),中间件类2()]
    return instances  # 返回类对象字典或列表
......

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41

# 3.3 关于rsplit()

rsplit() 方法通过指定分隔符对字符串进行分割并返回一个分割后的字符串列表，默认分隔符为所有空字符，包括空格、换行(\n)、制表符(\t)等。类似于 split() 方法，只不过是从字符串最后面开始分割。

s = "this is string example....wow!!!"
print(s.rsplit( ))
print(s.rsplit('i',1))
print(s.rsplit('w'))
# 以上实例输出结果如下：
# ['this', 'is', 'string', 'example....wow!!!']
# ['this is str', 'ng example....wow!!!']
# ['this is string example....', 'o', '!!!']

1
2
3
4
5
6
7
8

# 3.4 修改框架中的默认配置文件

scrapy_plus/conf/default_settings.py

......
# 新增
# 启用的默认管道类
PIPELINES = []

# 启用的默认爬虫中间件类
SPIDER_MIDDLEWARES = []

# 启用的默认下载器中间件类
DOWNLOADER_MIDDLEWARES = []

1
2
3
4
5
6
7
8
9
10
11
12

# 4 修改`main.py`

这样main.py就不用再导入并传入那么多对象了：

# project_dir/main.py
from scrapy_plus.core.engine import Engine    # 导入引擎

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

1
2
3
4
5
6

# 小结

掌握importlib.import_module方法使用
完成代码的重构，实现通过配置文件导入模块

# 本小结涉及修改的完整代码

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

from scrapy_plus.middlewares.spider_middlewares import SpiderMiddleware
from scrapy_plus.middlewares.downloader_middlewares import DownloaderMiddleware

import time
from datetime import datetime
from scrapy_plus.utils.log import logger    # 导入logger

import importlib
from scrapy_plus.conf.settings import SPIDERS, PIPELINES, SPIDER_MIDDLEWARES, DOWNLOADER_MIDDLEWARES


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

    def __init__(self):
        self.spiders = self._auto_import_instances(SPIDERS,isspider=True)   # 接收爬虫字典
        self.scheduler = Scheduler()    # 初始化调度器对象
        self.downloader = Downloader()    # 初始化下载器对象

        self.pipelines = self._auto_import_instances(PIPELINES) # 管道
        self.spider_mids = self._auto_import_instances(SPIDER_MIDDLEWARES) # 爬虫中间件
        self.downloader_mids = self._auto_import_instances(DOWNLOADER_MIDDLEWARES) # 下载中间件

        self.total_request_nums = 0
        self.total_response_nums = 0

    def _auto_import_instances(self, path=[], isspider=False):
        '''通过配置文件，动态导入类并实例化
        path: 表示配置文件中配置的导入类的路径
        isspider: 由于爬虫需要返回的是一个字典，因此对其做对应的判断和处理
        '''
        instances = {} if isspider else []
        for p in path:
            module_name = p.rsplit(".", 1)[0]  # 取出模块名称
            cls_name = p.rsplit(".", 1)[1]  # 取出类名称
            ret = importlib.import_module(module_name)  # 动态导入爬虫模块
            cls = getattr(ret, cls_name)  # 根据类名称获取类对象

            if isspider:
                instances[cls.name] = cls()  # 组装成爬虫字典{spider_name:spider(),}
            else:
                instances.append(cls())  # 实例化类对象
                # 把管道中间件分别组装成 管道列表=[管道类1(),管道类2()] / 中间件列表 = [中间件类1(),中间件类2()]
        return instances  # 返回类对象字典或列表

    def start(self):
        '''启动整个引擎'''
        start_time = datetime.now()  # 起始时间
        logger.info("开始运行时间：%s" % start_time)  # 使用日志记录起始运行时间
        self._start_engine()
        end_time = datetime.now()
        logger.info("爬虫结束：{}".format(end_time))
        logger.info("爬虫一共运行：{}秒".format((end_time-start_time).total_seconds()))
        logger.info("总的请求数量:{}".format(self.total_request_nums))
        logger.info("总的响应数量:{}".format(self.total_response_nums))

    def _start_request(self):
        for spider_name, spider in self.spiders.items():
            for start_request in spider.start_requests():
                #1. 对start_request进过爬虫中间件进行处理
                for spider_mid in self.spider_mids:
                    start_request = spider_mid.process_request(start_request)

                # 为请求对象绑定它所属的爬虫的名称
                start_request.spider_name = spider_name

                #2. 调用调度器的add_request方法，添加request对象到调度器中
                self.scheduler.add_request(start_request)
                #请求数+1
                self.total_request_nums += 1

    def _execute_request_response_item(self):
        '''根据请求、发起请求获取响应、解析响应、处理响应结果'''
        #3. 调用调度器的get_request方法，获取request对象
        request = self.scheduler.get_request()
        if request is None: #如果没有获取到请求对象，直接返回
            return

        #request对象经过下载器中间件的process_request进行处理
        for downloader_mid in self.downloader_mids:
            request = downloader_mid.process_request(request)

        #4. 调用下载器的get_response方法，获取响应
        response = self.downloader.get_response(request)

        response.meta = request.meta

        #response对象经过下载器中间件的process_response进行处理
        for downloader_mid in self.downloader_mids:
            response = downloader_mid.process_response(response)

        #response对象经过下爬虫中间件的process_response进行处理
        for spider_mid in self.spider_mids:
            response = spider_mid.process_response(response)

        # 根据request的spider_name属性，获取对应的爬虫对象
        spider = self.spiders[request.spider_name]
        # parse方法
        parse = getattr(spider, request.parse)  # getattr(类, 类中方法名的字符串) = 类方法对象

        #5. 调用爬虫的parse方法，处理响应
        for result in parse(response):
            #6.判断结果的类型，如果是request，重新调用调度器的add_request方法
            if isinstance(result,Request):
                #在解析函数得到request对象之后，使用process_request进行处理

                for spider_mid in self.spider_mids:
                    result = spider_mid.process_request(result)

                # 给request对象增加一个spider_name属性
                result.spider_name = request.spider_name

                self.scheduler.add_request(result)
                self.total_request_nums += 1
            #7如果不是，调用pipeline的process_item方法处理结果
            else:
                # 就通过process_item()传递数据给管道
                for pipeline in self.pipelines:
                    pipeline.process_item(result, spider)

        self.total_response_nums += 1

    def _start_engine(self):
        '''
        具体的实现引擎的细节
        :return:
        '''
        self._start_request()
        while True:
            time.sleep(0.001)
            self._execute_request_response_item()
            if self.total_response_nums>= self.total_request_nums:
                break

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144

scrapy_plus/default_settings.py

import logging

# 默认的日志配置
DEFAULT_LOG_LEVEL = logging.INFO    # 默认等级
DEFAULT_LOG_FMT = '%(asctime)s %(filename)s[line:%(lineno)d] \
                  %(levelname)s: %(message)s'   # 默认日志格式
DEFUALT_LOG_DATEFMT = '%Y-%m-%d %H:%M:%S'  # 默认时间格式
DEFAULT_LOG_FILENAME = 'log.log'    # 默认日志文件名称

# 启用的默认管道类
PIPELINES = []

# 启用的默认爬虫中间件类
SPIDER_MIDDLEWARES = []

# 启用的默认下载器中间件类
DOWNLOADER_MIDDLEWARES = []

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

项目路径/main.py

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

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

1
2
3
4
5