Django&DRF重点内容汇总

Posted 2020-11-28 gaimo

 Django&DRF重点内容大盘点

　　本文只是将学习过程中需要深刻记忆，在工作中常用的一些命令或者知识点进行一个罗列并阐释，不会全面的将所有内容进行讲解。大家可以在了解了Django框架和DRF框架之后再来看这边文章。否则会有点不知所云。

1.Django

1.1创建Django项目

这一命令必须熟记于心：

django-admin startproject 项目名

1.2 创建子应用

1.在工作中我们要开发很多项目，肯定需要很多模块，创建子应用肯定也需要掌握：

python manage.py startapp 子应用名

注意：此命令需要在项目的目录下进行输入。

2.创建完子应用中之后，千万不要忘记去INSTALLED_APPS中进行注册，这个参数在setting文件中。

1.3一个程序注意的点

1.3.1视图函数的定义

1）定义视图函数之后，要有一个request形参接收请求对象。

2）返回的时候用到了HttpResponse这一命令返回响应对象

1.3.2url地址的配置

1.在子应用中的urls.py文件中设置当前子应用中url地址和视图对应关系

urlpatterns = [
    url(r‘^url正则表达式$‘,views.视图函数名)
]

2.在项目总的urls.py文件中包含子应用中的urls.py文件

urlpatterns = [
    url(r‘^‘,include(‘users.urls‘))
]

1.4url配置

在子应用中进行url地址的配置时，建议严格匹配开头和结尾，避免在地址匹配时候出错。

1.5项目配置项

1.BASE_DIR指的是Django项目根目录

2.语言和时区本地化：

LANGUAGE_CODE = ‘zh-Hans‘ # 中文语言
TIME_ZONE = ‘Asia/Shanghai‘ # 中国时间

1.6客户端向服务器传递参数途径

1.6.1通过URL地址传递参数

在我们的url地址中的参数，我们如果想要获取可以在子应用中的urls文件中进行设置

/weather/城市/年份
url(r‘weather/(?P<city>w+)/(?P<year>d{4})/$‘views.weather)

1.6.2通过查询字符串传递参数

# /qs/?a=1&b=2&a=3
def qs(request):
    a = request.GET.get(‘a‘)
    b = request.GET.get(‘b‘)
    alist = request.GET.getlist(‘a‘)
    print(a)  # 3
    print(b)  # 2
    print(alist)  # [‘1‘, ‘3‘]
    return HttpResponse(‘OK‘)

重要：查询字符串不区分请求方式，即假使客户端进行POST方式的请求，依然可以通过request.GET获取请求中的查询字符串数据。

1.6.3通过请求体传递数据

1)post表单提交的数据

/form/
def form_data(request):
    name = request.POST.get(‘name‘)
    age = request.POST.get(‘age‘)
    return HttpResponse(‘OK‘)

2)json数据

/json/
def json_data(request):
    req_data = request.body
    json_str = req_data.decode()
    req_dict = json.loads(json_str)
    name = req_dict.get(‘name‘)
    age = req_dict.get(‘age‘)
    return HttpResponse(‘OK‘)

1.6.4通过请求头传递数据（了解即可）

1.6.5request对象的属性

request请求对象的属性	说明
GET	查询字符串参数
POST	请求体重的表单数据
body	请求体中原始的bytes数据
method	请求方式
path	请求的url路径
META	请求头
COOKIES	客户端发送的cookie信息
FILES	客户端上传的文件

1.7相应对象构造

1.7.1响应时返回json数据

def get_json(request):
    res_dict = {
        ‘name‘:‘xiaoyan‘,
        ‘age‘:‘18‘
    }
    return JsonResponse(res_dict)

1.7.2响应时进行页面重定向

def redirect_test(request):
    # 第一个参数是namespace，第二个参数是name
    req_url = reverse(‘users:index‘)
    return redirect(req_url)

1.8状态保持之session

1）将session信息保存到redis中

CACHES = {
    "default": {
        "BACKEND": "django_redis.cache.RedisCache",
        "LOCATION": "redis://127.0.0.1:6379/1",
        "OPTIONS": {
            "CLIENT_CLASS": "django_redis.client.DefaultClient",
        }
    }
}
SESSION_ENGINE = "django.contrib.sessions.backends.cache"
SESSION_CACHE_ALIAS = "default"

2)设置session

request.session[‘<key>‘] = ‘<value>‘

3)获取session

request.session.get(‘<key>‘)

1.9类视图

1.9.1类视图的使用

1）定义类视图

/register/
class RegisterView(View):
    def get(self,request):
        return HttpResponse(‘返回注册页面‘)
    def post(self,request):
        return HttpResponse(‘进行注册处理...‘)
    def put(self,request):
        return HttpResponse(‘put方法被调用‘)

2）进行url配置

url(r‘^register/$‘,views.RegisterView.as_view())

1.9.2类视图添加装饰器

使用Django框架提供method_decorator将针对函数视图装饰器添加到类视图的方法上面

# 为全部请求方法添加装饰器
@method_decorator(my_decorator, name=‘dispatch‘)
class DemoView(View):
    def get(self, request):
        print(‘get方法‘)
        return HttpResponse(‘ok‘)

    def post(self, request):
        print(‘post方法‘)
        return HttpResponse(‘ok‘)


# 为特定请求方法添加装饰器
@method_decorator(my_decorator, name=‘get‘)
class DemoView(View):
    def get(self, request):
        print(‘get方法‘)
        return HttpResponse(‘ok‘)

    def post(self, request):
        print(‘post方法‘)
        return HttpResponse(‘ok‘)

1.10中间件

1.10.1定义中间件

def simple_middleware(get_response):
    # 此处编写的代码仅在Django第一次配置和初始化的时候执行一次。

    def middleware(request):
        # 此处编写的代码会在每个请求处理视图前被调用。

        response = get_response(request)

        # 此处编写的代码会在每个请求处理视图之后被调用。

        return response

    return middleware

1.10.2 在MIDDLEWARE中注册中间

MIDDLEWARE = [
    ‘django.middleware.security.SecurityMiddleware‘,
    ‘django.contrib.sessions.middleware.SessionMiddleware‘,
    ‘django.middleware.common.CommonMiddleware‘,
    # ‘django.middleware.csrf.CsrfViewMiddleware‘,
    ‘django.contrib.auth.middleware.AuthenticationMiddleware‘,
    ‘django.contrib.messages.middleware.MessageMiddleware‘,
    ‘django.middleware.clickjacking.XFrameOptionsMiddleware‘,
    ‘users.middleware.my_middleware‘,  # 添加中间件
]

1.10.3注意：中间件是全局的

1.11使用模板的详细步骤

1.加载模板：指定使用模板文件，获取模板对象

from django.template import loader
temp = loader.get_template(‘模板文件名‘)

2.模板渲染：给模板文件传递变量，将模板文件中的变量进行替换，获取替换之后的html内容

res_html = temp.render(字典)

3.创建响应对象

return HttpResponse(res_html)

1.12数据库

1.12.1数据库链接配置

1.在settings.py进行配置

DATABASES = {
    ‘default‘: {
        ‘ENGINE‘: ‘django.db.backends.mysql‘,
        ‘HOST‘: ‘127.0.0.1‘,  # 数据库主机
        ‘PORT‘: 3306,  # 数据库端口
        ‘USER‘: ‘root‘,  # 数据库用户名
        ‘PASSWORD‘: ‘mysql‘,  # 数据库用户密码
        ‘NAME‘: ‘django_demo‘  # 数据库名字
    }
}

2.首次启动时需要在项目同名的目录init.py添加

pip install pymysql

import pymysql
pymysql.install_as_MySQLdb

1.12.2定义模型类

class 模型类名(models.Model):
    # 字段名 = models.字段类型(选项参数)
    # ...
    
    class Meta:
        db_table = ‘<表名>‘

定义外键属性

  hbook = models.ForeignKey(BookInfo, on_delete=models.CASCADE, verbose_name=‘图书‘)  # 外键

cascade是级联，删除主表数据时连同外键表中数据一起删除

1.12.3迁移生成表

1）生成迁移文件

python manage.py makemigrations

2）同步到数据库中

python manage.py migrate

1.12.4通过模型类和对象进行数据库操作（增删改查）

新增：

1. 创建模型类对象-->对象.save()

注意：添加HeroInfo时，可以给hbook赋值，也可以直接表中hbook_id赋值

HeroInfo是定义的英雄模型类，与图书BookInfo对应。

2. 模型类.objects.create(...)

修改：

1. 查询对象->修改对象属性->对象.save()
2. 模型类.objects.filter(...).update(...)

删除：

1. 查询对象->对象.delete()
2. 模型类.objects.filter(...).delete()

查询：

基本查询
    模型类.objects.查询函数
