8 min read
This article is an excerpt taken from the book, ‘Hands-On RESTful API Design Patterns and Best Practices‘ written by Harihara Subramanian and Pethura Raj. This book covers design strategy, essential and advanced Restful API Patterns, Legacy Modernization to Microservices centric apps.
In this article, we’ll explore two comprehensive frameworks, Django and Flask, so that you can choose the best one for developing your RESTful API.
Django is a web framework also available as open source with the BSD license, designed to help developers create their web app very quickly as it takes care of additional web-development needs. It includes several packages (also known as applications) to handle typical web-development tasks, such as authentication, content administration, scaffolding, templates, caching, and syndication. Let’s use the Django REST Framework (DRF) built with Python, and use it for REST API development and deployment.
Django Rest Framework
DRF is an open source, well-matured Python and Django library intended to help APP developers build sophisticated web APIs. DRF’s modular, flexible, and customizable architecture makes the development of both simple, turnkey API endpoints and complicated REST constructs possible. The goal of DRF is to divide a model, generalize the wire representation, such as JSON or XML, and customize a set of class-based views to satisfy the specific API endpoint using a serializer that describes the mapping between views and API endpoints.
Django has many distinct features including:
This feature enhances the REST API developed with DRF. It has a rich interface, and the web-browsable API supports multiple media types too. The browsable API does mean that the APIs we build will be self-describing and the API endpoints that we create as part of the REST services and return JSON or HTML representations. The interesting fact about the web-browsable API is that we can interact with it fully through the browser, and any endpoint that we interact with using a programmatic client will also be capable of responding with a browser-friendly view onto the web-browsable API.
One of the main attractive features of Django is authentication; it supports broad categories of authentication schemes, from basic authentication, token authentication, session authentication, remote user authentication, to OAuth Authentication. It also supports custom authentication schemes if we wish to implement one. DRF runs the authentication scheme at the start of the view, that is, before any other code is allowed to proceed. DRF determines the privileges of the incoming request from the permission and throttling policies and then decides whether the incoming request can be allowed or disallowed with the matched credentials.
Serialization and deserialization
Serialization is the process of converting complex data, such as querysets and model instances, into native Python datatypes. Converting facilitates the rendering of native data types, such as JSON or XML. DRF supports serialization through serializers classes. The serializers of DRF are similar to Django’s Form and ModelForm classes. It provides a serializer class, which helps to control the output of responses. The DRF ModelSerializer classes provide a simple mechanism with which we can create serializers that deal with model instances and querysets. Serializers also do deserialization, that is, serializers allow parsed data that needs to be converted back into complex types. Also, deserialization happens only after validating the incoming data.
Other noteworthy features
Here are some other noteworthy features of the DRF:
- Routers: The DRF supports automatic URL routing to Django and provides a consistent and straightforward way to wire the view logic to a set of URLs
- Class-based views: A dominant pattern that enables the reusability of common functionalities
- Hyperlinking APIs: The DRF supports various styles (using primary keys, hyperlinking between entities, and so on) to represent the relationship between entities
- Generic views: Allows us to build API views that map to the database models
DRF has many other features such as caching, throttling, testing, etc.
Benefits of the DRF
Here are some of the benefits of the DRF:
- Web-browsable API
- Authentication policies
- Powerful serialization
- Extensive documentation and excellent community support
- Simple yet powerful
- Test coverage of source code
- Secure and scalable
Drawbacks of the DRF
Here are some facts that may disappoint some Python app developers who intend to use the DRF:
- Monolithic and components get deployed together
- Based on Django ORM
- Steep learning curve
- Slow response time
Flask is a microframework for Python developers based on Werkzeug (WSGI toolkit) and Jinja 2 (template engine). It comes under BSD licensing. Flask is very easy to set up and simple to use. Like other frameworks, it comes with several out-of-the-box capabilities, such as a built-in development server, debugger, unit test support, templating, secure cookies, and RESTful request dispatching. The powerful Flask RESTful API framework is discussed below.
Flask-RESTful is an extension for Flask that provides additional support for building REST APIs. You will never be disappointed with the time it takes to develop an API. Flask-Restful is a lightweight abstraction that works with the existing ORM/libraries. Flask-RESTful encourages best practices with minimal setup.
Core features of Flask-RESTful
Flask-RESTful comes with several built-in features. Django and Flask have many common RESTful frameworks, because they have almost the same supporting core features. The unique RESTful features of Flask is mentioned below.
The design goal of Flask-RESTful is to provide resources built on top of Flask pluggable views. The pluggable views provide a simple way to access the HTTP methods. Consider the following example code:
class Todo(Resource): def get(self, user_id): .... def delete(self, user_id): .... def put(self, user_id): args = parser.parse_args() ....
Restful request parsing
Request parsing refers to an interface, modeled after the Python parser interface for command-line arguments, called argparser. The RESTful request parser is designed to provide uniform and straightforward access to any variable that comes within the (flask.request) request object.
In most cases, app developers prefer to control rendering response data, and Flask-RESTful provides a mechanism where you can use ORM models or even custom classes as an object to render. Another interesting fact about this framework is that app developers don’t need to worry about exposing any internal data structures as its let one format and filter the response objects. So, when we look at the code, it’ll be evident which data would go for rendering and how it’ll be formatted.
Other noteworthy features
Here are some other noteworthy features of Flask-RESTful:
- API: This is the main entry point for the restful API, which we’ll initialize with the Flask application.
- ReqParse: This enables us to add and parse multiple arguments in the context of the single request.
- Input: A useful functionality, it parses the input string and returns true or false depending on the Input. If the input is from the JSON body, the type is already native Boolean and passed through without further parsing.
Benefits of the Flask framework
Here are some of the benefits of Flask framework:
- Built-in development server and debugger
- Out-of-the-box RESTful request dispatching
- Support for secure cookies
- Integrated unit-test support
- Very minimal setup
- Faster (performance)
- Easy NoSQL integration
- Extensive documentation
Drawbacks of Flask
Here are some of Flask and Flask-RESTful’s disadvantages:
- Version management (managed by developers)
- No brownie points as it doesn’t have browsable APIs
- May incur a steep learning curve
Frameworks – a table of reference
The following table provides a quick reference of a few other prominent micro-frameworks, their features, and supported programming languages:
|Language||Framework||Short description||Prominent features|
|Java||Blade||Fast and elegant MVC framework for Java8||Lightweight|
Based on the MVC pattern
RESTful-style router interface
|Java/ Scala||Play Framework||High-velocity Reactive web||Lightweight, stateless, and web-friendly architecture|
Built on Akka
Supports predictable and minimal resource-consumption for highly-scalable applications
|Java||Ninja Web Framework||Full-stack web framework||Fast|
Plain vanilla Java, dependency injection, first-class IDE integration
Simple and fast to test (mocked tests/integration tests)
Excellent build and CI support
Clean codebase – easy to extend
|Java||RESTEASY||JBoss-based implementation that integrates several frameworks to help to build RESTful Web and Java applications||Fast and reliable|
|Java||RESTLET||A lightweight and comprehensive framework based on Java, suitable for both server and client applications.||Lightweight|
Native REST support
|PHP||Laravel||An open source web-app builder based on PHP and the MVC architecture pattern||Intuitive interface|
Blade template engine
Eloquent ORM as default
|Elixir||Phoenix (Elixir)||Powered with the Elixir functional language, a reliable and faster micro-framework||MVC-based|
High application performance
Erlong virtual machine enables better use of resources
Events and subscribers support
Easy implementations and high productivity
It’s evident that Python has two excellent frameworks. Depending on the choice of programming language you are intending to use and the required features, you can choose your type of framework to work on.
If you are interested in learning more about the design strategy, guidelines and best practices of Restful API Patterns, you can refer to our book ‘Hands-On RESTful API Design Patterns and Best Practices‘ here.