Bagaimana cara menyusun aplikasi Laravel yang besar dan kompleks?

To structure a large Laravel application effectively, use Domain-Driven Design to organize code by business domains, keep controllers thin by delegating logic to action or service classes, leverage Laravel’s features like FormRequests, events, jobs, and policies for separation of concerns, split routes and configurations by domain, use query objects or repositories sparingly for complex queries, keep models focused on Eloquent responsibilities, implement a domain-based testing strategy with unit and feature tests, extract shared logic into internal classes or private packages, document architecture clearly for team onboarding, and optionally consider Hexagonal Architecture for maximum decoupling — all to ensure maintainability, scalability, and clarity.

Building a large, complex Laravel application requires more than just following Laravel’s defaults — it demands thoughtful architecture to keep the codebase maintainable, scalable, and testable. Here’s how to structure it effectively.

1. Use Domain-Driven Design (DDD) Principles

Instead of organizing your app purely by technical layers (like Controllers, Models, etc.), group code by business domains or features.

Structure Example:

app/
├── Domains/
│   ├── User/
│   │   ├── Actions/
│   │   ├── Models/
│   │   ├── Http/
│   │   │   └── Controllers/
│   │   ├── Services/
│   │   └── Exceptions/
│   ├── Order/
│   │   ├── Actions/
│   │   ├── Models/
│   │   └── ...

Each domain encapsulates everything related to that part of the business logic. This reduces coupling and makes it easier to reason about functionality.

Why it helps:

• Teams can work on separate domains without stepping on each other’s toes.
• Easier to refactor or extract domains into microservices later.
• Business logic stays close to the domain, not scattered across service classes.

2. Modularize with Service Classes and Actions

Avoid putting logic in controllers or models. Instead, use action classes or service classes to encapsulate specific operations.

Example:

// app/Domains/Order/Actions/PlaceOrder.php
class PlaceOrder
{
    public function execute(User $user, array $items): Order
    {
        // validation, business logic, event dispatching
    }
}

Controllers become thin:

public function store(Request $request, PlaceOrder $placeOrder)
{
    $order = $placeOrder->execute(auth()->user(), $request->items);
    return response()->json($order);
}

Benefits:

• Reusable logic (CLI, API, queues can all use the same action).
• Easier testing — test the action directly.
• Clear intent and separation of concerns.

3. Leverage Laravel’s Built-in Features Wisely

Even in large apps, Laravel’s tools are powerful — but use them with discipline.

Key practices:

• Requests: Use FormRequests for validation, but keep them minimal. Don’t add business logic.
• Events & Listeners: Decouple side effects (e.g., send email after order placed). Use dispatch() in actions.
• Jobs: Offload slow tasks (e.g., PDF generation, external API calls).
• Policies & Gates: Handle authorization cleanly per domain.
• Resources (API Resources): Transform models for API responses without leaking internals.

Avoid putting any real logic in controllers or routes — they should just handle HTTP concerns.

4. Organize Configuration and Routes

As the app grows, avoid dumping everything in routes/web.php.

Better approach:

• Split routes by domain:

  routes/
  ├── user.php
  ├── order.php
  └── admin.php

• Register them in RouteServiceProvider using middleware groups.

Use configuration files for domain-specific settings:

config/user.php
config/payment.php

5. Use Repositories or Query Objects (Carefully)

For complex queries, avoid dumping everything in models or controllers.

Option 1: Query Objects

// app/Domains/User/Queries/ActiveUsersQuery.php
class ActiveUsersQuery
{
    public function search(array $filters) { ... }
}

Option 2: Repositories (only if you need abstraction over Eloquent)

But: Don’t over-abstract. Eloquent is usually fine. Only abstract if you’re planning to swap out the ORM or have complex data sources.

6. Keep Models Focused

Models should:

• Define relationships
• Contain Eloquent scopes
• Hold simple accessors/mutators

Avoid:

• Business logic
• HTTP-related code
• Massive monolithic models

Use Traits or Custom Base Models if you need shared behavior (e.g., HasUuid, SoftDeletes).

7. Testing Strategy

Large apps need solid tests.

Structure tests by domain:

tests/Feature/User/
tests/Feature/Order/

Use:

• Feature tests for critical user journeys (e.g., "user places order").
• Unit tests for actions, services, queries.
• Pest or PHPUnit — both work well.

Run tests in CI and enforce coverage thresholds.

8. Use Packages for Shared Logic

If multiple domains need similar functionality (e.g., notifications, exports), consider:

• Creating internal service classes
• Or, extracting to a private Composer package if reused across apps

Avoid code duplication.

9. Documentation and Onboarding

Large teams need clarity.

• Document domain boundaries and architecture decisions (use docs/ folder).
• Add clear PHPDoc and return types.
• Use Laravel IDE Helper for better autocompletion.

10. Consider Hexagonal Architecture (Optional, Advanced)

For very complex systems, consider separating core logic from frameworks entirely:

• Put business logic in app/Core/
• Make Laravel just an adapter (HTTP, DB, queue)

But this adds complexity — only adopt if you truly need framework independence.

Structuring a large Laravel app isn’t about complexity — it’s about clarity and boundaries. Focus on domains, keep layers clean, and resist the urge to dump logic in controllers or models.

Basically: Think in features, not files.

Atas ialah kandungan terperinci Bagaimana cara menyusun aplikasi Laravel yang besar dan kompleks?. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!