Laravel Service Container Deep Dive | Mohamed Said [Skip to content](#main) [ ![](https://cdn.msaied.com/01KT78WE565VEMM3PSNQAAB0MH.png) Mohamed SaidLaravel Backend Engineer ](https://msaied.com/public) - [Home](https://msaied.com/public) - [Projects](https://msaied.com/public/projects) - [Articles](https://msaied.com/public/articles) - [Certificates](https://msaied.com/public/certificates) - [About](https://msaied.com/public#about) [ Contact](https://msaied.com/public#contact) Menu Menu ---- Close - [HomeStart here](https://msaied.com/public) - [ProjectsCase studies](https://msaied.com/public/projects) - [ArticlesEngineering notes](https://msaied.com/public/articles) - [CertificatesCredentials](https://msaied.com/public/certificates) - [AboutHow I work](https://msaied.com/public#about) - [ContactGet in touch](https://msaied.com/public#contact) [Start a conversation](https://msaied.com/public#contact) [WhatsApp](https://wa.me/201094619204) [Email](mailto:hello@msaied.com) 1. [Home](https://msaied.com/public) 2. / 3. [Articles](https://msaied.com/public/articles) 4. / 5. Laravel Service Container: Contextual Binding, Tagging, and Method Injection Laravel Service Container: Contextual Binding, Tagging, and Method Injection ============================================================================= Go beyond basic binding. Learn how contextual binding resolves different implementations per consumer, how tagging aggregates services, and how method injection keeps controllers slim without sacrificing testability. ![](https://cdn.msaied.com/01M22N44A70A5MC2S599JP0MPH.webp) [Mohamed Said](https://msaied.com/public#person) Published 26 Jun 2026 · Updated 26 Jun 2026 · 3 min read ShareCopy linkCopied ![Laravel Service Container: Contextual Binding, Tagging, and Method Injection](https://cdn.msaied.com/294/e5b9d047bd33c3f8b80069ef6a178884.png) On this page +1. [Beyond app()->make(): The Container Features Most Devs Skip](#beyond-codeapp-gtmakecode-the-container-features-most-devs-skip) 2. [Contextual Binding](#contextual-binding) 3. [Giving a primitive value contextually](#giving-a-primitive-value-contextually) 4. [Tagging](#tagging) 5. [Method Injection](#method-injection) 6. [Practical pattern: action classes without constructor bloat](#practical-pattern-action-classes-without-constructor-bloat) 7. [Key Takeaways](#key-takeaways) Beyond `app()->make()`: The Container Features Most Devs Skip ------------------------------------------------------------- The Laravel service container is the backbone of the framework, yet most codebases only scratch its surface with simple `bind` and `singleton` calls. Three features — contextual binding, tagging, and method injection — unlock genuinely cleaner architecture when applied deliberately. --- Contextual Binding ------------------ Contextual binding lets you resolve a *different* concrete class depending on which class is requesting it. This is invaluable when two subsystems share an interface but need distinct implementations. ```php // AppServiceProvider::register() $this->app ->when(\App\Http\Controllers\ReportController::class) ->needs(\App\Contracts\StorageDriver::class) ->give(\App\Services\S3StorageDriver::class); $this->app ->when(\App\Console\Commands\ArchiveCommand::class) ->needs(\App\Contracts\StorageDriver::class) ->give(\App\Services\GcsStorageDriver::class); ``` Both consumers type-hint `StorageDriver`; the container silently injects the right driver. No factory, no `if` chain in the constructor. ### Giving a primitive value contextually ```php $this->app ->when(\App\Services\MailgunMailer::class) ->needs('$apiKey') ->give(fn () => config('services.mailgun.key')); ``` This keeps environment-specific config out of constructors and out of service classes themselves. --- Tagging ------- Tagging groups multiple bindings under a label so you can resolve all of them at once — perfect for plugin-style architectures, report generators, or notification channels. ```php // Register $this->app->bind(CsvExporter::class); $this->app->bind(XlsxExporter::class); $this->app->bind(PdfExporter::class); $this->app->tag( [CsvExporter::class, XlsxExporter::class, PdfExporter::class], 'exporters' ); ``` ```php // Consume class ExportManager { /** @param iterable $exporters */ public function __construct( private readonly iterable $exporters, ) {} public function export(string $format, mixed $data): string { foreach ($this->exporters as $exporter) { if ($exporter->supports($format)) { return $exporter->export($data); } } throw new \InvalidArgumentException("No exporter for {$format}"); } } ``` ```php // Bind ExportManager with tagged collection $this->app->bind(ExportManager::class, function ($app) { return new ExportManager($app->tagged('exporters')); }); ``` `$app->tagged('exporters')` returns a lazy `TaggedIterator` — instances are only resolved when iterated, keeping boot time low. --- Method Injection ---------------- The container can resolve dependencies directly into *any* callable, not just constructors. This is how route closures and controller methods already work, but you can leverage it explicitly. ```php // Dispatch a closure with auto-resolved dependencies app()->call(function ( UserRepository $users, CacheManager $cache, int $userId = 42, ): void { $user = $users->find($userId); $cache->put("user:{$userId}", $user, 3600); }); ``` You can also call instance methods: ```php app()->call([$reportService, 'generate'], ['month' => 'June']); ``` The container merges type-hinted dependencies from the container with the explicitly passed primitives. This is particularly useful in console commands, Artisan closures, and test helpers where you want full DI without registering a class. ### Practical pattern: action classes without constructor bloat ```php class GenerateInvoiceAction { public function handle( Invoice $invoice, PdfRenderer $renderer, StorageDriver $storage, ): string { $pdf = $renderer->render($invoice); return $storage->put("invoices/{$invoice->id}.pdf", $pdf); } } // Caller $path = app()->call( [app(GenerateInvoiceAction::class), 'handle'], ['invoice' => $invoice] ); ``` The action carries no constructor dependencies — they arrive at call time, making the class trivially testable with fakes. --- Key Takeaways ------------- - **Contextual binding** eliminates conditional logic in constructors when the same interface needs different implementations per consumer. - **Tagging** enables open/closed plugin patterns — add a new exporter by registering and tagging it, zero changes to `ExportManager`. - **`$app->tagged()`** is lazy; prefer it over resolving all tagged services upfront. - **Method injection via `app()->call()`** is the cleanest way to give action classes their dependencies without coupling them to the container in constructors. - All three features are fully supported by Laravel's test helpers — swap bindings in `setUp` and your contextual or tagged services resolve fakes automatically. - [laravel](https://msaied.com/public/articles?search=laravel) - [service-container](https://msaied.com/public/articles?search=service-container) - [dependency-injection](https://msaied.com/public/articles?search=dependency-injection) - [architecture](https://msaied.com/public/articles?search=architecture) Frequently asked questions --------------------------- Does contextual binding work with interface type-hints or only concrete classes?It works with both. The `needs()` call accepts an interface string just as well as a concrete class name, so you can contextually resolve different implementations of the same interface per consumer. Is there a performance cost to using `app()->tagged()` with many bindings?No significant cost at boot time because `tagged()` returns a lazy `TaggedIterator`. Concrete instances are only resolved when you iterate, so registering many tagged bindings does not slow down the container bootstrap. Can I use method injection in Pest tests without bootstrapping the full application?You need at least a partial application instance. In a Pest feature test the full app is available, so `app()->call()` works normally. For unit tests you can construct a minimal container, bind your fakes, and call the method — no HTTP kernel required. ![Mohamed Said](https://cdn.msaied.com/01M22N44A70A5MC2S599JP0MPH.webp)About the author ---------------- [Mohamed Said](https://msaied.com/public#person)Senior Backend Engineer specializing in Laravel, scalable SaaS platforms, APIs, and cloud infrastructure. I build secure, high-performance web applications that help businesses grow. [About](https://msaied.com/public#about) [GitHub ↗](https://github.com/EG-Mohamed) [LinkedIn ↗](https://www.linkedin.com/in/msaiedm/) [WhatsApp ↗](https://wa.me/201094619204) [Email Address ↗](mailto:hello@msaied.com) [My CV ↗](https://drive.google.com/file/u/0/d/1MF20IPRJyzfy32mhEutjL5EpSls0w2Q8/view) [Previous articlePostgreSQL JSONB in Laravel: Indexing, Querying, and Casting Without the Pain](https://msaied.com/public/articles/postgresql-jsonb-in-laravel-indexing-querying-and-casting-without-the-pain) [Next articleLaravel WhatsApp: Send Messages via Meta Cloud API and whatsapp-web.js Behind One Facade](https://msaied.com/public/articles/laravel-whatsapp-send-messages-via-meta-cloud-api-and-whatsapp-webjs-behind-one-facade) On this page ------------- 1. [Beyond app()->make(): The Container Features Most Devs Skip](#beyond-codeapp-gtmakecode-the-container-features-most-devs-skip) 2. [Contextual Binding](#contextual-binding) 3. [Giving a primitive value contextually](#giving-a-primitive-value-contextually) 4. [Tagging](#tagging) 5. [Method Injection](#method-injection) 6. [Practical pattern: action classes without constructor bloat](#practical-pattern-action-classes-without-constructor-bloat) 7. [Key Takeaways](#key-takeaways) ### Have a technical challenge? Tell me what you’re building. I reply within two working days. [Start a conversation](https://msaied.com/public#contact) Related articles ----------------- [ ![](https://cdn.msaied.com/745/8744e1be5136b430da52e9fca3ed3964.png) · 3 min read### Service Container Deep Dive: Contextual Binding, Tagging, and Method Injection 6 Oct 2026 ](https://msaied.com/public/articles/service-container-deep-dive-contextual-binding-tagging-and-method-injection-1) [ ![](https://cdn.msaied.com/743/8998fac3a41451ab3fe1588194e17a43.png) Filament · 3 min read### Securing Filament Plugins with Plumb: Automated Security Scoring for PHP Packages 5 Oct 2026 ](https://msaied.com/public/articles/securing-filament-plugins-with-plumb-automated-security-scoring-for-php-packages) [ ![](https://cdn.msaied.com/742/2d02018669cdeedccb5de2efb898f0ee.png) Filament · 3 min read### Filament v3.3.56 Released: File Hash Names and Livewire Upload Fix 5 Oct 2026 ](https://msaied.com/public/articles/filament-v3356-released-file-hash-names-and-livewire-upload-fix) Have a technical challenge? ---------------------------- Tell me what you’re building. I reply within two working days. [Discuss your project ↗](https://msaied.com/public#contact) © 2026 Mohamed Said · Built with Laravel, meant to last.Senior Backend Engineer specializing in Laravel, scalable SaaS platforms, APIs, and cloud infrastructure. I build secure, high-performance web applications that help businesses grow. - [Home](https://msaied.com/public) - [Articles](https://msaied.com/public/articles) - [Certificates](https://msaied.com/public/certificates) - [GitHub](https://github.com/EG-Mohamed) - [LinkedIn](https://www.linkedin.com/in/msaiedm/) - [WhatsApp](https://wa.me/201094619204) - [Email Address](mailto:hello@msaied.com) - [My CV](https://drive.google.com/file/u/0/d/1MF20IPRJyzfy32mhEutjL5EpSls0w2Q8/view) - [Sitemap](https://msaied.com/public/sitemap.xml)