DRF框架之使用Django框架完成后端接口（API）的定义

Posted 2021-03-12 老王同鞋

学习DRF框架，首先我们就需要明白为什么要学习这个框架。

接下来我们就先用原生的Django框架来定义一个符合RESTful设计方法的接口（API）。

RESTful接口的需求如下：

GET     /books/         查询所有图书信息
POST    /books/         新增图书信息
GET     /books/<pk>/    查询指定id的图书信息
PUT     /books/<pk>/    修改指定id的图书信息
DELETE  /books/<pk>/    删除指定id的图书信息
响应数据    JSON

1. 定义查询所有图书信息的接口：

class BooksInfoView(View):
    ‘‘‘查询所有图书信息,新增图书信息‘‘‘
    def get(self, request):
        ‘‘‘
        查询所有图书信息
        :return:JSON
        ‘‘‘

        # 查询所有图书模型:查询集
        book_model_list = BookInfo.objects.all()

        # 构造JSON数据
        book_list = []
        for book in book_model_list:
            book_dict = {
                ‘id‘: book.id,
                ‘btitle‘: book.btitle,
                ‘bpub_date‘: book.bpub_date,
                ‘bread‘: book.bread,
                ‘bcomment‘: book.bcomment,
            }
            book_list.append(book_dict)

        # 响应JSON
        # JsonResponse传递字典列表时，需要指定safe=False
        return http.JsonResponse(book_list, safe=False)

2. 定义添加图书信息的接口：

因为，添加图书信息的路由和查询图书信息的路由一致，所以可以代码复用，直接在上一个视图中定义与请求方式同名的方法即可。

def post(self, request):
        ‘‘‘
        新增图书信息
        :return: JSON
        ‘‘‘
        # 获取前端传递的数据
        json_dict = json.loads(request.body.decode())

        # 省略校验步骤

        # 核心逻辑：将数据保存到数据库中
        book = BookInfo.objects.create(
            btitle = json_dict.get(‘btitle‘),
            bpub_date = json_dict.get(‘bpub_date‘),
            bread = json_dict.get(‘bread‘),
            bcomment = json_dict.get(‘bcomment‘)
        )

        # 构造响应数据
        book_dict = {
            ‘id‘: book.id,
            ‘btitle‘: book.btitle,
            ‘bpub_date‘: book.bpub_date,
            ‘bread‘: book.bread,
            ‘bcomment‘: book.bcomment,
        }

        # 响应JSON
        # RESTful设计模式要求：增加后的数据需要返回给前端,并且响应status=201
        return http.JsonResponse(book_dict, status=201)

这里要注意，RESTful设计方法中要求添加和修改后的数据必须返回给前端，并且响应状态码为201.

3. 定义查询指定id的图书信息接口：

class BookInfoView(View):
    ‘‘‘查询、修改、删除指定id的图书信息‘‘‘

    def get(self, request, pk):
        ‘‘‘
        查询指定id的图书信息
        :param pk: 指定的图书id
        :return: JSON
        ‘‘‘
        try:
            # 查询图书信息
            book = BookInfo.objects.get(id=pk)
        except BookInfo.DoesNotExist:
            return http.HttpResponseNotFound()

        # 构造JSON数据
        book_dict = {
            ‘id‘: book.id,
            ‘btitle‘: book.btitle,
            ‘bpub_date‘: book.bpub_date,
            ‘bread‘: book.bread,
            ‘bcomment‘: book.bcomment,
        }

        # 响应JSON
        return http.JsonResponse(book_dict)

因为，修改、删除指定id的图书信息，路由地址与查询指定id的图书信息一致，所以可以进行接口定义代码的复用。

def put(self, request, pk):
        ‘‘‘
        修改指定id的图书信息
        :param pk: 指定的图书id
        :return: JSON
        ‘‘‘

        # 接受前端传递的数据
        json_dict = json.loads(request.body.decode())
        btitle = json_dict.get(‘btitle‘)
        bpub_date = json_dict.get(‘bpub_date‘)
        bread = json_dict.get(‘bread‘)
        bcomment = json_dict.get(‘bcomment‘)

        # 省略校验

        try:
            # 查询图书信息
            book = BookInfo.objects.get(id=pk)
        except BookInfo.DoesNotExist:
            return http.HttpResponseNotFound()

        # 核心逻辑：将新值覆盖旧值
        book.btitle = btitle
        book.bpub_date = bpub_date
        book.bread = bread
        book.bcomment = bcomment
        book.save()

        # 构造JSON数据
        book_dict = {
            ‘id‘: book.id,
            ‘btitle‘: book.btitle,
            ‘bpub_date‘: book.bpub_date,
            ‘bread‘: book.bread,
            ‘bcomment‘: book.bcomment
        }

        # 响应JSON
        # 在RESTful设计风格中，要求返回后端修改后的数据，并响应status=201
        return  http.JsonResponse(book_dict, status=201)

    def delete(self, request, pk):
        ‘‘‘
        删除指定id的图书信息
        :param pk: 指定的图书id
        :return: JSON
        ‘‘‘

        try:
            # 查询图书信息
            book = BookInfo.objects.get(id=pk)
        except BookInfo.DoesNotExist:
            return http.HttpResponseNotFound()

        # 核心逻辑：删除数据
        book.delete()

        # 响应http：RESTful设计风格，要求删除数据响应http且status=204
        return http.HttpResponse(status=204)

到此，我们就完成了使用原生的Django框架结合RESTful设计方法定义的接口（API）。

我们，可以发现我们进行了多次序列化与反序列化（获取JOSN数据、构造JSON数据）的代码的编写，造成了大量的代码冗余，极大地降低了我们开发的效率。

然而，DRF框架（Django REST framework）对序列化与反序列化的操作进行了高度的封装，使用DRF框架可以极大提升我们日常的工作效率。

工作效率高了，老板高兴了，给你发奖了，你也高兴了。

这也就是我们为什么要学习DRF框架的原因。