What are you looking for?
A Laravel Facade is a class that gives you a clean, static-looking syntax to access services from the Service Container — without injecting them as constructor dependencies.
The critical insight: it is NOT a real static call. It is a proxy that resolves the real object from the container and forwards the call to it. Think of it as a shortcut door into the Service Container.
Cache::get('key')
↓ (not a real static method)
resolves 'cache' from container → calls ->get('key') on the real CacheManager object
This means facades carry all the benefits of dependency injection — they're testable, mockable, and swappable — while giving you the terse, readable syntax of static calls.
Without facades, every class that needs a service must inject it through the constructor. For deeply nested helpers or utility calls, this bloats constructors unnecessarily.
<?php
use Illuminate\Contracts\Cache\Repository;
class UserController extends Controller
{
public function __construct(private Repository $cache) {}
public function show($id)
{
$user = $this->cache->get('user:' . $id);
}
}
<?php
use Illuminate\Support\Facades\Cache;
class UserController extends Controller
{
public function show($id)
{
$user = Cache::get('user:' . $id);
}
}
Both call the exact same underlying object. Facade is syntax sugar — it doesn't change what happens, only how it reads.
Every facade does three things:
Extends Illuminate\Support\Facades\Facade
Defines getFacadeAccessor() returning the container binding key
Uses PHP's __callStatic() magic to proxy calls to the real object
<?php
namespace Illuminate\Support\Facades;
class Cache extends Facade
{
protected static function getFacadeAccessor(): string
{
return 'cache'; // ← container binding key
}
}
// The Cache class has ZERO real methods.
// ALL calls are caught by __callStatic and forwarded.
Cache::get('key')
│
▼ __callStatic('get', ['key'])
│
▼ Facade base class:
1. calls getFacadeAccessor() → 'cache'
2. calls app()->make('cache') → resolves CacheManager from container
3. calls ->get('key') → on the CacheManager instance
│
▼
Result: identical to $this->cache->get('key')
Four steps to create your own facade for any service:
<?php
// app/Services/PaymentGateway.php
namespace App\Services;
class PaymentGateway
{
public function charge(int $amount): bool
{
// process charge...
return true;
}
public function refund(int $amount): bool
{
// process refund...
return true;
}
}
// In AppServiceProvider or your own PaymentServiceProvider
public function register(): void
{
$this->app->singleton(\App\Services\PaymentGateway::class);
}
<?php
// app/Facades/Payment.php
namespace App\Facades;
use Illuminate\Support\Facades\Facade;
class Payment extends Facade
{
protected static function getFacadeAccessor(): string
{
return \App\Services\PaymentGateway::class;
}
}
use App\Facades\Payment; // In a controller, route, anywhere: Payment::charge(5000); Payment::refund(1000);
Real-time facades let any class act as a facade instantly — with zero boilerplate. No need to create a dedicated Facade class.
Just prefix the import with Facades\:
use App\Contracts\Publisher;
class Podcast extends Model
{
// Must pass $publisher on every call
public function publish(Publisher $publisher): void
{
$publisher->publish($this);
}
}
use Facades\App\Contracts\Publisher; // ← just add "Facades\" prefix
class Podcast extends Model
{
// No injection needed
public function publish(): void
{
Publisher::publish($this);
}
}
Laravel sees: Facades\App\Contracts\Publisher
→ strips "Facades\" prefix
→ resolves App\Contracts\Publisher from the container
→ calls the method on the resolved object
Still fully testable:
Publisher::shouldReceive('publish')->once()->with($podcast);
$podcast->publish();
When to use real-time facades: ✅ One-off usage of a class without full facade boilerplate ✅ When you want static-style calling but still need testability ❌ Don't overuse — DI is still cleaner for classes with many dependencies or complex construction
Facades are NOT truly static — they can be mocked and spied on. This is one of their biggest advantages over real static methods.
Cache::shouldReceive('get')
->with('user:1')
->once()
->andReturn($user);
Cache::spy();
// ... run your code ...
Cache::shouldHaveReceived('put')
->with('user:1', $user, 3600);
// Mock only specific methods — rest still work normally
Cache::shouldReceive('get')->andReturn('cached');
// Cache::put(), Cache::forget(), etc. still hit real cache
cache('key') and Cache::get('key') resolve to the same object.
All three approaches resolve the same underlying object from the container. The choice is mostly about style and context.
Approach Syntax Testable? Auto-complete?
──────────────────── ────────────────────────────── ───────── ─────────────
Dependency Injection $this->cache->get('key') ✅ Yes ✅ Best
Facade Cache::get('key') ✅ Yes ✅ Yes
Helper function cache('key') ✅ Yes ⚠️ Sometimes
True static method MyClass::staticMethod() ❌ No ✅ Yes
When the dependency is central to the class's purpose
Large classes — a big constructor signals complexity (a useful feedback signal)
When building packages — more explicit, less Laravel-specific
Quick, expressive one-liners in routes and controllers
When injection would bloat the constructor for a minor, incidental use
Blade views and closures where injection isn't natural
Facades make it dangerously easy to add dependencies without noticing. Since there's no constructor injection, you get no visual feedback that your class is growing too large.
class OrderService
{
public function process(Order $order)
{
Cache::put(...) // facade 1
Mail::send(...) // facade 2
Log::info(...) // facade 3
Event::dispatch(...) // facade 4
DB::transaction(...) // facade 5
Notification::send(...) // facade 6
}
}
// With dependency injection you'd see 6 constructor params → alarm bell.
// With facades there's no visual signal — the class just grows silently.
Facade Underlying Class Container Key ────────────────── ──────────────────────────────────────── ───────────────── App Illuminate\Foundation\Application app Artisan Illuminate\Contracts\Console\Kernel artisan Auth Illuminate\Auth\AuthManager auth Auth (Instance) Illuminate\Contracts\Auth\Guard auth.driver Blade Illuminate\View\Compilers\BladeCompiler blade.compiler Broadcast Illuminate\Contracts\Broadcasting\Factory Bus Illuminate\Contracts\Bus\Dispatcher Cache Illuminate\Cache\CacheManager cache Cache (Instance) Illuminate\Cache\Repository cache.store Config Illuminate\Config\Repository config Context Illuminate\Log\Context\Repository Cookie Illuminate\Cookie\CookieJar cookie Crypt Illuminate\Encryption\Encrypter encrypter Date Illuminate\Support\DateFactory date DB Illuminate\Database\DatabaseManager db DB (Instance) Illuminate\Database\Connection db.connection Event Illuminate\Events\Dispatcher events Exceptions Illuminate\Foundation\Exceptions\Handler File Illuminate\Filesystem\Filesystem files Gate Illuminate\Contracts\Auth\Access\Gate Hash Illuminate\Contracts\Hashing\Hasher hash Http Illuminate\Http\Client\Factory Lang Illuminate\Translation\Translator translator Log Illuminate\Log\LogManager log Mail Illuminate\Mail\Mailer mailer Notification Illuminate\Notifications\ChannelManager Password Illuminate\Auth\Passwords\PasswordBrokerManager Pipeline Illuminate\Pipeline\Pipeline Process Illuminate\Process\Factory Queue Illuminate\Queue\QueueManager queue Queue (Instance) Illuminate\Contracts\Queue\Queue queue.connection RateLimiter Illuminate\Cache\RateLimiter Redirect Illuminate\Routing\Redirector redirect Redis Illuminate\Redis\RedisManager redis Redis (Instance) Illuminate\Redis\Connections\Connection redis.connection Request Illuminate\Http\Request request Response Illuminate\Contracts\Routing\ResponseFactory Route Illuminate\Routing\Router router Schedule Illuminate\Console\Scheduling\Schedule Schema Illuminate\Database\Schema\Builder Session Illuminate\Session\SessionManager session Session (Instance) Illuminate\Session\Store session.store Storage Illuminate\Filesystem\FilesystemManager filesystem Storage (Instance) Illuminate\Contracts\Filesystem\Filesystem filesystem.disk URL Illuminate\Routing\UrlGenerator url Validator Illuminate\Validation\Factory validator View Illuminate\View\Factory view Vite Illuminate\Foundation\Vite
// Cache
Cache::get('key') Cache::put('key', $val, $ttl)
Cache::remember('key', $ttl, fn) Cache::forget('key')
Cache::has('key') Cache::flush()
// Database
DB::table('users')->get() DB::select('SELECT ...')
DB::transaction(fn) DB::beginTransaction()
// Routing
Route::get('/path', fn) Route::middleware([...])->group(fn)
Route::resource('posts', PostController::class)
// Auth
Auth::user() Auth::check()
Auth::id() Auth::guard('api')->user()
// Logging
Log::info('msg', ['context']) Log::error('msg')
Log::debug('...') Log::warning('...')
// Storage
Storage::put('file.txt', $contents) Storage::get('file.txt')
Storage::disk('s3')->put(...) Storage::url('file.txt')
// Mail / Notifications / Events
Mail::to($user)->send(new WelcomeMail)
Notification::send($users, new OrderShipped)
Event::dispatch(new UserRegistered($user))
// Config / URL / Redirect
Config::get('app.name') Config::set('key', 'value')
URL::to('/path') URL::route('name', $params)
Redirect::to('/path') Redirect::route('name')
Request::input('field') Request::user()
Understanding how facades, the container, and service providers connect is the key to mastering Laravel's architecture:
┌──────────────────────────────────────────────────────────────────────┐
│ Service Provider (register) │
│ $this->app->singleton('cache', fn() => new CacheManager(...)) │
│ ↓ stores binding in container │
│ SERVICE CONTAINER │
│ ↓ on Cache::get('key') │
│ Facade (Cache) │
│ getFacadeAccessor() → 'cache' │
│ __callStatic() → app()->make('cache') → CacheManager │
│ → forwards ->get('key') to the real CacheManager │
└──────────────────────────────────────────────────────────────────────┘
The chain: Facade → Container → Real Object
You interact with the Facade.
You never touch the real class directly.
You can swap the real class without touching a single Facade call.
Laravel Facades are not magic — they're a well-designed proxy pattern that makes the Service
Container ergonomic to use. Once you understand getFacadeAccessor() and
__callStatic(), they hold no surprises.
A facade proxies to a real object in the container — it's not truly static
Every facade defines getFacadeAccessor() returning the container key
Facades are fully testable via shouldReceive() and spy()
Real-time facades (Facades\Your\Class) give any class facade syntax with zero boilerplate
All three — Facade, DI, helper function — resolve the same underlying object
Watch for scope creep — facades hide complexity that constructor injection would reveal
Build custom facades in 4 steps: service class → provider binding → Facade class → use it