Django高级开发

木白端墨
1,766 阅读7分钟

Django高级开发

一、自定义过滤器

针对个人中心页面，展示用户的手机号中间部分隐藏，可以有两种思路

1、视图中修改，在视图中将用户手机号中的部分内容修改为 *

2、视图返回原有的数据，使用自定义过滤器的方法，将手机号中的部分内容隐藏

  • 自定义过滤器定义

    1、在App中新建一个包 templatetags，名字固定

    2、在包中新建一个py文件，名字任意，例如：mytag.py

    3、创建过滤器，写函数代码（一个参数或者两个参数），并注册

    python
from django.template import Library

register = Library()


@register.filter
def filter_phone(phone):
    return phone[:3] + "*" * 4 + phone[8:]


if __name__ == '__main__':
    print(filter_phone("1223345464"))
    
# 注册过滤器
"buyer.templatetags"

  • 自定义过滤器使用

    1、在模板中加载过滤器

    在个人中心页面中的首行加载过滤器

    {% load mytag %}

    2、使用过滤器

    在个人中心页面中使用自定义过滤器

    联系方式: {{ user.phone | filter_phone }}

二、自定义实体类管理器manager

​ 通常我们通过模型的objects方法调用查询的方法，实质上，objects是Django模型动态生成的一 个 查询类，这个查询类继承了models.Manager

  • 自定义objects

    from django.db.models import Manager

  • 定义类

    from django.db.models import Manager


class SellerManager(Manager):
    
    def getname(self, id):
        return Seller.objects.get(pk=id).name

  • 将定义的类复制到objects

    objects =SellerManager()

    1个实体类只有能有1个名字是objects的管理器，如果定义其他管理器了，objects就没有

​ 通常在工作当中，自定义ORM查询的可能性不大，由于MySQL的灵活性和复杂性，导致大部分项 目愿意使用原生的SQL查询。但是对数据进行增删改都可以自定义ORM

三、中间件

  • 中间件介绍

    中间件是处理Django请求和响应的框架级别的钩子，它是一个轻量、低级别的插件系统，用于全局范围内改变Django的输入和输出，每一个中间件都有固定的功能，使用需要很谨慎。中间件尽可能的解决了项目代码冗余和代码一致性问题

    django中间件是django提供给用户可以影响全局请求和响应的接口

​ process_request 请求开始，视图之前

​ process_views 请求开始，视图之中

​ process_exception 错误

​ process_template_response 视图结束，模板开始渲染

​ process_response 响应结束

​ 中间件执行的顺序和平常代码执行的顺序有差距，开发者通过类来定义中间件，中间件类当中可 以

​ 包含上述的5个方法

  • 中间件使用

    1、创建文件

在项目的主目录下编写middleware文件，用来编写中间件

2、中间件的方法

python
"""中间件"""
from django.utils.deprecation import MiddlewareMixin
from django.http import HttpResponse


class MyMiddleware(MiddlewareMixin):
    """自定义中间件"""

    
    def process_request(self, request):
        print("process_request...")

        
    def process_view(self, request, callback, callback_args, callback_kwargs):
        print("process_view...")

        
    def process_template_response(self, request, response):
        """
        这个方法一般不会自动调用，除非视图函数的返回对象有render方法
        :param request:
        :param response:
        :return:
        """
        print("process_template_response...")
        return response

    def process_exception(self, request, exception):
        print("process_exception...")

    def process_response(self, request, response):
        print("process_response...")
        return response
  • 完成之后再settings当中注册中间件
MIDDLEWARE = ['dailyfresh.middleware.MyMiddleware']

  • process_request 请求开始，视图之前

    class MyMiddlewareIP(MiddlewareMixin):
    def process_request(self, request):
        ips = ["10.10.12.100", "10.10.12.133"]
        # 获取IP
        ip = request.META.get("REMOTE_ADDR")
        # 判断
        if ip in ips:
            # 响应，真实环境可以选择渲染到一个页面
            return HttpResponse("你已经被禁止了...")

四、缓存

Django用来做动态网站，每次请求页面都需要进行各种运算，然后从数据库当中取得数据，染好呈现到业务逻辑。从处理开销的角度来看，这个成本比在文本里读取内容大很多。这个时候，对常用的数据存放到独立的一个容器当中，当用户请求，不再直接数据库去取数据，而是先从容器里找。这种技术叫做缓存技术。这个容器可以是内存，文件，数据库或者专业缓存服务器(Memcache)

优点：

提高访问速度，降低服务器的压力（主要是数据库相关）

使用场景：

经常做查询，不要求实时数据，数据量大并且业务复杂

电商的首页，话费信息等等

内存缓存是缓存手段当中最快的，但是有内存溢出漏洞

文件缓存是缓存当中性价比最高，安全有漏洞

数据库缓存，再创建一个表存放经常查询的数据，设计难度比较高

缓存常用配置：

在settings当中，默认是没有缓存配置，可以到global_settings当中查找缓存配置。

Python目录下\Lib\site-packages\django\conf

  • 内存缓存

    使用本地的内存作为缓存

    # 缓存到内存
