从0开始基于python3用scrapy爬取数据

silly_sinba

浏览: 127327 次
性别:
来自: 成都

最近访客更多访客>>

llllmnglf

lbyzx123

chenmfly

Jan111

博主相关

博客

微博

相册

留言

关于我

文章分类

社区版块

存档分类

博客分类：

python爬虫

python scrapy 爬虫

写在开头：

博主刚开始爬取数据的时候选中的kanzhun网，结果被封了ip -_- 。查看了kanzhun网的robots协议(http://www.kanzhun.com/robots.txt)，发现它们非常严格，就是这个不让爬那个也不让爬。于是想起了参加儿博会的时候被安利的一个母婴电商app，一看他们连robots协议都没有，想必是程序员都去赶功能去了，应该是我们都喜闻乐见的网站。于是进去看了看...一共采集到了3000多个商品，发现大部分都是0-100元这个区间，还是挺亲民的价格，想了解

的可以联系我:)

摘要：

本文主要介绍0基础从python3的安装到使用scrapy框架抓取某母婴电商的数据并简单分析。主要包括以下内容：

第一爬：官网

第一次爬取数据强烈推荐内网系统，免得一个代理问题就让激情退却了：

安装python3

下载地址：https://www.python.org/downloads/

查看安装版本以验证安装成功：

$:python -V

注意：

1）python3和python2的差别非常大，大家在google的时候要看清楚是针对python2还是python3的。

比如在python2中，print是这样的

print "hello world"

而在python3中，print是函数要加上括号，变成了:

print("hello world")

2) python有很多多多多的库，可以通过pip install命令下载，例如下载我们前面画的那个柱状图的库：

pip install matplotlib

在python2.7和python3.6之后，pip已经集成到python安装包里面了，不用再单独下载。

3）如果是Mac用户，系统已经自带了python2.7，博主不敢随便升级，于是另外安装了python3。并不像网上很多老帖子写的需要装environment来切换两个python版本(猜测是针对windows用户的)。系统自带的python用python启动，而python3用命令python3启动，pip也是一样，有pip命令和pip3命令。就像是两个应用一样非常方便。

Zhuos-MacBook-Pro:demo jo$ python -V
Python 2.7.13
Zhuos-MacBook-Pro:demo jo$ python3 -V
Python 3.6.1

Windows用户如果要装两个版本...装好了来跟博主share下经验教训。

4）本文之后所有的代码示例都是基于python3的。

编辑器安装：

推荐使用pycharm，地址: https://www.jetbrains.com/pycharm/download/

爬取官网：

第一个爬虫代码，我们暂时不考虑url的相对路径问题，也不考虑公司代理问题等...下面的代码应该是最简单的了，再简单就是伪代码了。

import re
import urllib
import urllib.request
from collections import deque

url = "http://www.you_compay_home_page.com"

queue = deque()
visited = set()
total_count = 1
queue.append(url)

while queue:
    url = queue.popleft()
    visited |= {url}
    print("正在抓取第 " + str(total_count) + " 个, " + url)
    total_count += 1
    urllop = urllib.request.urlopen(url, timeout=1)
    if "html" not in urllop.getheader('Content-Type'):
        print(urllop + " 不是html页面，忽略！")
        continue
    try:
        data = urllop.read().decode("utf-8")
    except Exception as e:
        print(e)
        continue
    count_per_page = 0
    
    linkre = re.compile('href="(.+?)"')
    for x in linkre.findall(data):
        if 'https://www.you_compay_home_page.com/' in x and x not in visited:
            count_per_page += 1
            queue.append(x) #注意调试的时候注释本行,以免对服务器造成压力
            print("加入待爬页面：" + x)
    print("本页面共加入待爬页面:" + str(count_per_page))

解释:

line1~4：

导入我们需要的依赖库：re是正则表达式，顾名思义urllib与urllib.request是针对url，deque是针对队列的.

line6~11：

url：爬虫的入口；queue：存放要爬取的页面；visited：存放已经爬取过的页面，防止重复爬取。

1）url，queue，visited，total_count都是对象引用。

2) python不用像java一样需要定义引用的类型，每个引用都知道自己指向的是什么类型的对象。

3) python中没有原子数据类型，都是对象，例如line17，total_count也是一个int型的对象。

line13：有没花括号了，取而代之的是冒号+缩进，例如if, while, try...

line18: urlopen这个方法只有一个url是必填参数，timeout是有默认值的参数，但是我们传入了自定义的值。

urllop = urllib.request.urlopen(url, timeout=1)

看看这个方法的定义：

def urlopen(url, data=None, timeout=socket._GLOBAL_DEFAULT_TIMEOUT,
            *, cafile=None, capath=None, cadefault=False, context=None):

第一个url是必填参数，后面的data,timeout，cafile等是默认参数。我们调用该方法的时候，只提供了必选参数url和默认参数timeout。

python中参数有5可以任意组合，但是必须符合下面的顺序：

必选参数 → 默认参数 → 可变参数 → 命名关键字参数 → 关键字参数

必选参数：url

默认参数：data, timeout

可变参数：无。例如C中的数组指针*pointer，指向一个数组或元祖（元祖，既不可变的数组）。

命名关键字参数：cafile，capath，cadefault，context。 *,标志其后的参数是命名关键字参数，既只能指定参数名为cafile，capath，cadefault，context的参数。

关键字参数：无。**pointer，类似于C中传入一个二维指针，指向一个dict，包含了一组key-value对。

关于python的参数，Read More：http://blog.csdn.net/downing114/article/details/70257602?locationNum=2&fps=1

line29~35:通过正则表达式找到该页面包含的其他链接，加入到queue中等待被访问。

编写我们的pattern：href="(.+?)"，用这个pattern匹配读取到的网页数据data，匹配上的数据按照括号分组，linkre.findall(data)将返回分组数据，这里即为该页面中的其他链接。

第二爬：内网看板

看板系统需要登录，我们需要安装抓包的工具查看登录时发送给服务器的报文，让爬虫也能依样画葫芦的去登录。

抓包工具：Mac上我使用的是Charles试用版，Windwos上推荐Fiddler。

通过抓包工具我们可以看到发送到服务器的有4个field，用户名和密码都是自己录入的，另外两个字段应该是页面自己生成的，进一步查看页面，我们可以看到这两个字段在页面上的位置，通过正则表达式让爬虫看到token的值，以便后续和用户名，密码一起发送给服务器。

Tips: 对chrom和firefox,通过：

Windows：control+shift+i

Mac：command+option+i

打开开发者工具，切到Elements tab，就可以通过指到页面的元素，方便快捷的看到这个元素对应的html代码了。

Okay，我们想好了方法，就可以用手写伪装成浏览器获取token的代码了：

import re
import urllib
import urllib.request
import http.cookiejar
from collections import deque

print("\n\n*************** Step 1: visit index page and get the token generated in server side ******************")
url = "http://gitlab.your_company_addr.com/users/sign_in"
header = {
    'Connection': 'Keep-Alive',
    'Accept': 'text/html, application/xhtml+xml, */*',
    'Accept-Language': 'en-US,en;q=0.8,zh-Hans-CN;q=0.5,zh-Hans;q=0.3',
    'User-Agent': 'Mozilla/5.0 (Windows NT 6.3; WOW64; Trident/7.0; rv:11.0) like Gecko',
    'Host': 'www.zhihu.com',
    'DNT': '1'
    # 'Cookie': '_gitlab_session=f00c50db7dc2c83989419079760e5786'
}


def getToken(data):
    cer = re.compile('name=\"authenticity_token\" value=\"(.+?)\"')
    strlist = cer.findall(data)
    return strlist[0]