条件查询
    对应get, filter, exclude参数中可以写查询条件
    格式: 属性名__条件名=值
    注意：可以写多个查询条件，默认是且的关系
F对象
    用于查询时字段之间的比较
    from django.db.models import F
Q对象
    用于查询时条件之间的逻辑关系
    from django.db.models import Q
    &(与) |(或) ~(非)
聚合
    聚合类: from django.db.models import Count, Sum, Avg, Max, Min
aggregate
排序
    排序默认是升序，降序在排序字段前加-
    order_by
关联查询
    1. 查询和指定对象关联的数据
    由1查多
        一对象.多类名小写_set.all()
        例：book.heroinfo_set.all()
    由多查1
        多对象.外键属性
        例：hero.hbook
    2. 通过模型类进行关联查询
    查图书(一)
        一类.objects.get|filter(多类名__字段__条件=值)
        例：books = BookInfo.objects.filter(heroinfo__hcomment__contains=‘八‘)
    查英雄(多)
        多类.objects.filter(外键属性__字段__条件=值)
        例：heros = HeroInfo.objects.filter(hbook__bread__gt=30)

1.13admin站点

上传图片
Django自带文件存储系统，可以直接通过Admin站点进行图片的上传，默认上传的文件保存在服务器本地。
使用

1）在配置文件中设置配置项MEDIA_ROOT=‘上传文件的保存目录‘

2）定义模型类时，图片字段的类型使用ImageField

3）迁移生成表并在admin.py注册模型类，直接登录Admin站点就可以进行图片上传

2.DRF框架

2.1目的

利用DRF框架快速的实现RestAPI接口的设计

2.2RestfulAPI接口设计风格

关键点
1）url地址尽量使用名词，不要使用动词
2）请求url地址采用不同的请求方式执行不同的操作
GET(获取)
POST(新增)
PUT(修改)
DELETE(删除)
3）过滤参数可以放在查询字符串中
4）响应数据返回&响应状态码

状态码	说明
200	获取或修改成功
201	新增成功
204	删除成功
404	资源不存在
400	客户请求有误
500	服务器错误

5）响应数据的格式：json

2.3django自定义RestAPI接口

RestAPI接口核心工作
1.将数据库数据序列化为前端所需要的格式，并返回
2.将前端发送的数据反序列化为模型类对象，并保存到数据库中

2.4DRF框架

2.4.1作用：大大提高RestAPI接口开发效率

2.5序列化器Serializer

2.5.1功能

进行数据的序列化和反序列化

2.5.2序列化器的定义

继承自serializers.Serializer

from rest_framework import serializers

# serializers.Serializer:DRF框架中所有序列化器的父类，定义序列化器类时，可以直接继承此类
# serializers.ModelSerializer:Serializer类的子类，在父类的基础山，添加一些功能

class 序列化器类名(serializers.Serializer):
    # 字段名 = serializers.字段名(选项参数)

序列化器对象创建：

序列化器类(instance=<实例对象>,data=<数据>,**kwargs)

2.5.3序列化功能

说白了就是将实例对象转换为字典数据

1）序列化单个对象

book = BookInfo.objects.get(id=1)
serializer = BookInfoSerializer(book)
res = json.dumps(serializer.data,ensure_ascii=False,indent=4)

2）序列化多个对象，其实就是添加了一个many参数

books = BookInfo.objects.all()
serializer = BookInfoSerializer(books,many=True)
res = json.dumps(serializer.data,ensure_ascii=False,indent=4)

3）关联对象的嵌套序列化

1.将关联对象序列化为关联对象的主键

hbook = serializers.PrimaryKeyRelatedField(label=‘图书‘，read_only=True)

2.采用指定的序列化器将关联对象进行序列化

hbook = BookInfoSerializer(label=‘图书‘)    

3.将关联对象序列化为关联对象模型类_str_方法的返回值

hbook = serializers.StringRelatedField(label=‘图书‘)

注意：和对象关联的对象如果有多个，在序列化器中定义嵌套序列化字段时，需要添加many=True。

2.5.4反序列化功能

反序列化-数据校验：

data = {‘btitle‘:‘python‘,‘bpub_date‘:‘1980-1-1‘}
serializer = BookInfoSerializer(data)
serializer.is_valid()
serializer.errors
serialiser.validated_data

当系统提供的校验不能满足我们的需求的时候，我们可以补充额外的验证：

1）指定特定字段的validators参数进行补充验证

btitle = serializers.CharField(label=‘标题‘,max_length=20,validators=[about_django])

