您的位置:9159金沙官网 > www.9159.com > 基于DBUtils实现数据库连接池

基于DBUtils实现数据库连接池

发布时间:2019-12-07 00:36编辑:www.9159.com浏览(69)

    小知识:

    from flask import Flask
    #导入accout 和order
    from fcrm.views import accout
    from fcrm.views import order
    app = Flask(__name__)
    print(app.root_path)  #根目录
    
    app.register_blueprint(accout.accout)  #吧蓝图注册到app里面,accout.accout是创建的蓝图对象
    app.register_blueprint(order.order)
    

    基于DBUtils实现数据库连接池。 

     

    假定代码比超多,要举办分类。不相同的职能放在分化的文书,吧相关的视图函数也放进去。蓝图也正是对flask的目录构造实行分配(应用于小,中型的前后相继),

    accout.py

    依照DButils达成的数据库连接池有二种方式:

    一:pymysql
    二:SQLAlchemy
            是python 操作数据库的一个库。能够进行 orm 映射官方文档 sqlchemy
            SQLAlchemy“采用简单的Python语言,为高效和高性能的数据库访问设计,实现了完整的企业级持久模型”。SQLAlchemy的理念是,SQL数据库的量级和性能重要于对象集合;而对象集合的抽象又重要于表和行。
    

    导入来拿。能够不要导入,。直接导入多个current_基于DBUtils实现数据库连接池。app,这些正是当下的app对象,用current_app.config就能够查见到了近年来app的具有的布局文件

    app1中:
        import app2
        print('app1', __name__)
    
    
    app2中:
        print('app2', __name__)
    
    1 线程1
    2 线程2
    0 线程0
    4 线程4
    3 线程3
    

    示例:

    基于DBUtils实现数据库连接池。方式一:重写__setitem__方法

    1 线程1
    0 线程0
    2 线程2
    3 线程3
    4 线程4
    

    注: 格局风华正茂:假若线程比非常多依然会创制超多总是,形式二更常用 

    今昔app1是主程序,运营结果截图

    形式二:创设三个链接池,为所有线程提供连接,使用时来拓宽获取,使用达成后在放回到连接池。

    import time
    import pymysql
    import threading
    from DBUtils.PooledDB import PooledDB, SharedDBConnection
    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=[],  # 开始会话前执行的命令列表。如:["set datestyle to ...", "set time zone ..."]
        ping=0,
        # ping MySQL服务端,检查是否服务可用。# 如:0 = None = never, 1 = default = whenever it is requested, 2 = when a cursor is created, 4 = when a query is executed, 7 = always
        host='127.0.0.1',
        port=3306,
        user='root',
        password='123',
        database='pooldb',
        charset='utf8'
    )
    
    
    def func():
        # 检测当前正在运行连接数的是否小于最大链接数,如果不小于则:等待或报raise TooManyConnections异常
        # 否则
        # 则优先去初始化时创建的链接中获取链接 SteadyDBConnection。
        # 然后将SteadyDBConnection对象封装到PooledDedicatedDBConnection中并返回。
        # 如果最开始创建的链接没有链接,则去创建一个SteadyDBConnection对象,再封装到PooledDedicatedDBConnection中并返回。
        # 一旦关闭链接后,连接就返回到连接池让后续线程继续使用。
    
        # PooledDedicatedDBConnection
        conn = POOL.connection()
    
        # print(th, '链接被拿走了', conn1._con)
        # print(th, '池子里目前有', pool._idle_cache, 'rn')
    
        cursor = conn.cursor()
        cursor.execute('select * from tb1')
        result = cursor.fetchall()
        conn.close()
    
    
    
    
    
        conn = POOL.connection()
    
        # print(th, '链接被拿走了', conn1._con)
        # print(th, '池子里目前有', pool._idle_cache, 'rn')
    
        cursor = conn.cursor()
        cursor.execute('select * from tb1')
        result = cursor.fetchall()
        conn.close()
    
    
    func()
    
            - 本地线程:是Flask自己创建的一个线程(猜想:内部是不是基于本地线程做的?)
               vals = threading.local()
               def task(arg):
                    vals.name = num
                - 每个线程进来都是打印的自己的,只有自己的才能修改,
                - 通过他就能保证每一个线程里面有一个数据库链接,通过他就能创建出数据库链接池的第一种模式
            - 上下文原理
                -  类似于本地线程
            - 猜想:内部是不是基于本地线程做的?不是,是一个特殊的字典
    

    艺术二、不补助并发

    用了本地线程之后

    manage.py

    小结:假设是在温馨的模块中运行,__基于DBUtils实现数据库连接池。name__就是__main__,纵然是从其他文件中程导弹入进来的,就不是__name__了

    a、类似于本地线程
                创建Local类:
                {
                    线程或协程唯一标识: { 'stack':[request],'xxx':[session,] },
                    线程或协程唯一标识: { 'stack':[] },
                    线程或协程唯一标识: { 'stack':[] },
                    线程或协程唯一标识: { 'stack':[] },
                }
            b、上下文管理的本质
                每一个线程都会创建一个上面那样的结构,
                当请求进来之后,将请求相关数据添加到列表里面[request,],以后如果使用时,就去读取
                列表中的数据,请求完成之后,将request从列表中移除
            c、关系
                local = 小华={
                    线程或协程唯一标识: { 'stack':[] },
                    线程或协程唯一标识: { 'stack':[] },
                    线程或协程唯一标识: { 'stack':[] },
                    线程或协程唯一标识: { 'stack':[] },
                }
                stack = 强哥 = {
                    push
                    pop
                    top
                }
                存取东西时都要基于强哥来做
            d、最近看过一些flask源码,flask还是django有些区别
                - Flask和Django区别?
                    - 请求相关数据传递的方式
                        - django:是通过传request参数实现的
                        - Flask:基于local对象和,localstark对象来完成的
                                 当请求刚进来的时候就给放进来了,完了top取值就行了,取完之后pop走就行了
    
                        问题:多个请求过来会不会混淆
                            -答: 不会,因为,不仅是线程的,还是协程,每一个协程都是有唯一标识的:
                                from greenlent import getcurrentt as get_ident  #这个就是来获取唯一标识的        
    

    风流洒脱、设置配置文件的两种艺术

    五、本地线程:保障各种线程都唯有本身的风姿洒脱份数据,在操作时不会影响别人的,尽管是八线程,自身的值也是互相隔断的

    #!/usr/bin/env python
    # -*- coding:utf-8 -*-
    from functools import partial
    from flask.globals import LocalStack, LocalProxy
    
    ls = LocalStack()
    
    
    class RequestContext(object):
        def __init__(self, environ):
            self.request = environ
    
    
    def _lookup_req_object(name):
        top = ls.top
        if top is None:
            raise RuntimeError(ls)
        return getattr(top, name)
    
    
    session = LocalProxy(partial(_lookup_req_object, 'request'))
    
    ls.push(RequestContext('c1')) # 当请求进来时,放入
    print(session) # 视图函数使用
    print(session) # 视图函数使用
    ls.pop() # 请求结束pop
    
    
    ls.push(RequestContext('c2'))
    print(session)
    
    ls.push(RequestContext('c3'))
    print(session)
    

         链接池里有着的链接都能重复使用,分享的, 即完毕了出现,又防止了链接次数太多

    def release_local(local):
        local.__release_local__()
    
    
    class Local(object):
        __slots__ = ('__storage__', '__ident_func__')
    
        def __init__(self):
            # self.__storage__ = {}
            # self.__ident_func__ = get_ident
            object.__setattr__(self, '__storage__', {})
            object.__setattr__(self, '__ident_func__', get_ident)
    
        def __release_local__(self):
            self.__storage__.pop(self.__ident_func__(), None)
    
        def __getattr__(self, name):
            try:
                return self.__storage__[self.__ident_func__()][name]
            except KeyError:
                raise AttributeError(name)
    
        def __setattr__(self, name, value):
            ident = self.__ident_func__()
            storage = self.__storage__
            try:
                storage[ident][name] = value
            except KeyError:
                storage[ident] = {name: value}
    
        def __delattr__(self, name):
            try:
                del self.__storage__[self.__ident_func__()][name]
            except KeyError:
                raise AttributeError(name)
    
    
    class LocalStack(object):
        def __init__(self):
            self._local = Local()
    
        def __release_local__(self):
            self._local.__release_local__()
    
        def push(self, obj):
            """Pushes a new item to the stack"""
            rv = getattr(self._local, 'stack', None)
            if rv is None:
                self._local.stack = rv = []
            rv.append(obj)
            return rv
    
        def pop(self):
            """Removes the topmost item from the stack, will return the
            old value or `None` if the stack was already empty.
            """
            stack = getattr(self._local, 'stack', None)
            if stack is None:
                return None
            elif len(stack) == 1:
                release_local(self._local)
                return stack[-1]
            else:
                return stack.pop()
    
        @property
        def top(self):
            """The topmost item on the stack.  If the stack is empty,
            `None` is returned.
            """
            try:
                return self._local.stack[-1]
            except (AttributeError, IndexError):
                return None
    
    
    stc = LocalStack()
    
    stc.push(123)
    v = stc.pop()
    
    print(v)
    

    图片 1

    #!usr/bin/env python
    # -*- coding:utf-8 -*-
    import pymysql
    from  flask import Flask
    
    app = Flask(__name__)
    
    # 方式一:这种方式每次请求,反复创建数据库链接,多次链接数据库会非常耗时
    #        解决办法:放在全局,单例模式
    @app.route('/index')
    def index():
        # 链接数据库
        conn = pymysql.connect(host="127.0.0.1",port=3306,user='root',password='123', database='pooldb',charset='utf8')
        cursor = conn.cursor()
        cursor.execute("select * from td where id=%s", [5, ])
        result = cursor.fetchall()  # 获取数据
        cursor.close()
        conn.close()  # 关闭链接
        print(result)
        return  "执行成功"
    
    if __name__ == '__main__':
        app.run(debug=True)
    

    方式二:继承dict

    导入三个DButils模块

    打字与印刷结果:

    class Foo(dict):
        pass
    
    obj = Foo()
    obj["xxx"] = 123
    print(obj)
    

    图片 2

    from flask import Flask,current_app
    

    大型:

    二、蓝图(flask中多py文件拆分都要用到蓝图)

    方式三:继承dict,重写__init__措施的时候,记得要一连父类的__init__方法

    __init__.py(只要生机勃勃导入fcrm就能够进行__init__.py文件)

    1、子类世袭父类的两种方式

    情势大器晚成:为每贰个线程创造二个链接(是基于本地线程来落到实处的。thread.local),每一个线程独立使用本人的数据库链接,该线程关闭不是真正的关门,本线程再一次调用时,依然接受的最最初创办的链接,直到线程终止,数据库链接才关闭

    flask是哪些做的吗?

    要想在视图函数中赢得配置文件的值,都以透过app.config来拿。不过风流罗曼蒂克旦视图函数和Flask创造的靶子app不在叁个模块。就得

    #!usr/bin/env python
    # -*- coding:utf-8 -*-
    import pymysql
    from  flask import Flask
    from threading import RLock
    
    app = Flask(__name__)
    CONN = pymysql.connect(host="127.0.0.1",port=3306,user='root',password='123', database='pooldb',charset='utf8')
    # 方式二:放在全局,如果是单线程,这样就可以,但是如果是多线程,就得加把锁。这样就成串行的了
    #        不支持并发,也不好。所有我们选择用数据库连接池
    @app.route('/index')
    def index():
        with RLock:
            cursor = CONN.cursor()
            cursor.execute("select * from td where id=%s", [5, ])
            result = cursor.fetchall()  # 获取数据
            cursor.close()
            print(result)
            return  "执行成功"
    if __name__ == '__main__':
        app.run(debug=True)
    
    class Foo(object):
        def __setitem__(self, key, value):
            print(key,value)
    
    obj = Foo()
    obj["xxx"] = 123   #给对象赋值就会去执行__setitem__方法
    

    图片 3

    小中型:

    #!usr/bin/env python
    # -*- coding:utf-8 -*-
    from flask import Flask
    app = Flask(__name__)
    from DBUtils.PersistentDB import PersistentDB
    import pymysql
    POOL = PersistentDB(
        creator=pymysql,  # 使用链接数据库的模块
        maxusage=None,  # 一个链接最多被重复使用的次数,None表示无限制
        setsession=[],  # 开始会话前执行的命令列表。如:["set datestyle to ...", "set time zone ..."]
        ping=0,
        # ping MySQL服务端,检查是否服务可用。# 如:0 = None = never, 1 = default = whenever it is requested, 2 = when a cursor is created, 4 = when a query is executed, 7 = always
        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='123',
        database='pooldb',
        charset='utf8'
    )
    
    @app.route('/func')
    def func():
    
      conn = POOL.connection()
      cursor = conn.cursor()
      cursor.execute('select * from tb1')
      result = cursor.fetchall()
      cursor.close()
      conn.close() # 不是真的关闭,而是假的关闭。 conn = pymysql.connect()   conn.close()
    
      conn = POOL.connection()
      cursor = conn.cursor()
      cursor.execute('select * from tb1')
      result = cursor.fetchall()
      cursor.close()
      conn.close()
    
    if __name__ == '__main__': app.run(debug=True)
    
    import threading
    import time
    
    class Foo(object):
        def __init__(self):
            self.name = None
    local_values = Foo()
    
    def func(num):
        time.sleep(2)
        local_values.name = num
        print(local_values.name,threading.current_thread().name)
    
    for i in range(5):
        th = threading.Thread(target=func, args=(i,), name='线程%s' % i)
        th.start()
    

    图片 4

    何以要运用数据库连接池呢?不用连接池有哪些糟糕的地点吗?

    - 重写了__setitem__方法
    - 继承dict
    

    办法风华正茂、每一遍操作都要链接数据库,链接次数过多

    class Dog(Animal): #子类  派生类
        def __init__(self,name,breed, life_value,aggr):
            # Animal.__init__(self,name,breed, life_value,aggr)#让子类执行父类的方法 就是父类名.方法名(参数),连self都得传
            super().__init__(name,life_value,aggr) #super关键字  ,都不用传self了,在新式类里的
            # super(Dog,self).__init__(name,life_value,aggr)  #上面super是简写
            self.breed = breed
        def bite(self,person):   #狗的派生方法
            person.life_value -= self.aggr
        def eat(self):  #父类方法的重写
            super().eat()
            print('dog is eating')
    

    计算:假诺赶过obj["xxx"] = xx  , 

    @app.route('/index',methods=["GET","POST"])
    def index():
        print(current_app.config)   #当前的app的所有配置
        session["xx"] = "fdvbn"
        return "index"
    

    三、数据库连接池

    from flask import Blueprint
    order = Blueprint("order",__name__)
    
    @order.route('/order')
    def register():   #注意视图函数的名字不能和蓝图对象的名字一样
        return "order
    

    flask的request和session设置方法相比较新颖,若无这种办法,那么就一定要通过参数的传递。

    2、对象通过索引设置值的两种办法

        PS:若是最大链接数有十七个,其实也便是一个列表,当你pop贰个,人家会在append叁个,链接池的具备的链接都以信守排队的这么的艺术来链接的。

    措施三:由于地点二种方案都不完美,所以得把艺术蓬蓬勃勃和方式二协同一下(既让收缩链接次数,也能支撑并发)全体了主意三,必要

     

    flask中是还未有ORM的,借使在flask里面连接数据库有三种艺术

    打字与印刷结果:

    order.py

    from flask import  Blueprint,render_template
    accout = Blueprint("accout",__name__)
    
    @accout.route('/accout')
    def xx():
        return "accout"
    
    @accout.route("/login")
    def login():
        return render_template("login.html")
    
        - BDUtils数据库链接池  
                    - 模式一:基于threaing.local实现为每一个线程创建一个连接,关闭是
                      伪关闭,当前线程可以重复
                    - 模式二:连接池原理
                            - 可以设置连接池中最大连接数    9
                            - 默认启动时,连接池中创建连接  5
    
                            - 如果有三个线程来数据库中获取连接:
                                - 如果三个同时来的,一人给一个链接
                                - 如果一个一个来,有时间间隔,用一个链接就可以为三个线程提供服务
                                    - 说不准
                                        有可能:1个链接就可以为三个线程提供服务
                                        有可能:2个链接就可以为三个线程提供服务
                                        有可能:3个链接就可以为三个线程提供服务
                             PS、:maxshared在使用pymysql中均无用。链接数据库的模块:只有threadsafety>1的时候才有用
    

     

    1. Flask内部落实

      #!/usr/bin/env python # -- coding:utf-8 --

      from greenlet import getcurrent as get_ident

    import fcrm
    if __name__ == '__main__':
        fcrm.app.run()
    

    图片 5

     链接池原理

     图片 6

    图片 7

    3、测试__name__方法

    六、上下文管理

     

     

     

    这正是说大家用pymysql来做。

    没用线程从前

     

    class Foo(dict):
        def __init__(self,val):
            # dict.__init__(self, val)#继承父类方式一
            # super().__init__(val)  #继承父类方式二
            super(Foo,self).__init__(val)#继承父类方式三
    obj = Foo({"xxx":123})
    print(obj)
    
    import threading
    import time
    # 本地线程对象
    local_values = threading.local()
    def func(num):
    
        """
        # 第一个线程进来,本地线程对象会为他创建一个
        # 第二个线程进来,本地线程对象会为他创建一个
        {
            线程1的唯一标识:{name:1},
            线程2的唯一标识:{name:2},
        }
        :param num:
        :return:
        """
        local_values.name = num # 4
        # 线程停下来了
        time.sleep(2)
        # 第二个线程: local_values.name,去local_values中根据自己的唯一标识作为key,获取value中name对应的值
        print(local_values.name, threading.current_thread().name)
    
    
    for i in range(5):
        th = threading.Thread(target=func, args=(i,), name='线程%s' % i)
        th.start()
    
    ==========方式一:============
     app.config['SESSION_COOKIE_NAME'] = 'session_lvning'  #这种方式要把所有的配置都放在一个文件夹里面,看起来会比较乱,所以选择下面的方式
    ==========方式二:==============
    app.config.from_pyfile('settings.py')  #找到配置文件路径,创建一个模块,打开文件,并获取所有的内容,再将配置文件中的所有值,都封装到上一步创建的配置文件模板中
    
    print(app.config.get("CCC"))
    
    =========方式三:对象的方式============
     import os 
     os.environ['FLAKS-SETTINGS'] = 'settings.py'
     app.config.from_envvar('FLAKS-SETTINGS') 
    
    ===============方式四(推荐):字符串的方式,方便操作,不用去改配置,直接改变字符串就行了 ==============
    app.config.from_object('settings.DevConfig')
    
    ----------settings.DevConfig----------
    
    from app import app
    class BaseConfig(object):
        NNN = 123  #注意是大写
        SESSION_COOKIE_NAME = "session_sss"
    
    class TestConfig(BaseConfig):
        DB = "127.0.0.1"
    
    class DevConfig(BaseConfig):
        DB = "52.5.7.5"
    
    class ProConfig(BaseConfig):
        DB = "55.4.22.4"
    

    行使蓝图时索要在意的

    本文由9159金沙官网发布于www.9159.com,转载请注明出处:基于DBUtils实现数据库连接池

    关键词: