Laravel Facades Explained: Why They Feel So Clean and Powerful

1. Hook & Problem Statement

You're building a Laravel application. You need to cache some data. You write:

Cache::put('user_123', $user, 3600);
$user = Cache::get('user_123');

It works beautifully. The code is clean, readable, and expressive. You don't need to worry about instantiating anything. The Cache class is just... there.

Then you need to send an email:

Mail::to($user->email)->send(new WelcomeEmail($user));

Again, it just works. Clean. Simple. Powerful.

But what is Cache? What is Mail?

They're static facades. They look like static methods, but they're actually proxies to objects resolved from the service container.

Many developers use Laravel facades daily without understanding how they work. They're "magic." But behind the scenes, they're a sophisticated implementation of the Facade Pattern.

This pattern provides a simple, static-like interface to complex subsystems while maintaining testability and flexibility.

---

2. Why This Pattern Exists

The Software Engineering Problem It Solves

The Facade Pattern solves the problem of providing a simplified interface to a complex subsystem. It hides the complexity of the subsystem, making it easier to use.

The Pain That Existed Before

Before the Facade Pattern (or in codebases that don't use it), developers faced:

1. Complex Initialization: Using a service required multiple steps of configuration and instantiation.

2. Deep Dependencies: You needed to know the entire dependency graph to use a service.

3. Verbose Code: Simple operations required many lines of code.

4. Tight Coupling: Code was tightly coupled to the concrete implementation.

5. Difficult Testing: Testing required instantiating all dependencies.

6. Violation of Law of Demeter: Code had to "talk to strangers" to get things done.

Why Large Applications Need It

As applications grow, subsystems become more complex. A simple file storage operation might require:

• Setting up the client
• Configuring credentials
• Handling errors
• Managing retries
• Logging operations

The Facade Pattern provides:

• Simplicity: One method call for complex operations.
• Decoupling: Facade hides the subsystem's complexity.
• Testability: Facades can be mocked.
• Readability: Code reads like plain English.
• Consistency: All facades follow the same pattern.

---

3. Real World Analogy

The Hotel Concierge

Imagine a luxury hotel with hundreds of services: restaurants, spa, gym, laundry, room service, concierge, valet, etc.

The Bad Way:
You have to interact with each service directly:

• Call the restaurant for a reservation.
• Call the spa for a massage.
• Call the valet for your car.
• Call the concierge for directions.

You need to know every phone number and procedure.

The Facade Way:
You call the Concierge (the Facade):
"I need a dinner reservation, a massage at 3 PM, my car at 5 PM, and directions to the museum."

The concierge handles all the complexity. You have one point of contact for many services.

Analogy Mapping:

• Concierge: The Facade (e.g., Cache, Mail, DB).
• Hotel Services: The subsystem (e.g., CacheStore, Mailer, Database).
• You: The client code.
• Phone Number: The Facade's static-like interface.
• Reservation Process: The subsystem's complexity.

Why it works: You don't need to know how the hotel works. You just ask the concierge, and they handle the details.

---

4. The Pain (Bad Design)

Let's look at code without facades—manually managing dependencies everywhere.

namespace App\Http\Controllers;

use App\Models\Order;
use App\Models\User;
use App\Services\Cache\RedisCacheService;
use App\Services\Mail\MailgunMailer;
use App\Services\Logging\FileLogger;
use App\Services\Storage\S3StorageService;
use Illuminate\Http\Request;

class OrderController extends Controller
{
    private RedisCacheService $cache;
    private MailgunMailer $mailer;
    private FileLogger $logger;
    private S3StorageService $storage;

    public function __construct()
    {
        // Manual initialization—lots of configuration
        $this->cache = new RedisCacheService(
            config('cache.redis.host'),
            config('cache.redis.port'),
            config('cache.redis.password')
        );

        $this->mailer = new MailgunMailer(
            config('services.mailgun.api_key'),
            config('services.mailgun.domain'),
            config('services.mailgun.secret')
        );

        $this->logger = new FileLogger(
            storage_path('logs/orders.log')
        );

        $this->storage = new S3StorageService(
            config('services.s3.key'),
            config('services.s3.secret'),
            config('services.s3.region'),
            config('services.s3.bucket')
        );
    }

    public function store(Request $request)
    {
        // Validate
        $validated = $request->validate([
            'items' => 'required|array',
            'total' => 'required|numeric',
        ]);

        // Create order
        $order = new Order();
        $order->user_id = auth()->id();
        $order->items = json_encode($validated['items']);
        $order->total = $validated['total'];
        $order->status = 'pending';
        $order->save();

        // Cache the order
        $this->cache->put('order_' . $order->id, $order, 3600);

        // Send confirmation email
        $user = User::find(auth()->id());
        $this->mailer->send(
            $user->email,
            'Order Confirmation',
            "Your order #{$order->id} has been created."
        );

        // Upload receipt to S3
        $receipt = $this->generateReceipt($order);
        $this->storage->put("receipts/{$order->id}.pdf", $receipt);

        // Log
        $this->logger->log("Order created: {$order->id}");

        return response()->json($order, 201);
    }
}

Why This Is Terrible

1. Complex Initialization: The constructor is filled with service instantiation and configuration.

2. Tight Coupling: The controller is coupled to RedisCacheService, MailgunMailer, FileLogger, and S3StorageService.

3. Duplicate Configuration: If you have 20 controllers, you repeat this initialization 20 times.

4. Difficult Testing: You can't test without real services or complex mocking.

5. Violates SRP: The controller handles HTTP requests AND service configuration.

6. Violates DIP: The controller depends on concrete implementations, not abstractions.

Why Developers Write Code Like This

• They're not using facades.
• They're not using dependency injection properly.
• They're not separating concerns.
• They think "it's just configuration."

---

5. Solution Overview

The Facade Pattern provides a unified, simplified interface to a complex subsystem. In Laravel, facades are static proxies that resolve to services in the container.

Core Idea

Instead of manually instantiating and configuring services, you use a facade that:

1. Provides a static interface to a service.
2. Resolves the service from the container.
3. Delegates all calls to the resolved service.
4. Handles configuration internally.

Main Participants

1. Facade Class: The static proxy (e.g., Cache, Mail, DB).
2. Service Container: Resolves the underlying service.
3. Underlying Service: The actual service being used (e.g., CacheStore, Mailer).
4. Client: Your application code that uses the facade.

How Objects Collaborate

Client → Facade → Service Container → Underlying Service

The client calls a static method on the facade. The facade resolves the service from the container. The service executes the operation.

Mental Model

Think of a remote control for your TV.

• Remote Control: The Facade (simple interface).
• Button Press: The method call.
• TV: The underlying service.
• Remote's Programming: The facade's resolution logic.

You don't need to know how the TV works. You just press buttons on the remote.

Benefits

• Simplicity: Clean, readable code.
• Decoupling: Hides subsystem complexity.
• Testability: Facades can be mocked.
• Consistency: All facades work the same way.
• Lazy Loading: Services are only resolved when needed.

Trade-offs

• Static Interface: Some argue it's less "pure" OOP.
• Indirection: Harder to trace code flow.
• Testing Overhead: Need to mock facades with shouldReceive().

---

6. UML Diagram

Laravel Facade Pattern Mermaid Diagram

Diagram Explanation

1. Cache is the facade (static interface).
2. CacheManager is the actual service (real instance).
3. Store is the interface for cache drivers.
4. Container resolves the CacheManager.
5. The facade delegates to the resolved instance.

---

7. Vanilla PHP Example

Let's build a simple facade system in vanilla PHP.

Before Refactoring (No Facade)

(The terrible code shown above)

After Refactoring (With Facade)

Step 1: The Container

class Container
{
    private array $bindings = [];
    private array $instances = [];

    public function bind(string $abstract, $concrete): void
    {
        $this->bindings[$abstract] = $concrete;
    }

    public function singleton(string $abstract, $concrete): void
    {
        $this->bindings[$abstract] = $concrete;
        $this->instances[$abstract] = null;
    }

    public function make(string $abstract)
    {
        if (isset($this->instances[$abstract])) {
            return $this->instances[$abstract];
        }

        $concrete = $this->bindings[$abstract] ?? $abstract;

        if (is_callable($concrete)) {
            $instance = $concrete($this);
        } else {
            $instance = new $concrete();
        }

        if (isset($this->instances[$abstract])) {
            $this->instances[$abstract] = $instance;
        }

        return $instance;
    }
}

Step 2: The Services

interface CacheStore
{
    public function get(string $key, $default = null);
    public function put(string $key, $value, int $seconds): void;
    public function remember(string $key, int $seconds, callable $callback);
}

class RedisCache implements CacheStore
{
    private array $storage = [];

    public function get(string $key, $default = null)
    {
        return $this->storage[$key] ?? $default;
    }

    public function put(string $key, $value, int $seconds): void
    {
        $this->storage[$key] = $value;
    }

    public function remember(string $key, int $seconds, callable $callback)
    {
        if ($this->get($key) === null) {
            $value = $callback();
            $this->put($key, $value, $seconds);
            return $value;
        }

        return $this->get($key);
    }
}

interface Mailer
{
    public function send(string $to, string $subject, string $body): void;
}

class MailgunMailer implements Mailer
{
    public function send(string $to, string $subject, string $body): void
    {
        echo "Sending email to {$to}: {$subject}\n";
    }
}

Step 3: The Facade Base Class

abstract class Facade
{
    protected static Container $container;

    public static function setContainer(Container $container): void
    {
        static::$container = $container;
    }

    protected static function getFacadeAccessor(): string
    {
        throw new \Exception('Facade does not define getFacadeAccessor');
    }

    public static function resolveFacadeInstance()
    {
        $accessor = static::getFacadeAccessor();
        return static::$container->make($accessor);
    }

    public static function __callStatic($method, $args)
    {
        $instance = static::resolveFacadeInstance();
        return $instance->$method(...$args);
    }
}

Step 4: The Concrete Facades

class Cache extends Facade
{
    protected static function getFacadeAccessor(): string
    {
        return 'cache';
    }
}

class Mail extends Facade
{
    protected static function getFacadeAccessor(): string
    {
        return 'mailer';
    }
}

Step 5: Setup and Usage

// Setup the container
$container = new Container();

// Bind services
$container->singleton('cache', function () {
    return new RedisCache();
});

$container->singleton('mailer', function () {
    return new MailgunMailer();
});

// Set the container for facades
Facade::setContainer($container);

// Usage
Cache::put('user_1', ['name' => 'John'], 3600);
$user = Cache::get('user_1');
echo $user['name']; // "John"

$cached = Cache::remember('expensive_computation', 60, function () {
    return ['result' => 42];
});
var_dump($cached); // ['result' => 42]

Mail::send('[e-mail]', 'Welcome!', 'Welcome to our app!');
// Output: Sending email to [e-mail]: Welcome!

What We Improved

1. Clean Interface: Cache::put() instead of $cache->put() with manual instantiation.

2. Lazy Loading: Services are only resolved when called.

3. Centralized Configuration: Service binding in one place.

4. Decoupling: Client code doesn't know about service implementation.

5. Testability: Facades can be mocked (as we'll see later).

6. Consistency: All facades work the same way.

---

8. Laravel Internal Example

Laravel's facade system is sophisticated and elegant. Let's look at how it works.

The Facade Base Class

// Illuminate\Support\Facades\Facade
abstract class Facade
{
    protected static $app;
    protected static $resolvedInstance = [];

    public static function getFacadeAccessor()
    {
        throw new \RuntimeException('Facade does not implement getFacadeAccessor');
    }

    public static function shouldReceive()
    {
        $name = static::getFacadeAccessor();

        if (static::isMock()) {
            // Return a mock instance
        }

        return static::$app->make($name);
    }

    public static function __callStatic($method, $args)
    {
        $instance = static::getFacadeRoot();

        if (!$instance) {
            throw new \RuntimeException('Facade root has not been set.');
        }

        return $instance->$method(...$args);
    }
}

Concrete Facades

// Illuminate\Support\Facades\Cache
class Cache extends Facade
{
    protected static function getFacadeAccessor()
    {
        return 'cache';
    }
}

// Illuminate\Support\Facades\Mail
class Mail extends Facade
{
    protected static function getFacadeAccessor()
    {
        return 'mailer';
    }
}

// Illuminate\Support\Facades\DB
class DB extends Facade
{
    protected static function getFacadeAccessor()
    {
        return 'db';
    }
}

// Illuminate\Support\Facades\Log
class Log extends Facade
{
    protected static function getFacadeAccessor()
    {
        return 'log';
    }
}

// Illuminate\Support\Facades\Storage
class Storage extends Facade
{
    protected static function getFacadeAccessor()
    {
        return 'filesystem';
    }
}

How It Works in Laravel

1. Registration: Services are registered in the service container.

// In a service provider
$this->app->singleton('cache', function ($app) {
    return new CacheManager($app);
});

1. Resolution: When you call Cache::put(), the facade resolves 'cache' from the container.

2. Delegation: The facade delegates the call to the resolved instance.

The Elegance

1. Lazy Loading: Facades are resolved on first use.

2. No Manual Configuration: Everything is handled by the container.

3. Testability: Cache::shouldReceive('get')->andReturn('value')

4. Consistency: All facades follow the same pattern.

5. Extensibility: You can create your own facades.

Facades vs. Helper Functions

Laravel also provides helper functions for common facades:

// Facade
Cache::get('key');

// Helper
cache('key');

// Both work!

The helper functions are shorter but less explicit.

---

9. Real Laravel Application Example

Let's build a Report Generation System using Laravel facades.

Scenario

Your application needs to generate and deliver reports:

• Fetch data from the database
• Cache results
• Generate PDF reports
• Send via email
• Log all operations
• Upload to storage

Implementation

Step 1: The Report Service (Using Facades)

// app/Services/ReportService.php
namespace App\Services;

use Carbon\Carbon;
use Illuminate\Support\Facades\Cache;
use Illuminate\Support\Facades\DB;
use Illuminate\Support\Facades\Log;
use Illuminate\Support\Facades\Mail;
use Illuminate\Support\Facades\Storage;
use Illuminate\Support\Facades\View;

class ReportService
{
    public function generateAndSendReport(string $reportType, array $data, array $recipients): void
    {
        // Generate a unique report key
        $reportKey = $this->generateReportKey($reportType, $data);

        // Check cache
        $reportData = Cache::remember("report_{$reportKey}", 3600, function () use ($reportType, $data) {
            // Fetch data from database
            $results = $this->fetchData($reportType, $data);

            // Log the fetch
            Log::info('Report data fetched', [
                'type' => $reportType,
                'record_count' => count($results),
            ]);

            return $results;
        });

        // Generate PDF
        $pdf = $this->generatePDF($reportType, $reportData);

        // Store the PDF
        $filename = "reports/report_{$reportKey}_" . Carbon::now()->format('Y-m-d_H-i-s') . '.pdf';
        Storage::put($filename, $pdf);

        // Log storage
        Log::info('Report stored', [
            'filename' => $filename,
            'size' => strlen($pdf),
        ]);

        // Send email with attachment
        Mail::send(
            'emails.report',
            ['type' => $reportType, 'date' => Carbon::now()],
            function ($message) use ($recipients, $filename) {
                $message->to($recipients)
                        ->subject("Report: {$this->getReportTitle($filename)}")
                        ->attach(
                            Storage::path($filename),
                            ['as' => 'report.pdf', 'mime' => 'application/pdf']
                        );
            }
        );

        // Log completion
        Log::info('Report delivered', [
            'type' => $reportType,
            'recipients' => $recipients,
            'filename' => $filename,
        ]);
    }

    private function generateReportKey(string $reportType, array $data): string
    {
        $dataHash = md5(json_encode($data));
        return "{$reportType}_{$dataHash}";
    }

    private function fetchData(string $reportType, array $data): array
    {
        // Use DB facade
        return DB::table('reports')
            ->where('type', $reportType)
            ->whereBetween('created_at', $data['date_range'] ?? [])
            ->get()
            ->toArray();
    }

    private function generatePDF(string $reportType, array $data): string
    {
        // Use View facade
        $html = View::make('reports.template', [
            'type' => $reportType,
            'data' => $data,
        ])->render();

        // In a real app, use DomPDF or similar
        return $html;
    }

    private function getReportTitle(string $filename): string
    {
        $parts = explode('_', $filename);
        return $parts[1] ?? 'Report';
    }
}

Step 2: The Controller (Using the Service)

// app/Http/Controllers/ReportController.php
namespace App\Http\Controllers;

use App\Services\ReportService;
use Illuminate\Http\Request;
use Illuminate\Support\Facades\Auth;
use Illuminate\Support\Facades\Log;

class ReportController extends Controller
{
    public function __construct(
        private readonly ReportService $reportService
    ) {}

    public function generate(Request $request)
    {
        $validated = $request->validate([
            'type' => 'required|string',
            'date_from' => 'required|date',
            'date_to' => 'required|date|after:date_from',
        ]);

        $this->reportService->generateAndSendReport(
            $validated['type'],
            [
                'date_range' => [$validated['date_from'], $validated['date_to']],
            ],
            [$request->user()->email]
        );

        Log::info('Report generation initiated', [
            'user' => Auth::id(),
            'type' => $validated['type'],
        ]);

        return response()->json(['message' => 'Report is being generated']);
    }
}

Step 3: Custom Facade for the Report Service

// app/Facades/Report.php
namespace App\Facades;

use Illuminate\Support\Facades\Facade;

/**
 * @method static void generateAndSendReport(string $reportType, array $data, array $recipients)
 */
class Report extends Facade
{
    protected static function getFacadeAccessor()
    {
        return 'report.service';
    }
}

Step 4: Service Provider Registration

// app/Providers/ReportServiceProvider.php
namespace App\Providers;

use App\Services\ReportService;
use Illuminate\Support\ServiceProvider;

class ReportServiceProvider extends ServiceProvider
{
    public function register(): void
    {
        $this->app->singleton('report.service', function ($app) {
            return new ReportService();
        });
    }
}

Step 5: Using the Custom Facade

// In a controller or command
use App\Facades\Report;

class WeeklyReportCommand extends Command
{
    public function handle()
    {
        Report::generateAndSendReport(
            'weekly_sales',
            ['date_range' => [now()->subWeek(), now()]],
            ['[e-mail]']
        );
    }
}

Why This Works

1. Clean Code: The service uses facades for everything—no manual instantiation.

2. Decoupling: The service doesn't know about the underlying implementations.

3. Testability: You can mock Cache, DB, Mail, etc.

4. Readability: The code is expressive and self-documenting.

5. Consistency: All facades follow the same pattern.

---

10. SOLID Principles Mapping

S - Single Responsibility Principle (SRP)

Each facade represents a single service:

• Cache: Caching operations.
• Mail: Email operations.
• DB: Database operations.
• Log: Logging operations.
• Storage: File storage operations.

O - Open/Closed Principle (OCP)

Facades are open for extension but closed for modification:

// You can create your own facades
class Report extends Facade
{
    protected static function getFacadeAccessor()
    {
        return 'report.service';
    }
}

// The facade system doesn't need to be modified

D - Dependency Inversion Principle (DIP)

The facade resolves services from the container, which handles the dependencies:

// The facade doesn't depend on concrete implementations
Cache::get('key');

// The container resolves the actual implementation

L - Liskov Substitution Principle (LSP)

All facades work the same way and can be substituted.

I - Interface Segregation Principle (ISP)

Each facade provides a focused interface:

• Cache: Only cache operations.
• Mail: Only mail operations.

---

11. Trade-offs

Benefits

1. Simplicity: Clean, readable code.

2. Decoupling: Hides subsystem complexity.

3. Testability: Facades can be mocked.

4. Consistency: All facades work the same way.

5. Lazy Loading: Services are resolved only when used.

6. Extensibility: Create custom facades easily.

Costs

1. Static Interface: Some argue it's less "pure" OOP.

2. Indirection: Harder to trace code flow.

3. Testing Overhead: Need to mock facades with shouldReceive().

4. Hidden Dependencies: Dependencies aren't explicit in the constructor.

When Is Complexity Justified?

Use facades when:

• You want a simple, expressive interface.
• The underlying service is complex.
• You want to hide implementation details.
• You're building a framework or library.

Avoid facades when:

• You need explicit dependencies (constructor injection).
• You're writing highly testable code.
• You're following pure Dependency Injection.

---

12. When NOT To Use It

3 Green Flags (USE FACADES)

1. Simple Operations: The code is simple and expressive.

2. Complex Subsystem: The service has complex configuration.

3. Framework Code: You're building or extending Laravel.

3 Red Flags (AVOID FACADES)

1. Explicit Dependencies: You want to see dependencies in the constructor.

2. Pure DI: You're following strict Dependency Injection.

3. Complex Logic: The method does many different things.

---

13. Common Mistakes

1. Using Facades for Business Logic

// BAD: Business logic in controller using facades
class OrderController
{
    public function store(Request $request)
    {
        // ... business logic directly in controller
        Cache::put(...);
        Mail::send(...);
        Log::info(...);
    }
}

// GOOD: Inject a service
class OrderController
{
    private OrderService $orderService;

    public function store(Request $request)
    {
        return $this->orderService->createOrder($request->all());
    }
}

2. Not Mocking Facades in Tests

// BAD: Real facades in tests
public function testOrderCreation()
{
    // Real services are used
    $response = $this->post('/orders', $data);
}

// GOOD: Mock facades
public function testOrderCreation()
{
    Cache::shouldReceive('put')->once();
    Mail::shouldReceive('send')->once();

    $response = $this->post('/orders', $data);
}

3. Creating God Facades

// BAD: God facade doing everything
class Everything extends Facade
{
    protected static function getFacadeAccessor()
    {
        return 'everything';
    }
}

// GOOD: Focused facades
class Cache extends Facade { /* ... */ }
class Mail extends Facade { /* ... */ }
class Log extends Facade { /* ... */ }

4. Using Facades in Service Classes

// BAD: Service class using facades
class OrderService
{
    public function createOrder($data)
    {
        Cache::put(...); // Hard to test
        Mail::send(...); // Hard to test
    }
}

// GOOD: Service class with injected dependencies
class OrderService
{
    private CacheStore $cache;
    private Mailer $mailer;

    public function __construct(CacheStore $cache, Mailer $mailer)
    {
        $this->cache = $cache;
        $this->mailer = $mailer;
    }
}

---

14. Frequently Asked Interview Questions

Beginner/Intermediate

1. Q: What is a facade in Laravel?
   A: A facade is a static proxy to a service in the container. It provides a simple, expressive interface to complex subsystems.

2. Q: How do facades work in Laravel?
   A: Facades resolve a service from the container and delegate all calls to that service.

3. Q: What's the difference between a facade and a helper function?
   A: Facades are static proxies with a class name. Helper functions are global functions (e.g., cache(), logger()).

4. Q: When would you use a facade instead of dependency injection?
   A: When you want a simple, expressive interface and the service is used in many places.

5. Q: Can you create custom facades in Laravel?
   A: Yes, by extending Illuminate\Support\Facades\Facade and implementing getFacadeAccessor().

Senior/Architect

1. Q: Explain the difference between facades and the Facade Pattern.
   A: The Facade Pattern is a design pattern that provides a simplified interface to a complex system. Laravel's facades are a specific implementation that uses static proxies.

2. Q: How do you test code that uses facades?
   A: Use shouldReceive() to mock the facade's methods.

3. Q: What are the performance implications of facades?
   A: Facades use lazy loading, so performance overhead is minimal. The service is only resolved when first used.

4. Q: How do facades differ from real static classes?
   A: Facades use the container to resolve a real instance. Real static classes don't use the container.

5. Q: What's the relationship between facades and the service container?
   A: Facades resolve services from the container. The container manages the service's lifecycle and dependencies.

---

15. Interactive Practice Challenge

The Requirement

You're building a Notification System that uses facades everywhere. You need to refactor it to be more testable while keeping the facade interface.

The Code (POOR DESIGN)

namespace App\Services;

use App\Models\User;
use App\Models\Notification;
use Illuminate\Support\Facades\Cache;
use Illuminate\Support\Facades\Log;
use Illuminate\Support\Facades\Mail;
use Illuminate\Support\Facades\Queue;
use Illuminate\Support\Facades\DB;

class NotificationService
{
    public function sendNotification(User $user, Notification $notification): void
    {
        // Check if user is subscribed
        if (!$this->isSubscribed($user)) {
            Log::info('User not subscribed', ['user' => $user->id]);
            return;
        }

        // Check rate limit
        if ($this->rateLimited($user)) {
            Log::warning('Rate limit exceeded', ['user' => $user->id]);
            return;
        }

        // Send via email
        Mail::to($user->email)->send(new NotificationMail($notification));

        // Send via SMS if enabled
        if ($user->phone && $this->smsEnabled($user)) {
            $this->sendSms($user->phone, $notification->content);
        }

        // Cache the last sent time
        Cache::put("notify_{$user->id}_last", time(), 3600);

        // Log the notification
        DB::table('notifications_log')->insert([
            'user_id' => $user->id,
            'notification_id' => $notification->id,
            'sent_at' => now(),
        ]);

        // Queue a follow-up
        Queue::push(new FollowUpJob($user, $notification));
    }

    private function isSubscribed(User $user): bool
    {
        return Cache::remember("subscribed_{$user->id}", 3600, function () use ($user) {
            return DB::table('subscriptions')
                ->where('user_id', $user->id)
                ->where('active', true)
                ->exists();
        });
    }

    private function rateLimited(User $user): bool
    {
        $lastSent = Cache::get("notify_{$user->id}_last", 0);
        return time() - $lastSent < 60; // 1 minute limit
    }

    private function smsEnabled(User $user): bool
    {
        return $user->preferences['sms'] ?? false;
    }

    private function sendSms(string $phone, string $content): void
    {
        // SMS implementation
        Log::info('SMS sent', ['phone' => $phone]);
    }
}

The Challenges

The code uses facades everywhere, making it difficult to test. You need to:

1. Make the service testable without removing facades.

2. Add support for new notification channels (Slack, Push).

3. Add retry logic for failed notifications.

4. Add analytics tracking for notification delivery.

Your Task

Refactor this system to be more maintainable while preserving the facade pattern. Specifically:

1. Extract facade usage into separate services (optional).

2. Make facades mockable in tests.

3. Add dependency injection where it makes sense.

4. Implement proper error handling for each channel.

5. Create a notification factory for different channels.

Questions to Consider

• How do you test code with facades?
• How do you handle different notification channels?
• How do you implement retry logic?
• How do you track delivery metrics?
• How do you handle rate limiting across channels?

(We won't provide the solution—refactor this code and master facades!)

---

16. Final Mental Model

To keep it simple, memorize these three sentences:

• One-sentence definition: A facade provides a simplified, static-like interface to a complex subsystem, hiding its complexity and configuration.

• One-sentence intuition: Facades are like a concierge that handles all the details of a complex hotel.

• One-sentence decision rule: Use facades for clean, expressive code when the underlying service is complex and used in many places.

---

17. Related Concepts

SOLID Principles

• Single Responsibility: Each facade handles one service.
• Open/Closed: Facades can be extended with custom facades.
• Dependency Inversion: Facades resolve from the container.
• Liskov Substitution: All facades work the same way.

Design Patterns

• Facade Pattern: The pattern itself.
• Proxy Pattern: Facades are a form of proxy.
• Static Factory: Facades resolve services from the container.
• Singleton: Services are often singletons.

Laravel Internals

• Service Container: Resolves facades.
• Service Providers: Register services for facades.
• Contracts: Define the interfaces that facades use.
• Helpers: Global helper functions.
• Eloquent: Uses facades for database operations.

Enterprise Patterns

• Facade: The pattern itself.
• Service Layer: Often uses facades.
• Gateway: Similar to facades for external services.
• Proxy: Similar concept.

---

Final Thoughts

Laravel facades are one of the most misunderstood features of the framework. They look like static methods, but they're actually elegant proxies to the service container.

They provide:

• Clean Code: Expressive, readable interfaces.
• Decoupling: Hide subsystem complexity.
• Testability: Easy to mock.
• Consistency: All facades work the same way.

Use facades wisely. They're powerful when used correctly and dangerous when overused.

Remember: Facades are a tool, not a silver bullet. Use them for the right reasons.

---

Github: Facade Pattern Practice Labs