注意：此处的about_django为我们自定义的校验函数

2）在序列化器类中定义特定方法validate_<fieldname>针对特定字段进行补充验证

def validate_btitle(self,value):
    if ‘django‘ not in value.lower():
        raise serializers.validationError(‘图书不是关于Django的‘)
    return value

3）定义validate方法进行补充验证（结合多个字段内容验证）

def validate(self,attrs):
    """
    此处的attrs是一个字典，创建序列化器对象时，传入data数据
    """
    bread = attrs[‘bread‘]
    bcomment = attrs[‘bcomment‘]
    if bread<=bcomment:
        raise serializers.ValidationError(‘图书阅读量必须大于评论量‘)
    return attrs

2.5.5反序列化-数据保存（新增&更新）

校验通过之后，可以调用serializer.save()进行数据保存

1)数据新增

def create(self,validated_data):
    """
    validated_data:字典，校验之后的数据
    """
    book = BookInfo.objects.create(**validated_data)
    return book

------------------------------------
data = {‘btitle‘:‘python‘,‘bpub_data‘:‘1802-1-1‘,‘bread‘:30,‘bcomment:20‘}
serializer = BookInfoSerializer(data=data)
serializer.is_valid()
serializer.save()
serializer.data

2)数据更新

def update(self,instance,validated_data):
    """
    instance:创建序列化器对象时传入实例对象
    validated_data:是一个字典，校验之后的数据
    """
    btitle = validated_data.get(‘btitle‘)
    bpub_data_date = validated_data.get(‘bpub_date‘)
    
    instance.btitle = btitle
    instance.bpub_date = bpub_date
    instance.save()
    
    return instance

2.5.6使用序列化器改写RestAPI接口

我们举两个代表性的例子即可：

# /books/
class BookListView(View):
    def get(self, request):
        """
        获取所有的图书的信息：
        1. 查询所有的图书的数据
        2. 返回所有图书的json的数据
        """
        # 1. 查询所有的图书的数据
        books = BookInfo.objects.all() # QuerySet

        # 2. 返回所有图书的json的数据，状态码: 200
        books_li = []
        for book in books:
            # 将book对象转换成dict
            book_dict = {
                ‘id‘: book.id,
                ‘btitle‘: book.btitle,
                ‘bpub_date‘: book.bpub_date,
                ‘bread‘: book.bread,
                ‘bcomment‘: book.bcomment,
                ‘image‘: book.image.url if book.image else ‘‘
            }

            books_li.append(book_dict)

        return JsonResponse(books_li, safe=False)

    def post(self, request):
        """
        新增一本图书的信息：
        1. 获取参数btitle和bpub_date并进行校验
        2. 创建图书信息并添加进数据表中
        3. 返回新增的图书的json数据，状态码: 201
        """
        # 需求: 前端需要传递新增图书的信息(btitle, bpub_date)，通过json传递

        # 1. 获取参数btitle和bpub_date并进行校验
        # 获取json的原始数据
        req_data = request.body # bytes

        # 将bytes转换为str
        json_str = req_data.decode()

        # 将json字符串转换dict
        req_dict = json.loads(json_str)

        # 获取btitle和bpub_date
        btitle = req_dict.get(‘btitle‘)
        bpub_date = req_dict.get(‘bpub_date‘)

        # TODO: 省略参数校验过程...

        # 2. 创建图书信息并添加进数据表中
        book = BookInfo.objects.create(
            btitle=btitle,
            bpub_date=bpub_date
        )

        # 3. 返回新增的图书的json数据，状态码: 201
        # 将book对象转换成dict
        book_dict = {
            ‘id‘: book.id,
            ‘btitle‘: book.btitle,
            ‘bpub_date‘: book.bpub_date,
            ‘bread‘: book.bread,
            ‘bcomment‘: book.bcomment,
            ‘image‘: book.image.url if book.image else ‘‘
        }

        return JsonResponse(book_dict, status=201)

修改之后：

class BookListView(View):
    def get(self, request):
        books = BookInfo.objects.all() # QuerySet
        serializer = BookInfoSerializer(books, many=True)
        return JsonResponse(serializer.data, safe=False)

    def post(self, request):
        req_data = request.body # bytes
        json_str = req_data.decode()
        req_dict = json.loads(json_str)
        
        serializer = BookInfoSerializer(data=req_dict)
        serializer.is_valid(raise_exception=True)

        # 反序列化-数据保存(新增) -> create
        serializer.save()
        return JsonResponse(serializer.data, status=201)