def getOpener(head):
    # deal with the Cookies
    cj = cj = http.cookiejar.CookieJar()
    opener = urllib.request.build_opener(urllib.request.HTTPCookieProcessor(cj))
    header = []
    for key, value in head.items():
        elem = (key, value)
        header.append(elem)
    opener.addheaders = header
    return opener


opener = getOpener(header)
op = opener.open(url)
data = op.read().decode("utf-8")
token = getToken(data)
print(token)

line9~17: 设置header的内容。我们这里构造的header在python中是一种dict数据结构。dict类似于java的map。存储key-value对。

line20~23: 编写获取页面token的方法，入参是网页内容，出参是通过正则表达式提取到的token。

line26~35: 编写方法获取包含了header的opener，之后我们都通过opener伪装成浏览器来打开网页。

line26~35: 调用方法获取opener，打开网页，读取到了数据后用utf-8编码，然后再调用getToken方法从编码后的数据中提取到token。

Tips: 使用什么字符集对获取到的网页数据编码呢？直接查看网页的head即可。Scrapy框架获取到页面不需要指定字符集，因为它对http报文解析得到了编码字符集。

<meta charset="utf-8">

获取到了token后，我们开始登陆系统：

print("\n\n*************** Step 2: login the server with username, password and token generated before **********")
url = "http://gitlab.your_company_addr.com/users/auth/ldapmain/callback"
postDict = {
    'utf8': '✓',
    'username': 'zhuoyp001',
    'password': '********',
    'authenticity_token': token
}

postData = urllib.parse.urlencode(postDict)
postData = postData.encode('utf-8')
res = opener.open(url, postData)
print(res.status, res.reason)
if (res.status != 200):
    print("login failed")
    exit()

print('login successfully!')

line3~line8:构造http post方法要post的数据。这也是一个dict数据结构，在提交给服务器前，需要进行url encode一下。

print("\n\n*************** Step 3: begin scraping... **********")
baseUrl = "http://gitlab.your_company_addr.com/explore/projects"
project_queue = deque()
visited = set()
current_page = 1
page_amount = 3
url = baseUrl
while current_page <= page_amount:
    url = baseUrl + "?page=" + str(current_page)
    print("正在抓取第 " + str(current_page) + " 页, " + url)
    try:
        urllop = opener.open(url, timeout=1000)
        data = urllop.read().decode("utf-8")
    except:
        print("error")
        continue
    linkre = re.compile('<a class="project" .*href="(/.+?)"')  # match projects
    for x in linkre.findall(data):
        project_queue.append(x)
        print("加入待爬页面：" + x)
    current_page += 1
    url = baseUrl + "?page=" + str(current_page)

line2: 第一个示例爬取主页中，我们从官网主页入手，找到了link就继续爬。而在本例中，我们已经知道了要爬的网站的结构，可以通过一个固定的baseUrl加上页码获得每个列表页面地址，再访问并解析每个列表页面，获得这个列表页面包含的project详细页面的地址，再将详细页面地址存在内存等待爬取。

line3~7:跟第一个示例一样，project_queue是要爬的页面，visited是已经访问过的页面，current_page是当前页面，page_amount是通过正则表达式获得的总页面页数。（这里省略了正则取总页数的代码，直接设置为line13: 获取到一个列表页面

line17：在这个列表页面，凡是class定义为class的a标签，都是指向一个project，我们将这个project的地址放入project_queue中等待爬取。

通过解析完所有的列表页面，就将所有的project的地址放入了project_queue了，接下来就是逐个访问project_queue中的页面，将我们需要的信息提取出来：

print("\n\n*************** Step 4: visit each project and aggregate data")


class Issue:
    def __init__(self, project=None, open=0, closed=0):
        self.project = project
        self.open = open
        self.closed = closed

