Django进阶之旅

Burgesszheng 2020-06-16

1.django-debug-toolbar

  • 介绍
    django-debug-toolbar 是一组可配置的面板,可显示有关当前请求/响应的各种调试信息,并在单击时显示有关面板内容的更多详细信息。返回HttpResponse时会失效。

  • 安装:

    pip3 install django-debug-toolbar
  • settings.py文件中:

    #将 debug_toolbar 添加到 INSTALL_APPS 中
    INSTALLED_APPS = [
    	‘debug_toolbar‘,
    ]
    #如果是本机调试,还在将127.0.0.1加入 INTERNAL_IPS
    INTERNAL_IPS = ("127.0.0.1",)
    #在中间件中加入DebugToolbarMiddleware
    MIDDLEWARE = [
    ‘debug_toolbar.middleware.DebugToolbarMiddleware‘,
    ]
    #配置jQuery的URL
    #django-debug-toolbar 默认使用的是Google的地址,默认配置如下:
      JQUERY_URL = ‘//ajax.googleapis.com/ajax/libs/jquery/2.2.4/jquery.min.js‘
      #国内用不了的话可以在settings.py中配置一下,例如(我这里特意选用了和原作者相同版本的jQuery):
    DEBUG_TOOLBAR_CONFIG = {
      "JQUERY_URL": ‘//cdn.bootcss.com/jquery/2.2.4/jquery.min.js‘,
    }
  • urls.py中添加:

    from django.conf import settings
    # 开发环境使用,
    if settings.DEBUG:
        import debug_toolbar
        urlpatterns = [
                          url(r‘^__debug__/‘, include(debug_toolbar.urls)),
                      ] + urlpatterns

此时再打开自己的模板页面,就会发现右边多了一栏工具。

2. 缓存

  • 由于Django是动态网站,所有每次请求均会去数据进行相应的操作,当程序访问量大时,耗时必然会更加明显,最简单解决方式是使用:缓存,缓存将一个某个views的返回值保存至内存或者memcache中,5分钟内再有人来访问时,则不再去执行view中的操作,而是直接从内存或者memcache中之前缓存的内容拿到,并返回。
  • Django中提供了6种缓存方式:
    • 开发调试
    • 内存
    • 文件
    • 数据库
    • Memcache缓存(python-memcached模式)
    • Memcache缓存(pylibmc模块)

2.1 开发调试

开发调试--->起到占位作用,本身不具备缓存。等上线之后更改配置即可使用

不做任何缓存。咦?不做任何缓存?没听错吧,那干嘛要用它呢?

因为是开发调试模式,在本地进行调试,调试过程中,所有的相关缓存配置都需要加上,但是自己调试时候不需要加配置(效果半小时失效,不能干等半个小时看效果吧),要实时看结果。先起到占位作用,等到上线,再改配置就可以使用了。

实际配置代码:

  • settings.py文件中添加:

    # 此为开始调试用,实际内部不做任何操作
    # 配置:
    CACHES = {
        ‘default‘: {
            ‘BACKEND‘: ‘django.core.cache.backends.dummy.DummyCache‘,     # 引擎
            ‘TIMEOUT‘: 300,                                               # 缓存超时时间(默认300,None表示永不过期,0表示立即过期)
            ‘OPTIONS‘:{
                ‘MAX_ENTRIES‘: 300,                                       # 最大缓存个数(默认300)
                ‘CULL_FREQUENCY‘: 3,                                      # 缓存到达最大个数之后,剔除缓存个数的比例,即:1/CULL_FREQUENCY(默认3)
            },
            ‘KEY_PREFIX‘: ‘‘,                                             # 缓存key的前缀(默认空)
            ‘VERSION‘: 1,                                                 # 缓存key的版本(默认1)
            ‘KEY_FUNCTION‘ 函数名                                          # 生成key的函数(默认函数会生成为:【前缀:版本:key】)
        }
    }
    
    # 自定义key
    def default_key_func(key, key_prefix, version):
        """
            Default function to generate keys.
            Constructs the key used by all other methods. By default it prepends
            the `key_prefix‘. KEY_FUNCTION can be used to specify an alternate
            function with custom key making behavior.
            """
        return ‘%s:%s:%s‘ % (key_prefix, version, key)
    
    def get_key_func(key_func):
        """
            Function to decide which key function to use.
            Defaults to ``default_key_func``.
            """
        if key_func is not None:
            if callable(key_func):
                return key_func
            else:
                return import_string(key_func)
            return default_key_func

