Django教程

[toc]

网站开发逻辑

• 数据
• 页面
• api

通信协议

• HTTP

-   get
    -   url传参(对数据长度有限制(大约 2048 个字符)
        -   http://example.com/api?k1=v1&k2=v2
-   post
    -   传参
        -   类型
            -   request header
                -   Content-Type 指明数据格式
            -   request body
                -   json
                -   form-data
                -   text
        -   url传参 
-   put
    -   传参同 post, 只是需要对象存在
-   delete

数据获取方式总结

http

requests 同步请求 httpx 异步请求

发布/订阅消息传输协议

mqtt

核心概念:

关系流程:

graph TD
    ClientA[Client A: Publisher] -->|Publish| Broker((MQTT Broker))
    ClientB[Client B: Publisher] -->|Publish| Broker
    Broker -->|Forward| ClientC[Client C: Subscriber]
    Broker -->|Forward| ClientD[Client D: Subscriber]

kafka

特点: 提供持久性存储

关系流程:

flowchart LR
    subgraph Producers[生产者]
        P[Producer]
    end

    subgraph Kafka[Kafka Cluster]
        subgraph Broker1[Broker Leader]
            T1[Topic-Partition1]
        end
        
        subgraph Broker2[Broker Follower]
            R1[Replica]
        end
    end

    subgraph Consumers[消费者]
        C1[Consumer Group]
    end

    %% 核心流程
    P -->|1.发送消息| T1
    T1 -->|2.同步复制| R1
    T1 -->|3.消费消息| C1
    
    %% 添加说明
    classDef broker fill:#f9f,stroke:#333,stroke-width:2px;
    class Broker1,Broker2 broker;

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18

from kafka import KafkaConsumer
import json 

consumer = KafkaConsumer(
    'your_topic_name',
    bootstrap_servers='your_kafka_broker:9092',
    group_id='your_consumer_group',
    value_deserializer=lambda v: json.loads(v.decode('utf-8'))  # Deserialize JSON
)

# 阻塞
for i in consumer:
    ...

# 非阻塞
while 1:
    for topic, msg in consumer.poll():
        ...

常见问题:

kafka nobrokersavailable

前后端数据交互的类型

请求体:

• json

1
2
3
4
5

{
    username: 'john_doe',
    email: 'john@example.com',
    age: 30
}

• form username=john_doe&email=john@example.com

url:

/api/users?username=john_doe&email=john@example.com

网站开发逻辑梳理

• 前端
  • template
  • form
• 后端
  • model
  • view
  • url

初级阶段，使用 admin 后台快速建站

https://docs.djangoproject.com/en/5.1/ref/models/fields/#:~:text=ForeignKey

• model

  • model 分类
    • 普通的继承
    • abstruct 抽象基类
    • proxy 添加额外的方法
  • 模型管理器
    • objects =
  • 自定义 BaseModel

  1 2 3 4 5 6 7 8

  class BaseModel(models.Model): """为模型类补充字段""" create_time = models.DateTimeField(verbose_name='创建时间', auto_now_add=True) update_time = models.DateTimeField(verbose_name='更新时间', auto_now=True) class Meta: # 说明是抽象模型类 abstract = True

  1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27

  class ProjectModel(BaseModel): """项目""" user = models.ForeignKey(User, verbose_name='用户', on_delete=models.CASCADE) name = models.CharField(verbose_name='项目名', max_length=30) what = models.TextField(verbose_name='项目描述') why = RichTextUploadingField(verbose_name='项目意义') priority_choices = ((0, '不重要不紧急'), (1, '不重要紧急'), (2, '重要不紧急'), (3, '重要紧急')) priority = models.IntegerField(verbose_name='优先级', default=0, choices=priority_choices) public = models.BooleanField(verbose_name='是否公开', default=False) start_date = models.DateField(verbose_name='计划开始日期') end_date = models.DateField(verbose_name='计划完成日期') # how = RichTextUploadingField(verbose_name='执行步骤', config_name='default') how = MDTextField(verbose_name='执行步骤') attachments = models.FileField(verbose_name='附件', upload_to='attachments/%Y/%m/%d/', null=True, blank=True) status = models.BooleanField(verbose_name='是否完成', default=False) think = models.TextField(verbose_name='项目感想', null=True, blank=True) class Meta: verbose_name = '项目' verbose_name_plural = verbose_name def __str__(self): return self.name

• admin 后台管理

  • 管理模型类

    • 添加模型类到 admin

      1 2	# 直接添加 admin.site.register(ProjectModel)

    • 自定义模型类的功能页面

      1 2 3 4 5 6 7 8 9 10 11 12

      # 自定义模型类的admin class ProjectModelAdmin(admin.ModelAdmin): # list页面 list_display = ['user', 'name', 'what', 'priority', 'end_date', 'duration', 'status'] list_filter = ['user', 'status', 'priority', 'end_date'] search_fields = ['name', 'what', 'why', 'how', 'think'] ordering = ['status', '-priority', 'end_date'] # detail页面 readonly_fields = ['user'] # 只读字段，不能编辑 # 添加自定义的ProjectModelAdmin admin.site.register(ProjectModel, ProjectModelAdmin)

  • 邮件重置密码

直接编写后台逻辑和前台模板页面

https://python.plainenglish.io/building-a-basic-crud-using-django-b218d6859206

• url

  • include()
    • name
    • namespace
  • view 中访问
    • reverse()
  • 基本格式
    • ''
    • create/
    • <int:pk>/
    • <int:pk>/update/
    • <int:pk>/delete/
  • 传参数
    • 使用<>来传参

  • 嵌套的 url

• view

  • 概念：处理请求， 返回响应。通常会操作数据库
  • 请求和响应
    • https://docs.djangoproject.com/zh-hans/5.0/ref/request-response/
    • HttpRequest
      • 可以在中间件中设置各种需要的属性
      • GET
      • POST
      • body
    • HttpResponse
      • 分类
        • HttpResponse
        • JsonResponse / drf 的 Response
        • render
        • redirect
  • 数据库操作

    • https://docs.djangoproject.com/en/5.0/ref/models/querysets/#get

      1 2 3 4 5 6 7 8 9 10 11 12 13 14

      from django.db.models import Q # 查询 Book.objects.filter(**dct) Entry.objects.order_by("blog__name", "headline") Poll.objects.get( Q(question__startswith="Who"), Q(pub_date=date(2005, 5, 2)) | Q(pub_date=date(2005, 5, 6)), ) # 增改删 Book.objects.create(**dct) Book.objects.update_or_create(**dct) Book.objects.filter(**dct).delete()

      1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25

      # update_or_create defaults = {"first_name": "Bob"} create_defaults = {"first_name": "Bob", "birthday": date(1940, 10, 9)} try: obj = Person.objects.get(first_name="John", last_name="Lennon") for key, value in defaults.items(): setattr(obj, key, value) obj.save() except Person.DoesNotExist: new_values = {"first_name": "John", "last_name": "Lennon"} new_values.update(create_defaults) obj = Person(**new_values) obj.save() obj, created = Person.objects.update_or_create( first_name="John", last_name="Lennon", defaults={"first_name": "Bob"}, # 更新的数据 create_defaults={"first_name": "Bob", "birthday": date(1940, 10, 9)}, # 创建的数据 ) # 分组 from django.db.omdels import Count type1_lst = MyModel.objects.values('type1', 'type2').annotate(count=Count('id'))

  • FBV
    • 很直观，完全自主可控的写法
  • CBV
    • django提供了一些类来作为view, 不是很好用
  • 状态码

    代码	含义
    200	ok
    400	bad request
    401	auth fail
    403	permission
    404	not found
    500	server error

  • 中间件， 钩子
    • 概念：在HttpRequest到达view的前后，自定义额外的处理逻辑

• template

  • 页面的主要类型
    • list
    • detail
    • delete_confirm
  • 语法
    • tags
      • 常用语法
        • {% extends ‘xxx.html’ %} 必须在 html 的最开头
        • {% load xxx %} 每个模板页都要 load 自己使用的 tag， 而不能通过 extend 继承
        • {% include xxx %}
        • {% block xxx %} {% endblock xxx %}
        • {% url ’namespace:name’ %}
      • 自定义 tag
        • 在 app 内创建 templatetags/demo.py
        • {% include demo %}
    • variables
      • {{ var1 }}
    • filters
    • comments
  • overwrite
    • 模板加载顺序 DIRS -> APP_DIRS -> others

• form

  • Form: 灵活设置需要的字段
  • ModelForm：针对模型，添加了数据的验证和保存的功能

具体功能

认证 jwt

jwt存储方式:

• cookie
  • 优点
    • 可设置 HttpOnly 属性： 可以设置 HttpOnly 属性，防止客户端 JavaScript 访问 Cookie，提高安全性，防止 XSS 攻击。
    • 可设置 Secure 属性： 可以设置 Secure 属性，只允许在 HTTPS 连接中发送 Cookie，防止中间人攻击。
    • 可设置 SameSite 属性： 可以设置 SameSite 属性，防止 CSRF 攻击
    • 自动发送
  • 缺点
    • 不能跨域, 需要 cors
    • 大小有限制, 通常为4KB

jwt基础流程:

登录 -> 前端存储 -> 请求 -> 后端验证 -> 返回

JWT 续期:

1. 前端检测到 JWT 过期，使用刷新 token 请求新 JWT。
2. 后端验证刷新 token，生成并返回新 JWT。
3. 如果token也过期，则需要用户重新登录
4. 设置 HttpOnly, Secure, SameSite 属性

认证类型:

• Bearer: 通过 Authorization 请求头传递 JWT 令牌
• Basic Authentication: 使用 Base64 编码的用户名和密码
• Digest Authentication: 基于哈希签名的认证
• OAuth 2.0 Authorization Bearer Token: 用于 OAuth 2.0 框架中的访问令牌
• Hawk Authentication: 基于签名的认证，用于高安全性场景

用户和邮箱

新项目的用户模型

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18

# app/models.py
from django.contrib.auth.models import AbstractUser


class User(AbstractUser):
    pass

# project/settings.py
settings.AUTH_USER_MODEL = 'appname.User'

# app.admin.py
from django.contrib.auth.admin import UserAdmin


class CustomUserAdmin(UserAdmin):
    ...
    fieldsets = UserAdmin.fieldsets + ((None, {"fields": ["custom_field"]}),)
    add_fieldsets = UserAdmin.add_fieldsets + ((None, {"fields": ["custom_field"]}),)

老项目的用户模型

使用OneToOneField

1
2
3
4
5
6

from django.contrib.auth.models import User


class Employee(models.Model):
    user = models.OneToOneField(User, on_delete=models.CASCADE)
    department = models.CharField(max_length=100)

权限

• RBAC： 基于角色控制访问
• 权限分类
  • retrieve list
  • retrieve detail
  • create
  • update detail
  • delete detail

异步任务和定时任务

Celery 是一个分布式任务队列系统，广泛用于处理异步任务和定时任务。

https://docs.celeryq.dev/en/stable/index.html

graph TD
    A[Celery Beat] -->|调度任务| B(消息队列)
    B -->|发送任务| C[Celery Worker 1]
    B -->|发送任务| D[Celery Worker 2]
    B -->|发送任务| E[Celery Worker N]
    F[客户端应用] -->|发送任务| B
    C -->|存储结果| G[Backend]
    D -->|存储结果| G
    E -->|存储结果| G

常用命令

1
2
3
4

# 启动worker, 异步处理 耗时任务
celery -A djangoProject worker -l INFO -P eventlet
# 启动beat, 调用定时任务
celery -A djangoProject beat -l INFO

定时任务

1
2
3
4
5
6
7
8
9

# 5点执行
@periodic_task(run_every=crontab(hour="5"))
def func1():
    ...

# 每5小时执行
@periodic_task(run_every=crontab(hour="*/5"))
def func1():
    ... 

常见api:

• 查所有
• 增
• 查 状态,结果
• 删

前端获取结果的方式:

• 前端轮循
• websocket

缓存

查询优化

https://docs.djangoproject.com/en/5.1/ref/models/querysets/#select-related

select_related() foreign key and one-to-one prefetch_related() a ‘many’ relationship

前后端分离

TODO:

api

前后端 通过api来进行交互

优秀api的规范

• restful
  • 大多数现代 RESTful API 都使用-作为分隔符
• 文档
• 验证

DRF

• https://q1mi.github.io/Django-REST-framework-documentation/
• https://q1mi.github.io/Django-REST-framework-documentation/api-guide/serializers_zh/

概念: 对 django 框架进一步封装的第三方包，以便于写出 restfulAPI

Serializer

REST framework中的serializers与Django的Form和ModelForm类非常像。

作用: 简化view函数的实现, 数据库的数据转json. json转数据, 加数据验证

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28

# 定义

from rest_framework import serializers

class CommentSerializer(serializers.Serializer):
    email = serializers.EmailField()
    content = serializers.CharField(max_length=200)
    created = serializers.DateTimeField()

    def create():
        ...

    def update():
        ...

    def save():
        ...

    def validate():
        ...

    def valid_xxxx():
        # 重写验证逻辑
        ...
    def to_representation():
        # 重写序列化逻辑
        ...

嵌套

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32

from django.db import models

class Website(models.Model):
    name = models.CharField(max_length=255, verbose_name='网站名称')
    url = models.URLField(verbose_name='网站URL')

    def __str__(self):
        return self.name

class Audio(models.Model):
    website = models.ForeignKey(Website, on_delete=models.CASCADE, related_name='audios', verbose_name='所属网站')
    title = models.CharField(max_length=255, verbose_name='音频标题')
    file_path = models.FileField(upload_to='audio_files/', verbose_name='音频文件路径')

    def __str__(self):
        return self.title


from rest_framework import serializers
from .models import Website, Audio

class AudioSerializer(serializers.ModelSerializer):
    class Meta:
        model = Audio
        fields = ['id', 'title', 'file_path']

class WebsiteSerializer(serializers.ModelSerializer):
    audios = AudioSerializer(many=True, read_only=True)  # 附带

    class Meta:
        model = Website
        fields = ['id', 'name', 'url', 'audios']

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27

# 使用
@csrf_exempt
def snippet_detail(request, pk):
    """
    获取，更新或删除一个 code snippet。
    """
    try:
        snippet = Snippet.objects.get(pk=pk)
    except Snippet.DoesNotExist:
        return HttpResponse(status=404)

    if request.method == 'GET':
        serializer = SnippetSerializer(snippet)
        return JSONResponse(serializer.data)

    elif request.method == 'PUT':
        data = JSONParser().parse(request)
        serializer = SnippetSerializer(snippet, data=data)
        if serializer.is_valid():
            serializer.save()
            return JSONResponse(serializer.data)
        return JSONResponse(serializer.errors, status=400)

    elif request.method == 'DELETE':
        snippet.delete()
        return HttpResponse(status=204)

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52

class CreateListRetrieveViewSet(mixins.CreateModelMixin,
                                mixins.ListModelMixin,
                                mixins.RetrieveModelMixin,
                                viewsets.GenericViewSet):
    """
    A viewset that provides `retrieve`, `create`, and `list` actions.
    """
    queryset = Account.objects.all()
    serializer_class = AccountSerializer


class AccountViewSet(viewsets.ReadOnlyModelViewSet):
    """
    A simple ViewSet for viewing accounts.
    """
    queryset = Account.objects.all()
    serializer_class = AccountSerializer


from rest_framework.decorators import action
from rest_framework.filters import SearchFilter, OrderingFilter


class AccountViewSet(viewsets.ModelViewSet):
    """
    
    """
    queryset = Account.objects.all()
    serializer_class = AccountSerializer

    # 自定义各种配置

    # 权限
    authentication_classes = [] # 1
    permission_classes = [] # 2
    throttle_classes = [] # 3

    # 功能
    filter_backends = [SearchFilter, OrderingFilter]

    # GET /mymodels/?search=example
    search_fields = ['name', 'description']  # 指定搜索字段

    # GET /mymodels/?ordering=-created_at
    ordering_fields = ['created_at', 'name']  # 指定排序字段
    ordering = ['-created_at']  # 默认排序规则
    
    pagination_class = MyPageClass

    @action(methods=['get'], detail=False)
    def my_method(self):
        ...

drf 源码逻辑

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25

class APIView(View):

    # The following policies may be set at either globally, or per-view.
    renderer_classes = api_settings.DEFAULT_RENDERER_CLASSES
    parser_classes = api_settings.DEFAULT_PARSER_CLASSES
    authentication_classes = api_settings.DEFAULT_AUTHENTICATION_CLASSES
    throttle_classes = api_settings.DEFAULT_THROTTLE_CLASSES
    permission_classes = api_settings.DEFAULT_PERMISSION_CLASSES
    content_negotiation_class = api_settings.DEFAULT_CONTENT_NEGOTIATION_CLASS
    metadata_class = api_settings.DEFAULT_METADATA_CLASS
    versioning_class = api_settings.DEFAULT_VERSIONING_CLASS

    # Allow dependency injection of other settings to make testing easier.
    settings = api_settings

    schema = DefaultSchema()

    def initial(self, request, *args, **kwargs):
        ...

        # Ensure that the incoming request is permitted
        self.perform_authentication(request)
        self.check_permissions(request)
        self.check_throttles(request)

TODO: 源码设计优劣

django flask

• APIView
  • Request
  • Response
    • status.xxx
  • 顺序
    • as_view()
      • dispatch()
        • Authentication
        • Permission
        • Throttling
    • view func
• Router
• CORS 报错
  • pip install django-cors-headers
  • https://www.cnblogs.com/WiseAdministrator/articles/11488681.html
• VUE

网站部署

公共服务, 一起安装起来

1

pythono manage.py check --deploy

使用docker compose 配置 uwsgi 或者 gunicore

端口管理：

只需要暴露Nginx的80和443端口到主机。 Django应用和数据库的端口不需要对外暴露

nginx配置

proxy_pass 实际服务地址

1
2

proxy_pass http://127.0.0.1:8080;
proxy_pass http://127.0.0.1:8081;

nginx配置多个项目

• location 不同路径

1
2

location /project1/
location /project2/

• server_name 不同域名

1
2

server_name project1.localhost;
server_name project2.localhost;

• listen 不同端口

1
2

listen 8080;
listen 8081;

django 源码风格

广泛使用 Minin 和 decorator

相关文档

• Django Doc
• DRF Doc

常见问题

CORS

在前后端分离开发时, 经常遇到

CORS 浏览器的同源策略: 是一个重要的安全机制. 默认禁止不同源访问. 允许服务器声明哪些源可以访问它的资源。这需要服务器设置response来允许跨域。

源由协议、域名和端口号组成, 例如

• http://127.0.0.1:8000
• ws://127.0.0.1:8000

设置response来允许跨域:

1
2
3
4
5
6
7
8
9

from django.utils.deprecation import MiddlewareMixin

class CorsMiddleware(MiddlewareMixin):
    def process_response(self, request, response):
        # 主要是response 设置三个值
        response["Access-Control-Allow-Origin"] = "*"
        response["Access-Control-Allow-Methods"] = "GET, POST, PUT, PATCH, DELETE, OPTIONS"
        response["Access-Control-Allow-Headers"] = "Authorization, Content-Type"
        return response

CSRF

是一种攻击方式，攻击者利用已登录的session进行攻击, 因此使用一个token来二次验证

默认情况下，Django 的 CsrfViewMiddleware 会对所有非安全请求（如 POST、PUT、DELETE 等）进行 CSRF 验证.

drf auth跳过方式:

SessionAuthentication 改为 TokenAuthentication 或自定义 authentication_classes

• Previous
  Ubuntu使用配置
• Next
  Programming Paradigm