projects_found = 0
project_list = []
while project_queue:
    project = project_queue.popleft()
    project_url = "http://gitlab.your_company_addr.com" + project + "/issues"
    try:
        project = str(project).rsplit(sep="/", maxsplit=1)[-1]
        issue = Issue(project)
        project_page = opener.open(project_url, timeout=1000)
        data = project_page.read().decode("utf-8")

        openre = re.compile('<span>Open</span>.*<span class="badge">(.+?)</span>')
        for openNum in openre.findall(data):
            projects_found += 1
            issue.open = int(openNum)
        #省略对其他字段的提取
        project_list.append(issue)
    except:
        print("error page: " + project_url)
        traceback.print_exc()
        continue

line4~8:定义了一个Issue类，包括project的名字，以及project open的issue个数，closed的issue个数.

self:只要是类的成员方法，第一个参数都是self，调用这个方法的当前的对象，相当于java的this。

__init__：python中的构造方法。

line12：python中空的字符串、空集合、0，在取他们的bool量的时候，默认都是false。

line13~14：从project_queue中获取到一个项目地址的相对路径，构造这个project的issue地址。

line18~24：从project issue页面获取到数据，通过解析得到我们想要的数据，封装到issue对象中。

line26：将每个issue加入到list中。最终我们要分析和制图的入参即是这个list。

最后我们得到一共多少个项目，其中每个项目的open的issue有多少个，closed的issue有多少个。那么我们可以进行图表展示了。先上一个画出来的示例图看看：

print("\n\n*************** Step 5: analyze data and write pic")
project_names = []
project_open = []
project_closed = []
N = 0
for i in range(len(project_list)):
    if project_list[i].all > 0:
        project_names.append(project_list[i].project)
        project_open.append(project_list[i].open)
        project_closed.append(project_list[i].closed)
        N += 1

names = tuple(project_names)
open = tuple(project_open)
closed = tuple(project_closed)

ind = np.arange(N)  # the x locations for the groups
width = 0.65  # the width of the bars: can also be len(x) sequence

p1 = plt.bar(ind, open, width, color='#d62728')
p2 = plt.bar(ind, closed, width, bottom=open)

plt.ylabel('issues')
plt.title('project issues')
plt.xticks(ind, names)
plt.yticks(np.arange(0, 81, 10))
plt.legend((p1[0], p2[0]), ('open issues', 'closed issues'))

plt.show()

line20,21,25：这里都是调用pylab的函数，可以看到它画图需要的是三个list，因此在13~15行将我们的List<Issue>转为三个list。

对于pylab，不是我们爬虫讨论的重点，有兴趣自己google吧。

第三爬：Scrapy

安装scrapy

scrapy需要wheel来安装一些依赖，首先安装wheel：

pip install wheel

验证：

wheel

使用pip安装scrapy(博主没有成功，在windows下有问题。。大家可以试试，不行再按后面的操作安装)：

pip install Scrapy

Tip：如果是Mac用户，记得pip要用pip3哦~

如果上述有报错失败了，可以尝试使用wheel文件方式安装：

先卸载scrapy

pip uninstall Scrapy

下载scrapy和它依赖的wheel文件：twisted， lxml，scrapy

下载地址：http://www.lfd.uci.edu/~gohlke/pythonlibs/

找到Twisted， lxml和Scrapy的whl文件.

Twisted‑17.1.0‑cp36‑cp36m‑win32.whl

lxml‑3.7.3‑cp36‑cp36m‑win32.whl

Scrapy‑1.4.0‑py2.py3‑none‑any.whl

注意：cp36指的是python的版本，而win32不是我们windows的版本，如果win64不成功可以试试win32.

下载并安装，例如:

pip install  xxx.whl

验证scrapy安装成功：

scrapy

reference: http://scrapy-chs.readthedocs.io/zh_CN/0.24/intro/tutorial.html

创建scrapy项目

scrapy startproject demo

在spiders目录下新建一个spider类，取名为demo,

import scrapy
import logging

