Hướng dẫn cách tạo các Models trong Django đơn giản

Trong bài viết này, Vietnix sẽ giới thiệu về Django hay cụ thể hơn là thành phần Model của Django. Với các Models, bạn sẽ có thể dễ dàng tương tác với dữ liệu trong database, giúp quá trình phát triển ứng dụng được thuận tiện và nhanh hơn nhiều lần.

Giới thiệu về Models

Model trong mô hình MVC (Model – View – Controller) là một thành phần rất quan trọng và không thể thiếu được nếu chúng ta muốn phát triển một ứng dụng hay một trang web nào đó.

Model là thành phần giúp chúng ta map dữ liệu từ trên ứng dụng Django của mình với dữ liệu được lưu trong cơ sở dữ liệu. Trong bài hướng dẫn này, Vietnix sẽ giới thiệu về Models và cách tạo các Models trong Django, hay cụ thể hơn là ORM (Object Relational Mapping), cái được sử dùng để tạo ra và tương tác vơi các bảng trong cơ sở dữ liệu.

Yêu cầu tiên quyết để tạo các Models trong Django

Để thực hiện theo hướng dẫn, các bạn cần phải chuẩn bị trước những yêu cầu sau:

• Django phiên bản 4 hoặc cao hơn.
• Ứng dụng Django của các bạn đã kết nối với một cơ sở dữ liệu, ở đây sử dụng MySQL.
• Hệ điều hành Unix-based, khuyến khích nên sử dụng Ubuntu 20.04.

Nếu app Django của các bạn có cách setup hơi khác so với bài hướng dẫn này thì cũng không cần phải lo lắng, bởi vì hướng dẫn này chủ yếu xử lý với các Model mà thôi.

Nếu bạn đang có nhu cầu phát triển ứng dụng hay website trên Django thì bạn cần phải có một máy chủ có cấu hình mạnh mẽ, hỗ trợ nhiều ngôn ngữ và hệ điều hành. Hiện tại, các gói VPS tốc độ cao do Vietnix cung cấp có cấu hình đa dạng, mức phí phải chăng, dễ dàng mở rộng và hỗ trợ đa dạng hệ điều hành có thể giúp bạn triển khai ứng dụng Django hiệu quả. Liên hệ để được tư vấn chi tiết.

Các bước tiến hành

Bước 1: Tạo ứng dụng Django

Bạn sẽ khởi tạo ứng dụng Django bên trong project nơi chứa tất cả các files cần thiết để làm một trang blog, để tuân thủ theo convention hay cách tổ chức các module của Django.

Bất cứ khi nào làm việc với Python và Django, bạn nên kích hoạt môi trường ảo Python và di chuyển vào thư mục gốc của ứng dụng. Hãy nhập các lệnh sau để thực hiện những điều vừa nói trên.

cd ~/my_blog_app
. env/bin/activate
cd blog

Từ đây, hãy chạy lệnh:

python manage.py startapp blogsite

Lệnh trên sẽ tạo ra ứng dụng kèm theo một thư mục tên blogsite.

Theo những gì đã setup, thì đến đây cấu trúc thư mục cho project sẽ tương tự như sau.

my_blog_app/
└── blog
    ├── blog
    │   ├── __init__.py
    │   ├── __pycache__
    │   │   ├── __init__.cpython-38.pyc
    │   │   ├── settings.cpython-38.pyc
    │   │   ├── urls.cpython-38.pyc
    │   │   └── wsgi.cpython-38.pyc
    │   ├── asgi.py
    │   ├── settings.py
    │   ├── urls.py
    │   └── wsgi.py
    ├── blogsite
    │   ├── __init__.py
    │   ├── admin.py
    │   ├── apps.py
    │   ├── migrations
    │   │   └── __init__.py
    │   ├── models.py
    │   ├── tests.py
    │   └── views.py
    └── manage.py

Bài hướng dẫn này sẽ tập trung vào file models.py nằm bên trong thư mục blogsite.

Bước 2: Thêm Posts Model

Đầu tiên, bạn cần mở và chỉnh sửa file models.py để thêm vào phần code khởi tạo Post model. Post model sẽ chứa các trường trong database như sau:

• title: Tựa đề của bài post trên blog.
• slug: URL hợp lệ cho trang web.
• content: Nội dung ở dạng text của bài post.
• created on: Ngày tháng bài post được tạo.
• author: Tác giả của bài post

Sau đó bạn sẽ di chuyển vào thư mục chứa file models.py.

cd ~/my_blog_app/blog/blogsite

Sử dụng lệnh cat để hiển thị nội dung hiện có trong file models.py lên trên terminal.

cat models.py

Trong file sẽ có những dòng code sau, đầu tiên là một dòng import models và sau đó là một comment miêu tả những gì nên được viết bên trong file này.

from django.db import models

# Create your models here.

Sử dụng text editor tùy ý, thêm dòng code tiếp theo vào file models.py. Ở đây, sử dụng nano text editor, nhưng các bạn có thể sử dụng bất kì editor nào các bạn muốn.

nano models.py

Trong file này, dòng code để import API của models đã được thêm sẵn, vì thế bạn có thể xóa dòng comment đi. Sau đó import slugify để tạo các slugs từ strings, User của Django cho việc xác thực và reverse từ django.urls để giúp khởi tạo các URLs một cách linh hoạt.

from django.db import models
from django.template.defaultfilters import slugify
from django.contrib.auth.models import User
from django.urls import reverse

Sau đó, thêm các phương thức cho class model Post, với các trường trong database như đã được đề cập trước ở trên như title, slug, content, created_on và author.

Thêm những dòng code sau phía dưới các lệnh import.

# import statements ...

class Post(models.Model):
    title = models.CharField(max_length=255)
    slug = models.SlugField(unique=True, max_length=255)
    content = models.TextField()
    created_on = models.DateTimeField(auto_now_add=True)
    author = models.TextField()

Tiếp theo, bạn sẽ thêm hàm cho việc tạo ra các URL và hàm để lưu bài post lại. Điều này rất quan trọng, vì sẽ tạo ra các đường dẫn unique (duy nhất) đến từng bài post.

...
    def get_absolute_url(self):
        return reverse('blog_post_detail', args=[self.slug])

    def save(self, *args, **kwargs):
        if not self.slug:
            self.slug = slugify(self.title)
        super(Post, self).save(*args, **kwargs)

Bây giờ, bạn cần phải cho model biết cách để sắp xếp và hiển thị những bài post lên trang web. Để triển khai logic cho việc này, bạn sẽ tạo ra thêm một class nằm bên trong class model gọi là Meta. Class Meta này chủ yếu chứa các logic quan trọng khác không liên quan nhiều đến phần database.

...
    class Meta:
        ordering = ['created_on']

        def __unicode__(self):
            return self.title

Cuối cùng thêm Comment model vào file này. Khác với Post model đã có, Comment model này sẽ nhận tham số là models.Models như là signature và có các trường thông tin sau:

• name: Tên của người gửi comment.
• email: Địa chỉ email của người gửi comment.
• text: Nội dung dạng text của comment.
• post: Bài post nơi comment được tạo.
• created_on: Thời gian lúc comment được tạo.

...
class Comment(models.Model):
    name = models.CharField(max_length=42)
    email = models.EmailField(max_length=75)
    website = models.URLField(max_length=200, null=True, blank=True)
    content = models.TextField()
    post = models.ForeignKey(Post, on_delete=models.CASCADE)
    created_on = models.DateTimeField(auto_now_add=True)

Đến đây, file models.py của bạn được hoàn thành. Bản đầy đủ của file như sau:

from django.db import models
from django.template.defaultfilters import slugify
from django.contrib.auth.models import User
from django.urls import reverse


class Post(models.Model):
    title = models.CharField(max_length=255)
    slug = models.SlugField(unique=True, max_length=255)
    content = models.TextField()
    created_on = models.DateTimeField(auto_now_add=True)
    author = models.TextField()

    def get_absolute_url(self):
        return reverse('blog_post_detail', args=[self.slug])
    
    def save(self, *args, **kwargs):
        if not self.slug:
            self.slug = slugify(self.title)
        super(Post, self).save(*args, **kwargs)

    class Meta:
        ordering = ['created_on']

        def __unicode__(self):
            return self.title