CACHES = {
    'default': {
        'BACKEND': 'django.core.cache.backends.locmem.LocMemCache',#缓存后台使用的引擎
        'LOCATION': 'mem_cache',  # 缓存名称
        'TIMEOUT': 300,  # 缓存超时时间（默认300秒，None表示永不过期，0表示立即过期）
        'OPTIONS': {
            'MAX_ENTRIES': 300,  # 最大缓存记录的数量（默认300）
            'CULL_FREQUENCY': 3,  # 缓存到达最大个数之后，剔除缓存个数的比例，即：1/CULL_FREQUENCY（默认3）
        },
    }
}

  • 文件缓存

    # 缓存到文件
CACHES = {
    'default': {
        'BACKEND': 'django.core.cache.backends.filebased.FileBasedCache',  # 缓存后台使用的引擎
        'LOCATION': os.path.join(BASE_DIR, "file_cache"),  # 缓存到本地的文件夹
        'TIMEOUT': 300,  # 缓存超时时间（默认300秒，None表示永不过期，0表示立即过期）
        'OPTIONS': {
            'MAX_ENTRIES': 300,  # 最大缓存记录的数量（默认300）
            'CULL_FREQUENCY': 3,  # 缓存到达最大个数之后，剔除缓存个数的比例，即：1/CULL_FREQUENCY（默认3）
        },
    }
}

  • 数据库缓存

    创建缓存数据库

    python manage.py createcachetable

    # 数据库缓存
CACHES = {
    'default': {
        'BACKEND': 'django.core.cache.backends.db.DatabaseCache',  # 缓存后台使用的引擎
        'LOCATION': 'table_cache',  # 数据库表
        'TIMEOUT': 300,  # 缓存超时时间（默认300秒，None表示永不过期，0表示立即过期）
        'OPTIONS': {
            'MAX_ENTRIES': 300,  # 最大缓存记录的数量（默认300）
            'CULL_FREQUENCY': 3,  # 缓存到达最大个数之后，剔除缓存个数的比例，即：1/CULL_FREQUENCY（默认3）
        },
    }
}

  • Memcahce使用

    1、解压安装包

    2、打开当前路径的命令窗口

    3、执行安装命令

    memcached.exe -d install

    4、启动Memcache服务器

    5、安装Memcache的包

    pip install python-memcached

    6、配置

    CACHES = {
    'default': {
        'BACKEND': 'django.core.cache.backends.memcached.MemcachedCache',  # 缓存后台使用的引擎
        'LOCATION': '127.0.0.1:11211',  # memcached地址和端口号
        'TIMEOUT': 300,  # 缓存超时时间（默认300秒，None表示永不过期，0表示立即过期）
    }
}

    五、缓存的使用

    1、在视图中使用

    # 首页页面
from django.views.decorators.cahe import cache_page
@cache_page(60*15)
def index(request):
    # 1、查询所有的商品类型
    goodstype_obj_list = seller_models.GoodsType.objects.all()

    2、在路由中使用

    路由当中使用缓存的代码原理和视图相似但是缓存的范围更加精确

    from django.urls import path
from buyer.views import *
from djamgo.viwes.decorators.cache improt cache_page

urlpatterns =[
   path('index/',cache_page(15*60)(index)),   # 只对当前路由进行缓存
]

    ​

    3、在HTML中使用

    {% load cache %}
<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <title>Title</title>
</head>
<body>
test04.html
{{ now }}
<hr>
{% cache 10 suibian %}
<p>{{ now }}</p>
{% endcache %}
</body>
</html>

    缓存技术是提高访问效率，降低服务器压力的一种网站调优手段

    4、低层cache使用

    导包:

    from django.core.cache import cache

    方法：

    get ：获取缓存 cache.get(key)

    set ：设置缓存 cache.set(key,value,timeout)

    delete ：删除缓存 cache.delete(key)

  • 设置缓存

    流程：

    请求数据：

    判断缓存中是否存在数据

    如果有：

    直接返回数据

    如果没有：

    从数据库中查询

    设置缓存

    返回结果

  • 缓存电商的首页

    1、设置缓存的信息

    (1) 商品类型

    (2) 商品信息

    2、更新缓存信息

    商品信息修改/新增/删除了更新缓存

    def index(request):
    """首页"""
    # 查询缓存
    goodstype_list = cache.get("mycache_index")
    # 判断
    if not goodstype_list:  # 没有缓存
        # 查询并设置缓存
        set_index_cache()
    # 渲染
    return render(request, "ft/index.html", locals())

# 设置缓存函数
def set_index_cache():
    """查询并设置缓存"""
    from django.core.cache import cache
    from store.models import GoodsType
    # 查询数据：所有商品类型
    goodstype_list = GoodsType.objects.all()
    # 循环
    for goodstype in goodstype_list:
        # 动态增加属性，这样每个商品类型对象就添加了一个属性表示当前类型的前5个产品
        goodstype.goods5 = goodstype.goods_set.all().order_by("-id")[:5]
    # 设置缓存
    cache.set("mycache_index", goodstype_list, 60 * 60 * 24)
avatar
文章
阅读
粉丝