header = {
    'User-Agent': 'Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.11 (KHTML, like Gecko) Chrome/23.0.1271.64 Safari/537.11',
    'Accept': 'text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8',
    'Accept-Charset': 'ISO-8859-1,utf-8;q=0.7,*;q=0.3',
    # 'Accept-Encoding': LxxxSpider.py'gzip, deflate',
    'Accept-Language': 'en-US,en;q=0.8',
    'Host': 'www.lxxx.com.cn',
    'Connection': 'keep-alive'}


# scrapy crawl demo

class Demopider(scrapy.Spider):
    name = "demo"

    def start_requests(self):
        urls = [
            'http://www.lxxx.com.cn/',
        ]
        for url in urls:
            yield scrapy.Request(url=url, callback=self.parse_home, headers=header)

    def parse_home(self, response):
        content = response.body.decode("gb2312", "ignore")
        logging.debug("Open home page \n\n" + content)

line4~11：设置我们的header伪装浏览器，应该不陌生了：）

line16：定义我们的DemoSpider类，它继承了scrapy.Spider类。

line17：给我们的spider类取名字，后面我们将用这个名字启动爬虫。

line19~24：start_requests这个方法类定义入爬虫的入口页面，以及访问了这个页面后回调的函数。

line24：python的yeild一般用于一个for循环中，作为一个generator，这里代码解析的时候并不会真的产生一个request，而是在for循环内执行到这一句的时候，才计算如何产生request。这里代表产生一个url的访问，数据取回来后用self.parse_home来解析取回页面。

详细可以百度之.这里简单refer一个：https://www.ibm.com/developerworks/cn/opensource/os-cn-python-yield/

line24~28：编写在24行调用的回调函数。

Scrappy Proxy设置

1）在demo/middlewares.py文件下新建ProxyMiddleware类

class ProxyMiddleware(object):
    # overwrite process request
    def process_request(self, request, spider):
        # Set the location of the proxy
        request.meta['proxy'] = "http://host:port"

2）在demo/settings.py文件末增加对ProxyMiddleware的配置：

DOWNLOADER_MIDDLEWARES = {
    'scrapy.contrib.downloadermiddleware.httpproxy.HttpProxyMiddleware': 110,
    'demo.middlewares.ProxyMiddleware': 100,
}

middleware是一个dict，key是middleware class path，value是 the middleware orders。Order越小越靠近engine，越大越靠近downloader。这是什么意思呢？请看下图：

此图是scrapy的架构图，spider可以看成我们写的代码，如何用正则解析确认哪些页面需要。我们定义好了后调用yield scrapy.Request就将这个请求送到了引擎中（图中步骤1）。引擎通过scheduler（步骤23）, dowloader（步骤45）等获取到了response后，将页面再返回给spider，spider执行我们代码中的 scrapy.Request中的回调函数（步骤6），解析返回的reponse后在发起request（步骤7），在步骤4<-->5，6<-->7中，紫色的hook就是middlewares，这些middleware按顺序排列。

对于DOWNLOADER_MIDDLEWARES，数字越小的越靠近引擎，即越先执行process_request方法，数字越大的越靠近downloader，即越先执行process_response方法。

例如，如果优先执行的process_request返回了response，后面middleware的process_request或者process_exeception就不会被执行了；如果返回的none，则后面的process_request会继续执行直到有response返回；如果返回的是一个request（是的，你没看错），则这个response不会继续执行了，而是reschedule request。

The DOWNLOADER_MIDDLEWARES setting is merged with the DOWNLOADER_MIDDLEWARES_BASE setting defined in Scrapy (and not meant to be overridden) and then sorted by order to get the final sorted list of enabled middlewares: the first middleware is the one closer to the engine and the last is the one closer to the downloader.

class DownloaderMiddlewareManager(MiddlewareManager):
    def __init__(self, *middlewares):
        self.middlewares = middlewares
        self.methods = defaultdict(list)
        for mw in middlewares:
            self._add_middleware(mw)

    def _add_middleware(self, mw):
        if hasattr(mw, 'process_request'):
            self.methods['process_request'].append(mw.process_request)
        if hasattr(mw, 'process_response'):
            self.methods['process_response'].insert(0, mw.process_response)
        if hasattr(mw, 'process_exception'):
            self.methods['process_exception'].insert(0, mw.process_exception)

