Bài 01: Giới Thiệu Django

Django là gì?

Django là một high-level Python web framework giúp developers xây dựng web applications một cách nhanh chóng và hiệu quả. Django được phát triển bởi Lawrence Journal-World newspaper vào năm 2003 và được release như một open-source project vào năm 2005.

Đặc Điểm Chính

1. "Batteries Included" Philosophy

Django đi kèm với rất nhiều tính năng built-in, giúp bạn không phải "reinvent the wheel":

ORM (Object-Relational Mapping): Làm việc với database bằng Python code thay vì SQL
Admin Interface: Tự động tạo admin panel để quản lý data
Authentication System: User login, logout, permissions đã có sẵn
Form Handling: Validation, rendering forms dễ dàng
Security Features: Protection chống CSRF, XSS, SQL injection
Template Engine: System để render HTML động
URL Routing: Map URLs tới views linh hoạt
Internationalization: Hỗ trợ đa ngôn ngữ

2. DRY (Don't Repeat Yourself)

Django khuyến khích code reusability và tránh duplication:

# Thay vì viết lại validation nhiều lầnclass User(models.Model):    email = models.EmailField(unique=True)  # Validation tự động    age = models.IntegerField(validators=[MinValueValidator(18)])

3. Fast Development

Django giúp bạn build applications nhanh hơn:

# Tạo project trong 1 phútdjango-admin startproject mysite # Tạo app trong vài giâypython manage.py startapp blog # Admin interface có sẵn ngaypython manage.py createsuperuser

4. Secure by Default

Django tự động bảo vệ bạn khỏi nhiều lỗ hổng bảo mật phổ biến:

CSRF protection (Cross-Site Request Forgery)
XSS protection (Cross-Site Scripting)
SQL injection prevention
Clickjacking protection
SSL/HTTPS support

5. Scalable

Django được sử dụng bởi các trang web lớn như:

Instagram (hàng tỷ users)
Pinterest
Spotify
YouTube (một phần)
Dropbox
NASA

Lịch Sử và Phiên Bản

2005: Django 1.0 - First release2013: Django 1.6 - Transaction management2015: Django 1.8 - LTS (Long Term Support)2017: Django 2.0 - Python 3+ only2019: Django 3.0 - ASGI support2021: Django 4.0 - Async views2025: Django 5.x - Current version

LTS (Long Term Support):

Django 3.2 LTS: Support đến April 2024
Django 4.2 LTS: Support đến April 2026

Triết Lý Django

Django tuân theo các nguyên tắc thiết kế:

Loose Coupling: Components độc lập, dễ thay thế
Less Code: Viết ít code hơn nhưng làm được nhiều việc hơn
Quick Development: Từ concept đến production nhanh chóng
Don't Repeat Yourself (DRY): Mỗi piece of knowledge chỉ có một representation
Explicit is Better Than Implicit: Code phải rõ ràng, dễ hiểu

MVT (Model-View-Template) Pattern

Django sử dụng MVT pattern, một biến thể của MVC (Model-View-Controller) pattern.

Kiến Trúc MVT

┌─────────────────────────────────────────────┐│             User Request                     ││              (Browser)                       │└───────────────┬─────────────────────────────┘                │                ▼┌───────────────────────────────────────────────┐│              URLs (urls.py)                   ││         Route request to View                 │└───────────────┬───────────────────────────────┘                │                ▼┌───────────────────────────────────────────────┐│            VIEW (views.py)                    ││    - Business logic                           ││    - Interact with Model                      ││    - Select Template                          │└─────┬────────────────────────────┬────────────┘      │                            │      ▼                            ▼┌─────────────┐            ┌──────────────┐│   MODEL     │            │  TEMPLATE    ││ (models.py) │◄──────────►│  (.html)     ││             │            │              ││ - Database  │            │ - HTML       ││ - Logic     │            │ - Display    │└──────┬──────┘            └──────┬───────┘       │                          │       └────────┬─────────────────┘                ▼        ┌───────────────┐        │   RESPONSE    │        │   (HTML)      │        └───────────────┘

1. Model (models.py)

Model định nghĩa cấu trúc dữ liệu và business logic.

# blog/models.pyfrom django.db import modelsfrom django.contrib.auth.models import User class Post(models.Model):    title = models.CharField(max_length=200)    content = models.TextField()    author = models.ForeignKey(User, on_delete=models.CASCADE)    created_at = models.DateTimeField(auto_now_add=True)    published = models.BooleanField(default=False)        class Meta:        ordering = ['-created_at']        def __str__(self):        return self.title        def get_absolute_url(self):        return f'/blog/{self.id}/'

Trách nhiệm của Model:

Định nghĩa database schema
Validation dữ liệu
Business logic
Relationships giữa các models
Query data từ database

2. View (views.py)

View xử lý requests và trả về responses.

# blog/views.pyfrom django.shortcuts import render, get_object_or_404from .models import Post def post_list(request):    """View hiển thị danh sách posts."""    posts = Post.objects.filter(published=True)    context = {'posts': posts}    return render(request, 'blog/post_list.html', context) def post_detail(request, post_id):    """View hiển thị chi tiết một post."""    post = get_object_or_404(Post, id=post_id, published=True)    context = {'post': post}    return render(request, 'blog/post_detail.html', context) # Class-based viewfrom django.views.generic import ListView class PostListView(ListView):    model = Post    template_name = 'blog/post_list.html'    context_object_name = 'posts'    queryset = Post.objects.filter(published=True)

Trách nhiệm của View:

Nhận HTTP request
Query data từ Model
Xử lý business logic
Chọn Template
Trả về HTTP response

3. Template (.html)

Template định nghĩa cách hiển thị dữ liệu.

<!-- templates/blog/post_list.html -->{% extends 'base.html' %} {% block title %}Blog Posts{% endblock %} {% block content %}<div class="posts">    <h1>Latest Posts</h1>        {% for post in posts %}    <article class="post">        <h2>            <a href="{% url 'post_detail' post.id %}">                {{ post.title }}            </a>        </h2>        <p class="meta">            By {{ post.author.username }} on             {{ post.created_at|date:"F d, Y" }}        </p>        <div class="content">            {{ post.content|truncatewords:50 }}        </div>    </article>    {% empty %}    <p>No posts available.</p>    {% endfor %}</div>{% endblock %}

Trách nhiệm của Template:

Render HTML
Display data từ View
Template logic (loops, conditionals)
Template inheritance
Include reusable components

MVT Flow Example

Request Flow:

# 1. User visits: http://example.com/blog/ # 2. URLs mapping (urls.py)from django.urls import pathfrom blog import views urlpatterns = [    path('blog/', views.post_list, name='post_list'),    path('blog/<int:post_id>/', views.post_detail, name='post_detail'),] # 3. View processes (views.py)def post_list(request):    # Query Model    posts = Post.objects.filter(published=True)        # Prepare context    context = {'posts': posts}        # Render Template    return render(request, 'blog/post_list.html', context) # 4. Template renders (post_list.html)# HTML được generate và return về browser

MVT vs MVC

Aspect	Django MVT	Traditional MVC
Model	Database + Logic	Database + Logic
View	Business Logic	Presentation (UI)
Template	Presentation (UI)	N/A
Controller	Django Framework	User-defined

Key Difference:

Trong MVC: Controller xử lý requests
Trong MVT: Django framework tự động xử lý routing, View chỉ xử lý logic

Django vs Flask vs FastAPI

So Sánh Tổng Quan

Feature	Django	Flask	FastAPI
Type	Full-stack	Micro	API-first
Philosophy	Batteries included	Minimalist	Modern & Fast
Learning Curve	Steep	Gentle	Medium
Setup Time	Quick for full apps	Quick for simple	Quick for APIs
Built-in Features	Many	Few	Medium
ORM	Built-in	Optional (SQLAlchemy)	Optional (SQLAlchemy)
Admin Panel	Yes	No	No
Authentication	Built-in	Extensions	Extensions
Async Support	Yes (3.1+)	Limited	Native
Performance	Good	Good	Excellent
Best For	Full websites	Simple apps/APIs	Modern APIs

Django

# Django - Full-featured# myproject/settings.py - Cấu hình chi tiết# myapp/models.pyclass Article(models.Model):    title = models.CharField(max_length=200)    content = models.TextField() # myapp/views.pyfrom django.views.generic import ListView class ArticleListView(ListView):    model = Article    template_name = 'articles/list.html' # Admin có sẵnfrom django.contrib import adminadmin.site.register(Article)

Pros:

✅ Admin interface tự động
✅ ORM mạnh mẽ
✅ Security built-in
✅ Authentication system
✅ Form handling
✅ Migration system
✅ Ecosystem lớn

Cons:

❌ Monolithic (nhiều features không dùng)
❌ Learning curve cao
❌ Overhead cho projects đơn giản

Flask

# Flask - Minimalistfrom flask import Flask, render_templatefrom flask_sqlalchemy import SQLAlchemy app = Flask(__name__)db = SQLAlchemy(app) class Article(db.Model):    id = db.Column(db.Integer, primary_key=True)    title = db.Column(db.String(200))    content = db.Column(db.Text) @app.route('/articles')def articles():    articles = Article.query.all()    return render_template('articles.html', articles=articles) if __name__ == '__main__':    app.run(debug=True)

Pros:

✅ Lightweight
✅ Flexible
✅ Easy to learn
✅ Minimal boilerplate
✅ Good for microservices

Cons:

❌ Phải tự setup nhiều thứ
❌ Không có admin
❌ Ít structure hơn
❌ Extensions quality varies

FastAPI

# FastAPI - Modern & Fastfrom fastapi import FastAPIfrom pydantic import BaseModelfrom typing import List app = FastAPI() class Article(BaseModel):    id: int    title: str    content: str @app.get("/articles", response_model=List[Article])async def get_articles():    # Async operation    articles = await db.fetch_all("SELECT * FROM articles")    return articles @app.post("/articles", response_model=Article)async def create_article(article: Article):    await db.execute(        "INSERT INTO articles VALUES (:id, :title, :content)",        values=article.dict()    )    return article # Auto-generated OpenAPI docs at /docs

Pros:

✅ Very fast (Starlette + Pydantic)
✅ Async native
✅ Auto documentation (Swagger)
✅ Type hints + validation
✅ Modern Python features
✅ Easy testing

Cons:

❌ Mới (2018)
❌ Ecosystem nhỏ hơn
❌ Chủ yếu cho APIs
❌ Không phải full-stack

Khi Nào Dùng Framework Nào?

Chọn Django khi:

🎯 Cần build full website (frontend + backend)
🎯 Cần admin panel
🎯 Project phức tạp với nhiều models
🎯 Cần authentication/authorization
🎯 Muốn structure và conventions
🎯 Team lớn cần consistency

Ví dụ: E-commerce, CMS, Social network, Internal tools

Chọn Flask khi:

🎯 Project nhỏ, đơn giản
🎯 Cần flexibility cao
🎯 Microservices
🎯 Learning web development
🎯 Prototype nhanh
🎯 Custom structure

Ví dụ: Landing pages, Simple APIs, Microservices, Tools

Chọn FastAPI khi:

🎯 Build RESTful APIs
🎯 Cần performance cao
🎯 Async operations
🎯 Machine Learning APIs
🎯 Microservices modern
🎯 Auto documentation

Ví dụ: APIs cho mobile apps, ML models serving, Real-time services

Khi Nào Nên Dùng Django

Django Phù Hợp Với

1. Content Management Systems (CMS)

Django xuất sắc cho content-heavy websites:

# Blog, News, Magazine websitesclass Article(models.Model):    title = models.CharField(max_length=200)    slug = models.SlugField(unique=True)    content = models.TextField()    category = models.ForeignKey(Category, on_delete=models.CASCADE)    tags = models.ManyToManyField(Tag)    author = models.ForeignKey(User, on_delete=models.CASCADE)    published_date = models.DateTimeField(auto_now_add=True)    featured_image = models.ImageField(upload_to='articles/')        class Meta:        ordering = ['-published_date'] # Admin tự động để manage content@admin.register(Article)class ArticleAdmin(admin.ModelAdmin):    list_display = ['title', 'author', 'published_date']    list_filter = ['category', 'published_date']    search_fields = ['title', 'content']    prepopulated_fields = {'slug': ('title',)}

2. E-commerce Platforms

Django có packages mạnh như django-oscar, saleor:

class Product(models.Model):    name = models.CharField(max_length=200)    price = models.DecimalField(max_digits=10, decimal_places=2)    stock = models.IntegerField()    category = models.ForeignKey(Category, on_delete=models.CASCADE) class Order(models.Model):    user = models.ForeignKey(User, on_delete=models.CASCADE)    products = models.ManyToManyField(Product, through='OrderItem')    total = models.DecimalField(max_digits=10, decimal_places=2)    status = models.CharField(max_length=20)    class Cart(models.Model):    user = models.OneToOneField(User, on_delete=models.CASCADE)    items = models.ManyToManyField(Product)

3. Social Networks

Instagram được build bằng Django:

class Profile(models.Model):    user = models.OneToOneField(User, on_delete=models.CASCADE)    bio = models.TextField()    avatar = models.ImageField()    followers = models.ManyToManyField('self', symmetrical=False) class Post(models.Model):    user = models.ForeignKey(User, on_delete=models.CASCADE)    image = models.ImageField()    caption = models.TextField()    likes = models.ManyToManyField(User, related_name='liked_posts') class Comment(models.Model):    post = models.ForeignKey(Post, on_delete=models.CASCADE)    user = models.ForeignKey(User, on_delete=models.CASCADE)    text = models.TextField()

4. Internal Business Tools

Dashboard, CRM, Project management:

class Project(models.Model):    name = models.CharField(max_length=200)    team = models.ManyToManyField(User)    deadline = models.DateField() class Task(models.Model):    project = models.ForeignKey(Project, on_delete=models.CASCADE)    assignee = models.ForeignKey(User, on_delete=models.CASCADE)    status = models.CharField(max_length=20)    priority = models.IntegerField() # Admin interface cho internal users

5. Educational Platforms

Learning management systems:

class Course(models.Model):    title = models.CharField(max_length=200)    instructor = models.ForeignKey(User, on_delete=models.CASCADE)    students = models.ManyToManyField(User, related_name='enrolled_courses') class Lesson(models.Model):    course = models.ForeignKey(Course, on_delete=models.CASCADE)    title = models.CharField(max_length=200)    video = models.FileField()    order = models.IntegerField() class Progress(models.Model):    student = models.ForeignKey(User, on_delete=models.CASCADE)    lesson = models.ForeignKey(Lesson, on_delete=models.CASCADE)    completed = models.BooleanField(default=False)

Django KHÔNG Phù Hợp Với

1. Real-time Applications

WebSocket-heavy apps (chat, gaming):

❌ Django không native async
✅ Dùng: Node.js, FastAPI with WebSockets

2. Microservices Architecture

Distributed systems với nhiều services nhỏ:

❌ Django quá heavy cho microservices
✅ Dùng: Flask, FastAPI, Go, Node.js

3. Static Websites

Landing pages, portfolios đơn giản:

❌ Overhead không cần thiết
✅ Dùng: Static site generators (Hugo, Jekyll)

4. CPU-Intensive Tasks

Video processing, data analysis:

❌ Python không phải lựa chọn tốt
✅ Dùng: Go, Rust, C++, với Python làm orchestrator

5. Mobile Backend Chỉ API

Nếu chỉ cần API không có web interface:

❌ Django có nhiều features không dùng
✅ Dùng: FastAPI, Flask-RESTful

Decision Matrix

Project Size: Small → Medium → Large           Flask    Django    Django           API Only?  Yes → FastAPI/Flask  No  → Django Need Admin?  Yes → Django  No  → Flask/FastAPI Team Size: 1-2 → 3-5 → 5+          Flask  Django Django Timeline: Quick → Standard → Long         Flask   Django   Django

Bài Tập

Bài 1: Research Questions

Tìm hiểu 3 websites lớn sử dụng Django và list các features họ sử dụng
So sánh performance Django vs FastAPI cho API endpoints
Research Django REST Framework và khi nào nên dùng

Bài 2: Analysis

Phân tích các scenarios sau nên dùng framework nào:

Startup MVP: Social network cho students
E-commerce: Online bookstore với 1000+ products
API Service: Weather data API cho mobile app
Corporate Tool: Internal HR management system
Real-time App: Multiplayer game backend

Bài 3: Exploration

Visit Django official website và explore documentation
Xem Django admin demo tại: https://demo.django-admin.org/
Clone một Django starter project và chạy thử

Tài Liệu Tham Khảo

Official Resources

Books

Django for Beginners by William S. Vincent
Two Scoops of Django by Daniel Roy Greenfeld
Django for Professionals by William S. Vincent

Online Courses

Django for Everybody (Coursera)
Python Django - The Practical Guide (Udemy)
Django 4 and Python Full-Stack Developer Masterclass

Communities

Useful Links

Next: Bài 02: Django Installation và Setup

#mvt

Giới Thiệu Django