2.2 基于内存做缓存

  • settings.py

    # 此缓存将内容保存至内存的变量中
    # 配置:
    CACHES = {
        ‘default‘: {
            ‘BACKEND‘: ‘django.core.cache.backends.locmem.LocMemCache‘,
            ‘LOCATION‘: ‘unique-snowflake‘,
            ‘TIMEOUT‘: 300,         # 缓存超时时间(默认300,None表示永不过期,0表示立即过期)
            ‘OPTIONS‘:{
                ‘MAX_ENTRIES‘: 300,  # 最大缓存个数(默认300)
                ‘CULL_FREQUENCY‘: 3, # 缓存到达最大个数之后,剔除缓存个数的比例,即:1/CULL_FREQUENCY(默认3)
            },
        }
    }
    # 注:其他配置同开发调试版本
  • views.py(需要加缓存的视图函数文件)

    # 给视图加缓存
    from django.views.decorators.cache import cache_page
    @cache_page(5)       # 装饰器cache_timeout=5表示缓存超时时间5秒
    def student_list(request):
        students = models.Student.objects.all()
        print("打印代表没缓存")
        return render(request,‘stu.html‘,{"students":students})
    #5秒内除了第一次,多次访问是没有打印结果,代表不走缓存

2.3 基于文件进行缓存的配置

  • settings.py

    CACHES = {
        ‘default‘: {
            ‘BACKEND‘: ‘django.core.cache.backends.filebased.FileBasedCache‘,
            ‘LOCATION‘: ‘G:\homework\day复习篇\day121Django\缓存\cache‘,
            ‘TIMEOUT‘: 300,         # 缓存超时时间(默认300,None表示永不过期,0表示立即过期)
            ‘OPTIONS‘:{
                ‘MAX_ENTRIES‘: 300,  # 最大缓存个数(默认300)
                ‘CULL_FREQUENCY‘: 3, # 缓存到达最大个数之后,剔除缓存个数的比例,即:1/CULL_FREQUENCY(默认3)
            },
        }
    }
    #只是更改了‘BACKEND‘ :‘django.core.cache.backends.filebased.FileBasedCache‘
    #‘LOCATION‘ 文件存储位置。生成 .djcache后缀文件

2.4 基于数据库进行缓存的配置

  • settings.py:

    CACHES = {
        ‘default‘: {
            ‘BACKEND‘: ‘django.core.cache.backends.db.DatabaseCache‘,
            ‘LOCATION‘: ‘my_cache_table‘,
            ‘TIMEOUT‘: 300,         # 缓存超时时间(默认300,None表示永不过期,0表示立即过期)
            ‘OPTIONS‘:{
                ‘MAX_ENTRIES‘: 300,  # 最大缓存个数(默认300)
                ‘CULL_FREQUENCY‘: 3, # 缓存到达最大个数之后,剔除缓存个数的比例,即:1/CULL_FREQUENCY(默认3)
            },
        }
    }
  • Terminal执行命令:

    python3 manage.py createcachetable
    # 生成表:表字段cache_key,value,expires

2.5 基于Memcache进行缓存的配置(python-memcached模块)

  • settings.py

    # 以下3种模式可选择(任选其一即可)
    # ip端口访问
    CACHES = {
        ‘default‘: {
            ‘BACKEND‘: ‘django.core.cache.backends.memcached.MemcachedCache‘,
            ‘LOCATION‘: ‘127.0.0.1:11211‘,
        }
    }
    # 建立socket访问
    CACHES = {
        ‘default‘: {
            ‘BACKEND‘: ‘django.core.cache.backends.memcached.MemcachedCache‘,
            ‘LOCATION‘: ‘unix:/tmp/memcached.sock‘,
        }
    }   
    # 多个缓存ip和端口,类似分布式
    CACHES = {
        ‘default‘: {
            ‘BACKEND‘: ‘django.core.cache.backends.memcached.MemcachedCache‘,
            ‘LOCATION‘: [
                ‘172.19.26.240:11211‘,
                ‘172.19.26.242:11211‘,
            ]
        }
    }

2.6 基于Memcache进行缓存的配置(pylibmc模块)

  • settings.py

    # 以下3种模式可选择(任选其一即可)
    # ip端口访问
    CACHES = {
        ‘default‘: {
            ‘BACKEND‘: ‘django.core.cache.backends.memcached.PyLibMCCache‘,
            ‘LOCATION‘: ‘127.0.0.1:11211‘,
        }
    }
    # 建立socket访问
    CACHES = {
        ‘default‘: {
            ‘BACKEND‘: ‘django.core.cache.backends.memcached.PyLibMCCache‘,
            ‘LOCATION‘: ‘/tmp/memcached.sock‘,
        }
    }     
    # 多个缓存ip和端口,类似分布式
    CACHES = {
        ‘default‘: {
            ‘BACKEND‘: ‘django.core.cache.backends.memcached.PyLibMCCache‘,
            ‘LOCATION‘: [
                ‘192.168.26.240:11211‘,
                ‘192.168.26.242:11211‘,
            ]
        }
    }

