python之数据库链接池DBUtils

DBUtils 是Python 的一个用于实现数据库链接池的模块。

此链接池有两种链接模式：

    DBUtils ：提供两种外部接口：

    PersistentDB ：提供线程专用的数据库链接，并自动管理链接。

    PooledDB ：提供线程间可共享的数据库链接，并自动管理链接。

介绍

PersistentDB模式

为每一个线程建立一个链接，线程即便调用了 close 方法，也不会关闭，只是把连接从新放到连接池，供本身线程再次使用，当线程终止时，连接自动关闭。

from DBUtils.PersistentDB import PersistentDB
import pymysql
POOL = PersistentDB(
    creator=pymysql,  # 使用连接数据库的模块
    maxusage=None,  # 一个连接最多被重复使用的次数，None表示无限制
    setsession=[],  # 开始会话前执行的命令列表。
    ping=0,  # ping MySQL服务端，检查是否服务可用。
    closeable=False,  # 若是为False时， conn.close() 实际上被忽略，供下次使用，再线程关闭时，才会自动关闭连接。若是为True时， conn.close()则关闭连接，那么再次调用pool.connection时就会报错，由于已经真的关闭了链接（pool.steady_connection()能够获取一个新的连接）
    threadlocal=None,  # 本线程独享值得对象，用于保存连接对象，若是连接对象被重置
    host='127.0.0.1',
    port=3306,
    user='root',
    password='123456',
    database='test',
    charset='utf8'
)

def func():
    conn = POOL.connection(shareable=False)
    cursor = conn.cursor()
    cursor.execute('select * from user')
    result = cursor.fetchall()
    print(result)
    cursor.close()
    conn.close()
if __name__ == '__main__':

    func()

PooledDB模式

建立一批链接到链接池，供全部线程共享使用。

import pymysql

from DBUtils.PooledDB import PooledDB
POOL = PooledDB(
    creator=pymysql,  # 使用连接数据库的模块
    maxconnections=6,  # 链接池容许的最大链接数，0和None表示不限制链接数
    mincached=2,  # 初始化时，连接池中至少建立的空闲的连接，0表示不建立
    maxcached=5,  # 连接池中最多闲置的连接，0和None不限制
    maxshared=3,  # 连接池中最多共享的连接数量，0和None表示所有共享。PS: 无用，由于pymysql和MySQLdb等模块的 threadsafety都为1，全部值不管设置为多少，_maxcached永远为0，因此永远是全部连接都共享。
    blocking=True,  # 链接池中若是没有可用链接后，是否阻塞等待。True，等待；False，不等待而后报错
    maxusage=None,  # 一个连接最多被重复使用的次数，None表示无限制
    setsession=[],  # 开始会话前执行的命令列表。
    ping=0,  # ping MySQL服务端，检查是否服务可用。
    host='127.0.0.1',
    port=3306,
    user='root',
    password='123456',
    database='test',
    charset='utf8'
)


def func():
    # 检测当前正在运行链接数的是否小于最大连接数，若是不小于则等待或报raise TooManyConnections异常
    # 不然则优先去初始化时建立的连接中获取连接 SteadyDBConnection。
    # 而后将SteadyDBConnection对象封装到PooledDedicatedDBConnection中并返回。
    # 若是最开始建立的连接没有连接，则去建立一个SteadyDBConnection对象，再封装到PooledDedicatedDBConnection中并返回。
    # 一旦关闭连接后，链接就返回到链接池让后续线程继续使用。
    conn = POOL.connection()
    cursor = conn.cursor(pymysql.cursors.DictCursor)
    cursor.execute('select * from user')
    result = cursor.fetchall()
    print(result)
    conn.close()

if __name__ == '__main__':

    func()

工具类

# TEST数据库信息
DB_TEST_HOST = "127.0.0.1"
DB_TEST_PORT = 3306
DB_TEST_DBNAME = "1019"
DB_TEST_USER = "root"
DB_TEST_PASSWORD = "root"

# 数据库链接编码
DB_CHARSET = "utf8"

# mincached : 启动时开启的闲置链接数量(缺省值 0 开始时不建立链接)
DB_MIN_CACHED = 10

# maxcached : 链接池中容许的闲置的最多链接数量(缺省值 0 表明不闲置链接池大小)
DB_MAX_CACHED = 10

# maxshared : 共享链接数容许的最大数量(缺省值 0 表明全部链接都是专用的)若是达到了最大数量,被请求为共享的链接将会被共享使用
DB_MAX_SHARED = 20

# maxconnecyions : 建立链接池的最大数量(缺省值 0 表明不限制)
DB_MAX_CONNECYIONS = 100

# blocking : 设置在链接池达到最大数量时的行为(缺省值 0 或 False 表明返回一个错误<toMany......>; 其余表明阻塞直到链接数减小,链接被分配)
DB_BLOCKING = True

# maxusage : 单个链接的最大容许复用次数(缺省值 0 或 False 表明不限制的复用).当达到最大数时,链接会自动从新链接(关闭和从新打开)
DB_MAX_USAGE = 0

# setsession : 一个可选的SQL命令列表用于准备每一个会话，如["set datestyle to german", ...]
DB_SET_SESSION = None

db_config.py

import pymysql
from DBUtils.PooledDB import PooledDB
import db_config as Config


class ConnectionPool(object):
    __pool = None

    def __enter__(self):
        self.conn = self.__getConn()
        self.cursor = self.conn.cursor()
        print("数据库建立conn和cursor")
        return self

    def __getConn(self):
        if self.__pool is None:
            self.__pool = PooledDB(creator=pymysql, mincached=Config.DB_MIN_CACHED, maxcached=Config.DB_MAX_CACHED,
                                   maxshared=Config.DB_MAX_SHARED, maxconnections=Config.DB_MAX_CONNECYIONS,
                                   blocking=Config.DB_BLOCKING, maxusage=Config.DB_MAX_USAGE,
                                   setsession=Config.DB_SET_SESSION,
                                   host=Config.DB_TEST_HOST, port=Config.DB_TEST_PORT,
                                   user=Config.DB_TEST_USER, passwd=Config.DB_TEST_PASSWORD,
                                   db=Config.DB_TEST_DBNAME, use_unicode=False, charset=Config.DB_CHARSET)
        return self.__pool.connection()

    def __exit__(self, type, value, trace):
        """
         @summary: 释放链接池资源
         """
        self.cursor.close()
        self.conn.close()
        print("链接池释放conn和cursor")

    def getconn(self):
        '''
        从链接池中取出一个链接
        '''
        conn = self.__getConn()
        cursor = conn.cursor(pymysql.cursors.DictCursor)
        return cursor, conn

    def close(self):
        '''
        关闭链接归还给链接池
        '''
        self.cursor.close()
        self.conn.close()
        print("链接池释放conn和cursor")


POOL = ConnectionPool()


class MysqlHelper(object):
    mysql = None

    def __init__(self):
        self.db = POOL

    def __new__(cls, *args, **kwargs):
        if not hasattr(cls, 'inst'):
            cls.inst = super(MysqlHelper, cls).__new__(cls, *args, **kwargs)
        return cls.inst

    def selectall(self, sql='', param=()):
        '''
        查询全部
        '''

        try:
            cursor, conn = self.execute(sql, param)
            res = cursor.fetchall()
            self.close(cursor, conn)
            return res
        except Exception as e:
            print('selectall except   ', e.args)
            self.close(cursor, conn)
            return None

    def selectone(self, sql='', param=()):
        '''
        查询一条
        '''
        try:
            cursor, conn = self.execute(sql, param)
            res = cursor.fetchone()
            self.close(cursor, conn)
            return res
        except Exception as e:
            print('selectone except   ', e.args)
            self.close(cursor, conn)
            return None

    def insert(self, sql='', param=()):
        '''
        增长
        '''
        try:
            cursor, conn = self.execute(sql, param)
            print('============')
            _id = cursor.lastrowid
            print('_id   ', _id)
            conn.commit()
            self.close(cursor, conn)
            # 防止表中没有id返回0
            if _id == 0:
                return True
            return _id
        except Exception as e:
            print('insert except   ', e.args)
            conn.rollback()
            self.close(cursor, conn)
            # self.conn.rollback()
            return 0

    def insertmany(self, sql='', param=()):
        '''
        增长多行
        '''
        cursor, conn = self.db.getconn()
        try:
            cursor.executemany(sql, param)
            conn.commit()
            self.close(cursor, conn)
            return True
        except Exception as e:
            print('insert many except   ', e.args)
            conn.rollback()
            self.close(cursor, conn)
            return False

    def delete(self, sql='', param=()):
        '''
        删除
        '''
        try:
            cursor, conn = self.execute(sql, param)
            self.close(cursor, conn)
            return True
        except Exception as e:
            print('delete except   ', e.args)
            conn.rollback()
            self.close(cursor, conn)
            return False

    def update(self, sql='', param=()):
        '''
        更新
        '''
        try:
            cursor, conn = self.execute(sql, param)
            self.close(cursor, conn)
            return True
        except Exception as e:
            print('update except   ', e.args)
            conn.rollback()
            self.close(cursor, conn)
            return False

    @classmethod
    def getInstance(self):
        if MysqlHelper.mysql == None:
            MysqlHelper.mysql = MysqlHelper()
        return MysqlHelper.mysql

    # 执行命令
    def execute(self, sql='', param=(), autoclose=False):
        cursor, conn = self.db.getconn()
        try:
            if param:
                cursor.execute(sql, param)
            else:
                cursor.execute(sql)
            conn.commit()
            if autoclose:
                self.close(cursor, conn)
        except Exception as e:
            pass
        return cursor, conn

    def executemany(self, list=[]):
        '''
        # 执行多条命令
         '[{"sql":"xxx","param":"xx"}....]'
        '''
        cursor, conn = self.db.getconn()
        try:
            for order in list:
                sql = order['sql']
                param = order['param']
                if param:
                    cursor.execute(sql, param)
                else:
                    cursor.execute(sql)
            conn.commit()
            self.close(cursor, conn)
            return True
        except Exception as e:
            print('execute failed========', e.args)
            conn.rollback()
            self.close(cursor, conn)
            return False

    def close(self, cursor, conn):
        cursor.close()
        conn.close()
        print("PT链接池释放con和cursor")

mysqlhelper