class Comment(models.Model):
    name = models.CharField(max_length=42)
    email = models.EmailField(max_length=75)
    website = models.URLField(max_length=200, null=True, blank=True)
    content = models.TextField()
    post = models.ForeignKey(Post, on_delete=models.CASCADE)
    created_on = models.DateTimeField(auto_now_add=True)

Hãy lưu và đóng file lại. Nếu các bạn đang sử dụng nano thì có thể nhấn CTRL + X, sau đó Y và ENTER.

Sau khi hoàn thành file models.py, tiếp theo ta sẽ tiến hành việc cập nhật lại file settings.py.

Bước 3: Cập nhật Settings

Sau khi đã thêm model mới vào ứng dụng của mình, bạn cần thông báo cho project biết về ứng dụng blogsite mới được thêm. Bạn sẽ thông báo bằng cách thêm blogsite app đó vào mục INSTALLED_APPS bên trong settings.py.

Di chuyển tới thư mục có chứa settings.py.

cd ~/my_blog_app/blog/blog

Từ đây hãy mở file settings.py bằng text editor tùy ý. Trong bài bài hướng dẫn này sử dụng nano.

nano settings.py

Sau khi mở file, hãy thêm ứng dụng blogsite vào mục INSTALLED_APPS trong file như hình bên dưới.

# Application definition
INSTALLED_APPS = [
    'blogsite',
    'django.contrib.admin',
    'django.contrib.auth',
    'django.contrib.contenttypes',
    'django.contrib.sessions',
    'django.contrib.messages',
    'django.contrib.staticfiles',
]

Sau khi thêm blogsite vào, hãy lưu và đóng file lại.

Vào thời điểm này, chúng ta đã có thể apply những sự thay đổi này vào project của mình.

Bước 4: Thực hiện Migrations

Với model Post và Comment đã được tạo, bước tiếp theo là apply những thay đổi đó để schema của MySQL nhận biết và tạo ra các bảng tương ứng.

Đầu tiên, bạn phải gom các model đã qua chỉnh sửa của mình vào những file migrations bằng lệnh makemigrations. Những file này cũng tương tự như các commits trong các hệ thống Version Control như Git.

Bây giờ, hãy di chuyển vào ~/my_blog_app/blog/blogsite/migrations và chạy lệnh ls, bạn sẽ thấy rằng chỉ có mỗi file __init__.py. File này sẽ thay đổi khi thêm các migrations.

Di chuyển vào thư mục blog bằng lệnh cd như sau:

cd ~/my_blog_app/blog

Sau đó chạy lệnh makemigrations trên file manage.py

python manage.py makemigrations

Các bạn sẽ nhận được Ouput tương tự như bên dưới:

Output
Migrations for 'blogsite':
  blogsite/migrations/0001_initial.py
    - Create model Post
    - Create model Comment

Ở trên, khi bạn di chuyển vào /~/my_blog_app/blog/blogsite/migrations và ở đó chỉ có mỗi file __init__.py. Nếu bây giờ, bạn quay lại thư mục đó bằng lênh “cd”, sẽ thấy có thêm hai items mới vừa được thêm vào: __pycache__ và 0001_initial.py. File 0001_initial.py sẽ được tự động tạo khi chạy makemigrations. Và sẽ có mỗi file tương tự như vậy được tạo ra khi chạy makemigrations.

Nếu các bạn muốn xem bên trong file đó có chứa thông tin gì, hãy chạy lệnh less 0001_initial.py.

Bây giờ, hãy quay trở lại ~/my_blog_app/blog:

cd ~/my_blog_app/blog

Trước khi apply những thay đổi của file migrations bằng lệnh migrate, bạn nên kiểm tra thử xem hiện đang có những migrations nào bằng lệnh showmigrations

python manage.py showmigrations

