一：twisted中的adbapi

       数据库pymysql的commit()和execute()在提交数据时，都是同步提交至数据库，由于scrapy框架数据的解析和异步多线程的，所以scrapy的数据解析速度，要远高于数据的写入数据库的速度。如果数据写入过慢，会造成数据库写入的阻塞，影响数据库写入的效率。

使用twisted异步IO框架，实现数据的异步写入，通过多线程异步的形式对数据进行写入，可以提高数据的写入速度。

1.1 两个主要方法

adbapi.ConnectionPool：

创建一个数据库连接池对象，其中包括多个连接对象，每个连接对象在独立的线程中工作。adbapi只是提供了异步访问数据库的编程框架，再其内部依然使MySQLdb这样的库访问数据库。

dbpool.runInteraction(do_insert,item)：

异步调用do_insert函数，dbpool会选择连接池中的一个连接对象在独立线程中调用insert_db，其中参数item会被传给do_insert的第二个参数，传给do_insert的第一个参数是一个Transaction对象，其接口与Cursor对象类似，可以调用execute方法执行SQL语句，do_insert执行后，连接对象会自动调用commit方法

1.2 使用实例

from twisted.enterprise import adbapi

# 初始化数据库连接池(线程池)
# 参数一：mysql的驱动
# 参数二：连接mysql的配置信息
dbpool = adbapi.ConnectionPool('pymysql', **params)


# 参数1：在异步任务中要执行的函数insert_db；
# 参数2：给该函数insert_db传递的参数
query = self.dbpool.runInteraction(self.do_insert, item)

 # 在execute()之后，不需要再进行commit()，连接池内部会进行提交的操作。
    def do_insert(self, cursor, item):
        insert_sql = """
                insert into qa_sample( 
                need_id, 
                need_question_uptime, 
                need_title, 
                need_title_describe, 
                need_answer_uptime, 
                need_answer)
                values (%s, %s, %s, %s, %s, %s)
                """
        params = (item['need_id'],
                  item['need_question_uptime'],
                  item['need_title'],
                  item['need_title_describe'],
                  item['need_answer_uptime'],
                  item['need_answer'])
        cursor.execute(insert_sql, params)

二：结合scrapy中的pipelines

# -*- coding: utf-8 -*-
from twisted.enterprise import adbapi
import pymysql

# Define your item pipelines here
#
# Don't forget to add your pipeline to the ITEM_PIPELINES setting
# See: https://docs.scrapy.org/en/latest/topics/item-pipeline.html


class QaSpiderPipeline(object):
    def process_item(self, item, spider):
        return item

class MysqlTwistedPipeline(object):
    def __init__(self, dbpool):
        self.dbpool = dbpool

    @classmethod
    def from_settings(cls, settings):
        dbparams = dict(
            host=settings['MYSQL_HOST'],
            db=settings['MYSQL_DBNAME'],
            user=settings['MYSQL_USER'],
            passwd=settings['MYSQL_PASSWORD'],
            charset='utf8',
            cursorclass=pymysql.cursors.DictCursor,
            use_unicode=True
        )
        dbpool = adbapi.ConnectionPool('pymysql', **dbparams)
        return cls(dbpool)

    def process_item(self, item, spider):
        query = self.dbpool.runInteraction(self.do_insert, item)

    def do_insert(self, cursor, item):
        insert_sql = """
                insert into qa_sample( 
                need_id, 
                need_question_uptime, 
                need_title, 
                need_title_describe, 
                need_answer_uptime, 
                need_answer)
                values (%s, %s, %s, %s, %s, %s)
                """
        params = (item['need_id'],
                  item['need_question_uptime'],
                  item['need_title'],
                  item['need_title_describe'],
                  item['need_answer_uptime'],
                  item['need_answer'])
        cursor.execute(insert_sql, params)



 

在某些爬虫项目下，我们需要每次执行一条插入语句，就立即调用commit方法更新数据库，如果爬取时间太长，中途可能被迫中断，这样程序就不能执行close_spider中的commit。但如果在insert_db中直接加入commit，又会使程序执行变得很慢。这里就可以使用Twisted中提供的以异步方式多线程访问数据库的模块adbapi，可以显著提供程序访问数据库的效率。

adbapi.ConnectionPool方法可以创建一个数据库连接池对象，其中包括多个连接对象，每个连接对象在独立的线程中工作。adbapi只是提供了异步访问数据库的编程框架，再其内部依然使MySQLdb这样的库访问数据库。
	
dbpool.runInteraction(insert_db,item)以异步方式调用insert_db函数，dbpool会选择连接池中的一个连接对象在独立线程中调用insert_db，其中参数item会被传给insert_db的第二个参数，传给insert_db的第一个参数是一个Transaction对象，其借口与Cursor对象类似，可以调用execute方法执行SQL语句，insert_db执行后，连接对象会自动调用commit方法
from twisted.enterprise import adbapi

class MysqlAsyncPipeline(object):
    def open_spider(self, spider):
        ...
        self.dbpool = adbapi.ConnectionPool('MySQLdb', host=host, db=db, user=user, passwd=passwd, charset='utf8')

    def close_spider(self, spider):
        self.dbpool.close()

    def process_item(self, item, spider):
        self.dbpool.runInteraction(self.insert_db, item)

        return item

    def insert_db(self, tx, item):
        values = (
            item['name'],
            item['price'],
            ...
        )
        sql = 'INSERT INTO books VALUES (%s, %s, %s, %s, %s, %s)'
        tx.execute(sql ,values)

 

1.采用连接池技术，可以很大程度上提高数据库连接的利用率，避免频繁创建、销毁数据库连接带来的性能影响。 

2.正确使用SQL批处理以及事务控制，优化大量SQL执行的效率。 

3.使用合适的缓存技术。 

4.结合数据库特性以及实际数据情况优化SQL语句，例如数据库表增加索引、使用数据库内置的函数等等。

      昨天在将一个项目的数据库从SQL Server 2005改成访问SQLLite数据库时，发现数据库的读写速度变得出奇的慢啊，原来在SQL Server 2005中进行的一个事务处理可能1S就完成了，而在改成访问SQLLite后则需要5，6S实在是无法接受啊。可是在SQLLite中的数据库结构和SQLServer中的一样啊，只是将访问SQL Server 2005的数据库访问层进行了小许的改动而已啊。所有的数据库访问语句也很简单啊，数据库的表结构也很简单，一般一个表也就10个字段左右，目前数据库的数据量也不大，就几百条数据而已，我们做的操作也就是查询，插入，删除而已，而且尽量优化了SQL的使用，一般也就是单表操作，而且也避免了使用select
 * from 这种检索，表连接也是都使用inner join。感觉比较奇怪，原因调查中，也请各位大侠帮忙指点下。
转载于:https://www.cnblogs.com/kevinGao/archive/2012/06/18/2555415.html