Building a Simple API with Django REST Framework

Django REST Framework (DRF) is an extension of Django that makes building APIs easier. It helps convert Django models into RESTful APIs that can be used by web apps, mobile apps, or other services.

Before creating an API, it's important to understand three main components:

• Serialization: Converts complex data, such as Django models or querysets, into JSON or XML format.
• Viewsets: Define views that handle API requests and responses.
• URL Routing: Maps URLs to API views so clients can access them.

A simple CRUD API

Consider a Django project with an app that includes a Book model containing three fields: title, author and publish_date.

Step 1: Add DRF to Installed Apps

In settings.py, add "rest_framework" and the app name to "INSTALLED_APPS" to enable Django REST Framework in the project:

Make sure the Django REST Framework module is installed:

pip install djangorestframework

Step 2: Create the Book Model

In app/models.py, define the Book model with three fields:

• CharField is used for short text (title, author).
• DateField stores the date when the book was published.
• __str__ method returns a human-readable representation of each book instance.

Step 3: Create a Serializer

Serializers convert model instances into JSON and validate incoming JSON data.

Create app/serializers.py:

• ModelSerializer automatically generates fields based on the model.
• fields tuple specifies which model fields to expose via the API.
• id field (primary key) is included to uniquely identify each record.

Step 4: Define a ViewSet

ViewSets provide CRUD operations in one place.

In app/views.py:

• ModelViewSet automatically provides list, retrieve, create, update and destroy actions.
• queryset defines the set of objects available via the API.
• serializer_class tells DRF how to serialize/deserialize the Book data.

Note: You do not need to manually convert data to JSON. The BookSerializer handles serialization and deserialization automatically when using ModelViewSet.

Step 5: Create app URLs with a DRF router

DRF routers automatically generate URL patterns for your ViewSets.

Create app/urls.py:

Using DefaultRouter, don’t need to manually define each URL for CRUD operations. It automatically creates standard RESTful endpoints like:

• GET /books/ (list all books)
• POST /books/ (create new book)
• GET /books/{id}/ (retrieve a single book)
• PUT /books/{id}/ (update a book)
• DELETE /books/{id}/ (delete a book)

Including these URLs in the project’s main urls.py file exposes the API endpoints.

Step 6: Migrate and Run the Server

Run the following commands to create your database tables and start the server:

python manage.py makemigrations
python manage.py migrate
python manage.py runserver

Step 7: Include app URLs from the project URLs

In project/urls.py:

Once the server is running:

• The /books/ endpoint lists all books (initially empty).
• Use POST requests to add new books.
• Individual books can be retrieved, updated, or deleted via their respective URLs.

Accessing the API Endpoints

Including the app URLs under path('api/', include('app.urls')) in the main urls.py adds the /api/ prefix to every route defined inside the app. As a result, all API endpoints automatically start with /api/.

Output:/books/ endpoint after adding some entries.

Output:/books/{id}/ with id of some book.

You can perform all CRUD operations using the following endpoints:

These endpoints show that all CRUD operations are available and functioning correctly in the application.