Output
admin
 [X] 0001_initial
 [X] 0002_logentry_remove_auto_add
 [X] 0003_logentry_add_action_flag_choices
auth
 [X] 0001_initial
 [X] 0002_alter_permission_name_max_length
 [X] 0003_alter_user_email_max_length
 [X] 0004_alter_user_username_opts
 [X] 0005_alter_user_last_login_null
 [X] 0006_require_contenttypes_0002
 [X] 0007_alter_validators_add_error_messages
 [X] 0008_alter_user_username_max_length
 [X] 0009_alter_user_last_name_max_length
 [X] 0010_alter_group_name_max_length
 [X] 0011_update_proxy_permissions
blogsite
 [ ] 0001_initial
contenttypes
 [X] 0001_initial
 [X] 0002_remove_content_type_name
sessions
 [X] 0001_initial

Các bạn sẽ để ý thấy rằng tất cả các migrations khác đều đã được đánh dấu [X] (đã được apply) riêng chỉ có 0001_initial là chưa, cái mà chúng ta vừa tạo cho model Post và Comment.

Ngoài ra trước khi tiến hành migration bạn có thể kiểm tra xem câu lệnh truy vấn SQL nào sẽ được thực thi vào lúc migration bằng câu lệnh sqlmigrate, lệnh này nhận hai tham số là migration và tiêu đề của migration đó:

python manage.py sqlmigrate blogsite 0001_initial

Dưới đây là câu lệnh SQL sẽ được thực thi khi tiến hành migration.

Output
--
-- Create model Post
--
CREATE TABLE `blogsite_post` (`id` integer AUTO_INCREMENT NOT NULL PRIMARY KEY, `title` varchar(255) NOT NULL, `slug` varchar(255) NOT NULL UNIQUE, `content` longtext NOT NULL, `created_on` datetime(6) NOT NULL, `author` longtext NOT NULL);
--
-- Create model Comment
--
CREATE TABLE `blogsite_comment` (`id` integer AUTO_INCREMENT NOT NULL PRIMARY KEY, `name` varchar(42) NOT NULL, `email` varchar(75) NOT NULL, `website` varchar(200) NULL, `content` longtext NOT NULL, `created_on` datetime(6) NOT NULL, `post_id` integer NOT NULL);
ALTER TABLE `blogsite_comment` ADD CONSTRAINT `blogsite_comment_post_id_de248bfe_fk_blogsite_post_id` FOREIGN KEY (`post_id`) REFERENCES `blogsite_post` (`id`);

Sau khi đã kiểm tra câu lệnh truy vấn, ta sẽ tiến hành thực hiện migration để database tạo ra các bảng tương ứng với hai model Post và Comment vừa tạo.

python manage.py migrate

Dưới đây là kết quả sau khi migration.

Output
Operations to perform:
  Apply all migrations: admin, auth, blogsite, contenttypes, sessions
Running migrations:
  Applying blogsite.0001_initial... OK

Như vậy là các bạn đã thực hiện migration thành công.

Theo tài liệu của Django, có ba điều cần lưu ý khi làm việc với Django migration với MySQL mà bạn cần nắm đó là:

• Không có sự hỗ trợ về rollback transaction. Hay nói cách khác khi thất bại trong việc tiến hành migration, bạn cần phải tự thay đổi hay sửa lỗi để có thể khôi phục lại trạng thái của database trước khi migration.
• Hầu hết các thao tác thay thế trên schema, MySQL sẽ viết lại hoàn toàn những bảng đó. Trong trường hợp tệ nhất, độ phức tạp về thời gian của thao tác sẽ tỉ lệ thuận với số lượng hàng trong bảng để có thể thêm hoặc xóa các cột theo điều chỉnh. Theo tài liệu của Django, điều này có thể sẽ diễn ra với tốc độ khoảng một phút trên một triệu dòng.
• Trong MySQL, sẽ có giới hạn về kích thước của chiều dài tên của cột, bảng và các chỉ mục (index). Và cũng có giới hạn kích thước kết hợp của các cột và index covers. Tuy nhiên, một vài backend thì lại có thể hỗ trợ ở môt khoảng giới hạn cao hơn như trong Django, có thể sẽ làm cho việc migration bị thất bại.