这是scrapy的源码，对于每个middleware，如果它有process_reques方法，就把它加入到process_request middleware list里面；反之如果有process_response方法，就按加入到process_response middleware list中。

所以，在我们的例子中，在发起request时，是先执行order 顺序小的，即先设置我们自己定义的proxy。

refer to：https://stackoverflow.com/questions/6623470/scrapy-middleware-order

在下面的渲染ps部分，我们将实现自己的downloader，编码process_response方法，由于要等待页面渲染完成再下载，因此我们这个downloader的order将被设置成999。

还是不知道该设置成多少order对吧？这里有内置的middleware的order，可以和内置的比大小来设置自己的order。refer to：https://docs.scrapy.org/en/latest/topics/settings.html#std:setting-DOWNLOADER_MIDDLEWARES_BASE

{
    'scrapy.downloadermiddlewares.robotstxt.RobotsTxtMiddleware': 100,
    'scrapy.downloadermiddlewares.httpauth.HttpAuthMiddleware': 300,
    'scrapy.downloadermiddlewares.downloadtimeout.DownloadTimeoutMiddleware': 350,
    'scrapy.downloadermiddlewares.defaultheaders.DefaultHeadersMiddleware': 400,
    'scrapy.downloadermiddlewares.useragent.UserAgentMiddleware': 500,
    'scrapy.downloadermiddlewares.retry.RetryMiddleware': 550,
    'scrapy.downloadermiddlewares.ajaxcrawl.AjaxCrawlMiddleware': 560,
    'scrapy.downloadermiddlewares.redirect.MetaRefreshMiddleware': 580,
    'scrapy.downloadermiddlewares.httpcompression.HttpCompressionMiddleware': 590,
    'scrapy.downloadermiddlewares.redirect.RedirectMiddleware': 600,
    'scrapy.downloadermiddlewares.cookies.CookiesMiddleware': 700,
    'scrapy.downloadermiddlewares.httpproxy.HttpProxyMiddleware': 750,
    'scrapy.downloadermiddlewares.stats.DownloaderStats': 850,
    'scrapy.downloadermiddlewares.httpcache.HttpCacheMiddleware': 900,
}

启动demo爬虫

scrapy crawl demo

debug demo

在settings的同级目录下新建一个py文件，比如命名为run.py，用这个命令来执行我们上面的启动命令：

# -*- coding: utf-8 -*-
from scrapy import cmdline

name = 'demo'
cmd = 'scrapy crawl {0}'.format(name)
cmdline.execute(cmd.split())

然后就可以打断点了，打完断点，在run.py文件上右键点“debug”，启动程序。就可以debug了

