python中mysql连接池 pymysql数据库连接池

参数配置：

db_config.py

# -*- coding: utf-8 -*-
# ---
# @Software: PyCharm
# @Site: 
# @File: db_config.py
# ---

import pymysql


# 数据库信息
# DB_TEST_HOST = "127.0.0.1"
# DB_TEST_PORT = 3306
# DB_TEST_DBNAME = "ball"
# DB_TEST_USER = "root"
# DB_TEST_PASSWORD = "123456"
# 我在别的地方设了根据环境自动获取数据库参数 如果是固定的就直接设这里就好

# 数据库连接编码
# 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 = 150

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

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

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

# creator : 使用连接数据库的模块
DB_CREATOR = pymysql

my_config.py

class EnvConfig(Config):
    def __init__(self, ENV):
        self.db_config = get_db_config(ENV)

        self.DB_HOST = self.db_config.get("DB_HOST", "")
        self.DB_PORT = self.db_config.get("DB_PORT", "")
        self.DB_DATABASE = self.db_config.get("DB_DATABASE", "")
        self.DB_USER = self.db_config.get("DB_USER", "")
        self.DB_PASSWORD = self.db_config.get("DB_PASSWORD", "")
        self.DB_PASSWORD = self.db_config.get("DB_PASSWORD", "")

        self.CHARSET = self.db_config.get("CHARSET", "")

        self.DB_MIN_CACHED = db_dbutils_config.DB_MIN_CACHED
        self.DB_MAX_CACHED = db_dbutils_config.DB_MAX_CACHED
        self.DB_MAX_SHARED = db_dbutils_config.DB_MAX_SHARED
        self.DB_MAX_CONNECYIONS = db_dbutils_config.DB_MAX_CONNECYIONS

        self.DB_BLOCKING = db_dbutils_config.DB_BLOCKING
        self.DB_MAX_USAGE = db_dbutils_config.DB_MAX_USAGE
        self.DB_SET_SESSION = db_dbutils_config.DB_SET_SESSION
        self.DB_CREATOR = db_dbutils_config.DB_CREATOR

        self.ACCESS_URL = self.es_config.get("ACCESS_URL", "")
        self.USERNAME = self.es_config.get("USERNAME", "")
        self.PASSWORD = self.es_config.get("PASSWORD", "")
        self.PORT = self.es_config.get("PORT", "")

ps:

get_db_config 可以写自己的参数设定函数

或者写死在db_config.py文件里，读取的时候参考下列方式

 self.DB_MIN_CACHED = db_dbutils_config.DB_MIN_CACHED

连接池：

db_dbutils_init.py

# -*- coding: utf-8 -*-
# ---
# @Software: PyCharm
# @Site: 
# @File: db_dbutils_init.py
# ---


"""
@功能：创建数据库连接池
"""

import dbutils
from dbutils.pooled_db import PooledDB

import pymysql, os, configparser
from pymysql.cursors import DictCursor


class BasePymysqlPool(object):
    def __init__(self, envconfig):
        self.DB_HOST = envconfig.DB_HOST
        self.DB_PORT = envconfig.DB_PORT
        self.DB_DATABASE = envconfig.DB_DATABASE
        self.DB_USER = envconfig.DB_USER
        self.DB_PASSWORD = envconfig.DB_PASSWORD
        self.CHARSET = envconfig.CHARSET

        self.DB_MIN_CACHED = envconfig.DB_MIN_CACHED
        self.DB_MAX_CACHED = envconfig.DB_MAX_CACHED
        self.DB_MAX_SHARED = envconfig.DB_MAX_SHARED
        self.DB_MAX_CONNECYIONS = envconfig.DB_MAX_CONNECYIONS
        self.DB_BLOCKING = envconfig.DB_BLOCKING
        self.DB_MAX_USAGE = envconfig.DB_MAX_USAGE
        self.DB_SET_SESSION = envconfig.DB_SET_SESSION
        self.DB_CREATOR = envconfig.DB_CREATOR


class MyPymysqlPool(BasePymysqlPool):
    """
    MYSQL数据库对象，负责产生数据库连接 , 此类中的连接采用连接池实现获取连接对象：conn = Mysql.getConn()
            释放连接对象;conn.close()或del conn
    """
    # 连接池对象
    __pool = None

    def __init__(self, conf_env=None):
        self.conf = conf_env
        super(MyPymysqlPool, self).__init__(self.conf)
        # 数据库构造函数，从连接池中取出连接，并生成操作游标
        self._conn = self.__getConn()
        self._cursor = self._conn.cursor()

    def __getConn(self):
        """
        @summary: 静态方法，从连接池中取出连接
        @return MySQLdb.connection
        """
        if MyPymysqlPool.__pool is None:
            __pool = PooledDB(creator=self.DB_CREATOR,
                              mincached=self.DB_MIN_CACHED,
                              maxcached=self.DB_MAX_CACHED,
                              host=self.DB_HOST,
                              port=self.DB_PORT,
                              user=self.DB_USER,
                              passwd=self.DB_PASSWORD,
                              db=self.DB_DATABASE,
                              use_unicode=False,
                              charset=self.CHARSET,
                              cursorclass=DictCursor)
        return __pool.connection()

    def getAll(self, sql, param=None):
        """
        @summary: 执行查询，并取出所有结果集
        @param sql:查询ＳＱＬ，如果有查询条件，请只指定条件列表，并将条件值使用参数[param]传递进来
        @param param: 可选参数，条件列表值（元组/列表）
        @return: result list(字典对象)/boolean 查询到的结果集
        """
        if param is None:
            count = self._cursor.execute(sql)
        else:
            count = self._cursor.execute(sql, param)
        if count > 0:
            result = self._cursor.fetchall()
        else:
            result = False
        return result

    def getOne(self, sql, param=None):
        """
        @summary: 执行查询，并取出第一条
        @param sql:查询ＳＱＬ，如果有查询条件，请只指定条件列表，并将条件值使用参数[param]传递进来
        @param param: 可选参数，条件列表值（元组/列表）
        @return: result list/boolean 查询到的结果集
        """
        if param is None:
            count = self._cursor.execute(sql)
        else:
            count = self._cursor.execute(sql, param)
        if count > 0:
            result = self._cursor.fetchone()
        else:
            result = False
        return result

    def getMany(self, sql, num, param=None):
        """
        @summary: 执行查询，并取出num条结果
        @param sql:查询ＳＱＬ，如果有查询条件，请只指定条件列表，并将条件值使用参数[param]传递进来
        @param num:取得的结果条数
        @param param: 可选参数，条件列表值（元组/列表）
        @return: result list/boolean 查询到的结果集
        """
        if param is None:
            count = self._cursor.execute(sql)
        else:
            count = self._cursor.execute(sql, param)
        if count > 0:
            result = self._cursor.fetchmany(num)
        else:
            result = False
        return result

    def insertMany(self, sql, values):
        """
        @summary: 向数据表插入多条记录
        @param sql:要插入的ＳＱＬ格式
        @param values:要插入的记录数据tuple(tuple)/list[list]
        @return: count 受影响的行数
        """
        count = self._cursor.executemany(sql, values)
        return count

    def __query(self, sql, param=None):
        if param is None:
            count = self._cursor.execute(sql)
        else:
            count = self._cursor.execute(sql, param)
        return count

    def update(self, sql, param=None):
        """
        @summary: 更新数据表记录
        @param sql: ＳＱＬ格式及条件，使用(%s,%s)
        @param param: 要更新的  值 tuple/list
        @return: count 受影响的行数
        """
        return self.__query(sql, param)

    def insert(self, sql, param=None):
        """
        @summary: 更新数据表记录
        @param sql: ＳＱＬ格式及条件，使用(%s,%s)
        @param param: 要更新的  值 tuple/list
        @return: count 受影响的行数
        """
        return self.__query(sql, param)

    def delete(self, sql, param=None):
        """
        @summary: 删除数据表记录
        @param sql: ＳＱＬ格式及条件，使用(%s,%s)
        @param param: 要删除的条件 值 tuple/list
        @return: count 受影响的行数
        """
        return self.__query(sql, param)

    # 从连接池中取出一个连接
    def getconn(self):
        self._conn = self.__getConn()
        self._cursor = self._conn.cursor()

    def begin(self):
        """
        @summary: 开启事务
        """
        self._conn.autocommit(0)

    def end(self, option='commit'):
        """
        @summary: 结束事务
        """
        if option == 'commit':
            self._conn.commit()
        else:
            self._conn.rollback()

    def dispose(self, isEnd=1):
        """
        @summary: 释放连接池资源
        """
        if isEnd == 1:
            self.end('commit')
        else:
            self.end('rollback')
        self._cursor.close()
        self._conn.close()

初始化建立连接池

from db_dbutils_init import MyPymysqlPool
from my_config import EnvConfig


config_db = EnvConfig(ENV)


pool= MyPymysqlPool(config_db) # config_db 为配置的数据库参数文件

每次的使用：

pool.getconn() # 每次都重新获取连接
ret = pool.getOne(sql) # 执行sql获取结果
func(ret) #对结果进行处理
pool.dispose() # commit sql 并将conn重新放回连接池