Vì vậy, khi chọn database sử dụng chung với Django, các bạn nên xem xét kĩ các yếu tố trên về cả những điểm tốt và điểm hạn chế.

Bước 5: Xác nhận Schema trong Database

Sau khi hoàn thành migration, bạn nên xác minh lại các bảng tương ứng với models trong Django đã được tạo thành công trong MySQL hay chưa.

Để xác minh điều đó, ta sẽ chạy các lệnh sau để có thể đăng nhập vào MySQL. Ở đây, bạn sử dụng user có tên là djangouser.

mysql blog_data -u djangouser

Tiếp theo, chọn database là blog_data. Nếu các bạn không nhớ được tên database mà mình đang sử dụng thì có thể dùng lệnh SHOW DATABASE; trong SQL.

USE blog_data;

Sau đó dùng lệnh sau để xem tất cả các bảng có trong database đang sử dụng.

SHOW TABLES;

Câu truy vấn trên sẽ cho ra kết quả như sau:

Output
+----------------------------+
| Tables_in_blog_data        |
+----------------------------+
| auth_group                 |
| auth_group_permissions     |
| auth_permission            |
| auth_user                  |
| auth_user_groups           |
| auth_user_user_permissions |
| blogsite_comment           |
| blogsite_post              |
| django_admin_log           |
| django_content_type        |
| django_migrations          |
| django_session             |
+----------------------------+
12 rows in set (0.01 sec)

Trong các bảng trên có blogsite_comment và blogsite_post – chính là những model mà chúng ta đã tạo ra trên Django. Tiếp theo, hãy kiểm tra những bảng đó chứa các cột gì.

DESCRIBE blogsite_comment;

Output
+------------+--------------+------+-----+---------+----------------+
| Field      | Type         | Null | Key | Default | Extra          |
+------------+--------------+------+-----+---------+----------------+
| id         | int          | NO   | PRI | NULL    | auto_increment |
| name       | varchar(42)  | NO   |     | NULL    |                |
| email      | varchar(75)  | NO   |     | NULL    |                |
| website    | varchar(200) | YES  |     | NULL    |                |
| content    | longtext     | NO   |     | NULL    |                |
| created_on | datetime(6)  | NO   |     | NULL    |                |
| post_id    | int          | NO   | MUL | NULL    |                |
+------------+--------------+------+-----+---------+----------------+
7 rows in set (0.00 sec)

DESCRIBE blogsite_post;

Output
+------------+--------------+------+-----+---------+----------------+
| Field      | Type         | Null | Key | Default | Extra          |
+------------+--------------+------+-----+---------+----------------+
| id         | int          | NO   | PRI | NULL    | auto_increment |
| title      | varchar(255) | NO   |     | NULL    |                |
| slug       | varchar(255) | NO   | UNI | NULL    |                |
| content    | longtext     | NO   |     | NULL    |                |
| created_on | datetime(6)  | NO   |     | NULL    |                |
| author     | longtext     | NO   |     | NULL    |                |
+------------+--------------+------+-----+---------+----------------+
6 rows in set (0.00 sec)

Đến đây thì ta thấy được rằng, các bảng trên đã được khởi tạo thành công trong khi migration và tương ứng với các models mà ta đã miêu tả.

Cuối cùng, nếu muốn đóng MySQL lại các bạn có thể nhấn CTRL + D. Và sau đó để thoát khỏi môi trường ảo của Python, ta có thể nhập lệnh deactivate như sau:

deactivate

Tắt môi trường ảo đi sẽ đưa chúng ta trở lại với terminal bình thường của mình.

Lời kết

Trong bài này, bạn đã được hướng dẫn thêm cách tạo các models trong Django với những chức năng cơ bản cho một trang blog cũng như cách để code một model, migration và quá trình chuyển đổi các Django models sang các bảng bên MySQL. Nếu có gì thắc mắc các bạn có thể để lại comment bên dưới nhé và hẹn gặp lại các bạn trong những bài viết tiếp theo.