解析并下载网页

    def start_requests(self):
        urls = [
            'http://www.lxxx.com.cn/',
        ]
        for url in urls:
            yield scrapy.Request(url=url, callback=self.parse_home, headers=header)

    def parse_home(self, response):
        content = response.body.decode("gb2312", "ignore")
        linkre = re.compile(
                '<a .*href="((/|http://www.lxxx.com.cn/|http://s.lxxx.com.cn/|http://item.lxxx.com.cn/)product/.+?)"')
        for link in linkre.findall(content):
            url = str(link[0])
            full_url = response.urljoin(url)
            try:
                logging.debug("|--Will opne pages with its full url : " + full_url)
                yield scrapy.Request(full_url, callback=self.parse_page)
            except Exception as e:
                logging.debug("\n\nError: " + e)
                continue

    def parse_page(self, response):
        url = response.url
        product_detail = response.xpath('//div[@ng-app="singleApp"]')
        total_page = response.xpath('//li[@id="fenyes"]/span/text()')
        logging.debug("|-Opened one page : " + url)
        if product_detail != []:
            logging.debug("|--Found one detail page: " + url)
            DemoSpider.download_detail(response)
        elif product_detail == [] and total_page != []:
            logging.debug("|--Found one list page: " + url)

            brand_lst = response.xpath('//span[@class="damon_brand"]/text()').extract()
            DemoSpider.add_brands(brand_lst)

            logging.debug("|-In a list page : " + url)
            total_page = response.xpath('//li[@id="fenyes"]/span/text()').extract_first()
            total_page = total_page[total_page.index('共') + 1:total_page.index('页')]
            logging.debug("|-Analyze pagesize : " + url + " pagesize: " + total_page)
            query_str = DemoSpider.analyze_quer_str(url)
            for page in range(1, int(total_page)):
                next_list_page = "http://www.lxxx.com.cn/newweb/ajaxfile/skuslie.php?random=0.6151283582927061" + query_str + "&page=" + str(
                        page)
                logging.debug("|--Will go the next page : " + next_list_page + " page: " + str(page))
                yield scrapy.Request(url=next_list_page, callback=self.parse_list, headers=header)
        else:
            logging.debug("|--Found one unknown page : " + url)

line2~6：设置要爬的网站的入口地址，这里只有一个，lxxx的主页。取回来的入口页面都用self.parse_home解析。

line10：解析主页的函数，定义主页中包含的我们要继续爬取的url的正则表达式。

line12~20：遍历匹配的url地址，通过urljoin方法将路径都转换成绝对路径，然后继续产生访问这些url的request，并用parse_page函数来解析这些url。

line22~47：parse_page函数，解析当前页面，当前页面有三种可能：

第一种是产品详细页面(line28~29)，包括商品定价，描述等。这种页面是我们需要的目标页面，直接下载line29；

第二种是商品的列表页面(line30~45)，包含了分页，每一页都连接了很多商品详细页面。这类需要进一步解析总共的页面并进一步访问每页，对每个分页页面，执行parse_list (line45)进一步解析出其每页的产品。

第三种是其他页面，比如报错页面等，暂时直接忽略掉。

JS渲染

大部分页面下载后都能正常显示，但是发现有几个页面如下，是使用的angularjs进行渲染页面的，我们下载页面的时候，页面的渲染还没有完成，因此我们需要的数据都还是angularjs的代码。通过selenium操作chromedriver来等待页面渲染完成后，我们在读取response的数据。如下图一是用了selenium渲染后与渲染前的对比：

为了等待js渲染完成再下载页面，我们需要编写downloader中间件，采用selenium来渲染js。

scrapy的中间件知识refer to：http://scrapy-chs.readthedocs.io/zh_CN/1.0/topics/downloader-middleware.html

创建一个渲染js的middleware：

class JavaScriptMiddleware(object):
    def process_request(self, request, spider):
        print("Chrome is starting...")
        driver = webdriver.Chrome()  # PhantomJS与angularjs有点问题，我们用chrome
        driver.get(request.url)
        time.sleep(3)
        body = driver.page_source
        print("访问" + request.url)
        return HtmlResponse(driver.current_url, body=body, encoding='utf8', request=request)

line4：需要用到chromedriver，通过以下命令安装：

brew install chromedriver --verbose

line6：这里我们等了3秒等待页面加载完成，这会大大的延迟爬取时间。优化方案可以是加个循环条件判断期望的一个值是否已经出现了，来判断是否加载完成。

在settings里面设置该JavaScriptMiddleware proxy：

DOWNLOADER_MIDDLEWARES = {
    'scrapy.contrib.downloadermiddleware.httpproxy.HttpProxyMiddleware': 110,
    'demo.middlewares.ProxyMiddleware': 100,
    'scrapy.downloadermiddlewares.useragent.UserAgentMiddleware': None,
    'demo.middlewares.JavaScriptMiddleware': 543
}

line4：对于scrapy内置的middlewares，默认都是启动的，如果不想用，要手动的设置他们的order为None。