2.7 全站使用缓存

  • 使用中间件,经过一系列的认证等操作,如果内容在缓存中存在,则使用FetchFromCacheMiddleware获取内容并返回给用户,当返回给用户之前,判断缓存中是否已经存在,如果不存在则UpdateCacheMiddleware会将缓存保存至缓存,从而实现全站缓存。

    MIDDLEWARE = [
    ‘django.middleware.cache.UpdateCacheMiddleware‘,#最上面
    # 其他中间件...
    ‘django.middleware.cache.FetchFromCacheMiddleware‘,#最下面
    ]
    #只是添加2个中间件UpdateCacheMiddleware作用是更新缓存,FetchFromCacheMiddleware从缓存中获取数据
    CACHE_MIDDLEWARE_ALIAS = ""
    CACHE_MIDDLEWARE_SECONDS = ""
    CACHE_MIDDLEWARE_KEY_PREFIX = ""

2.8 局部模板使用缓存

  • 指的是页面返回数据,因为页面有些数据要实时看,有些不需要实时更新的。给不经常发生变化的加上缓存。

  • views.py

    import time
    from django.shortcuts import render
    from app01 import models
    def student_list(request):
        students = models.Student.objects.all()
        print("打印代表没缓存")
        now = time.time()
        return render(request,‘stu.html‘,{"students":students,"now":now})
    # 往模版传入时间
  • 模版

    <!DOCTYPE html>
    <html lang="en">
    <head>
        <meta charset="UTF-8">
        <title>Title</title>
    </head>
    <body>
    <ul>
        {% for student in students %}
            <li>{{ student.name }}</li>
        {% endfor %}
    </ul>
        {# 实时更新 时间#}
        {{ now }}
    <br>
    {# 导入缓存#}
    {% load cache %}
    {# 设置缓存 5秒 更新一次,必须还有设置一个key #}
    {% cache 5 ‘keys‘%}
    缓存{{ now }}{# 内部代码5秒更新一次 #}
    {% endcache %}
    </body>
    </html>

2.9 django-redis配置

  • django本身不支持redis做缓存,我们通过django-redis

  • django-redis 中文文档地址: https://django-redis-chs.readthedocs.io/zh_CN/latest/

  • 下载(Terminal执行命令)

    pip install django-redis
  • settings文件中:

    CACHES = {
        "default": {
            "BACKEND": "django_redis.cache.RedisCache",
            #1为redis 的 1号库
            "LOCATION": "redis://127.0.0.1:6379/1",
            "OPTIONS": {
                "CLIENT_CLASS": "django_redis.client.DefaultClient",
            }
        }
    }

2.10 作为 session backend 使用配置

  • Django 默认可以使用任何 cache backend 作为 session backend, 将 django-redis 作为 session 储存后端不用安装任何额外的 backend。

    SESSION_ENGINE = "django.contrib.sessions.backends.cache"
    SESSION_CACHE_ALIAS = "default"

3. 信号

  • Django中提供了“信号调度”,用于在框架执行操作时解耦。通俗来讲,就是一些动作发生的时候,信号允许特定的发送者去提醒一些接受者。

  • 应用:比如插入数据到数据库,插入之前写日志,插入之后写日志。

    Model signals
        pre_init                    # django的model执行其构造方法前,自动触发
        post_init                   # django的model执行其构造方法后,自动触发
        pre_save                    # django的model对象保存前,自动触发
        post_save                   # django的model对象保存后,自动触发
        pre_delete                  # django的model对象删除前,自动触发
        post_delete                 # django的model对象删除后,自动触发
        m2m_changed                 # django的model中使用m2m字段操作第三张表(add,remove,clear)前后,自动触发
        class_prepared              # 程序启动时,检测已注册的app中modal类,对于每一个类,自动触发
    Management signals
        pre_migrate                 # 执行migrate命令前,自动触发
        post_migrate                # 执行migrate命令后,自动触发
    Request/response signals
        request_started             # 请求到来前,自动触发
        request_finished            # 请求结束后,自动触发
        got_request_exception       # 请求异常后,自动触发
    Test signals
        setting_changed             # 使用test测试修改配置文件时,自动触发
        template_rendered           # 使用test测试渲染模板时,自动触发
    Database Wrappers
        connection_created          # 创建数据库连接时,自动触发

3.1 信号用法一:

  • 对于Django内置的信号,仅需注册指定信号,当程序执行相应操作时,自动触发注册函数,注册信号,写入与project同名的文件夹下的__init__.py文件中,也是换数据库引擎的地方。这里拿post_save举例

  • __init__.py

    # post_save:django的model对象保存后,自动触发
    from django.db.models.signals import post_save
    def callback(sender,**kwargs):
        print("执行post_save信号")
        print(sender,kwargs)
    
    post_save.connect(callback)#信号连接,并调用回调函数
  • views.py

    def student_list(request):
        students = models.Student.objects.all()
        print(students)
        models.Student.objects.create(name=‘xxoo‘)#创建一个对象,用于触发信号
        return render(request,‘stu.html‘,{"students":students})

3.2 信号用法二:

  • 通过装饰器receiver,也可以添加多个信号

    from django.db.models.signals import post_save
    from django.dispatch import receiver
    @receiver(post_save)# django的model对象保存后,自动触发
    def callback(sender,**kwargs):
        print("执行post_save信号")
        print(sender,kwargs)
    
    post_save.connect(callback)
    
    @receiver(pre_save)# django的model对象保存前,自动触发
    def callback2(sender,**kwargs):
        print("执行pre_save信号")
        print(sender,kwargs)
    
    pre_save.connect(callback2)

3.3 自定义信号:

  • 在一个py文件定义信号!例如:sign.py

    import django.dispatch
    pizza_done = django.dispatch.Signal(providing_args=["toppings", "size"])#toppings,size自己定义字段
  • __init__.py中注册信号

    from sign import pizza_done
    def callback(sender, **kwargs):
        print("callback")
        print(sender, kwargs)
    
    pizza_done.connect(callback)
    
    #触发后打印结果:
    callback
    seven {‘signal‘: <django.dispatch.dispatcher.Signal object at 0x000001BCD6D82B38>, ‘toppings‘: 123, ‘size‘: 456}
  • 在视图函数触发信号,由于内置信号的触发者已经集成到Django中,所以其会自动调用,而对于自定义信号则需要开发者在任意位置触发。

    from django.shortcuts import render
    from app01 import models
    
    from sig import pizza_done
    
    def student_list(request):
    	students = models.Student.objects.all()
    	pizza_done.send(sender=‘seven‘, toppings=123, size=456)#给sig中定义的字段传值,发起信号者赋值
    	return render(request,‘stu.html‘,{"students":students})
  • 另外:

    触发信号:如果在视图函数写函数,当代码取消则功能失效,不方便。如果单独写函数,虽然添加信号会繁琐,但不用这个功能时,取消就方便许多。

4. orm性能相关

  • 尽量不用对象进行查询,多用values

  • select_related(‘关联外键字段‘) 连表查询 用于多对一,一对一

  • prefetch_related(‘关联外键字段‘) 子表查询 用于多对一,多对多

  • 只要返回某个字段。只是查某些字段 only(‘name‘)

  • 排除某些字段,defer("name")

  • QuerySet特性

    1. 尽量不查对象,会跨表或多语句查询,用values直接取字段值,跨表一条语句,且结果为字典

      查询指定字段值时,尽量不用对象,而使用values直接取值,例如:

      def index(request):
          ret = models.Student.objects.all()  #获取所有对象
          for i in ret:
              print(i.name,i.classname)   #这里要跨表查询对象的外键关联数据值时,orm会每一个对象都发一次sql查询,效率降低
          return render(request,‘index.html‘,{‘students‘:ret,})
      # 核心问题是我们通过对象点出来外键关联属性,我们可以不用all查询对象,而是用values直接获取到我们要的属性和值:
      def index(request):
          ret = models.Student.objects.values(‘name‘,‘classname‘)  #获取所有数据
          for i in ret:
              print(i[name],i[classname])   #这里values得到的是字典,字典取值即可,此时orm会只发一次sql做了一次连表查询,效率高
          return render(request,‘index.html‘,{‘students‘:ret,})
    2. 对象查询时, 一对一、多对一获取关联对象时,使用select_related(‘外键字段’) 使多条语句sql合并为一条链表查询sql:

      ret = models.Student.objects.all().select_related(‘classes‘)
      # 这条语句会在查询对象时,通过使用外键,仍能连表查询,效率提高
    3. 对象查询时,多对一多对多时使用prefetch_related(’外键‘),把多条sql合并使用子查询,减少查询次数:

      ret = models.Student.objects.all().prefetch_related(‘classes‘)
    4. 当对象查询指定字段值时,在orm后添加.only(‘指定字段’),得到的仍然是对象,与value不同的是value得到的是字典:

      ret = models.Student.objects.all().only(‘name‘)
    5. 当对象查询排除指定字段时,在orm后添加.defer(‘指定字段’),得到的仍然是对象,与value不同的是value得到的是字典:

      ret = models.Student.objects.all().defer(‘name‘)
    6. query_set特性
      只有在使用时才会查询数据库,而不是遇到查询语句就执行,比如html对象页面渲染

相关推荐

inspuryhq / 0评论 2020-07-28