[ Better ] Modules vs Services và 4 bước cấu trúc modules

Trong Flask, việc xây dựng ứng dụng có thể được thực hiện thông qua việc tổ chức mã nguồn thành các modules hoặc xây dựng services.
Cả hai cách tiếp cận này đều có những ưu điểm riêng về tính linh hoạt, và lựa chọn giữa chúng phụ thuộc vào quy mô và yêu cầu cụ thể của dự án.
Dưới đây là so sánh chi tiết giữa hai cách tiếp cận này:

Xây dựng Modules trong Flask

Ưu điểm:

Phân tách rõ ràng các thành phần: Mỗi module có thể chịu trách nhiệm cho một phần cụ thể của ứng dụng, chẳng hạn như một module cho xử lý người dùng, một module cho xử lý sản phẩm, v.v.
Tái sử dụng mã nguồn: Các module có thể được tách riêng và tái sử dụng trong các dự án khác.
Quản lý dễ dàng hơn: Việc quản lý và bảo trì mã nguồn trở nên dễ dàng hơn do cấu trúc rõ ràng và phân chia nhiệm vụ cụ thể.
Phù hợp với ứng dụng nhỏ đến trung bình: Cách tiếp cận này thường hiệu quả với các ứng dụng không quá phức tạp.

Nhược điểm:

Giới hạn trong phân tách dịch vụ: Dù phân tách các thành phần nhưng tất cả vẫn chạy trong cùng một ứng dụng Flask duy nhất.
Khó mở rộng: Khi ứng dụng trở nên phức tạp, việc quản lý và mở rộng các module có thể gặp khó khăn.

Xây dựng Services trong Flask (Microservices)

Ưu điểm:

Phân tách dịch vụ: Mỗi service là một ứng dụng Flask riêng biệt, có thể triển khai, bảo trì và mở rộng độc lập.
Mở rộng linh hoạt: Dễ dàng mở rộng từng service mà không ảnh hưởng đến toàn bộ hệ thống.
Phù hợp với ứng dụng lớn: Cách tiếp cận này lý tưởng cho các ứng dụng phức tạp và lớn, yêu cầu khả năng mở rộng cao.

Nhược điểm:

Độ phức tạp cao: Việc quản lý nhiều service đòi hỏi kiến thức về các công cụ và kỹ thuật triển khai phức tạp, chẳng hạn như Docker, Kubernetes, v.v.
Tốn kém tài nguyên: Việc chạy nhiều dịch vụ đồng thời có thể tốn kém về tài nguyên máy chủ và cần phải có cơ sở hạ tầng phù hợp.
Giao tiếp giữa các dịch vụ: Cần phải quản lý giao tiếp giữa các dịch vụ, đảm bảo độ tin cậy và hiệu suất cao.

Kết luận

Modules: Phù hợp cho các dự án nhỏ đến trung bình, với ưu điểm là dễ quản lý và bảo trì mã nguồn.
Services: Phù hợp cho các dự án lớn, phức tạp, yêu cầu khả năng mở rộng cao và phân tách dịch vụ độc lập.

Tóm lại, lựa chọn giữa xây dựng modules hay services trong Flask phụ thuộc vào quy mô, yêu cầu và mục tiêu của dự án cụ thể.
Nếu bạn mới bắt đầu hoặc làm việc với một ứng dụng nhỏ, việc sử dụng modules có thể là lựa chọn tốt hơn.
Ngược lại, nếu bạn đang xây dựng một hệ thống lớn với yêu cầu mở rộng cao, việc phân chia thành các services sẽ mang lại nhiều lợi ích hơn.

Modules vs Services và 4 bước cấu trúc modules

Dưới đây là một ví dụ về cách tổ chức mã nguồn của ứng dụng Flask theo mô hình modules.
Giả sử bạn đang xây dựng một ứng dụng web quản lý người dùng và bài viết.
Chúng ta sẽ tạo ra hai module chính: users và posts.

Cấu trúc Thư mục

my_flask_app/
|-- app.py
|-- config.py
|-- requirements.txt
|-- run.py
|-- users/
|   |-- __init__.py
|   |-- models.py
|   |-- routes.py
|   |-- forms.py
|   |-- templates/
|       |-- users/
|           |-- register.html
|           |-- login.html
|-- posts/
|   |-- __init__.py
|   |-- models.py
|   |-- routes.py
|   |-- forms.py
|   |-- templates/
|       |-- posts/
|           |-- create_post.html
|           |-- post.html
|-- templates/
    |-- base.html

Nội dung các tệp mã nguồn

app.py

from flask import Flask
from config import Config

def create_app():
    app = Flask(__name__)
    app.config.from_object(Config)
    
    from users.routes import users
    from posts.routes import posts
    
    app.register_blueprint(users, url_prefix='/users')
    app.register_blueprint(posts, url_prefix='/posts')
    
    return app

config.py

class Config:
    SECRET_KEY = 'your_secret_key'
    SQLALCHEMY_DATABASE_URI = 'sqlite:///site.db'

run.py

from app import create_app

app = create_app()

if __name__ == '__main__':
    app.run(debug=True)

users/init.py

# users module initialization

users/models.py

from flask_sqlalchemy import SQLAlchemy

db = SQLAlchemy()

class User(db.Model):
    id = db.Column(db.Integer, primary_key=True)
    username = db.Column(db.String(20), unique=True, nullable=False)
    email = db.Column(db.String(120), unique=True, nullable=False)
    password = db.Column(db.String(60), nullable=False)

users/routes.py

from flask import Blueprint, render_template

users = Blueprint('users', __name__)

@users.route('/register')
def register():
    return render_template('users/register.html')

@users.route('/login')
def login():
    return render_template('users/login.html')

posts/init.py

# posts module initialization

posts/models.py

from flask_sqlalchemy import SQLAlchemy
from datetime import datetime

db = SQLAlchemy()

class Post(db.Model):
    id = db.Column(db.Integer, primary_key=True)
    title = db.Column(db.String(100), nullable=False)
    date_posted = db.Column(db.DateTime, nullable=False, default=datetime.utcnow)
    content = db.Column(db.Text, nullable=False)
    user_id = db.Column(db.Integer, db.ForeignKey('user.id'), nullable=False)

posts/routes.py

from flask import Blueprint, render_template

posts = Blueprint('posts', __name__)

@posts.route('/new')
def new_post():
    return render_template('posts/create_post.html')

@posts.route('/<int:post_id>')
def post(post_id):
    return render_template('posts/post.html')

Templates

templates/base.html

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <title>Flask App</title>
</head>
<body>
    <nav>
        <a href="/">Home</a>
        <a href="/users/register">Register</a>
        <a href="/users/login">Login</a>
        <a href="/posts/new">New Post</a>
    </nav>
    <div>
        {% block content %}{% endblock %}
    </div>
</body>
</html>

templates/users/register.html

{% extends "base.html" %}
{% block content %}
<h2>Register</h2>
<!-- Registration form here -->
{% endblock %}

{% extends "base.html" %}
{% block content %}
<h2>Login</h2>
<!-- Login form here -->
{% endblock %}

templates/posts/create_post.html

{% extends "base.html" %}
{% block content %}
<h2>Create a New Post</h2>
<!-- Post creation form here -->
{% endblock %}

templates/posts/post.html

{% extends "base.html" %}
{% block content %}
<h2>Post</h2>
<!-- Post content here -->
{% endblock %}

Giải thích

Cấu trúc thư mục: Chúng ta có hai module chính users và posts, mỗi module chứa các thành phần riêng như models, routes, forms và templates.
app.py: Đây là nơi chúng ta tạo ứng dụng Flask và đăng ký các blueprint.
config.py: Chứa cấu hình ứng dụng.
run.py: Điểm khởi động của ứng dụng.
Models: Định nghĩa các mô hình cơ sở dữ liệu cho người dùng và bài viết.
Routes: Định nghĩa các đường dẫn (routes) cho các module người dùng và bài viết.
Templates: Chứa các file HTML được sử dụng để render các trang web.

Cách tổ chức này giúp mã nguồn trở nên rõ ràng, dễ quản lý và mở rộng khi ứng dụng phát triển.

Để sử dụng các modules users và posts trong ứng dụng Flask, bạn cần thực hiện các bước sau để khởi tạo và chạy ứng dụng.
Dưới đây là hướng dẫn chi tiết về cách thực hiện điều đó.

Bước 1: Tạo Cơ sở Dữ liệu và Khởi Tạo Flask App

Cập nhật app.py để bao gồm SQLAlchemy và tạo cơ sở dữ liệu:

from flask import Flask
from flask_sqlalchemy import SQLAlchemy
from config import Config

db = SQLAlchemy()

def create_app():
    app = Flask(__name__)
    app.config.from_object(Config)
    
    db.init_app(app)
    
    from users.routes import users
    from posts.routes import posts
    
    app.register_blueprint(users, url_prefix='/users')
    app.register_blueprint(posts, url_prefix='/posts')
    
    return app

Cập nhật models trong users/models.py và posts/models.py để sử dụng chung SQLAlchemy instance:

from flask_sqlalchemy import SQLAlchemy

db = SQLAlchemy()

class User(db.Model):
    id = db.Column(db.Integer, primary_key=True)
    username = db.Column(db.String(20), unique=True, nullable=False)
    email = db.Column(db.String(120), unique=True, nullable=False)
    password = db.Column(db.String(60), nullable=False)
    posts = db.relationship('Post', backref='author', lazy=True)

from datetime import datetime
from users.models import db, User

class Post(db.Model):
    id = db.Column(db.Integer, primary_key=True)
    title = db.Column(db.String(100), nullable=False)
    date_posted = db.Column(db.DateTime, nullable=False, default=datetime.utcnow)
    content = db.Column(db.Text, nullable=False)
    user_id = db.Column(db.Integer, db.ForeignKey('user.id'), nullable=False)

Thêm init.py trong thư mục gốc để tránh lỗi ImportError:

# __init__.py

Bước 2: Khởi Tạo Cơ sở Dữ liệu

Tạo một tệp create_db.py để khởi tạo cơ sở dữ liệu:

from app import create_app, db

app = create_app()

with app.app_context():
    db.create_all()

Chạy tập tin create_db.py để tạo cơ sở dữ liệu:

python create_db.py

Bước 3: Chạy Ứng Dụng

Chạy tệp run.py để khởi động ứng dụng Flask:

python run.py

Bước 4: Sử Dụng Ứng Dụng

Bây giờ, bạn có thể truy cập vào các đường dẫn mà bạn đã định nghĩa trong các modules users và posts.

Truy cập đường dẫn /users/register để hiển thị trang đăng ký người dùng.
Truy cập đường dẫn /users/login để hiển thị trang đăng nhập người dùng.
Truy cập đường dẫn /posts/new để tạo một bài viết mới.
Truy cập đường dẫn /posts/ để hiển thị nội dung của một bài viết cụ thể.

Tóm Tắt

Bằng cách tổ chức mã nguồn theo mô hình modules, bạn có thể quản lý mã nguồn một cách rõ ràng và dễ mở rộng.
Các bước chính bao gồm:

Cấu hình và khởi tạo ứng dụng Flask với các modules.
Định nghĩa các mô hình cơ sở dữ liệu và tạo cơ sở dữ liệu.
Đăng ký các blueprint của các modules.
Chạy ứng dụng và sử dụng các đường dẫn đã định nghĩa.

Cấu trúc và tổ chức như trên giúp bạn dễ dàng mở rộng ứng dụng trong tương lai bằng cách thêm các modules mới hoặc cải tiến các modules hiện tại.

Khi các modules phụ thuộc vào nhau trong Flask, việc quản lý và sử dụng các dependencies này cần được thực hiện một cách cẩn thận để tránh các vấn đề về vòng lặp (circular imports).
Dưới đây là một số kỹ thuật để xử lý dependencies giữa các modules users và posts:

1. Sử Dụng Flask Application Context

Bạn có thể sử dụng Flask application context để truy cập các dependencies trong các modules khác nhau mà không cần phải import trực tiếp.
Điều này giúp tránh các vấn đề về vòng lặp.

Cấu trúc Thư mục:

my_flask_app/
|-- app.py
|-- config.py
|-- requirements.txt
|-- run.py
|-- users/
|   |-- __init__.py
|   |-- models.py
|   |-- routes.py
|   |-- forms.py
|   |-- templates/
|       |-- users/
|           |-- register.html
|           |-- login.html
|-- posts/
|   |-- __init__.py
|   |-- models.py
|   |-- routes.py
|   |-- forms.py
|   |-- templates/
|       |-- posts/
|           |-- create_post.html
|           |-- post.html
|-- templates/
    |-- base.html

app.py

from flask import Flask
from flask_sqlalchemy import SQLAlchemy
from config import Config

db = SQLAlchemy()

def create_app():
    app = Flask(__name__)
    app.config.from_object(Config)
    
    db.init_app(app)
    
    from users.routes import users
    from posts.routes import posts
    
    app.register_blueprint(users, url_prefix='/users')
    app.register_blueprint(posts, url_prefix='/posts')
    
    with app.app_context():
        from users.models import User
        from posts.models import Post
        db.create_all()
    
    return app

users/models.py

from app import db

class User(db.Model):
    id = db.Column(db.Integer, primary_key=True)
    username = db.Column(db.String(20), unique=True, nullable=False)
    email = db.Column(db.String(120), unique=True, nullable=False)
    password = db.Column(db.String(60), nullable=False)
    posts = db.relationship('Post', backref='author', lazy=True)

posts/models.py

from app import db
from datetime import datetime

class Post(db.Model):
    id = db.Column(db.Integer, primary_key=True)
    title = db.Column(db.String(100), nullable=False)
    date_posted = db.Column(db.DateTime, nullable=False, default=datetime.utcnow)
    content = db.Column(db.Text, nullable=False)
    user_id = db.Column(db.Integer, db.ForeignKey('user.id'), nullable=False)

users/routes.py

from flask import Blueprint, render_template
from .models import User
from posts.models import Post  # Import Post model

users = Blueprint('users', __name__)

@users.route('/register')
def register():
    return render_template('users/register.html')

@users.route('/login')
def login():
    return render_template('users/login.html')

@users.route('/user/<int:user_id>')
def user_posts(user_id):
    user = User.query.get_or_404(user_id)
    posts = Post.query.filter_by(user_id=user_id).all()
    return render_template('users/user_posts.html', user=user, posts=posts)

posts/routes.py

from flask import Blueprint, render_template
from .models import Post
from users.models import User  # Import User model

posts = Blueprint('posts', __name__)

@posts.route('/new')
def new_post():
    return render_template('posts/create_post.html')

@posts.route('/<int:post_id>')
def post(post_id):
    post = Post.query.get_or_404(post_id)
    return render_template('posts/post.html', post=post)

@posts.route('/author/<int:author_id>')
def author_posts(author_id):
    author = User.query.get_or_404(author_id)
    posts = Post.query.filter_by(user_id=author_id).all()
    return render_template('posts/author_posts.html', author=author, posts=posts)

2. Sử Dụng Lazy Imports

Một kỹ thuật khác để tránh vòng lặp là sử dụng lazy imports, tức là chỉ import khi cần thiết trong một hàm hoặc một phương thức thay vì ở đầu tệp.

Ví dụ với users/routes.py

from flask import Blueprint, render_template

users = Blueprint('users', __name__)

@users.route('/register')
def register():
    return render_template('users/register.html')

@users.route('/login')
def login():
    return render_template('users/login.html')

@users.route('/user/<int:user_id>')
def user_posts(user_id):
    from .models import User
    from posts.models import Post
    user = User.query.get_or_404(user_id)
    posts = Post.query.filter_by(user_id=user_id).all()
    return render_template('users/user_posts.html', user=user, posts=posts)

Ví dụ với posts/routes.py

from flask import Blueprint, render_template

posts = Blueprint('posts', __name__)

@posts.route('/new')
def new_post():
    return render_template('posts/create_post.html')

@posts.route('/<int:post_id>')
def post(post_id):
    from .models import Post
    post = Post.query.get_or_404(post_id)
    return render_template('posts/post.html', post=post)

@posts.route('/author/<int:author_id>')
def author_posts(author_id):
    from users.models import User
    from .models import Post
    author = User.query.get_or_404(author_id)
    posts = Post.query.filter_by(user_id=author_id).all()
    return render_template('posts/author_posts.html', author=author, posts=posts)

3. Tạo Một Module Riêng Cho Models

Một phương pháp khác là tạo một module riêng cho các models để chúng có thể được chia sẻ dễ dàng giữa các modules khác nhau mà không gây ra vấn đề về vòng lặp.

Cấu trúc Thư mục:

my_flask_app/
|-- app.py
|-- config.py
|-- requirements.txt
|-- run.py
|-- models.py
|-- users/
|   |-- __init__.py
|   |-- routes.py
|   |-- forms.py
|   |-- templates/
|       |-- users/
|           |-- register.html
|           |-- login.html
|-- posts/
|   |-- __init__.py
|   |-- routes.py
|   |-- forms.py
|   |-- templates/
|       |-- posts/
|           |-- create_post.html
|           |-- post.html
|-- templates/
    |-- base.html

models.py

from flask_sqlalchemy import SQLAlchemy

db = SQLAlchemy()

class User(db.Model):
    id = db.Column(db.Integer, primary_key=True)
    username = db.Column(db.String(20), unique=True, nullable=False)
    email = db.Column(db.String(120), unique=True, nullable=False)
    password = db.Column(db.String(60), nullable=False)
    posts = db.relationship('Post', backref='author', lazy=True)

class Post(db.Model):
    id = db.Column(db.Integer, primary_key=True)
    title = db.Column(db.String(100), nullable=False)
    date_posted = db.Column(db.DateTime, nullable=False, default=datetime.utcnow)
    content = db.Column(db.Text, nullable=False)
    user_id = db.Column(db.Integer, db.ForeignKey('user.id'), nullable=False)

app.py

from flask import Flask
from config import Config
from models import db

def create_app():
    app = Flask(__name__)
    app.config.from_object(Config)
    
    db.init_app(app)
    
    from users.routes import users
    from posts.routes import posts
    
    app.register_blueprint(users, url_prefix='/users')
    app.register_blueprint(posts, url_prefix='/posts')
    
    with app.app_context():
        db.create_all()
    
    return app

users/routes.py

from flask import Blueprint, render_template
from models import User, Post

users = Blueprint('users', __name__)

@users.route('/register')
def register():
    return render_template('users/register.html')

@users.route('/login')
def login():
    return render_template('users/login.html')

@users.route('/user/<int:user_id>')
def user_posts(user_id):
    user = User.query.get_or_404(user_id)
    posts = Post.query.filter_by(user_id=user_id).all()
    return render_template('users/user_posts.html', user=user, posts=posts)

posts/routes.py

from flask import Blueprint, render_template
from models import User, Post

posts = Blueprint('posts', __name__)

@posts.route('/new')
def new_post():
    return render_template('posts/create_post.html')

@posts.route('/<int:post_id>')
def post(post_id):
    post = Post.query.get_or_404(post_id)
    return render_template('posts/post.html', post=post)

@posts.route('/author/<int:author_id>')
def author_posts(author_id):
    author = User.query.get_or_404(author_id)
    posts = Post.query.filter_by(user_id=author_id).all()
    return render_template('posts/author_posts.html', author=author, posts=posts)

Bằng cách này, bạn có thể tổ chức mã nguồn một cách rõ ràng và tránh các vấn đề về vòng lặp.

Giảm việc lặp lại code khi sử dụng modules trong Flask có thể đạt được bằng cách tận dụng các kỹ thuật và mô hình như sau:

Sử dụng Blueprints để Tái Sử Dụng Mã:Flask blueprints cho phép bạn tổ chức và chia sẻ các route, model và logic xử lý giữa các modules mà không phải lặp lại mã.
Flask blueprints cho phép bạn tổ chức và chia sẻ các route, model và logic xử lý giữa các modules mà không phải lặp lại mã.
Tạo Các Tiện Ích Chung:Đặt các hàm tiện ích chung và logic xử lý thường dùng vào một tệp riêng, sau đó import vào các modules khi cần thiết.
Đặt các hàm tiện ích chung và logic xử lý thường dùng vào một tệp riêng, sau đó import vào các modules khi cần thiết.
Sử Dụng Base Templates:Dùng template inheritance của Jinja2 để tạo các template cơ sở và kế thừa chúng, giúp giảm thiểu việc lặp lại mã HTML.
Dùng template inheritance của Jinja2 để tạo các template cơ sở và kế thừa chúng, giúp giảm thiểu việc lặp lại mã HTML.
Tái Sử Dụng Form và Validation:Đặt các form và logic validation vào các lớp riêng để dễ dàng tái sử dụng giữa các modules.
Đặt các form và logic validation vào các lớp riêng để dễ dàng tái sử dụng giữa các modules.
Tạo Middleware hoặc Decorators Chung:Sử dụng middleware hoặc decorators để xử lý logic chung như xác thực người dùng, kiểm tra quyền truy cập, v.v.
Sử dụng middleware hoặc decorators để xử lý logic chung như xác thực người dùng, kiểm tra quyền truy cập, v.v.

Sử dụng Blueprints để Tái Sử Dụng Mã:

Flask blueprints cho phép bạn tổ chức và chia sẻ các route, model và logic xử lý giữa các modules mà không phải lặp lại mã.

Tạo Các Tiện Ích Chung:

Đặt các hàm tiện ích chung và logic xử lý thường dùng vào một tệp riêng, sau đó import vào các modules khi cần thiết.

Sử Dụng Base Templates:

Dùng template inheritance của Jinja2 để tạo các template cơ sở và kế thừa chúng, giúp giảm thiểu việc lặp lại mã HTML.

Tái Sử Dụng Form và Validation:

Đặt các form và logic validation vào các lớp riêng để dễ dàng tái sử dụng giữa các modules.

Tạo Middleware hoặc Decorators Chung:

Sử dụng middleware hoặc decorators để xử lý logic chung như xác thực người dùng, kiểm tra quyền truy cập, v.v.

Ví dụ Cụ Thể:

Cấu Trúc Thư Mục:

my_flask_app/
|-- app.py
|-- config.py
|-- requirements.txt
|-- run.py
|-- common/
|   |-- __init__.py
|   |-- utils.py
|   |-- forms.py
|   |-- decorators.py
|-- templates/
|   |-- base.html
|-- users/
|   |-- __init__.py
|   |-- models.py
|   |-- routes.py
|   |-- templates/
|       |-- users/
|           |-- register.html
|           |-- login.html
|-- posts/
|   |-- __init__.py
|   |-- models.py
|   |-- routes.py
|   |-- templates/
|       |-- posts/
|           |-- create_post.html
|           |-- post.html

1. Sử Dụng Blueprints:

app.py

from flask import Flask
from flask_sqlalchemy import SQLAlchemy
from config import Config

db = SQLAlchemy()

def create_app():
    app = Flask(__name__)
    app.config.from_object(Config)
    
    db.init_app(app)
    
    from users.routes import users
    from posts.routes import posts
    
    app.register_blueprint(users, url_prefix='/users')
    app.register_blueprint(posts, url_prefix='/posts')
    
    with app.app_context():
        db.create_all()
    
    return app

2. Tạo Các Tiện Ích Chung:

common/utils.py

from flask import flash

def flash_message(message, category='info'):
    flash(message, category)

common/forms.py

from flask_wtf import FlaskForm
from wtforms import StringField, PasswordField, SubmitField
from wtforms.validators import DataRequired, Email, EqualTo

class RegistrationForm(FlaskForm):
    username = StringField('Username', validators=[DataRequired()])
    email = StringField('Email', validators=[DataRequired(), Email()])
    password = PasswordField('Password', validators=[DataRequired()])
    confirm_password = PasswordField('Confirm Password', validators=[DataRequired(), EqualTo('password')])
    submit = SubmitField('Sign Up')

class LoginForm(FlaskForm):
    email = StringField('Email', validators=[DataRequired(), Email()])
    password = PasswordField('Password', validators=[DataRequired()])
    submit = SubmitField('Login')

3. Sử Dụng Base Templates:

templates/base.html

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <title>Flask App</title>
</head>
<body>
    <nav>
        <a href="/">Home</a>
        <a href="/users/register">Register</a>
        <a href="/users/login">Login</a>
        <a href="/posts/new">New Post</a>
    </nav>
    <div>
        {% block content %}{% endblock %}
    </div>
</body>
</html>

users/templates/users/register.html

{% extends "base.html" %}
{% block content %}
<h2>Register</h2>
<form method="POST">
    {{ form.hidden_tag() }}
    {{ form.username.label }} {{ form.username(size=32) }}<br>
    {{ form.email.label }} {{ form.email(size=32) }}<br>
    {{ form.password.label }} {{ form.password(size=32) }}<br>
    {{ form.confirm_password.label }} {{ form.confirm_password(size=32) }}<br>
    {{ form.submit() }}
</form>
{% endblock %}

4. Tái Sử Dụng Form và Validation:

users/routes.py

from flask import Blueprint, render_template, redirect, url_for
from common.forms import RegistrationForm, LoginForm
from common.utils import flash_message

users = Blueprint('users', __name__)

@users.route('/register', methods=['GET', 'POST'])
def register():
    form = RegistrationForm()
    if form.validate_on_submit():
        flash_message('Account created for {form.username.data}!', 'success')
        return redirect(url_for('users.login'))
    return render_template('users/register.html', form=form)

@users.route('/login', methods=['GET', 'POST'])
def login():
    form = LoginForm()
    if form.validate_on_submit():
        flash_message('Logged in successfully!', 'success')
        return redirect(url_for('posts.new_post'))
    return render_template('users/login.html', form=form)

5. Tạo Middleware hoặc Decorators Chung:

common/decorators.py

from flask import redirect, url_for, flash
from functools import wraps

def login_required(f):
    @wraps(f)
    def decorated_function(*args, **kwargs):
        if not current_user.is_authenticated:
            flash('Please log in to access this page.', 'warning')
            return redirect(url_for('users.login'))
        return f(*args, **kwargs)
    return decorated_function

posts/routes.py

from flask import Blueprint, render_template
from common.decorators import login_required
from .forms import PostForm

posts = Blueprint('posts', __name__)

@posts.route('/new', methods=['GET', 'POST'])
@login_required
def new_post():
    form = PostForm()
    if form.validate_on_submit():
        flash_message('Your post has been created!', 'success')
        return redirect(url_for('posts.post', post_id=new_post.id))
    return render_template('posts/create_post.html', form=form)

@posts.route('/<int:post_id>')
def post(post_id):
    post = Post.query.get_or_404(post_id)
    return render_template('posts/post.html', post=post)

Tổng Kết:

Sử dụng blueprints để tổ chức và tái sử dụng route.
Tạo các tiện ích chung trong thư mục common và import khi cần thiết.
Sử dụng base templates để giảm thiểu lặp lại mã HTML.
Tái sử dụng form và validation từ các lớp form chung.
Sử dụng decorators để áp dụng logic chung như xác thực người dùng.

Bằng cách áp dụng các kỹ thuật trên, bạn có thể giảm thiểu việc lặp lại mã, tăng tính tái sử dụng và dễ bảo trì mã nguồn trong ứng dụng Flask của mình.

#Mtips5s #Contact

Fanpage: https://www.facebook.com/mtipscoder

Group trao đổi, chia sẻ: https://www.facebook.com/groups/mtipscoder

Website: https://mtips5s.com

Youtube: https://mtips5s.com

Twitter(X): @takagiks99

Instagram: @khuongkara

Threads: @khuongkara

Google Maps: @khuongkara

#Base Code #Souce Code

Bộ công cụ My Self: @tools.mtips5s.com

Github: @github

Npm: @npm

Docker: @docker

Chúc các bạn thành công!