Bỏ qua

Các Design Pattern có trong Laravel Framework

1. Creational Patterns (Khởi tạo)

Các pattern này cung cấp cơ chế tạo object linh hoạt, tăng khả năng tái sử dụng code.

Singleton

  • Dịch vụ: Service Container (IoC), Config, Logging
  • Mục đích: Đảm bảo chỉ có một instance duy nhất trong lifecycle
  • Lợi ích: Tiết kiệm tài nguyên, quản lý state nhất quán

Factory Method

  • Dịch vụ: Eloquent Model Factories (database/factories)
  • Mục đích: Tạo test data và seed data có cấu trúc
  • Lợi ích: Tách logic khởi tạo, dễ testing và seeding

Abstract Factory

  • Dịch vụ: Cache, Queue, Mail, Storage Drivers
  • Mục đích: Tạo families của objects với interface thống nhất
  • Lợi ích: Hỗ trợ multiple backends, dễ thay đổi configuration

Builder

  • Dịch vụ: Query Builder, Eloquent Builder, Schema Builder
  • Mục đích: Xây dựng objects phức tạp theo từng bước
  • Lợi ích: Fluent interface, code dễ đọc hơn SQL thô

Prototype

  • Dịch vụ: Model::replicate()
  • Mục đích: Nhân bản objects đã tồn tại
  • Lợi ích: Copy nhanh chóng mà không cần tạo từ đầu

2. Structural Patterns (Cấu trúc)

Các pattern này giải thích cách tổ chức objects và classes thành cấu trúc lớn hơn.

Facade

  • Dịch vụ: Cache::get(), DB::table(), Auth::user()
  • Mục đích: Cung cấp interface đơn giản cho subsystem phức tạp
  • Lợi ích: Syntax ngắn gọn, che giấu complexity

Adapter

  • Dịch vụ: Cache, Queue, Mail, Storage Drivers
  • Mục đích: Chuyển đổi interface của third-party services
  • Lợi ích: Tích hợp dễ dàng, đảm bảo consistency

Decorator

  • Dịch vụ: Middleware
  • Mục đích: Thêm chức năng mà không thay đổi core object
  • Lợi ích: Tách biệt concerns, dễ add/remove features

Proxy

  • Dịch vụ: Lazy Loading ($user->posts)
  • Mục đích: Kiểm soát access và trì hoãn loading
  • Lợi ích: Tối ưu performance, giảm query không cần thiết

Composite

  • Dịch vụ: Collections (collect([...]))
  • Mục đích: Xử lý groups of objects như single object
  • Lợi ích: API đồng nhất cho single item và collections

3. Behavioral Patterns (Hành vi)

Các pattern này tập trung vào algorithms và phân công trách nhiệm giữa objects.

Observer

  • Dịch vụ: Eloquent Model Observers, Events & Listeners
  • Mục đích: Định nghĩa dependency one-to-many giữa objects
  • Lợi ích: Tách biệt side effects, loose coupling

Strategy

  • Dịch vụ: Auth Guards, Cache Drivers, Queue Drivers
  • Mục đích: Thay đổi algorithms tại runtime
  • Lợi ích: Flexibility trong implementation, easy configuration

Template Method

  • Dịch vụ: Base Controller, Jobs, Migrations, Commands
  • Mục đích: Định nghĩa skeleton, subclass override steps
  • Lợi ích: Code reuse, structure nhất quán

Chain of Responsibility

  • Dịch vụ: Middleware stack, Pipeline
  • Mục đích: Pass request qua chain of handlers
  • Lợi ích: Flexible processing, dễ add/remove handlers

Command

  • Dịch vụ: Artisan Console Commands, Queued Jobs
  • Mục đích: Đóng gói request thành object
  • Lợi ích: Decouple invoker/receiver, support queuing

Iterator

  • Dịch vụ: Eloquent Collections, Query Result Sets
  • Mục đích: Traverse collections mà không expose structure
  • Lợi ích: Uniform traversal, memory efficient

Mediator

  • Dịch vụ: Event Dispatcher
  • Mục đích: Điều phối communication qua mediator
  • Lợi ích: Loose coupling, centralized control

State

  • Dịch vụ: Auth States, Session Drivers
  • Mục đích: Thay đổi behavior dựa trên internal state
  • Lợi ích: Clean state management, tránh complex conditionals

Memento

  • Dịch vụ: Database Transactions (beginTransaction(), rollback())
  • Mục đích: Lưu và khôi phục state của object
  • Lợi ích: Data integrity, rollback capability

4. Architectural Patterns (Kiến trúc)

Các pattern này định hình cấu trúc tổng thể của ứng dụng.

MVC (Model–View–Controller)

  • Scope: Toàn bộ framework
  • Mục đích: Tách biệt presentation, business logic và data
  • Lợi ích: Separation of concerns, maintainable code

Repository Pattern

  • Scope: Repository Layer (optional)
  • Mục đích: Tách logic database khỏi business logic
  • Lợi ích: Testability, flexibility trong data source

Service Layer Pattern

  • Scope: Service Classes
  • Mục đích: Tập trung business logic vào service layer
  • Lợi ích: Thin controllers, reusable business logic

Dependency Injection / IoC

  • Scope: Service Container
  • Mục đích: Inject dependencies từ bên ngoài
  • Lợi ích: Loose coupling, easy testing với mocks

Active Record Pattern

  • Scope: Eloquent ORM
  • Mục đích: Object đại diện cho database row với behavior
  • Lợi ích: Intuitive API, simple CRUD operations

Data Mapper (một phần)

  • Scope: Query Builder → Object mapping
  • Mục đích: Tách biệt objects khỏi database schema
  • Lợi ích: Flexibility trong database design

Front Controller

  • Scope: public/index.php
  • Mục đích: Single entry point cho tất cả requests
  • Lợi ích: Centralized request handling, consistent middleware

5. Bảng chi tiết tổng hợp

Pattern Ví dụ trong Laravel Lý do sử dụng
Singleton Service Container, Config, Logging Đảm bảo một service chỉ có một instance duy nhất trong toàn bộ lifecycle request, tiết kiệm tài nguyên và quản lý dễ hơn
Factory Method Model Factories Cho phép tạo object (Eloquent model) linh hoạt, ẩn đi logic khởi tạo phức tạp. Giúp việc testing & seeding dữ liệu dễ dàng hơn
Abstract Factory Cache, Queue, Mail, Storage Drivers Cho phép Laravel hỗ trợ nhiều backend (Redis, S3, Mailgun…) mà giữ nguyên API thống nhất, dễ thay đổi mà không sửa code
Builder Query Builder, Eloquent Builder Hỗ trợ xây dựng query phức tạp bằng chain methods (fluent interface), dễ đọc, dễ maintain hơn SQL thô
Prototype Model::replicate() Cho phép nhân bản một model mà không cần tạo mới từ đầu, giữ nguyên các thuộc tính. Tiện khi copy dữ liệu
Facade DB::table(), Cache::get(), Auth::user() Cung cấp API "tĩnh" dễ dùng cho developer, nhưng thực chất gọi object phức tạp trong Service Container → đơn giản hóa cú pháp
Adapter Cache Drivers, Mail Drivers, Queue Drivers Đóng vai trò "trung gian" giữa Laravel và service bên ngoài, đảm bảo thay đổi backend không ảnh hưởng đến code business
Decorator Middleware Cho phép gói thêm logic xử lý trước/sau request (auth, log, CORS…) mà không cần thay đổi core controller
Proxy Lazy Loading ($user->posts) Chỉ load dữ liệu khi cần → giảm query dư thừa, tối ưu hiệu năng
Composite Collections (collect([...])) Cung cấp API đồng nhất để làm việc với nhiều phần tử hoặc một phần tử theo cùng cách (map, filter, reduce)
Observer Eloquent Model Observers, Events & Listeners Cho phép tách biệt logic xử lý khi có event (user created, order paid…) → giảm coupling, dễ mở rộng
Strategy Auth Guards, Cache Drivers Dễ dàng thay đổi cách thực hiện (strategy) như guard = session/token mà không đổi code phía trên
Template Method Base Controller, Jobs, Migrations Laravel định nghĩa sẵn "khung" (skeleton), bạn chỉ việc override phần tùy biến → code đồng nhất, tái sử dụng cao
Chain of Responsibility Middleware stack, Pipeline Cho phép xử lý tuần tự qua nhiều lớp (validation, auth, throttling…), mỗi lớp chỉ làm nhiệm vụ riêng
Command Artisan Commands, Queued Jobs Đóng gói một tác vụ thành object độc lập, dễ dàng chạy đồng bộ hoặc queue
Iterator Eloquent Collections, Query Results Cung cấp cách duyệt dữ liệu đồng nhất, hỗ trợ foreach, map, filter
Mediator Event Dispatcher Đóng vai trò "điều phối viên" giữa các thành phần → giảm sự phụ thuộc trực tiếp, chỉ giao tiếp thông qua event
State Auth States, Session Drivers Thay đổi hành vi ứng dụng dựa trên trạng thái (logged in/out, session file/db/redis)
Memento DB Transactions (beginTransaction(), rollback()) Lưu lại trạng thái DB trước khi thực hiện thao tác → có thể quay lại khi có lỗi

6. Ví dụ thực tế

Factory Method - Model Factories

// database/factories/UserFactory.php
class UserFactory extends Factory
{
    protected $model = User::class;

    public function definition()
    {
        return [
            'name' => $this->faker->name(),
            'email' => $this->faker->unique()->safeEmail(),
            'password' => bcrypt('password'),
        ];
    }
}

// Sử dụng
User::factory()->count(10)->create();
User::factory()->make(['email' => 'test@example.com']);

Singleton - Service Container

// Laravel đảm bảo Config service chỉ có 1 instance
$config1 = app('config');
$config2 = app('config');
var_dump($config1 === $config2); // true

// Binding singleton
app()->singleton('custom.service', function () {
    return new CustomService();
});

Facade - Static Interface

// Thay vì sử dụng Service Container trực tiếp
app('cache')->put('key', 'value', 3600);
app('db')->table('users')->get();

// Sử dụng Facade cho syntax đơn giản
Cache::put('key', 'value', 3600);
DB::table('users')->get();

Observer - Model Events

// app/Observers/UserObserver.php
class UserObserver
{
    public function created(User $user)
    {
        Mail::to($user)->send(new WelcomeEmail($user));
        Log::info("User created: {$user->email}");
    }

    public function updated(User $user)
    {
        if ($user->wasChanged('email')) {
            // Send email verification
        }
    }
}

// Đăng ký Observer
User::observe(UserObserver::class);

Strategy - Auth Guards

// config/auth.php
'guards' => [
    'web' => [
        'driver' => 'session',
        'provider' => 'users',
    ],
    'api' => [
        'driver' => 'passport',
        'provider' => 'users',
    ],
],

// Sử dụng different strategies
Auth::guard('web')->attempt($credentials);
Auth::guard('api')->user();

Chain of Responsibility - Middleware

// app/Http/Kernel.php
protected $middleware = [
    \App\Http\Middleware\TrustProxies::class,
    \App\Http\Middleware\CheckForMaintenanceMode::class,
    \Illuminate\Foundation\Http\Middleware\ValidatePostSize::class,
    \Illuminate\Foundation\Http\Middleware\TrimStrings::class,
];

// Middleware xử lý request theo chuỗi
class AuthMiddleware
{
    public function handle($request, Closure $next)
    {
        if (!Auth::check()) {
            return redirect('/login');
        }

        return $next($request); // Pass to next middleware
    }
}

Builder - Query Builder

// Fluent interface cho complex queries
$users = DB::table('users')
    ->select('name', 'email')
    ->where('active', true)
    ->where('created_at', '>', Carbon::now()->subDays(30))
    ->orderBy('name')
    ->limit(10)
    ->get();

// Eloquent Builder
$posts = Post::with('user')
    ->where('status', 'published')
    ->whereHas('tags', function ($query) {
        $query->where('name', 'laravel');
    })
    ->latest()
    ->paginate(15);

Abstract Factory - Cache Drivers

// config/cache.php - Multiple cache stores
'stores' => [
    'file' => [
        'driver' => 'file',
        'path' => storage_path('framework/cache/data'),
    ],
    'redis' => [
        'driver' => 'redis',
        'connection' => 'cache',
    ],
    'database' => [
        'driver' => 'database',
        'table' => 'cache',
        'connection' => null,
    ],
],

// Cùng interface, khác implementation
Cache::store('redis')->put('key', 'value');
Cache::store('file')->put('key', 'value');
Cache::store('database')->put('key', 'value');