The Django REST Framework is widely distributed as a standard Python package that users may require to get started with developing RESTful APIs. It is sophisticated, powerful, amazingly easy to use, and offers an attractive and browsable version for APIs. The Django REST Framework provides the option of returning JSON objects. This framework offers a powerful serialization of the model and displays the data using basic function-based views altogether in a fully REST viewer. Know more about the Django REST framework below:
Table of Contents
What Is The Django REST Framework?
The Django REST Framework is a flexible and robust tool kit that makes it easy for developers to build web APIs. It also offers class-based generalized views and serializers for the API. Being a source code, it is abbreviated as DRF, which represents a Python library for developing web application programming interfaces. As in this article, we are talking about development APIs with step-by-step instructions.
But before getting started with the guide, it is important to understand why the framework is even important. Many available frameworks allow developers to build APIs for their block applications easily, but the Django REST framework is preferred. This framework is convenient to use in a number of ways and offers the below-mentioned advantages-
- It offers web browsers an able Application Programming Interface, which is a great win for developers
- It has authentication policies including the packages for OAuth1, OAuth2, etc
- the serialization processor in it supports the ORM and non-ORM data sources
- this framework has extensive documentation and offers great community support
- It is utilized and trusted by great platforms, including Mozilla, Heroku, RedHat, etc.
Read: Django Applications: Everything You Need to Know About
Set The Django REST Framework Development
For starters, you have to install the Python dependencies for the operating system. If you are using the Windows platform, you can easily install the Linux platform as your secondary operating system with a virtual box or a manual command. To proceed with the framework, you can use effective and convenient Python management tools.
Most of the tools are a go-to helper. They allow developers to change Python versions quickly, set project-specific versions, manage the virtual environment, and install multiple versions on the system. If you are using Linux or Mac operating systems, it would be easy to install it.
With the Django REST framework’s help, we can convert a non-RESTful application into a RESTful one. This is inclusive of the below-mentioned procedures-
DRF Setup
For DRF Setup, you have to install-
Shell
$ pip install djangorestframework
$ pip freeze > requirements.txt
Update settings:py:
Python
INSTALLED_APPS = (
‘django.contrib.admin’,
‘django.contrib.auth’,
‘django.contrib.contenttypes’,
‘django.contrib.sessions’,
‘django.contrib.messages’,
‘django.contrib.staticfiles’,
‘talk’,
‘rest_framework’
)
RESTful Structure
In a RESTful API development, the endpoints represent its structure and user access from the application with the help of methods like GET, PUT, POST, DELETE. These endpoints are logically organized around the element and collections, both of which are counted as resources. If there is a single resource then corresponding links will be used as URLs for elements and collections.
GET
POST
PUT
DELETE
/posts/
Show all posts
Add new post
Update all posts
Delete all posts
/posts/<id>
Show <id>
N/A
Update <id>
Delete id
Serializers And Views
The major building block of the Django REST framework is serializers, and they are used to elaborate on the representation of various data records based on the Django models. Serializers are the standard Python class that can inherit the behavior of the model from the framework.
Inside the serializers class, separate fieldsets are present that utilize data types from their package of the same framework. They also noticed the similarities between the framework and classes. Serializer classes on their own do not think, and they are integrated with views that manage the bulk of REST service logic. Furthermore, it uses the serializer classes to transform the data. For example, a regular Django view method is-
from coffeehouse.stores.models import Store
from coffeehouse.stores.serializers import StoreSerializer
from rest_framework.decorators import api_view
from rest_framework.response import Response
@api_view([‘GET’,’POST’,’DELETE’])
def rest_store(request):
if request.method == ‘GET’:
stores = Store.objects.all()
serializer = StoreSerializer(stores, many=True)
return Response(serializer.data)
elif request.method == ‘POST’:
… #logic for HTTP POST operation
elif request.method == ‘DELETE’:
… #logic for HTTP DELETE operation
Class-Based Views
With the help of class-based views, the Django REST framework provides access to users’ supreme and complex functions. Class-based views offer the functions of true fully-fledged Python classes and allow Django views to easily operate with the help of object-oriented programming principles that leads to greater reusability along with short implementation times.
The Django class-based views highlight a powerful approach to build Django views, and they are also an alternative to the methods that are used to build APIs. To develop a class-based view, it is important to create a class that can inherit from one of the other classes. For example:
# views.py
from Django.views.generic import TemplateView
class AboutIndex(TemplateView):
template_name = ‘index.html’
def get_context_data(self, **kwargs):
# **kwargs contains keyword context initialization values (if any)
# Call base implementation to get a context
context = super(AboutIndex, self).get_context_data(**kwargs)
# Add context data to pass to template
context[‘aboutdata’] = ‘Custom data’
return context
# urls.py
from coffeehouse.about.views import AboutIndex
from django.urls import path
urlpatterns = [
path(‘about/index/’,AboutIndex.as_view(),{‘onsale’:True}),
Checkout: Top 12 Django Interview Questions & Answers for Beginners
Update Views
To fit the RESTful application structure it is important to refactor the current views. You can comment out these views and add them as-
Python
from django.shortcuts import render
from django.http import HttpResponse
from rest_framework.decorators import api_view
from rest_framework.response import Response
from talk.models import Post
from talk.serializers import PostSerializer
from talk.forms import PostForm
def home(request):
tmpl_vars = {‘form’: PostForm()}
return render(request, ‘talk/index.html’, tmpl_vars)
@api_view([‘GET’])
def post_collection(request):
if request.method == ‘GET’:
posts = Post.objects.all()
serializer = PostSerializer(posts, many=True)
return Response(serializer.data)
@api_view([‘GET’])
def post_element(request, pk):
try:
post = Post.objects.get(pk=pk)
except Post.DoesNotExist:
return HttpResponse(status=404)
if request.method == ‘GET’:
serializer = PostSerializer(post)
return Response(serializer.data)
Explanation
- In the instructions that are given above, the @api_view decorator analyses the corresponding HTTP request, which is passed into the view function.
- Now the view either use a single post if it is for an element or grabs the entire data if it is for the collection
- Finally, the data is now serialized to the JSON and returned accordingly
Web Browsable API Or Updated URL
Some updated URLs for Python are:
# Talk URLs
from django.conf.urls import patterns, URL
urlpatterns = patterns(
‘talk.views’,
url(r’^$’, ‘home’),
# api
url(r’^api/v1/posts/$’, ‘post_collection’),
url(r’^api/v1/posts/(?P<pk>[0-9]+)$’, ‘post_element’)
)
Refactor For RESTful API Integration
It is inclusive of the major HTTP methods like-
GET
Initial page load, it is important to display the posts, and to do that, you can add this request:
load_posts()
// Load all posts on page load
function load_posts() {
$.ajax({
url : “api/v1/posts/”, // the endpoint
type : “GET”, // http method
// handle a successful response
success : function(json) {
for (var i = 0; i < json.length; i++) {
console.log(json[i])
$(“#talk”).prepend(“<li id=’post-“+json[i].id+”‘><strong>”+json[i].text+”</strong> – <em> “+json[i].author+”</em> – <span> “+json[i].created+
“</span> – <a id=’delete-post-“+json[i].id+”‘>delete me</a></li>”);
}
},
// handle a non-successful response
error : function(xhr,errmsg,err) {
$(‘#results’).html(“<div class=’alert-box alert radius’ data-alert>Oops! We have encountered an error: “+errmsg+
” <a href=’#’ class=’close’>×</a></div>”); // add the error to the dom
console.log(xhr.status + “: ” + xhr.responseText); // provide a bit more info about the error to the console
}
});
};
POST
POST requests are managed in a similar fashion and you can test this by updating the views. You can update the post_collection () function in views.py:
@api_view([‘GET’, ‘POST’])
def post_collection(request):
if request.method == ‘GET’:
posts = Post.objects.all()
serializer = PostSerializer(posts, many=True)
return Response(serializer.data)
elif request.method == ‘POST’:
data = {‘text’: request.DATA.get(‘the_post’), ‘author’: request.user.pk}
serializer = PostSerializer(data=data)
if serializer.is_valid():
serializer.save()
return Response(serializer.data, status=status.HTTP_201_CREATED)
return Response(serializer.errors, status=status.HTTP_400_BAD_REQUEST)
Also Read: Django Developer Salary in India
The Bottom Line
The actual Django REST framework‘s REST part is pretty simple and all you have to do is update the post element function in order to handle the request. If you still have any queries then there are a number of Django REST frameworks and resources for improvisation.
If you’re interested to learn more about Django and other full-stack developer languages and tools, check out upGrad & IIIT-B’s PG Diploma in Full-stack Software Development which is designed for working professionals and offers 500+ hours of rigorous training, 9+ projects, and assignments, IIIT-B Alumni status, practical hands-on capstone projects & job assistance with top firms.
