Как установить django rest framework
Обновлено: 07.07.2024
Итак, вы учитесь использовать Django Web Framework и вы любите его. Но вам нужен привлекательный, простой в использовании API для вашего приложения? Посмотрите не дальше, чем Django Rest Framework (DRF). DRF является мощным, утонченный и удивительно простым в использовании. Он предлагает привлекательную, доступную в Интернете версию вашего API и возможность возврата сырого JSON. Django Rest Framework обеспечивает мощную сериализацию модели, отображение данных с использованием стандартных представлений, основанных на функциях, или получить гранулы с мощными представлениями на основе классов для более сложных функций. Все в полностью совместимой REST оболочке. Давайте начнем.
Укладка фундамента
При работе с приложениями Python всегда рекомендуется изолировать вашу разработку виртуальной средой. Это помогает предотвратить конфликты версий между библиотеками, которые вам нужны в вашем приложении, и библиотеки, которые вы, возможно, уже установили на вашем компьютере, упрощают установку зависимостей в виртуальном env с помощью файла requirements.txt , и, наконец, он обеспечивает совместное использование среды разработки с помощью других разработчиков.
Tuts + имеет два отличных видео о том, как установить virtualenv и virtualenvwrapper. Потратьте несколько минут, чтобы пройти через эти видеоролики, чтобы получить virtualenv и virtualenvwrapper, установленные на вашем компьютере. Если вы уже установили их, пропустите следующий раздел.
Настройка виртуальной среды
Первое, что мы сделаем как часть нашего приложения, - это настроить виртуальную среду. Введите в свой терминал следующие команды.
Неважно, где вы находитесь в файловой системе, когда эти команды запущены. Все файлы virtualenv хранятся в централизованном месте и активируются по требованию.
Установка приложения Django
Если в какой-то момент вы не получите ожидаемых результатов, попробуйте переключить ветвь локального репозитория в финал, чтобы увидеть результаты: git checkout final .
Fab? Что это?
«Fabric - это библиотека Python (2,5 или выше) и средство командной строки для оптимизации использования SSH для задач развертывания приложений или системного администрирования».
Хотя более полная дискуссия о Fabric выходит за рамки этой статьи, я внедрил некоторые основные команды fab, которые упрощают работу с этим приложением. Вы видели команду fab runserver . Существует также команда fab shell , которая вызывает интерактивную оболочку iPython в контексте приложения и команду fab syncdb , которая запускает команду syncdb Django для синхронизации изменений в моделях с базой данных.
Работа с сериализацией
Одной из мощных возможностей Django Rest Framework является встроенная сериализация модели, которую она предлагает. Имея всего несколько строк кода, вы можете создавать мощные представления ваших данных, которые могут быть доставлены в нескольких форматах. Как уже упоминалось ранее, наше приложение будет простым приложением хранения книг и авторов. Я уже создал для вас модели Author and Book , поэтому откройте /app/bookreview/models.py . Уже есть несколько авторов, хранящихся в локальной базе данных SQLite, поэтому давайте откроем интерактивную оболочку для нашего приложения и поработаем. Перейдите в окно терминала, убедитесь, что вы находитесь в ./app и введите следующую команду.
После загрузки оболочки введите следующие несколько строк, чтобы получить запись автора из базы данных, которая просто оказалась моей. Какое совпадение. :)
Аналогичным образом вы можете получить все записи автора из базы данных с помощью другой команды:
К сожалению, это не возвращает данные, которые может понять вызов AJAX. Итак, добавим сериализатор для авторов. Закройте оболочку, набрав quit и откройте bookreview / serializers.py . Введите или вставьте следующие несколько строк кода и сохраните файл.
Не внося никаких изменений, сериализатор дает нам довольно много мощи. Вернитесь в оболочку и давайте рассмотрим.
Давайте добавим еще несколько строк кода и посмотрим, что наш API покажет нам в браузере после того, как наши данные будут запущены через наш новый AuthorSerializer .
Проверка API-интерфейса, доступного в Интернете
Сначала откройте bookreview / urls.py и добавьте следующую строку сразу после маршрута index_view :
Затем откройте bookreview / views.py и добавьте эти строки в конец файла:
Затем добавьте импорт для AuthorSerializer в верхней части страницы:
Представление по умолчанию для Django Rest Framework - это APIView. Он позволяет вам определять свои методы get , put и delete . Это хороший способ получить базовую функциональность, но все же контролировать конечный результат. В нашем случае, однако, мы позволяем DRF делать тяжелый подъем для нас, расширяя ListAPIView. Нам просто нужно предоставить несколько бит информации, чтобы позволить DRF подключать куски. Мы даем ему модель автора , чтобы он знал, как разговаривать с базой данных, и AuthorSerializer , чтобы DRF знал, как вернуть информацию. Мы будем работать только с несколькими встроенными APIViews, но вы можете прочитать обо всех параметрах на веб-сайте Django Rest Framework.
Теперь, когда у нас есть представление API авторов, попробуйте нажать этот URL с помощью команды curl :
Довольно шумный, да?
Предоставьте несколько авторских книг!
Хотя этот вид API довольно красивый, он один-к-одному с базой данных. Давайте перейдем к нашему представлению API, составив более сложный набор данных для авторов, включив список всех своих книг. Откройте bookreview / serializers.py и добавьте следующую строку кода перед определением класса AuthorSerializer .
Прежде чем мы сможем добавить книги в AuthorSerializer , мы должны сериализовать книги. Это должно быть полностью знакомо вам. Поскольку он почти идентичен AuthorSerializer , мы не будем обсуждать его.
Затем добавьте следующую строку сразу после docstring класса AuthorSerializer :
Затем добавьте книги в свойство полей внутреннего класса Meta AuthorSerializer :
Перезагрузите /authors/ в конечном результате, и теперь вы должны увидеть массив книг для каждого автора. Неплохо бы еще несколько строк кода, да?.
Хороший парень DRF!
Использование SerializerMethodField для создания пользовательских свойств
Сериализатор умный . когда мы укажем, какую модель он должен сериализовать внутри внутреннего метакласса, он знает все об этой модели . свойствах, длине, значениях по умолчанию и т. д. Обратите внимание, что мы не определяем какие-либо свойства, найденные в модели непосредственно в сериализаторе, мы укажем только, какие поля должны быть возвращены API в свойстве fields .
Поскольку DRF уже знает о свойствах модели, это не требует от нас повторения. Если бы мы хотели, мы могли бы быть явными в BookSerializer и добавлять следующие строки . и DRF был бы так же счастлив.
Метод serializers.field позволяет указать на существующее свойство модели, исходное поле и позволяет явно называть его чем-то другим при возврате его конечному пользователю. Но как насчет serializers.SerializerMethodField ? Это позволяет вам по существу создать настраиваемое свойство, которое напрямую не привязано к модели, содержимое которой является результатом вызова метода. В нашем случае мы вернем URL-адрес, который содержит список мест, куда вы могли бы пойти, чтобы купить книгу. Давайте добавим этот пользовательский метод.
Сразу после строки документации BookSerializer добавьте следующую строку:
Затем после определения класса Meta BookSerializer добавьте следующие строки:
Затем, наконец, нам нужно добавить наше новое свойство в список полей. Измените это:
Перезагрузите /authors/ в конечном результате, и теперь вы должны увидеть URL-адрес, возвращающийся вместе с другой информацией о книге.
Добавление конечной точки автора
У нас уже есть список авторов, но было бы хорошо, если бы у каждого автора была своя страница . точно так же, как MySpace? Позволяет добавить конечную точку API для просмотра одного автора. Откройте urls.py и добавьте следующую строку после маршрута author-list :
Затем откройте view.py и добавьте следующие строки после класса AuthorView :
Нажмите одно из имен авторов на индексной странице, и вы увидите, что страница авторского экземпляра загружается.
Рефакторинг для победы!
Теперь самое подходящее время для быстрого рефакторинга. Поскольку Django предлагает вариант назначения ваших маршрутов, мы можем ссылаться на маршрут по этому имени. Это не позволяет нам создавать URL-адрес вручную. Откройте templates/index.html и замените следующий фрагмент:
Сохранение данных: пусть DRF работает для вас!
До сих пор наше приложение было только для чтения. Пора начать сохранять некоторые данные. Откройте templates/index.html и добавьте следующие строки под заголовком авторов:
Введите имя, ваше, если хотите, и нажмите submit . и скоро, вы получите . ошибку?
DRF не совсем такой магический . или не так ли?
Откройте views.py , измените класс, который AuthorView расширяет с generics.ListAPIView на generics.ListCreateAPIView . Затем повторите попытку. Бум! Вы автор! И ваш учитель гимнастики четвертого класса сказал, что вы ни на что не годитесь. Но что он знал, он работал каждый день вокруг потных носков. Вернитесь на главную страницу автора, чтобы увидеть свое имя в огнях.
Что сейчас произошло? По умолчанию API View, который мы использовали, разрешал только запросы GET конечной точке авторов. Изменив его на ListCreateAPIView, мы сказали DRF, что хотим также разрешить POST запросы. Он делает все остальное для нас. Мы могли бы также легко определить наш собственный метод post в AuthorView и написать немного лишнего материала. Это может выглядеть так:
Заканчиваем
Вы уже много узнали о платформе Django Rest Framework: как реализовать API-интерфейс для просмотра веб-страниц, который может вернуть JSON для вас, как настроить сериализаторы для составления и преобразования ваших данных, а также как использовать представления на основе классов для абстрагирования кода шаблона.
DRF имеет больше, чем несколько бит, которые мы смогли усвоить, но я надеюсь, что он вам будет полезен для вашего следующего приложения.
Термин REST API расшифровывается как Representational State Transfer Application Programming Interface. Следовательно, RESTful API — это программный интерфейс приложения, соответствующий ограничениям архитектурного стиля REST.
REST — не протокол и не стандарт. Это, как уже было сказано, архитектурное ограничение. Чтобы API считался RESTful, он должен соответствовать следующим критериям.
Благодаря вышеперечисленным архитектурным правилам REST API масштабируемый, переносимый и гибкий.
2. Что такое Django REST Framework?
Django — масштабируемый полнофункциональный веб-фреймворк, написанный на Python. Django берет на себя все хлопоты, зачастую связанные с веб-разработкой, такие как безопасность и доступ к базам данных.
Существует множество библиотек для Django, расширяющих его функционал. Одна из них, о которой мы поговорим сегодня, — это Django REST Framework или DRF, которая позволяет сериализовать данные из Django ORM через REST API.
Сериализация — это преобразование таблиц из базы данных в формат JSON.
Руководство написано для новичков, прошлый опыт работы с фреймворком Django не предполагается, так как вы многому научитесь прямо сейчас. Кроме того, в статье не будет обширного описания технических нюансов каждой операции. Рассматривайте руководство в качестве упражнения.
Давайте создадим сайт бронирования отелей! Исходный код и справка доступны на GitHub.
3. Установка Django
Прежде чем приступить непосредственно к работе с REST API, сделаем краткий экскурс в Django.
3.1. Создание виртуальной среды
3.2. Установка зависимостей
3.3. Начало проекта
3.4. Изменение директории
3.5. Запуск сервера
3.6. Создание приложения
Приложения в Django — это независимые многократно используемые компоненты. Создадим приложение hotel_app .
3.7. Список приложений в проекте
Чтобы подключить к проекту hotel_reservation приложения hotel_app и rest_framework , необходимо отредактировать файл results/settings.py , указав эти приложения в списке INSTALLED_APPS :
3.8. Миграции
Теперь нужно выполнить Django-миграции — это способ Django распространять в схему базы данных все изменения, вносимые в модели, такие как добавление поля, удаление модели. Выполняйте эту команду каждый раз, когда модель или база данных сколько-нибудь меняются:
3.9. Административная панель
Django поставляется со встроенной панелью администратора, что позволяет создать суперпользователя с помощью одной команды. Заполните форму — появится учетная запись администратора:
Снова выполните миграции, авторизуйтесь.
3.10. Создание модели
Django ORM абстрагирует базу данных, позволяя легко запрашивать данные и манипулировать ими через объектно-ориентированное отображение, называемое моделью. Django ORM заставляет писать код согласно паттерну MVC (Model View Controller), который станет интуитивно понятным для вас после прохождения кривой обучения.
hotel_app/models.py :
Мы создали модель, хранящую имя студента и его оценки. Метод __str__ определяет имя объекта, отображаемое в браузере. Если пропустить определение данного метода, то вы увидите в панели администратора объект под названием <ClassName> .
3.11. Не забывайте о миграциях!
Теперь, когда изменения уже внесены в модель, настало время выполнить миграции.
3.12. Добавление приложения в админ-панель
Во встроенное приложение административной панели можно добавить созданную ранее пользовательскую модель.
hotel_app/admin.py :
Теперь мы завершили ту общую часть разработки веб-приложения, которая относится к фреймворку Django. Настало время приступить к проектированию REST API.
4. Написание Django REST API
Структура директорий проекта:
Добавим в проект файлы urls.py и serializers.py . Вот новый список файлов.
4.1. Сериализатор
Сериализация — процесс перевода структуры данных в последовательность байтов. Она используется для передачи объектов по сети и для сохранения их в файлы (Википедия).
hotel_app/serializers.py :
Сериализаторы определяют, как именно и какие данные отобразит представление API. При запросе по REST API к экземпляру модели Hotel мы получим список следующих полей, взятых из самой модели при помощи сериализатора:
4.2. Представления
Файл представления определяет то, как сериализованные объекты отображаются пользователю.
4.3. URL: ссылки на ресурсы
hotel_app/urls.py :
hotel_reservation/urls.py :
Перейдя по данной ссылке, вы получите доступ ко всем ранее определенным “разделам” REST API проекта:
5. Выводы
API-сервисы позволяют приложениям общаться с другими приложения с помощью данных, передаваемых в формате JSON. Достаточно создать и использовать его данные из любого API-клиента или фронтенд-приложения.
Django REST Framework — это набор инструментов для создания REST API с помощью Django. В этом руководстве рассмотрим, как правильно его использовать. Создадим эндпоинты(точки доступа к ресурсам) для пользователей, постов в блоге, комментариев и категорий.
Также рассмотрим аутентификацию, чтобы только залогиненный пользователь мог изменять данные приложения.
Вот чему вы научитесь:
- Добавлять новые и существующие модели Django в API.
- Сериализовать модели с помощью встроенных сериализаторов для распространенных API-паттернов.
- Создавать представления и URL-паттерны.
- Создавать отношения многие-к-одному и многие-ко-многим.
- Аутентифицировать пользовательские действия.
- Использовать созданный API Django REST Framework.
Требования
У вас в системе должен быть установлен Python 3, желательно 3.8. Также понадобится опыт работы с REST API. Вы должны быть знакомы с реляционными базами данными, включая основные и внешние ключи, модели баз данных, миграции, а также отношения многие-к-одному и многие-ко-многим.
Наконец, потребуется опыт работы с Python и Django.
Настройка проекта
Для создания нового API-проекта для начала создайте виртуальную среду Python в своей рабочей директории. Для этого запустите следующую команду в терминале:
В Windows это будет source env\Scripts\activate .
Не забывайте запускать все команды из этого руководства в виртуальной среде. Убедиться в том, что она активирована можно благодаря надписи ( env ) в начале строки приглашения к вводу в терминале.
Чтобы деактивировать среду, введите deactivate .
После этого установите Django и REST Framework в среду:
Вам также понадобится пользователь admin для взаимодействия с панелью управления Django и API. Из терминала запустите следующее:
Установите любой пароль (у него должно быть как минимум 8 символов). Если вы введете слишком простой пароль, то можете получить ошибку.
Для настройки, добавьте rest_framework и api в файл конфигурации (blog/blog/settings.py):
Добавление ApiConfig позволит добавлять параметры конфигурации в приложение. Другие настройки для этого руководства не потребуются.
Наконец, запустите локальный сервер с помощью команды python manage.py runserver .
Создание API для пользователей
Сериализатор для User
REST Framework Django использует сериализаторы, чтобы переводить наборы запросов и экземпляры моделей в JSON-данные. Сериализация также определяет, какие данные вернет API в ответ на запрос клиента.
Пользователи Django создаются из модели User , которая определена в django.contrib.auth . Для создания сериализатора для модели добавьте следующее в blog/api/serializers.py (файл нужно создать):
По примеру импортируйте модель User из Django вместе с набором сериализаторов из REST Framework Django.
Теперь создайте класс UserSerializer , который должен наследоваться от класса ModelSerializer .
Определите модель, которая должна ассоциироваться с сериализатором (model = User). Массив fields определяет, какие поля модели должны быть включены. Например, можно добавлять поля first_name и last_name .
Класс ModelSerializer генерирует поля сериализатора, которые основаны на соответствующих свойствах модели. Это значит, что не нужно вручную указывать все атрибуты для поля сериализации, поскольку они вытягиваются напрямую из модели.
Этот сериализатор также создает простые методы create() и update() . При необходимости их можно переписать.
Ознакомиться подробнее с работой ModelSerializer можно на официальном сайте.
Представления для User
Есть несколько способов создавать представления в REST Framework Django. Чтобы получить возможность повторного использования кода и избегать повторений, используйте классовые представления.
REST Framework предоставляет несколько обобщенных представлений, основанных на классе APIView . Они представляют собой самые распространенные паттерны.
Например, ListAPIView используется для эндпоинтов с доступом только для чтения. Он предоставляет метод-обработчик get . ListCreateAPIView используется для эндпоинтов с разрешением чтения-записи, а также обработчики get и post .
Для создания эндпоинта только для чтения, который возвращал бы список пользователей, добавьте следующее в blog/api/views.py:
В первую очередь здесь импортируется generics коллекция представлений, а также модель User и UserSerialized из предыдущего шага. Представление UserList предоставляет доступ только для чтения (через get ) к списку пользователей, а UserDetails — к одному пользователю.
Названия представлений должны быть в следующем формате: List и Details для коллекции объектов и одного объекта соответственно.
Для каждого представления переменная queryset содержит коллекцию экземпляров модели, которую возвращает User.objects.all() . Значением serializer_class должно быть UserSerializer , который и сериализует данные модели User .
Пути к эндпоинтам будут настроены на следующем шаге.
URL-паттерны
С моделью, сериализатором и набором представлений для User финальным шагом будет создание эндпоинтов (которые в Django называются URL-паттернами) для каждого представления.
В первую очередь добавьте следующее в blog/api/urls.py (этот файл тоже нужно создать):
Здесь импортируется функция path и также коллекция представлений приложения api .
Функция path создает элемент, который Django использует для показа страницы приложения. Для этого Django в первую очередь ищет нужный элемент с соответствующим URL (например, users/ ) для запрошенного пользователем. После этого он импортирует и вызывает соответствующее представление (то есть, UserList )
Последовательность <int:pk> указывает на целочисленное значение, которое является основным ключом ( pk ). Django захватывает эту часть URL и отправляет в представление в виде аргумента-ключевого слова.
Прежде чем можно будет взаимодействовать с этими URL-паттернами (и теми, которые будут созданы позже) их нужно добавить в проект. Добавьте следующее в blog/blog/urls.py:
В итоге класс модели Django сериализуется с помощью UserSerializaer . Он предоставляет данные представлениям UserList и UserDetail , доступ к которым можно получить с помощью паттернов users/ и users/<int:pk> .
Создание API для Post
После базовой настройки можно приступать к созданию полноценного API для блога с эндпоинтами для постов, комментариев и категорий. Начнем с API для Post.
Модель Post
В blog/api/models.py создайте модель Post , которая наследуется от класса Model из Django и определите ее поля:
Типы полей соответствуют таковым в реляционных базах данные. Можете ознакомиться со страницей Models на официальном сайте фреймворка.
В этом случае пользователь может иметь много статей, но у поста может быть всего один владелец. Поле owner может быть использовано во фронтенд-приложении для получения пользователя и отображения его имени в качестве автора поста.
Аргумент related_name позволяет задать другое имя доступа к текущей модели ( posts ) вместо стандартного ( post_set ). Список постов будет добавлен в сериализатор User на следующем шаге для завершения отношения многие-к-одному.
Каждый раз при обновлении модели запускайте следующие команды для обновления базы данных:
Поскольку мы работаем с моделями Django, таким как User , посты можно изменить из административной панели Django, зарегистрировав ее в blog/api/admin.py:
Позже их можно будет создавать и через графическое представление API.
Также можно выбрать owner среди существующих пользователей. При создании поста в API пользователя выбирать не нужно. Owner будет задан автоматически на основе данных залогиненного пользователя. Это настроим в следующем шаге.
Сериализатор Post
Чтобы добавить модель Post в API, нужно повторить шаги добавления модели User .
Сначала нужно сериализовать данные модели Post . В blog/api/serializers.py добавьте следующее:
Импортируйте модель Post из приложения api и создайте PostSerializer , который будет наследоваться от класса ModelSerializer . Задайте модель и поля, которые будут использоваться сериализатором.
ReadOnlyField — это класс, возвращающий данные без изменения. В этом случае он используется для возвращения поля username вместо стандартного id .
Дальше добавьте поле posts в UserSerializer . Отношение многие-к-одному между постами и пользователями определено моделью Post в прошлом шаге. Название поля ( posts ) должно быть равным аргументу related_field поля Post.owner . Замените posts на post_set (значение по умолчанию), если вы не задали значение related_field в прошлом шаге.
PrimaryKeyRelatedField представляет список публикаций в этом отношении многие-к-одному ( many=True указывает на то, что постов может быть больше чем один).
Если не задать read_only=True поле posts будет иметь права записи по умолчанию. Это значит, что будет возможность вручную задавать список статей, принадлежащих пользователю при его создании. Вряд ли это желаемое поведение.
Обратите внимание на то, что список posts — это, по сути, список id. Вместо этого можно возвращать список URL с помощью HyperLinkModelSerializer .
Итак, приступим. Начнем с установки Django и Django Rest Framework. В терминале создайте каталог и дайте ему любое описательное имя; Затем перейдите в созданный каталог и установите Django, набрав:
Так как мы будем использовать Django Rest Framework (DRF) для создания API, установите и его, так же, как мы делали это выше.
Теперь все готово что бы создать наш первый DRF API.
Для этого нам нужно создать проект Django для работы. Для этого мы запустим следующую команду:
Затем запустить миграцию базы данных. Таким образом будет создана база данных по умолчанию (на sqlite), со всеми требуемыми таблицами. Запустите команду:
Теперь можно запустить сервер, чтобы убедиться, что все в порядке:
Далее приступим к созданию приложения для нашего проекта. Мы создадим приложение article, в котором мы разместим все, что связано со статьями.
Потом необходимо включить созданное приложение в список установленных приложений:
Затем перейдите к файлу models.py. В нем, мы создадим наши модели.
Начнем с создания модели авторов:
Затем ниже создадим модель статей:
Далее нужно создать таблицы в базе данных на основе описанные моделей. Для этого нужно провести миграцию. С начало нужно создать файлы миграции а потом ее запустить. Для этого в командной строки запустите две команды:
Далее, создадим пользователя с правами администратора:
команда запросить данные нового пользователя. Нужно будет ввести имя пользователя, его email и пароль с подтверждением.
Далее, нужно зарегистрировать наши модели, чтобы они появлялись на этой странице.
Для этого мы откройте файл article/admin.py и внесите следующие изменения:
Теперь наша админка должна выглядеть как то так:
Пришло время создать наше API.
Мы начнем с метода через которого можно просмотреть все статьи. Для этого откройте файл article/views.py и вставьте следующий код
Далее нам нужно создать URL-адрес, с которого пользователь сможет получить доступ к этому методу. Для этого создайте файл article/urls.py . В этом файле вставьте следующий код.
Далее нам нужно включить эти URL-адреса в основной файл URL-адресов test_django/urls.py
Чтобы включить наши URL из приложения articles в основную конфигурацию URL, мы будем использовать метод include Django. Откройте файл test_django/urls.py, отредактируйте следующим образом:
Теперь у нас метод API через который мы можем просматривать все статьи в базе данных.
В настоящее время в нашей базе данных нет статей, поэтому мы получаем пустой список. Одной из причин, по которой мы добавили наши модели Article и Author на страницу администратора, была возможность добавлять авторов и статьи непосредственно в нашу базу данных через приложение администратора.
Теперь давайте создадим новые объекты в таблице Author и Article в приложение администратора.
После добавления одного и более автора и статьи, вы может заметить что их отображение не совсем так как хотелось бы
Article object(1) не особо информативное отображение имени объекта. Давай те изменим это, добавим отображение имени статьи. Для этого вернемся в наш article/models.py и добавим метод __str__ Этот метод даст нам удобочитаемое отображение объектов Article .
После добавления этого метода в класс Article , наша админка будет выглядеть как то так:
Добавьте такой же метод в класс Author .
TypeError. Серьезно? После всего того что мы сделали?
Ошибка возникла в строке return Response() где мы пытаемся сериализовать (то есть сконвертировать из объектов в формат JSON) список объектов articles . Но так как мы еще не указали класс для сериализации объектов статей, мы получили ошибку.
Serializers (Сериализаторы) позволяют преобразовывать сложные данные, такие как наборы запросов querysets и объекты моделей, в типы данных Python, которые затем можно легко преобразовать в JSON, XML или другие content types.
Теперь, давайте создадим сериалайзер, который преобразует наши статьи в список Python, который мы можем вернуть в API запросе.
Создайте новый файл в папке статей и назовите его что-то вроде article/serializers.py. В этот файл добавьте следующий код:
Как видите, мы используем созданный ранее сериализатор, чтобы создать новый объект статьи из данных которые мы получаем от пользователя. Как мы уже говорили ранее, мы проигнорировали поле автора в нашем сериализаторе, и поэтому оно не возвращается в полученном ответе. Чтобы мы могли использовать наш сериализатор для создания статей, нам нужно добавить поле author_id в сериализатор, а затем нам потребуется реализовать метод create в сериализаторе, который сообщит сериализатору, что делать, когда вызывается метод save сериализатора.
Обновим наш ArticleSerializer , чтобы он выглядел следующим образом.
Учитывая, что мы создали автора с панели администратора, теперь вы можете использовать postman или любой другой REST клиент для создания статьи (например какой нибудь REST плагин в хроме). Пример такого запроса показан ниже.
Благодаря этому каждый теперь сможет создавать статьи используя API. Теперь создадим возможность редактирования статьи.
Для этого мы обновим API articles , чтобы пользователи могли обновить статью, отправив запрос PUT. Сначала добавим новый path в файл article/urls.py.
Далее, добавим метод update в наш сериализатор, который сделает обновление за нас. Теперь наш код сериалайзера должен выглядеть следующим образом
Что происходит в методе update ? В том случае если мы что то передаем в экземпляр статьи, который мы хотим обновить, мы переназначаем это значение, в противном случае мы сохраняем старое значение атрибута.
Теперь создадим обработку запроса на обновление статьи. Мы должны определить метод put в нашем ArticleView , этот метод должен принять параметр pk из URL, найти требуемый экземпляр из базы и запустить сериалайзер на обновление. Внесем соотвествующие изменения в файл article.views.py.
Последнее что нам осталось добавить для создания полноценного CRUD API, это метод удаления. Для этого мы создадим метод delete в APIView , который будет принимать id статьи, в качестве аргумента.
Теперь у нас есть полностью функционирующие API, с помощью которого мы можем выполнить все основные задачи API, т. е. Операции Create Read Update Delete (CRUD).
Во второй части этой серии мы рассмотрим, как использовать Django Rest Framework GenericAPIView.
Читайте также: