scrapy中数据处理的两个模块：ItemPipeline与Exporter

import pymongo



class MongoDBPipeline(object):

    """

    1、连接数据库操作

    """

    def __init__(self,mongourl,mongoport,mongodb):

        '''

        初始化mongodb数据的url、端口号、数据库名称

        :param mongourl:

        :param mongoport:

        :param mongodb:

        '''

        self.mongourl = mongourl

        self.mongoport = mongoport

        self.mongodb = mongodb



    @classmethod

    def from_crawler(cls,crawler):

        """

        1、读取settings里面的mongodb数据的url、port、DB。

        :param crawler:

        :return:

        """

        return cls(

            mongourl = crawler.settings.get("MONGO_URL"),

            mongoport = crawler.settings.get("MONGO_PORT"),

            mongodb = crawler.settings.get("MONGO_DB")

        )



    def open_spider(self,spider):

        '''

        1、连接mongodb数据

        :param spider:

        :return:

        '''

        self.client = pymongo.MongoClient(self.mongourl,self.mongoport)

        self.db = self.client[self.mongodb]



    def process_item(self,item,spider):

        '''

        1、将数据写入数据库

        :param item:

        :param spider:

        :return:

        '''

        name = item.__class__.__name__

        self.db['user'].update({'url_token':item['url_token']},{'$set':item},True)

        return item



    def close_spider(self,spider):

        '''

        1、关闭数据库连接

        :param spider:

        :return:

        '''

        self.client.close()

ITEM_PIPELINES = {

   'objectname.pipelines.MongoDBPipeline': 300,

}

FEED_EXPORTERS_BASE = {

    'json': 'scrapy.exporters.JsonItemExporter',

    'jsonlines': 'scrapy.exporters.JsonLinesItemExporter',

    'jl': 'scrapy.exporters.JsonLinesItemExporter',

    'csv': 'scrapy.exporters.CsvItemExporter',

    'xml': 'scrapy.exporters.XmlItemExporter',

    'marshal': 'scrapy.exporters.MarshalItemExporter',

    'pickle': 'scrapy.exporters.PickleItemExporter',

}

"""

Item Exporters are used to export/serialize items into different formats.

"""



import csv

import io

import sys

import pprint

import marshal

import six

from six.moves import cPickle as pickle

from xml.sax.saxutils import XMLGenerator



from scrapy.utils.serialize import ScrapyJSONEncoder

from scrapy.utils.python import to_bytes, to_unicode, to_native_str, is_listlike

from scrapy.item import BaseItem

from scrapy.exceptions import ScrapyDeprecationWarning

import warnings





__all__ = ['BaseItemExporter', 'PprintItemExporter', 'PickleItemExporter',

           'CsvItemExporter', 'XmlItemExporter', 'JsonLinesItemExporter',

           'JsonItemExporter', 'MarshalItemExporter']





class BaseItemExporter(object):



    def __init__(self, **kwargs):

        self._configure(kwargs)



    def _configure(self, options, dont_fail=False):

        """Configure the exporter by poping options from the ``options`` dict.

        If dont_fail is set, it won't raise an exception on unexpected options

        (useful for using with keyword arguments in subclasses constructors)

        """

        self.encoding = options.pop('encoding', None)

        self.fields_to_export = options.pop('fields_to_export', None)

        self.export_empty_fields = options.pop('export_empty_fields', False)

        self.indent = options.pop('indent', None)

        if not dont_fail and options:

            raise TypeError("Unexpected options: %s" % ', '.join(options.keys()))



    def export_item(self, item):

        raise NotImplementedError



    def serialize_field(self, field, name, value):

        serializer = field.get('serializer', lambda x: x)

        return serializer(value)



    def start_exporting(self):

        pass



    def finish_exporting(self):

        pass



    def _get_serialized_fields(self, item, default_value=None, include_empty=None):

        """Return the fields to export as an iterable of tuples

        (name, serialized_value)

        """

        if include_empty is None:

            include_empty = self.export_empty_fields

        if self.fields_to_export is None:

            if include_empty and not isinstance(item, dict):

                field_iter = six.iterkeys(item.fields)

            else:

                field_iter = six.iterkeys(item)

        else:

            if include_empty:

                field_iter = self.fields_to_export

            else:

                field_iter = (x for x in self.fields_to_export if x in item)



        for field_name in field_iter:

            if field_name in item:

                field = {} if isinstance(item, dict) else item.fields[field_name]

                value = self.serialize_field(field, field_name, item[field_name])

            else:

                value = default_value



            yield field_name, value





class JsonLinesItemExporter(BaseItemExporter):



    def __init__(self, file, **kwargs):

        self._configure(kwargs, dont_fail=True)

        self.file = file

        kwargs.setdefault('ensure_ascii', not self.encoding)

        self.encoder = ScrapyJSONEncoder(**kwargs)



    def export_item(self, item):

        itemdict = dict(self._get_serialized_fields(item))

        data = self.encoder.encode(itemdict) + '\n'

        self.file.write(to_bytes(data, self.encoding))





class JsonItemExporter(BaseItemExporter):

····

class XmlItemExporter(BaseItemExporter):

····



class CsvItemExporter(BaseItemExporter):

·····




class PickleItemExporter(BaseItemExporter):····
class MarshalItemExporter(BaseItemExporter):

····



class PprintItemExporter(BaseItemExporter):

····

   

class PythonItemExporter(BaseItemExporter):

    """The idea behind this exporter is to have a mechanism to serialize items

    to built-in python types so any serialization library (like

    json, msgpack, binc, etc) can be used on top of it. Its main goal is to

    seamless support what BaseItemExporter does plus nested items.

    """

····