Building Web Application is fun and challenging as well. But why do you want to build a web application? is there any need to do that? Yes, there are Business requirements to building an application and requirements could be anything like build an application for data management, build an application for workflow management, etc.
So how Would you map those Business requirements to your code? let me discuss that. the first thing we do is analyze the requirements and come up with a good architecture that also includes the technology stack that you are going to use.
Based on the technology stack we map requirements to code. let say the technology stack that we are going to use also includes Django. so how would one write business logic or map requirements to code in Django? the answer is Django views, Yes you heard right `Django Views`which is `V` in the `MVT Patterns of Django`.
if You don't know what is MVT pattern in Django then you can learn from this article MVT patterns of Django
So, In this post will discuss Django views
What are Django Views?
Django views are Block of code that contains the specific business logic which Takes a web request and returns the response according to the logic. make sense? if not then no worries will understand it with a simple example
Let say you want to write a function that takes some arguments and based on those arguments you want to return some specific response. like if arguments equal to that then return this and vice-versa.
Same with Django views you write a function that takes web request as an argument and returns the response, the response could be anything like an HTML web page, 404 Error, or an image
What Problem it solves?
Django views let you map your business logic into the block of code or the function, where you can define what to return? when to return? whom to return?. also it can contain logic related to databases like Reading, writing, updating and deleting. so, basically in these block of code, or functions, you can write whatever different functionality you wanted to
Types of views in Django
Basically, there are two types of views in Django Function-based and class-based views. both of them have their own use cases and when to use which one is still one of the most asked questions in the Django community, so would not do the same it totally depends on developer and business requirements
Function-based views
Function-based views are nothing but a function that takes the Web request and return the response.
Most people preferred this type of view because they like functional programming and it also more open like whatever we are writing we know what each line of code for
Classe-based views
Class-based views are based on Object-Oriented Programming(OOP) and come with some abstraction. but Class-based views are reusable with the help of inheritance which is also of the concept of OOP. by using it you can structure your code better
How to write Views in Django?
Writing Views in Django is very simple and will write some so that you will get a better understanding of it
Function-based view
Let say you want to write a view that returns the list of blogs from the database
from Django. shortcuts import render
from .models import Blog
def get_blogs(request):
template_name="blog_list.html"
context={}
blogs=Blog.objects.all()
context["blogs"]=blogs
return render(request,template_name,context)
|
The above function will return all the blogs that are available in the database.
Create one template under the templates folder `blog_list.html
< div class ="blog_list" >
{ % for the blog in blogs %}.
< div class ="card" >
< div class ="card_title" >
{{blog.title}}
< / div >
< div class ="card_description" >
{{blog.description}}
< / div >
< span class ="card_link" >
< a href = "{{ blog.url }}" > < / a >
< / span >
< / div >
{ % endfor %}
< / div >
|
from Django. shortcuts import render |
Django provides the render method that takes three arguments request object, template_name and context or dynamic data. the third one is optional because not every view will contain the database logic.
Now we have the view but how to access it, it's simple you just have to add the view in URL patterns with some path like `/blogs/`
urls.py file
from .views import get_blogs
urlpatterns = [
path('blogs/', get_blogs),
]
|
If You visit the yoursite.com/blogs/ you will see blogs are listed there
Class-based view
Let say you want to handle the forms for adding a blog to your site.
A basic function-based view that handles forms may look something like this:
from Django.shortcuts import render, redirect
from .forms import AddBlog
def add_blog(request):
template_name = 'add_blog.html'
context = {}
if request.method == "POST":
form = AddBlog(request.POST)
if form.is_valid():
# perform some operation if form is valid
return redirect('blogs')
else:
form = AddBlog()
context["form"] = form
return render(request, template_name, context)
|
The above function will return a simple form when we make the `GET` request and When we make The `POST` request with some data it will check if data is valid then it will redirect us to the blog list page.
A similar class-based view might look like this:
from Django.shortcuts import render, redirect
from Django.views import View
from .forms import AddBlog
class AddBlog(View):
form_class = AddBlog
template_name = 'add_blog.html'
context = {}
def get(self, request, *args, **kwargs):
form = self.form_class()
self.context["form"] = form
return render(request, self.template_name, self.context)
def post(self, request, *args, **kwargs):
form = self.form_class(request.POST)
self.context["form"] = form
if form.is_valid():
# perform some operation if form is valid
return redirect('blogs')
return render(request, self.template_name, self.context)
|
In the above code, you can see we are inheriting the View class from Django. as earlier I said class-based view is better-structured ones here you can see that we have two separate methods one is for `GET request` and another is for `POST request`. and these methods come with the `View` class.
Now we have the view but how to access it, it's simple you just have to add the view in URL patterns with some path like `/add/`
urls.py file
from .views import AddBlog
urlpatterns = [
path('add/', AddBlog.as_view()),
]
|
As you can see for the class-based view we have to execute the `as_view` method so that Django treat it as a view.
If You visit the yoursite.com/blogs/ you will see a form for adding a new blog.
Article Contributed By :
|
|
|
|
1143 Views |