Service Container

The Laravel service container is a powerful tool for managing class dependencies and performing dependency injection. Dependency injection is a fancy phrase that essentially means this: class dependencies are "injected" into the class via the constructor or, in some cases, "setter" methods.<\/p>\n
 1<\/span><?php<\/span><\/div> 2<\/span> <\/div> 3<\/span>namespace<\/span> App\\Http\\Controllers;<\/span><\/div> 4<\/span> <\/div> 5<\/span>use<\/span> App\\Services\\<\/span>AppleMusic<\/span>;<\/span><\/div> 6<\/span>use<\/span> Illuminate\\View\\<\/span>View<\/span>;<\/span><\/div> 7<\/span> <\/div> 8<\/span>class<\/span> <\/span>PodcastController<\/span> <\/span>extends<\/span> <\/span>Controller<\/span><\/div> 9<\/span>{<\/span><\/div>10<\/span>    <\/span>\/**<\/span><\/div>11<\/span>     * Create a new controller instance.<\/span><\/div>12<\/span>     <\/span>*\/<\/span><\/div>13<\/span>    <\/span>public<\/span> <\/span>function<\/span> <\/span>__construct<\/span>(<\/span><\/div>14<\/span>        <\/span>protected<\/span> <\/span>AppleMusic<\/span> <\/span>$apple<\/span>,<\/span><\/div>15<\/span>    <\/span>)<\/span> {}<\/span><\/div>16<\/span> <\/div>17<\/span>    <\/span>\/**<\/span><\/div>18<\/span>     * Show information about the given podcast.<\/span><\/div>19<\/span>     <\/span>*\/<\/span><\/div>20<\/span>    <\/span>public<\/span> <\/span>function<\/span> <\/span>show<\/span>(<\/span>string<\/span> <\/span>$id<\/span>)<\/span>:<\/span> <\/span>View<\/span><\/div>21<\/span>    {<\/span><\/div>22<\/span>        <\/span>return<\/span> <\/span>view<\/span>(<\/span>'<\/span>podcasts.show<\/span>'<\/span>,<\/span> <\/span>[<\/span><\/div>23<\/span>            <\/span>'<\/span>podcast<\/span>'<\/span> <\/span>=><\/span> <\/span>$<\/span>this<\/span>->apple-><\/span>findPodcast<\/span>($<\/span>id<\/span>)<\/span><\/div>24<\/span>        <\/span>]);<\/span><\/div>25<\/span>    }<\/span><\/div>26<\/span>}<\/span><\/div>\n<?php\n\nnamespace App\\Http\\Controllers;\n\nuse App\\Services\\AppleMusic;\nuse Illuminate\\View\\View;\n\nclass PodcastController extends Controller\n{\n    \/**\n     * Create a new controller instance.\n     *\/\n    public function __construct(\n        protected AppleMusic $apple,\n    ) {}\n\n    \/**\n     * Show information about the given podcast.\n     *\/\n    public function show(string $id): View\n    {\n        return view('podcasts.show', [\n            'podcast' => $this->apple->findPodcast($id)\n        ]);\n    }\n}<\/div><\/code><\/pre>\n<\/div>\n


In this example, the PodcastController<\/code> needs to retrieve podcasts from a data source such as Apple Music. So, we will inject<\/strong> a service that is able to retrieve podcasts. Since the service is injected, we are able to easily "mock", or create a dummy implementation of the AppleMusic<\/code> service when testing our application.<\/p>\n
A deep understanding of the Laravel service container is essential to building a powerful, large application, as well as for contributing to the Laravel core itself.<\/p>\n
Zero Configuration Resolution<\/a><\/h3>\nIf a class has no dependencies or only depends on other concrete classes (not interfaces), the container does not need to be instructed on how to resolve that class. For example, you may place the following code in your routes\/web.php<\/code> file:<\/p>\n\n 1<\/span><?php<\/span><\/div> 2<\/span> <\/div> 3<\/span>class<\/span> <\/span>Service<\/span><\/div> 4<\/span>{<\/span><\/div> 5<\/span>    <\/span>\/\/<\/span> ...<\/span><\/div> 6<\/span>}<\/span><\/div> 7<\/span> <\/div> 8<\/span>Route<\/span>::<\/span>get<\/span>(<\/span>'<\/span>\/<\/span>'<\/span>, <\/span>function<\/span> <\/span>(<\/span>Service<\/span> <\/span>$service<\/span>)<\/span> {<\/span><\/div> 9<\/span>    <\/span>dd<\/span>($<\/span>service<\/span>::<\/span>class<\/span>);<\/span><\/div>10<\/span>});<\/span><\/div>\n<?php\n\nclass Service\n{\n    \/\/ ...\n}\n\nRoute::get('\/', function (Service $service) {\n    dd($service::class);\n});<\/div><\/code><\/pre>\n<\/div>\nIn this example, hitting your application's \/<\/code> route will automatically resolve the Service<\/code> class and inject it into your route's handler. This is game changing. It means you can develop your application and take advantage of dependency injection without worrying about bloated configuration files.<\/p>\n
Thankfully, many of the classes you will be writing when building a Laravel application automatically receive their dependencies via the container, including controllers<\/a>, event listeners<\/a>, middleware<\/a>, and more. Additionally, you may type-hint dependencies in the handle<\/code> method of queued jobs<\/a>. Once you taste the power of automatic and zero configuration dependency injection it feels impossible to develop without it.<\/p>\n
When to Utilize the Container<\/a><\/h3>\nThanks to zero configuration resolution, you will often type-hint dependencies on routes, controllers, event listeners, and elsewhere without ever manually interacting with the container. For example, you might type-hint the Illuminate\\Http\\Request<\/code> object on your route definition so that you can easily access the current request. Even though we never have to interact with the container to write this code, it is managing the injection of these dependencies behind the scenes:<\/p>\n\n1<\/span>use<\/span> Illuminate\\Http\\<\/span>Request<\/span>;<\/span><\/div>2<\/span> <\/div>3<\/span>Route<\/span>::<\/span>get<\/span>(<\/span>'<\/span>\/<\/span>'<\/span>, <\/span>function<\/span> <\/span>(<\/span>Request<\/span> <\/span>$request<\/span>)<\/span> {<\/span><\/div>4<\/span>    <\/span>\/\/<\/span> ...<\/span><\/div>5<\/span>});<\/span><\/div>\nuse Illuminate\\Http\\Request;\n\nRoute::get('\/', function (Request $request) {\n    \/\/ ...\n});<\/div><\/code><\/pre>\n<\/div>\nIn many cases, thanks to automatic dependency injection and facades<\/a>, you can build Laravel applications without ever<\/strong> manually binding or resolving anything from the container. So, when would you ever manually interact with the container?<\/strong> Let's examine two situations.<\/p>\n
First, if you write a class that implements an interface and you wish to type-hint that interface on a route or class constructor, you must tell the container how to resolve that interface<\/a>. Secondly, if you are writing a Laravel package<\/a> that you plan to share with other Laravel developers, you may need to bind your package's services into the container.<\/p>\n
Binding<\/a><\/h2>\nBinding Basics<\/a><\/h3>\nSimple Bindings<\/a><\/h4>\nAlmost all of your service container bindings will be registered within service providers<\/a>, so most of these examples will demonstrate using the container in that context.<\/p>\n
Within a service provider, you always have access to the container via the $this->app<\/code> property. We can register a binding using the bind<\/code> method, passing the class or interface name that we wish to register along with a closure that returns an instance of the class:<\/p>\n
\n1<\/span>use<\/span> App\\Services\\<\/span>Transistor<\/span>;<\/span><\/div>2<\/span>use<\/span> App\\Services\\<\/span>PodcastParser<\/span>;<\/span><\/div>3<\/span>use<\/span> Illuminate\\Contracts\\Foundation\\<\/span>Application<\/span>;<\/span><\/div>4<\/span> <\/div>5<\/span>$this<\/span>->app-><\/span>bind<\/span>(<\/span>Transistor<\/span>::<\/span>class<\/span>, <\/span>function<\/span> <\/span>(<\/span>Application<\/span> <\/span>$app<\/span>)<\/span> {<\/span><\/div>6<\/span>    <\/span>return<\/span> <\/span>new<\/span> <\/span>Transistor<\/span>(<\/span>$app<\/span>-><\/span>make<\/span>(<\/span>PodcastParser<\/span>::<\/span>class<\/span>));<\/span><\/div>7<\/span>});<\/span><\/div>\nuse App\\Services\\Transistor;\nuse App\\Services\\PodcastParser;\nuse Illuminate\\Contracts\\Foundation\\Application;\n\n$this->app->bind(Transistor::class, function (Application $app) {\n    return new Transistor($app->make(PodcastParser::class));\n});<\/div><\/code><\/pre>\n<\/div>\nNote that we receive the container itself as an argument to the resolver. We can then use the container to resolve sub-dependencies of the object we are building.<\/p>\n
As mentioned, you will typically be interacting with the container within service providers; however, if you would like to interact with the container outside of a service provider, you may do so via the App<\/code> facade<\/a>:<\/p>\n
\n1<\/span>use<\/span> App\\Services\\<\/span>Transistor<\/span>;<\/span><\/div>2<\/span>use<\/span> Illuminate\\Contracts\\Foundation\\<\/span>Application<\/span>;<\/span><\/div>3<\/span>use<\/span> Illuminate\\Support\\Facades\\<\/span>App<\/span>;<\/span><\/div>4<\/span> <\/div>5<\/span>App<\/span>::<\/span>bind<\/span>(<\/span>Transistor<\/span>::<\/span>class<\/span>, <\/span>function<\/span> <\/span>(<\/span>Application<\/span> <\/span>$app<\/span>)<\/span> {<\/span><\/div>6<\/span>    <\/span>\/\/<\/span> ...<\/span><\/div>7<\/span>});<\/span><\/div>\nuse App\\Services\\Transistor;\nuse Illuminate\\Contracts\\Foundation\\Application;\nuse Illuminate\\Support\\Facades\\App;\n\nApp::bind(Transistor::class, function (Application $app) {\n    \/\/ ...\n});<\/div><\/code><\/pre>\n<\/div>\nYou may use the bindIf<\/code> method to register a container binding only if a binding has not already been registered for the given type:<\/p>\n
\n1<\/span>$this<\/span>->app-><\/span>bindIf<\/span>(<\/span>Transistor<\/span>::<\/span>class<\/span>, <\/span>function<\/span> <\/span>(<\/span>Application<\/span> <\/span>$app<\/span>)<\/span> {<\/span><\/div>2<\/span>    <\/span>return<\/span> <\/span>new<\/span> <\/span>Transistor<\/span>(<\/span>$app<\/span>-><\/span>make<\/span>(<\/span>PodcastParser<\/span>::<\/span>class<\/span>));<\/span><\/div>3<\/span>});<\/span><\/div>\n$this->app->bindIf(Transistor::class, function (Application $app) {\n    return new Transistor($app->make(PodcastParser::class));\n});<\/div><\/code><\/pre>\n<\/div>\nFor convenience, you may omit providing the class or interface name that you wish to register as a separate argument and instead allow Laravel to infer the type from the return type of the closure you provide to the bind<\/code> method:<\/p>\n
\n1<\/span>App<\/span>::<\/span>bind<\/span>(<\/span>function<\/span> <\/span>(<\/span>Application<\/span> <\/span>$app<\/span>)<\/span>:<\/span> <\/span>Transistor<\/span> {<\/span><\/div>2<\/span>    <\/span>return<\/span> <\/span>new<\/span> <\/span>Transistor<\/span>(<\/span>$app<\/span>-><\/span>make<\/span>(<\/span>PodcastParser<\/span>::<\/span>class<\/span>));<\/span><\/div>3<\/span>});<\/span><\/div>\nApp::bind(function (Application $app): Transistor {\n    return new Transistor($app->make(PodcastParser::class));\n});<\/div><\/code><\/pre>\n<\/div>\n\n    \n        \nThere is no need to bind classes into the container if they do not depend on any interfaces. The container does not need to be instructed on how to build these objects, since it can automatically resolve these objects using reflection.<\/p>\n<\/div>\n
Binding A Singleton<\/a><\/h4>\nThe singleton<\/code> method binds a class or interface into the container that should only be resolved one time. Once a singleton binding is resolved, the same object instance will be returned on subsequent calls into the container:<\/p>\n\n1<\/span>use<\/span> App\\Services\\<\/span>Transistor<\/span>;<\/span><\/div>2<\/span>use<\/span> App\\Services\\<\/span>PodcastParser<\/span>;<\/span><\/div>3<\/span>use<\/span> Illuminate\\Contracts\\Foundation\\<\/span>Application<\/span>;<\/span><\/div>4<\/span> <\/div>5<\/span>$this<\/span>->app-><\/span>singleton<\/span>(<\/span>Transistor<\/span>::<\/span>class<\/span>, <\/span>function<\/span> <\/span>(<\/span>Application<\/span> <\/span>$app<\/span>)<\/span> {<\/span><\/div>6<\/span>    <\/span>return<\/span> <\/span>new<\/span> <\/span>Transistor<\/span>(<\/span>$app<\/span>-><\/span>make<\/span>(<\/span>PodcastParser<\/span>::<\/span>class<\/span>));<\/span><\/div>7<\/span>});<\/span><\/div>\nuse App\\Services\\Transistor;\nuse App\\Services\\PodcastParser;\nuse Illuminate\\Contracts\\Foundation\\Application;\n\n$this->app->singleton(Transistor::class, function (Application $app) {\n    return new Transistor($app->make(PodcastParser::class));\n});<\/div><\/code><\/pre>\n<\/div>\nYou may use the singletonIf<\/code> method to register a singleton container binding only if a binding has not already been registered for the given type:<\/p>\n
\n1<\/span>$this<\/span>->app-><\/span>singletonIf<\/span>(<\/span>Transistor<\/span>::<\/span>class<\/span>, <\/span>function<\/span> <\/span>(<\/span>Application<\/span> <\/span>$app<\/span>)<\/span> {<\/span><\/div>2<\/span>    <\/span>return<\/span> <\/span>new<\/span> <\/span>Transistor<\/span>(<\/span>$app<\/span>-><\/span>make<\/span>(<\/span>PodcastParser<\/span>::<\/span>class<\/span>));<\/span><\/div>3<\/span>});<\/span><\/div>\n$this->app->singletonIf(Transistor::class, function (Application $app) {\n    return new Transistor($app->make(PodcastParser::class));\n});<\/div><\/code><\/pre>\n<\/div>\nSingleton Attribute<\/a><\/h4>\nAlternatively, you may mark an interface or class with the #[Singleton]<\/code> attribute to indicate to the container that it should be resolved one time:<\/p>\n\n 1<\/span><?php<\/span><\/div> 2<\/span> <\/div> 3<\/span>namespace<\/span> App\\Services;<\/span><\/div> 4<\/span> <\/div> 5<\/span>use<\/span> Illuminate\\Container\\Attributes\\<\/span>Singleton<\/span>;<\/span><\/div> 6<\/span> <\/div> 7<\/span>#[Singleton]<\/span><\/div> 8<\/span>class<\/span> <\/span>Transistor<\/span><\/div> 9<\/span>{<\/span><\/div>10<\/span>    <\/span>\/\/<\/span> ...<\/span><\/div>11<\/span>}<\/span><\/div>\n<?php\n\nnamespace App\\Services;\n\nuse Illuminate\\Container\\Attributes\\Singleton;\n\n#[Singleton]\nclass Transistor\n{\n    \/\/ ...\n}<\/div><\/code><\/pre>\n<\/div>\nBinding Scoped Singletons<\/a><\/h4>\nThe scoped<\/code> method binds a class or interface into the container that should only be resolved one time within a given Laravel request \/ job lifecycle. While this method is similar to the singleton<\/code> method, instances registered using the scoped<\/code> method will be flushed whenever the Laravel application starts a new "lifecycle", such as when a Laravel Octane<\/a> worker processes a new request or when a Laravel queue worker<\/a> processes a new job:<\/p>\n
\n1<\/span>use<\/span> App\\Services\\<\/span>Transistor<\/span>;<\/span><\/div>2<\/span>use<\/span> App\\Services\\<\/span>PodcastParser<\/span>;<\/span><\/div>3<\/span>use<\/span> Illuminate\\Contracts\\Foundation\\<\/span>Application<\/span>;<\/span><\/div>4<\/span> <\/div>5<\/span>$this<\/span>->app-><\/span>scoped<\/span>(<\/span>Transistor<\/span>::<\/span>class<\/span>, <\/span>function<\/span> <\/span>(<\/span>Application<\/span> <\/span>$app<\/span>)<\/span> {<\/span><\/div>6<\/span>    <\/span>return<\/span> <\/span>new<\/span> <\/span>Transistor<\/span>(<\/span>$app<\/span>-><\/span>make<\/span>(<\/span>PodcastParser<\/span>::<\/span>class<\/span>));<\/span><\/div>7<\/span>});<\/span><\/div>\nuse App\\Services\\Transistor;\nuse App\\Services\\PodcastParser;\nuse Illuminate\\Contracts\\Foundation\\Application;\n\n$this->app->scoped(Transistor::class, function (Application $app) {\n    return new Transistor($app->make(PodcastParser::class));\n});<\/div><\/code><\/pre>\n<\/div>\nYou may use the scopedIf<\/code> method to register a scoped container binding only if a binding has not already been registered for the given type:<\/p>\n
\n1<\/span>$this<\/span>->app-><\/span>scopedIf<\/span>(<\/span>Transistor<\/span>::<\/span>class<\/span>, <\/span>function<\/span> <\/span>(<\/span>Application<\/span> <\/span>$app<\/span>)<\/span> {<\/span><\/div>2<\/span>    <\/span>return<\/span> <\/span>new<\/span> <\/span>Transistor<\/span>(<\/span>$app<\/span>-><\/span>make<\/span>(<\/span>PodcastParser<\/span>::<\/span>class<\/span>));<\/span><\/div>3<\/span>});<\/span><\/div>\n$this->app->scopedIf(Transistor::class, function (Application $app) {\n    return new Transistor($app->make(PodcastParser::class));\n});<\/div><\/code><\/pre>\n<\/div>\nScoped Attribute<\/a><\/h4>\nAlternatively, you may mark an interface or class with the #[Scoped]<\/code> attribute to indicate to the container that it should be resolved one time within a given Laravel request \/ job lifecycle:<\/p>\n\n 1<\/span><?php<\/span><\/div> 2<\/span> <\/div> 3<\/span>namespace<\/span> App\\Services;<\/span><\/div> 4<\/span> <\/div> 5<\/span>use<\/span> Illuminate\\Container\\Attributes\\<\/span>Scoped<\/span>;<\/span><\/div> 6<\/span> <\/div> 7<\/span>#[Scoped]<\/span><\/div> 8<\/span>class<\/span> <\/span>Transistor<\/span><\/div> 9<\/span>{<\/span><\/div>10<\/span>    <\/span>\/\/<\/span> ...<\/span><\/div>11<\/span>}<\/span><\/div>\n<?php\n\nnamespace App\\Services;\n\nuse Illuminate\\Container\\Attributes\\Scoped;\n\n#[Scoped]\nclass Transistor\n{\n    \/\/ ...\n}<\/div><\/code><\/pre>\n<\/div>\nBinding Instances<\/a><\/h4>\nYou may also bind an existing object instance into the container using the instance<\/code> method. The given instance will always be returned on subsequent calls into the container:<\/p>\n\n1<\/span>use<\/span> App\\Services\\<\/span>Transistor<\/span>;<\/span><\/div>2<\/span>use<\/span> App\\Services\\<\/span>PodcastParser<\/span>;<\/span><\/div>3<\/span> <\/div>4<\/span>$service<\/span> <\/span>=<\/span> <\/span>new<\/span> <\/span>Transistor<\/span>(<\/span>new<\/span> <\/span>PodcastParser<\/span>);<\/span><\/div>5<\/span> <\/div>6<\/span>$this<\/span>->app-><\/span>instance<\/span>(<\/span>Transistor<\/span>::<\/span>class<\/span>, <\/span>$service<\/span>);<\/span><\/div>\nuse App\\Services\\Transistor;\nuse App\\Services\\PodcastParser;\n\n$service = new Transistor(new PodcastParser);\n\n$this->app->instance(Transistor::class, $service);<\/div><\/code><\/pre>\n<\/div>\nBinding Interfaces to Implementations<\/a><\/h3>\nA very powerful feature of the service container is its ability to bind an interface to a given implementation. For example, let's assume we have an EventPusher<\/code> interface and a RedisEventPusher<\/code> implementation. Once we have coded our RedisEventPusher<\/code> implementation of this interface, we can register it with the service container like so:<\/p>\n\n1<\/span>use<\/span> App\\Contracts\\<\/span>EventPusher<\/span>;<\/span><\/div>2<\/span>use<\/span> App\\Services\\<\/span>RedisEventPusher<\/span>;<\/span><\/div>3<\/span> <\/div>4<\/span>$this<\/span>->app-><\/span>bind<\/span>(<\/span>EventPusher<\/span>::<\/span>class<\/span>, <\/span>RedisEventPusher<\/span>::<\/span>class<\/span>);<\/span><\/div>\nuse App\\Contracts\\EventPusher;\nuse App\\Services\\RedisEventPusher;\n\n$this->app->bind(EventPusher::class, RedisEventPusher::class);<\/div><\/code><\/pre>\n<\/div>\nThis statement tells the container that it should inject the RedisEventPusher<\/code> when a class needs an implementation of EventPusher<\/code>. Now we can type-hint the EventPusher<\/code> interface in the constructor of a class that is resolved by the container. Remember, controllers, event listeners, middleware, and various other types of classes within Laravel applications are always resolved using the container:<\/p>\n\n1<\/span>use<\/span> App\\Contracts\\<\/span>EventPusher<\/span>;<\/span><\/div>2<\/span> <\/div>3<\/span>\/**<\/span><\/div>4<\/span> * Create a new class instance.<\/span><\/div>5<\/span> <\/span>*\/<\/span><\/div>6<\/span>public<\/span> <\/span>function<\/span> <\/span>__construct<\/span>(<\/span><\/div>7<\/span>    <\/span>protected<\/span> <\/span>EventPusher<\/span> <\/span>$pusher<\/span>,<\/span><\/div>8<\/span>)<\/span> {}<\/span><\/div>\nuse App\\Contracts\\EventPusher;\n\n\/**\n * Create a new class instance.\n *\/\npublic function __construct(\n    protected EventPusher $pusher,\n) {}<\/div><\/code><\/pre>\n<\/div>\nBind Attribute<\/a><\/h4>\nLaravel also provides a Bind<\/code> attribute for added convenience. You can apply this attribute to any interface to tell Laravel which implementation should be automatically injected whenever that interface is requested. When using the Bind<\/code> attribute, there is no need to perform any additional service registration in your application's service providers.<\/p>\n
In addition, multiple Bind<\/code> attributes may be placed on an interface in order to configure a different implementation that should be injected for a given set of environments:<\/p>\n\n 1<\/span><?php<\/span><\/div> 2<\/span> <\/div> 3<\/span>namespace<\/span> App\\Contracts;<\/span><\/div> 4<\/span> <\/div> 5<\/span>use<\/span> App\\Services\\<\/span>FakeEventPusher<\/span>;<\/span><\/div> 6<\/span>use<\/span> App\\Services\\<\/span>RedisEventPusher<\/span>;<\/span><\/div> 7<\/span>use<\/span> Illuminate\\Container\\Attributes\\<\/span>Bind<\/span>;<\/span><\/div> 8<\/span> <\/div> 9<\/span>#[Bind(<\/span>RedisEventPusher<\/span>::<\/span>class<\/span>)]<\/span><\/div>10<\/span>#[Bind(<\/span>FakeEventPusher<\/span>::<\/span>class<\/span>, environments: [<\/span>'<\/span>local<\/span>'<\/span>, <\/span>'<\/span>testing<\/span>'<\/span>])]<\/span><\/div>11<\/span>interface<\/span> EventPusher<\/span><\/div>12<\/span>{<\/span><\/div>13<\/span>    <\/span>\/\/<\/span> ...<\/span><\/div>14<\/span>}<\/span><\/div>\n<?php\n\nnamespace App\\Contracts;\n\nuse App\\Services\\FakeEventPusher;\nuse App\\Services\\RedisEventPusher;\nuse Illuminate\\Container\\Attributes\\Bind;\n\n#[Bind(RedisEventPusher::class)]\n#[Bind(FakeEventPusher::class, environments: ['local', 'testing'])]\ninterface EventPusher\n{\n    \/\/ ...\n}<\/div><\/code><\/pre>\n<\/div>\nFurthermore, Singleton<\/a> and Scoped<\/a> attributes may be applied to indicate if the container bindings should be resolved once or once per request \/ job lifecycle:<\/p>\n
\n 1<\/span>use<\/span> App\\Services\\<\/span>RedisEventPusher<\/span>;<\/span><\/div> 2<\/span>use<\/span> Illuminate\\Container\\Attributes\\<\/span>Bind<\/span>;<\/span><\/div> 3<\/span>use<\/span> Illuminate\\Container\\Attributes\\<\/span>Singleton<\/span>;<\/span><\/div> 4<\/span> <\/div> 5<\/span>#[Bind(<\/span>RedisEventPusher<\/span>::<\/span>class<\/span>)]<\/span><\/div> 6<\/span>#[Singleton]<\/span><\/div> 7<\/span>interface<\/span> EventPusher<\/span><\/div> 8<\/span>{<\/span><\/div> 9<\/span>    <\/span>\/\/<\/span> ...<\/span><\/div>10<\/span>}<\/span><\/div>\nuse App\\Services\\RedisEventPusher;\nuse Illuminate\\Container\\Attributes\\Bind;\nuse Illuminate\\Container\\Attributes\\Singleton;\n\n#[Bind(RedisEventPusher::class)]\n#[Singleton]\ninterface EventPusher\n{\n    \/\/ ...\n}<\/div><\/code><\/pre>\n<\/div>\nContextual Binding<\/a><\/h3>\nSometimes you may have two classes that utilize the same interface, but you wish to inject different implementations into each class. For example, two controllers may depend on different implementations of the Illuminate\\Contracts\\Filesystem\\Filesystem<\/code> contract<\/a>. Laravel provides a simple, fluent interface for defining this behavior:<\/p>\n
\n 1<\/span>use<\/span> App\\Http\\Controllers\\<\/span>PhotoController<\/span>;<\/span><\/div> 2<\/span>use<\/span> App\\Http\\Controllers\\<\/span>UploadController<\/span>;<\/span><\/div> 3<\/span>use<\/span> App\\Http\\Controllers\\<\/span>VideoController<\/span>;<\/span><\/div> 4<\/span>use<\/span> Illuminate\\Contracts\\Filesystem\\<\/span>Filesystem<\/span>;<\/span><\/div> 5<\/span>use<\/span> Illuminate\\Support\\Facades\\<\/span>Storage<\/span>;<\/span><\/div> 6<\/span> <\/div> 7<\/span>$this<\/span>->app-><\/span>when<\/span>(<\/span>PhotoController<\/span>::<\/span>class<\/span>)<\/span><\/div> 8<\/span>    <\/span>-><\/span>needs<\/span>(<\/span>Filesystem<\/span>::<\/span>class<\/span>)<\/span><\/div> 9<\/span>    <\/span>-><\/span>give<\/span>(<\/span>function<\/span> <\/span>()<\/span> {<\/span><\/div>10<\/span>        <\/span>return<\/span> <\/span>Storage<\/span>::<\/span>disk<\/span>(<\/span>'<\/span>local<\/span>'<\/span>);<\/span><\/div>11<\/span>    });<\/span><\/div>12<\/span> <\/div>13<\/span>$this<\/span>->app-><\/span>when<\/span>([<\/span>VideoController<\/span>::<\/span>class<\/span>, <\/span>UploadController<\/span>::<\/span>class<\/span>])<\/span><\/div>14<\/span>    <\/span>-><\/span>needs<\/span>(<\/span>Filesystem<\/span>::<\/span>class<\/span>)<\/span><\/div>15<\/span>    <\/span>-><\/span>give<\/span>(<\/span>function<\/span> <\/span>()<\/span> {<\/span><\/div>16<\/span>        <\/span>return<\/span> <\/span>Storage<\/span>::<\/span>disk<\/span>(<\/span>'<\/span>s3<\/span>'<\/span>);<\/span><\/div>17<\/span>    });<\/span><\/div>\nuse App\\Http\\Controllers\\PhotoController;\nuse App\\Http\\Controllers\\UploadController;\nuse App\\Http\\Controllers\\VideoController;\nuse Illuminate\\Contracts\\Filesystem\\Filesystem;\nuse Illuminate\\Support\\Facades\\Storage;\n\n$this->app->when(PhotoController::class)\n    ->needs(Filesystem::class)\n    ->give(function () {\n        return Storage::disk('local');\n    });\n\n$this->app->when([VideoController::class, UploadController::class])\n    ->needs(Filesystem::class)\n    ->give(function () {\n        return Storage::disk('s3');\n    });<\/div><\/code><\/pre>\n<\/div>\nContextual Attributes<\/a><\/h3>\nSince contextual binding is often used to inject implementations of drivers or configuration values, Laravel offers a variety of contextual binding attributes that allow to inject these types of values without manually defining the contextual bindings in your service providers.<\/p>\nFor example, the Storage<\/code> attribute may be used to inject a specific storage disk<\/a>:<\/p>\n
\n 1<\/span><?php<\/span><\/div> 2<\/span> <\/div> 3<\/span>namespace<\/span> App\\Http\\Controllers;<\/span><\/div> 4<\/span> <\/div> 5<\/span>use<\/span> Illuminate\\Container\\Attributes\\<\/span>Storage<\/span>;<\/span><\/div> 6<\/span>use<\/span> Illuminate\\Contracts\\Filesystem\\<\/span>Filesystem<\/span>;<\/span><\/div> 7<\/span> <\/div> 8<\/span>class<\/span> <\/span>PhotoController<\/span> <\/span>extends<\/span> <\/span>Controller<\/span><\/div> 9<\/span>{<\/span><\/div>10<\/span>    <\/span>public<\/span> <\/span>function<\/span> <\/span>__construct<\/span>(<\/span><\/div>11<\/span>        #[Storage(<\/span>'<\/span>local<\/span>'<\/span>)] <\/span>protected<\/span> <\/span>Filesystem<\/span> <\/span>$filesystem<\/span><\/div>12<\/span>    <\/span>)<\/span> {<\/span><\/div>13<\/span>        <\/span>\/\/<\/span> ...<\/span><\/div>14<\/span>    }<\/span><\/div>15<\/span>}<\/span><\/div>\n<?php\n\nnamespace App\\Http\\Controllers;\n\nuse Illuminate\\Container\\Attributes\\Storage;\nuse Illuminate\\Contracts\\Filesystem\\Filesystem;\n\nclass PhotoController extends Controller\n{\n    public function __construct(\n        #[Storage('local')] protected Filesystem $filesystem\n    ) {\n        \/\/ ...\n    }\n}<\/div><\/code><\/pre>\n<\/div>\nIn addition to the Storage<\/code> attribute, Laravel offers Auth<\/code>, Cache<\/code>, Config<\/code>, Context<\/code>, DB<\/code>, Give<\/code>, Log<\/code>, RouteParameter<\/code>, and Tag<\/a> attributes:<\/p>\n
\n 1<\/span><?php<\/span><\/div> 2<\/span> <\/div> 3<\/span>namespace<\/span> App\\Http\\Controllers;<\/span><\/div> 4<\/span> <\/div> 5<\/span>use<\/span> App\\Contracts\\<\/span>UserRepository<\/span>;<\/span><\/div> 6<\/span>use<\/span> App\\Models\\<\/span>Photo<\/span>;<\/span><\/div> 7<\/span>use<\/span> App\\Repositories\\<\/span>DatabaseRepository<\/span>;<\/span><\/div> 8<\/span>use<\/span> Illuminate\\Container\\Attributes\\<\/span>Auth<\/span>;<\/span><\/div> 9<\/span>use<\/span> Illuminate\\Container\\Attributes\\<\/span>Cache<\/span>;<\/span><\/div>10<\/span>use<\/span> Illuminate\\Container\\Attributes\\<\/span>Config<\/span>;<\/span><\/div>11<\/span>use<\/span> Illuminate\\Container\\Attributes\\<\/span>Context<\/span>;<\/span><\/div>12<\/span>use<\/span> Illuminate\\Container\\Attributes\\<\/span>DB<\/span>;<\/span><\/div>13<\/span>use<\/span> Illuminate\\Container\\Attributes\\<\/span>Give<\/span>;<\/span><\/div>14<\/span>use<\/span> Illuminate\\Container\\Attributes\\<\/span>Log<\/span>;<\/span><\/div>15<\/span>use<\/span> Illuminate\\Container\\Attributes\\<\/span>RouteParameter<\/span>;<\/span><\/div>16<\/span>use<\/span> Illuminate\\Container\\Attributes\\<\/span>Tag<\/span>;<\/span><\/div>17<\/span>use<\/span> Illuminate\\Contracts\\Auth\\<\/span>Guard<\/span>;<\/span><\/div>18<\/span>use<\/span> Illuminate\\Contracts\\Cache\\<\/span>Repository<\/span>;<\/span><\/div>19<\/span>use<\/span> Illuminate\\Database\\<\/span>Connection<\/span>;<\/span><\/div>20<\/span>use<\/span> Psr\\Log\\<\/span>LoggerInterface<\/span>;<\/span><\/div>21<\/span> <\/div>22<\/span>class<\/span> <\/span>PhotoController<\/span> <\/span>extends<\/span> <\/span>Controller<\/span><\/div>23<\/span>{<\/span><\/div>24<\/span>    <\/span>public<\/span> <\/span>function<\/span> <\/span>__construct<\/span>(<\/span><\/div>25<\/span>        #[Auth(<\/span>'<\/span>web<\/span>'<\/span>)] <\/span>protected<\/span> <\/span>Guard<\/span> <\/span>$auth<\/span>,<\/span><\/div>26<\/span>        #[Cache(<\/span>'<\/span>redis<\/span>'<\/span>)] <\/span>protected<\/span> <\/span>Repository<\/span> <\/span>$cache<\/span>,<\/span><\/div>27<\/span>        #[Config(<\/span>'<\/span>app.timezone<\/span>'<\/span>)] <\/span>protected<\/span> <\/span>string<\/span> <\/span>$timezone<\/span>,<\/span><\/div>28<\/span>        #[Context(<\/span>'<\/span>uuid<\/span>'<\/span>)] <\/span>protected<\/span> <\/span>string<\/span> <\/span>$uuid<\/span>,<\/span><\/div>29<\/span>        #[Context(<\/span>'<\/span>ulid<\/span>'<\/span>, hidden: <\/span>true<\/span>)] <\/span>protected<\/span> <\/span>string<\/span> <\/span>$ulid<\/span>,<\/span><\/div>30<\/span>        #[DB(<\/span>'<\/span>mysql<\/span>'<\/span>)] <\/span>protected<\/span> <\/span>Connection<\/span> <\/span>$connection<\/span>,<\/span><\/div>31<\/span>        #[Give(<\/span>DatabaseRepository<\/span>::<\/span>class<\/span>)] <\/span>protected<\/span> <\/span>UserRepository<\/span> <\/span>$users<\/span>,<\/span><\/div>32<\/span>        #[Log(<\/span>'<\/span>daily<\/span>'<\/span>)] <\/span>protected<\/span> <\/span>LoggerInterface<\/span> <\/span>$log<\/span>,<\/span><\/div>33<\/span>        #[RouteParameter(<\/span>'<\/span>photo<\/span>'<\/span>)] <\/span>protected<\/span> <\/span>Photo<\/span> <\/span>$photo<\/span>,<\/span><\/div>34<\/span>        #[Tag(<\/span>'<\/span>reports<\/span>'<\/span>)] <\/span>protected<\/span> <\/span>iterable<\/span> <\/span>$reports<\/span>,<\/span><\/div>35<\/span>    <\/span>)<\/span> {<\/span><\/div>36<\/span>        <\/span>\/\/<\/span> ...<\/span><\/div>37<\/span>    }<\/span><\/div>38<\/span>}<\/span><\/div>\n<?php\n\nnamespace App\\Http\\Controllers;\n\nuse App\\Contracts\\UserRepository;\nuse App\\Models\\Photo;\nuse App\\Repositories\\DatabaseRepository;\nuse Illuminate\\Container\\Attributes\\Auth;\nuse Illuminate\\Container\\Attributes\\Cache;\nuse Illuminate\\Container\\Attributes\\Config;\nuse Illuminate\\Container\\Attributes\\Context;\nuse Illuminate\\Container\\Attributes\\DB;\nuse Illuminate\\Container\\Attributes\\Give;\nuse Illuminate\\Container\\Attributes\\Log;\nuse Illuminate\\Container\\Attributes\\RouteParameter;\nuse Illuminate\\Container\\Attributes\\Tag;\nuse Illuminate\\Contracts\\Auth\\Guard;\nuse Illuminate\\Contracts\\Cache\\Repository;\nuse Illuminate\\Database\\Connection;\nuse Psr\\Log\\LoggerInterface;\n\nclass PhotoController extends Controller\n{\n    public function __construct(\n        #[Auth('web')] protected Guard $auth,\n        #[Cache('redis')] protected Repository $cache,\n        #[Config('app.timezone')] protected string $timezone,\n        #[Context('uuid')] protected string $uuid,\n        #[Context('ulid', hidden: true)] protected string $ulid,\n        #[DB('mysql')] protected Connection $connection,\n        #[Give(DatabaseRepository::class)] protected UserRepository $users,\n        #[Log('daily')] protected LoggerInterface $log,\n        #[RouteParameter('photo')] protected Photo $photo,\n        #[Tag('reports')] protected iterable $reports,\n    ) {\n        \/\/ ...\n    }\n}<\/div><\/code><\/pre>\n<\/div>\nFurthermore, Laravel provides a CurrentUser<\/code> attribute for injecting the currently authenticated user into a given route or class:<\/p>\n\n1<\/span>use<\/span> App\\Models\\<\/span>User<\/span>;<\/span><\/div>2<\/span>use<\/span> Illuminate\\Container\\Attributes\\<\/span>CurrentUser<\/span>;<\/span><\/div>3<\/span> <\/div>4<\/span>Route<\/span>::<\/span>get<\/span>(<\/span>'<\/span>\/user<\/span>'<\/span>, <\/span>function<\/span> <\/span>(<\/span>#[CurrentUser] <\/span>User<\/span> <\/span>$user<\/span>)<\/span> {<\/span><\/div>5<\/span>    <\/span>return<\/span> <\/span>$user<\/span>;<\/span><\/div>6<\/span>})<\/span>-><\/span>middleware<\/span>(<\/span>'<\/span>auth<\/span>'<\/span>);<\/span><\/div>\nuse App\\Models\\User;\nuse Illuminate\\Container\\Attributes\\CurrentUser;\n\nRoute::get('\/user', function (#[CurrentUser] User $user) {\n    return $user;\n})->middleware('auth');<\/div><\/code><\/pre>\n<\/div>\nDefining Custom Attributes<\/a><\/h4>\nYou can create your own contextual attributes by implementing the Illuminate\\Contracts\\Container\\ContextualAttribute<\/code> contract. The container will call your attribute's resolve<\/code> method, which should resolve the value that should be injected into the class utilizing the attribute. In the example below, we will re-implement Laravel's built-in Config<\/code> attribute:<\/p>\n\n 1<\/span><?php<\/span><\/div> 2<\/span> <\/div> 3<\/span>namespace<\/span> App\\Attributes;<\/span><\/div> 4<\/span> <\/div> 5<\/span>use<\/span> <\/span>Attribute<\/span>;<\/span><\/div> 6<\/span>use<\/span> Illuminate\\Contracts\\Container\\<\/span>Container<\/span>;<\/span><\/div> 7<\/span>use<\/span> Illuminate\\Contracts\\Container\\<\/span>ContextualAttribute<\/span>;<\/span><\/div> 8<\/span> <\/div> 9<\/span>#[Attribute(<\/span>Attribute<\/span>::<\/span>TARGET_PARAMETER<\/span>)]<\/span><\/div>10<\/span>class<\/span> <\/span>Config<\/span> <\/span>implements<\/span> <\/span>ContextualAttribute<\/span><\/div>11<\/span>{<\/span><\/div>12<\/span>    <\/span>\/**<\/span><\/div>13<\/span>     * Create a new attribute instance.<\/span><\/div>14<\/span>     <\/span>*\/<\/span><\/div>15<\/span>    <\/span>public<\/span> <\/span>function<\/span> <\/span>__construct<\/span>(<\/span>public<\/span> <\/span>string<\/span> <\/span>$key<\/span>, <\/span>public<\/span> <\/span>mixed<\/span> <\/span>$default<\/span> <\/span>=<\/span> <\/span>null<\/span>)<\/span><\/div>16<\/span>    {<\/span><\/div>17<\/span>    }<\/span><\/div>18<\/span> <\/div>19<\/span>    <\/span>\/**<\/span><\/div>20<\/span>     * Resolve the configuration value.<\/span><\/div>21<\/span>     *<\/span><\/div>22<\/span>     * <\/span>@param<\/span>  <\/span>self<\/span>  $attribute<\/span><\/div>23<\/span>     * <\/span>@param<\/span>  <\/span>\\<\/span>Illuminate<\/span>\\<\/span>Contracts<\/span>\\<\/span>Container<\/span>\\<\/span>Container<\/span>  $container<\/span><\/div>24<\/span>     * <\/span>@return<\/span> <\/span>mixed<\/span><\/div>25<\/span>     <\/span>*\/<\/span><\/div>26<\/span>    <\/span>public<\/span> <\/span>static<\/span> <\/span>function<\/span> <\/span>resolve<\/span>(<\/span>self<\/span> <\/span>$attribute<\/span>, <\/span>Container<\/span> <\/span>$container<\/span>)<\/span><\/div>27<\/span>    {<\/span><\/div>28<\/span>        <\/span>return<\/span> <\/span>$container<\/span>-><\/span>make<\/span>(<\/span>'<\/span>config<\/span>'<\/span>)<\/span>-><\/span>get<\/span>(<\/span>$attribute<\/span>->key<\/span>, <\/span>$attribute<\/span>->default<\/span>);<\/span><\/div>29<\/span>    }<\/span><\/div>30<\/span>}<\/span><\/div>\n<?php\n\nnamespace App\\Attributes;\n\nuse Attribute;\nuse Illuminate\\Contracts\\Container\\Container;\nuse Illuminate\\Contracts\\Container\\ContextualAttribute;\n\n#[Attribute(Attribute::TARGET_PARAMETER)]\nclass Config implements ContextualAttribute\n{\n    \/**\n     * Create a new attribute instance.\n     *\/\n    public function __construct(public string $key, public mixed $default = null)\n    {\n    }\n\n    \/**\n     * Resolve the configuration value.\n     *\n     * @param  self  $attribute\n     * @param  \\Illuminate\\Contracts\\Container\\Container  $container\n     * @return mixed\n     *\/\n    public static function resolve(self $attribute, Container $container)\n    {\n        return $container->make('config')->get($attribute->key, $attribute->default);\n    }\n}<\/div><\/code><\/pre>\n<\/div>\nBinding Primitives<\/a><\/h3>\nSometimes you may have a class that receives some injected classes, but also needs an injected primitive value such as an integer. You may easily use contextual binding to inject any value your class may need:<\/p>\n\n1<\/span>use<\/span> App\\Http\\Controllers\\<\/span>UserController<\/span>;<\/span><\/div>2<\/span> <\/div>3<\/span>$this<\/span>->app-><\/span>when<\/span>(<\/span>UserController<\/span>::<\/span>class<\/span>)<\/span><\/div>4<\/span>    <\/span>-><\/span>needs<\/span>(<\/span>'<\/span>$variableName<\/span>'<\/span>)<\/span><\/div>5<\/span>    <\/span>-><\/span>give<\/span>(<\/span>$value<\/span>);<\/span><\/div>\nuse App\\Http\\Controllers\\UserController;\n\n$this->app->when(UserController::class)\n    ->needs('$variableName')\n    ->give($value);<\/div><\/code><\/pre>\n<\/div>\nSometimes a class may depend on an array of tagged<\/a> instances. Using the giveTagged<\/code> method, you may easily inject all of the container bindings with that tag:<\/p>\n\n1<\/span>$this<\/span>->app-><\/span>when<\/span>(<\/span>ReportAggregator<\/span>::<\/span>class<\/span>)<\/span><\/div>2<\/span>    <\/span>-><\/span>needs<\/span>(<\/span>'<\/span>$reports<\/span>'<\/span>)<\/span><\/div>3<\/span>    <\/span>-><\/span>giveTagged<\/span>(<\/span>'<\/span>reports<\/span>'<\/span>);<\/span><\/div>\n$this->app->when(ReportAggregator::class)\n    ->needs('$reports')\n    ->giveTagged('reports');<\/div><\/code><\/pre>\n<\/div>\nIf you need to inject a value from one of your application's configuration files, you may use the giveConfig<\/code> method:<\/p>\n\n1<\/span>$this<\/span>->app-><\/span>when<\/span>(<\/span>ReportAggregator<\/span>::<\/span>class<\/span>)<\/span><\/div>2<\/span>    <\/span>-><\/span>needs<\/span>(<\/span>'<\/span>$timezone<\/span>'<\/span>)<\/span><\/div>3<\/span>    <\/span>-><\/span>giveConfig<\/span>(<\/span>'<\/span>app.timezone<\/span>'<\/span>);<\/span><\/div>\n$this->app->when(ReportAggregator::class)\n    ->needs('$timezone')\n    ->giveConfig('app.timezone');<\/div><\/code><\/pre>\n<\/div>\nBinding Typed Variadics<\/a><\/h3>\nOccasionally, you may have a class that receives an array of typed objects using a variadic constructor argument:<\/p>\n\n 1<\/span><?php<\/span><\/div> 2<\/span> <\/div> 3<\/span>use<\/span> App\\Models\\<\/span>Filter<\/span>;<\/span><\/div> 4<\/span>use<\/span> App\\Services\\<\/span>Logger<\/span>;<\/span><\/div> 5<\/span> <\/div> 6<\/span>class<\/span> <\/span>Firewall<\/span><\/div> 7<\/span>{<\/span><\/div> 8<\/span>    <\/span>\/**<\/span><\/div> 9<\/span>     * The filter instances.<\/span><\/div>10<\/span>     *<\/span><\/div>11<\/span>     * <\/span>@var<\/span> <\/span>array<\/span><\/div>12<\/span>     <\/span>*\/<\/span><\/div>13<\/span>    <\/span>protected<\/span> <\/span>$filters<\/span>;<\/span><\/div>14<\/span> <\/div>15<\/span>    <\/span>\/**<\/span><\/div>16<\/span>     * Create a new class instance.<\/span><\/div>17<\/span>     <\/span>*\/<\/span><\/div>18<\/span>    <\/span>public<\/span> <\/span>function<\/span> <\/span>__construct<\/span>(<\/span><\/div>19<\/span>        <\/span>protected<\/span> <\/span>Logger<\/span> <\/span>$logger<\/span>,<\/span><\/div>20<\/span>        <\/span>Filter<\/span> <\/span>...<\/span>$filters<\/span>,<\/span><\/div>21<\/span>    <\/span>)<\/span> {<\/span><\/div>22<\/span>        <\/span>$this<\/span>->filters<\/span> <\/span>=<\/span> <\/span>$filters<\/span>;<\/span><\/div>23<\/span>    }<\/span><\/div>24<\/span>}<\/span><\/div>\n<?php\n\nuse App\\Models\\Filter;\nuse App\\Services\\Logger;\n\nclass Firewall\n{\n    \/**\n     * The filter instances.\n     *\n     * @var array\n     *\/\n    protected $filters;\n\n    \/**\n     * Create a new class instance.\n     *\/\n    public function __construct(\n        protected Logger $logger,\n        Filter ...$filters,\n    ) {\n        $this->filters = $filters;\n    }\n}<\/div><\/code><\/pre>\n<\/div>\nUsing contextual binding, you may resolve this dependency by providing the give<\/code> method with a closure that returns an array of resolved Filter<\/code> instances:<\/p>\n\n1<\/span>$this<\/span>->app-><\/span>when<\/span>(<\/span>Firewall<\/span>::<\/span>class<\/span>)<\/span><\/div>2<\/span>    <\/span>-><\/span>needs<\/span>(<\/span>Filter<\/span>::<\/span>class<\/span>)<\/span><\/div>3<\/span>    <\/span>-><\/span>give<\/span>(<\/span>function<\/span> <\/span>(<\/span>Application<\/span> <\/span>$app<\/span>)<\/span> {<\/span><\/div>4<\/span>          <\/span>return<\/span> [<\/span><\/div>5<\/span>              <\/span>$app<\/span>-><\/span>make<\/span>(<\/span>NullFilter<\/span>::<\/span>class<\/span>),<\/span><\/div>6<\/span>              <\/span>$app<\/span>-><\/span>make<\/span>(<\/span>ProfanityFilter<\/span>::<\/span>class<\/span>),<\/span><\/div>7<\/span>              <\/span>$app<\/span>-><\/span>make<\/span>(<\/span>TooLongFilter<\/span>::<\/span>class<\/span>),<\/span><\/div>8<\/span>          ];<\/span><\/div>9<\/span>    });<\/span><\/div>\n$this->app->when(Firewall::class)\n    ->needs(Filter::class)\n    ->give(function (Application $app) {\n          return [\n              $app->make(NullFilter::class),\n              $app->make(ProfanityFilter::class),\n              $app->make(TooLongFilter::class),\n          ];\n    });<\/div><\/code><\/pre>\n<\/div>\nFor convenience, you may also just provide an array of class names to be resolved by the container whenever Firewall<\/code> needs Filter<\/code> instances:<\/p>\n\n1<\/span>$this<\/span>->app-><\/span>when<\/span>(<\/span>Firewall<\/span>::<\/span>class<\/span>)<\/span><\/div>2<\/span>    <\/span>-><\/span>needs<\/span>(<\/span>Filter<\/span>::<\/span>class<\/span>)<\/span><\/div>3<\/span>    <\/span>-><\/span>give<\/span>([<\/span><\/div>4<\/span>        <\/span>NullFilter<\/span>::<\/span>class<\/span>,<\/span><\/div>5<\/span>        <\/span>ProfanityFilter<\/span>::<\/span>class<\/span>,<\/span><\/div>6<\/span>        <\/span>TooLongFilter<\/span>::<\/span>class<\/span>,<\/span><\/div>7<\/span>    ]);<\/span><\/div>\n$this->app->when(Firewall::class)\n    ->needs(Filter::class)\n    ->give([\n        NullFilter::class,\n        ProfanityFilter::class,\n        TooLongFilter::class,\n    ]);<\/div><\/code><\/pre>\n<\/div>\nVariadic Tag Dependencies<\/a><\/h4>\nSometimes a class may have a variadic dependency that is type-hinted as a given class (Report ...$reports<\/code>). Using the needs<\/code> and giveTagged<\/code> methods, you may easily inject all of the container bindings with that tag<\/a> for the given dependency:<\/p>\n\n1<\/span>$this<\/span>->app-><\/span>when<\/span>(<\/span>ReportAggregator<\/span>::<\/span>class<\/span>)<\/span><\/div>2<\/span>    <\/span>-><\/span>needs<\/span>(<\/span>Report<\/span>::<\/span>class<\/span>)<\/span><\/div>3<\/span>    <\/span>-><\/span>giveTagged<\/span>(<\/span>'<\/span>reports<\/span>'<\/span>);<\/span><\/div>\n$this->app->when(ReportAggregator::class)\n    ->needs(Report::class)\n    ->giveTagged('reports');<\/div><\/code><\/pre>\n<\/div>\nTagging<\/a><\/h3>\nOccasionally, you may need to resolve all of a certain "category" of binding. For example, perhaps you are building a report analyzer that receives an array of many different Report<\/code> interface implementations. After registering the Report<\/code> implementations, you can assign them a tag using the tag<\/code> method:<\/p>\n\n1<\/span>$this<\/span>->app-><\/span>bind<\/span>(<\/span>CpuReport<\/span>::<\/span>class<\/span>, <\/span>function<\/span> <\/span>()<\/span> {<\/span><\/div>2<\/span>    <\/span>\/\/<\/span> ...<\/span><\/div>3<\/span>});<\/span><\/div>4<\/span> <\/div>5<\/span>$this<\/span>->app-><\/span>bind<\/span>(<\/span>MemoryReport<\/span>::<\/span>class<\/span>, <\/span>function<\/span> <\/span>()<\/span> {<\/span><\/div>6<\/span>    <\/span>\/\/<\/span> ...<\/span><\/div>7<\/span>});<\/span><\/div>8<\/span> <\/div>9<\/span>$this<\/span>->app-><\/span>tag<\/span>([<\/span>CpuReport<\/span>::<\/span>class<\/span>, <\/span>MemoryReport<\/span>::<\/span>class<\/span>], <\/span>'<\/span>reports<\/span>'<\/span>);<\/span><\/div>\n$this->app->bind(CpuReport::class, function () {\n    \/\/ ...\n});\n\n$this->app->bind(MemoryReport::class, function () {\n    \/\/ ...\n});\n\n$this->app->tag([CpuReport::class, MemoryReport::class], 'reports');<\/div><\/code><\/pre>\n<\/div>\nOnce the services have been tagged, you may easily resolve them all via the container's tagged<\/code> method:<\/p>\n\n1<\/span>$this<\/span>->app-><\/span>bind<\/span>(<\/span>ReportAnalyzer<\/span>::<\/span>class<\/span>, <\/span>function<\/span> <\/span>(<\/span>Application<\/span> <\/span>$app<\/span>)<\/span> {<\/span><\/div>2<\/span>    <\/span>return<\/span> <\/span>new<\/span> <\/span>ReportAnalyzer<\/span>(<\/span>$app<\/span>-><\/span>tagged<\/span>(<\/span>'<\/span>reports<\/span>'<\/span>));<\/span><\/div>3<\/span>});<\/span><\/div>\n$this->app->bind(ReportAnalyzer::class, function (Application $app) {\n    return new ReportAnalyzer($app->tagged('reports'));\n});<\/div><\/code><\/pre>\n<\/div>\nExtending Bindings<\/a><\/h3>\nThe extend<\/code> method allows the modification of resolved services. For example, when a service is resolved, you may run additional code to decorate or configure the service. The extend<\/code> method accepts two arguments, the service class you're extending and a closure that should return the modified service. The closure receives the service being resolved and the container instance:<\/p>\n\n1<\/span>$this<\/span>->app-><\/span>extend<\/span>(<\/span>Service<\/span>::<\/span>class<\/span>, <\/span>function<\/span> <\/span>(<\/span>Service<\/span> <\/span>$service<\/span>, <\/span>Application<\/span> <\/span>$app<\/span>)<\/span> {<\/span><\/div>2<\/span>    <\/span>return<\/span> <\/span>new<\/span> <\/span>DecoratedService<\/span>(<\/span>$service<\/span>);<\/span><\/div>3<\/span>});<\/span><\/div>\n$this->app->extend(Service::class, function (Service $service, Application $app) {\n    return new DecoratedService($service);\n});<\/div><\/code><\/pre>\n<\/div>\nResolving<\/a><\/h2>\nThe make<\/code> Method<\/a><\/h3>\nYou may use the make<\/code> method to resolve a class instance from the container. The make<\/code> method accepts the name of the class or interface you wish to resolve:<\/p>\n\n1<\/span>use<\/span> App\\Services\\<\/span>Transistor<\/span>;<\/span><\/div>2<\/span> <\/div>3<\/span>$transistor<\/span> <\/span>=<\/span> <\/span>$this<\/span>->app-><\/span>make<\/span>(<\/span>Transistor<\/span>::<\/span>class<\/span>);<\/span><\/div>\nuse App\\Services\\Transistor;\n\n$transistor = $this->app->make(Transistor::class);<\/div><\/code><\/pre>\n<\/div>\nIf some of your class's dependencies are not resolvable via the container, you may inject them by passing them as an associative array into the makeWith<\/code> method. For example, we may manually pass the $id<\/code> constructor argument required by the Transistor<\/code> service:<\/p>\n\n1<\/span>use<\/span> App\\Services\\<\/span>Transistor<\/span>;<\/span><\/div>2<\/span> <\/div>3<\/span>$transistor<\/span> <\/span>=<\/span> <\/span>$this<\/span>->app-><\/span>makeWith<\/span>(<\/span>Transistor<\/span>::<\/span>class<\/span>, [<\/span>'<\/span>id<\/span>'<\/span> <\/span>=><\/span> <\/span>1<\/span>]);<\/span><\/div>\nuse App\\Services\\Transistor;\n\n$transistor = $this->app->makeWith(Transistor::class, ['id' => 1]);<\/div><\/code><\/pre>\n<\/div>\nThe bound<\/code> method may be used to determine if a class or interface has been explicitly bound in the container:<\/p>\n\n1<\/span>if<\/span> (<\/span>$this<\/span>->app-><\/span>bound<\/span>(<\/span>Transistor<\/span>::<\/span>class<\/span>)) {<\/span><\/div>2<\/span>    <\/span>\/\/<\/span> ...<\/span><\/div>3<\/span>}<\/span><\/div>\nif ($this->app->bound(Transistor::class)) {\n    \/\/ ...\n}<\/div><\/code><\/pre>\n<\/div>\nIf you are outside of a service provider in a location of your code that does not have access to the $app<\/code> variable, you may use the App<\/code> facade<\/a> or the app<\/code> helper<\/a> to resolve a class instance from the container:<\/p>\n\n1<\/span>use<\/span> App\\Services\\<\/span>Transistor<\/span>;<\/span><\/div>2<\/span>use<\/span> Illuminate\\Support\\Facades\\<\/span>App<\/span>;<\/span><\/div>3<\/span> <\/div>4<\/span>$transistor<\/span> <\/span>=<\/span> <\/span>App<\/span>::<\/span>make<\/span>(<\/span>Transistor<\/span>::<\/span>class<\/span>);<\/span><\/div>5<\/span> <\/div>6<\/span>$transistor<\/span> <\/span>=<\/span> <\/span>app<\/span>(<\/span>Transistor<\/span>::<\/span>class<\/span>);<\/span><\/div>\nuse App\\Services\\Transistor;\nuse Illuminate\\Support\\Facades\\App;\n\n$transistor = App::make(Transistor::class);\n\n$transistor = app(Transistor::class);<\/div><\/code><\/pre>\n<\/div>\nIf you would like to have the Laravel container instance itself injected into a class that is being resolved by the container, you may type-hint the Illuminate\\Container\\Container<\/code> class on your class's constructor:<\/p>\n\n1<\/span>use<\/span> Illuminate\\Container\\<\/span>Container<\/span>;<\/span><\/div>2<\/span> <\/div>3<\/span>\/**<\/span><\/div>4<\/span> * Create a new class instance.<\/span><\/div>5<\/span> <\/span>*\/<\/span><\/div>6<\/span>public<\/span> <\/span>function<\/span> <\/span>__construct<\/span>(<\/span><\/div>7<\/span>    <\/span>protected<\/span> <\/span>Container<\/span> <\/span>$container<\/span>,<\/span><\/div>8<\/span>)<\/span> {}<\/span><\/div>\nuse Illuminate\\Container\\Container;\n\n\/**\n * Create a new class instance.\n *\/\npublic function __construct(\n    protected Container $container,\n) {}<\/div><\/code><\/pre>\n<\/div>\nAutomatic Injection<\/a><\/h3>\nAlternatively, and importantly, you may type-hint the dependency in the constructor of a class that is resolved by the container, including controllers<\/a>, event listeners<\/a>, middleware<\/a>, and more. Additionally, you may type-hint dependencies in the handle<\/code> method of queued jobs<\/a>. In practice, this is how most of your objects should be resolved by the container.<\/p>\n
For example, you may type-hint a service defined by your application in a controller's constructor. The service will automatically be resolved and injected into the class:<\/p>\n\n 1<\/span><?php<\/span><\/div> 2<\/span> <\/div> 3<\/span>namespace<\/span> App\\Http\\Controllers;<\/span><\/div> 4<\/span> <\/div> 5<\/span>use<\/span> App\\Services\\<\/span>AppleMusic<\/span>;<\/span><\/div> 6<\/span> <\/div> 7<\/span>class<\/span> <\/span>PodcastController<\/span> <\/span>extends<\/span> <\/span>Controller<\/span><\/div> 8<\/span>{<\/span><\/div> 9<\/span>    <\/span>\/**<\/span><\/div>10<\/span>     * Create a new controller instance.<\/span><\/div>11<\/span>     <\/span>*\/<\/span><\/div>12<\/span>    <\/span>public<\/span> <\/span>function<\/span> <\/span>__construct<\/span>(<\/span><\/div>13<\/span>        <\/span>protected<\/span> <\/span>AppleMusic<\/span> <\/span>$apple<\/span>,<\/span><\/div>14<\/span>    <\/span>)<\/span> {}<\/span><\/div>15<\/span> <\/div>16<\/span>    <\/span>\/**<\/span><\/div>17<\/span>     * Show information about the given podcast.<\/span><\/div>18<\/span>     <\/span>*\/<\/span><\/div>19<\/span>    <\/span>public<\/span> <\/span>function<\/span> <\/span>show<\/span>(<\/span>string<\/span> <\/span>$id<\/span>)<\/span>:<\/span> <\/span>Podcast<\/span><\/div>20<\/span>    {<\/span><\/div>21<\/span>        <\/span>return<\/span> <\/span>$this<\/span>->apple-><\/span>findPodcast<\/span>(<\/span>$id<\/span>);<\/span><\/div>22<\/span>    }<\/span><\/div>23<\/span>}<\/span><\/div>\n<?php\n\nnamespace App\\Http\\Controllers;\n\nuse App\\Services\\AppleMusic;\n\nclass PodcastController extends Controller\n{\n    \/**\n     * Create a new controller instance.\n     *\/\n    public function __construct(\n        protected AppleMusic $apple,\n    ) {}\n\n    \/**\n     * Show information about the given podcast.\n     *\/\n    public function show(string $id): Podcast\n    {\n        return $this->apple->findPodcast($id);\n    }\n}<\/div><\/code><\/pre>\n<\/div>\nMethod Invocation and Injection<\/a><\/h2>\nSometimes you may wish to invoke a method on an object instance while allowing the container to automatically inject that method's dependencies. For example, given the following class:<\/p>\n\n 1<\/span><?php<\/span><\/div> 2<\/span> <\/div> 3<\/span>namespace<\/span> App;<\/span><\/div> 4<\/span> <\/div> 5<\/span>use<\/span> App\\Services\\<\/span>AppleMusic<\/span>;<\/span><\/div> 6<\/span> <\/div> 7<\/span>class<\/span> <\/span>PodcastStats<\/span><\/div> 8<\/span>{<\/span><\/div> 9<\/span>    <\/span>\/**<\/span><\/div>10<\/span>     * Generate a new podcast stats report.<\/span><\/div>11<\/span>     <\/span>*\/<\/span><\/div>12<\/span>    <\/span>public<\/span> <\/span>function<\/span> <\/span>generate<\/span>(<\/span>AppleMusic<\/span> <\/span>$apple<\/span>)<\/span>:<\/span> <\/span>array<\/span><\/div>13<\/span>    {<\/span><\/div>14<\/span>        <\/span>return<\/span> [<\/span><\/div>15<\/span>            <\/span>\/\/<\/span> ...<\/span><\/div>16<\/span>        ];<\/span><\/div>17<\/span>    }<\/span><\/div>18<\/span>}<\/span><\/div>\n<?php\n\nnamespace App;\n\nuse App\\Services\\AppleMusic;\n\nclass PodcastStats\n{\n    \/**\n     * Generate a new podcast stats report.\n     *\/\n    public function generate(AppleMusic $apple): array\n    {\n        return [\n            \/\/ ...\n        ];\n    }\n}<\/div><\/code><\/pre>\n<\/div>\nYou may invoke the generate<\/code> method via the container like so:<\/p>\n\n1<\/span>use<\/span> App\\<\/span>PodcastStats<\/span>;<\/span><\/div>2<\/span>use<\/span> Illuminate\\Support\\Facades\\<\/span>App<\/span>;<\/span><\/div>3<\/span> <\/div>4<\/span>$stats<\/span> <\/span>=<\/span> <\/span>App<\/span>::<\/span>call<\/span>([<\/span>new<\/span> <\/span>PodcastStats<\/span>, <\/span>'<\/span>generate<\/span>'<\/span>]);<\/span><\/div>\nuse App\\PodcastStats;\nuse Illuminate\\Support\\Facades\\App;\n\n$stats = App::call([new PodcastStats, 'generate']);<\/div><\/code><\/pre>\n<\/div>\nThe call<\/code> method accepts any PHP callable. The container's call<\/code> method may even be used to invoke a closure while automatically injecting its dependencies:<\/p>\n\n1<\/span>use<\/span> App\\Services\\<\/span>AppleMusic<\/span>;<\/span><\/div>2<\/span>use<\/span> Illuminate\\Support\\Facades\\<\/span>App<\/span>;<\/span><\/div>3<\/span> <\/div>4<\/span>$result<\/span> <\/span>=<\/span> <\/span>App<\/span>::<\/span>call<\/span>(<\/span>function<\/span> <\/span>(<\/span>AppleMusic<\/span> <\/span>$apple<\/span>)<\/span> {<\/span><\/div>5<\/span>    <\/span>\/\/<\/span> ...<\/span><\/div>6<\/span>});<\/span><\/div>\nuse App\\Services\\AppleMusic;\nuse Illuminate\\Support\\Facades\\App;\n\n$result = App::call(function (AppleMusic $apple) {\n    \/\/ ...\n});<\/div><\/code><\/pre>\n<\/div>\nContainer Events<\/a><\/h2>\nThe service container fires an event each time it resolves an object. You may listen to this event using the resolving<\/code> method:<\/p>\n\n 1<\/span>use<\/span> App\\Services\\<\/span>Transistor<\/span>;<\/span><\/div> 2<\/span>use<\/span> Illuminate\\Contracts\\Foundation\\<\/span>Application<\/span>;<\/span><\/div> 3<\/span> <\/div> 4<\/span>$this<\/span>->app-><\/span>resolving<\/span>(<\/span>Transistor<\/span>::<\/span>class<\/span>, <\/span>function<\/span> <\/span>(<\/span>Transistor<\/span> <\/span>$transistor<\/span>, <\/span>Application<\/span> <\/span>$app<\/span>)<\/span> {<\/span><\/div> 5<\/span>    <\/span>\/\/<\/span> Called when container resolves objects of type "Transistor"...<\/span><\/div> 6<\/span>});<\/span><\/div> 7<\/span> <\/div> 8<\/span>$this<\/span>->app-><\/span>resolving<\/span>(<\/span>function<\/span> <\/span>(<\/span>mixed<\/span> <\/span>$object<\/span>, <\/span>Application<\/span> <\/span>$app<\/span>)<\/span> {<\/span><\/div> 9<\/span>    <\/span>\/\/<\/span> Called when container resolves object of any type...<\/span><\/div>10<\/span>});<\/span><\/div>\nuse App\\Services\\Transistor;\nuse Illuminate\\Contracts\\Foundation\\Application;\n\n$this->app->resolving(Transistor::class, function (Transistor $transistor, Application $app) {\n    \/\/ Called when container resolves objects of type "Transistor"...\n});\n\n$this->app->resolving(function (mixed $object, Application $app) {\n    \/\/ Called when container resolves object of any type...\n});<\/div><\/code><\/pre>\n<\/div>\nAs you can see, the object being resolved will be passed to the callback, allowing you to set any additional properties on the object before it is given to its consumer.<\/p>\nRebinding<\/a><\/h3>\nThe rebinding<\/code> method allows you to listen for when a service is re-bound to the container, meaning it is registered again or overridden after its initial binding. This can be useful when you need to update dependencies or modify behavior each time a specific binding is updated:<\/p>\n\n 1<\/span>use<\/span> App\\Contracts\\<\/span>PodcastPublisher<\/span>;<\/span><\/div> 2<\/span>use<\/span> App\\Services\\<\/span>SpotifyPublisher<\/span>;<\/span><\/div> 3<\/span>use<\/span> App\\Services\\<\/span>TransistorPublisher<\/span>;<\/span><\/div> 4<\/span>use<\/span> Illuminate\\Contracts\\Foundation\\<\/span>Application<\/span>;<\/span><\/div> 5<\/span> <\/div> 6<\/span>$this<\/span>->app-><\/span>bind<\/span>(<\/span>PodcastPublisher<\/span>::<\/span>class<\/span>, <\/span>SpotifyPublisher<\/span>::<\/span>class<\/span>);<\/span><\/div> 7<\/span> <\/div> 8<\/span>$this<\/span>->app-><\/span>rebinding<\/span>(<\/span><\/div> 9<\/span>    <\/span>PodcastPublisher<\/span>::<\/span>class<\/span>,<\/span><\/div>10<\/span>    <\/span>function<\/span> <\/span>(<\/span>Application<\/span> <\/span>$app<\/span>, <\/span>PodcastPublisher<\/span> <\/span>$newInstance<\/span>)<\/span> {<\/span><\/div>11<\/span>        <\/span>\/\/<\/span><\/div>12<\/span>    },<\/span><\/div>13<\/span>);<\/span><\/div>14<\/span> <\/div>15<\/span>\/\/<\/span> New binding will trigger rebinding closure...<\/span><\/div>16<\/span>$this<\/span>->app-><\/span>bind<\/span>(<\/span>PodcastPublisher<\/span>::<\/span>class<\/span>, <\/span>TransistorPublisher<\/span>::<\/span>class<\/span>);<\/span><\/div>\nuse App\\Contracts\\PodcastPublisher;\nuse App\\Services\\SpotifyPublisher;\nuse App\\Services\\TransistorPublisher;\nuse Illuminate\\Contracts\\Foundation\\Application;\n\n$this->app->bind(PodcastPublisher::class, SpotifyPublisher::class);\n\n$this->app->rebinding(\n    PodcastPublisher::class,\n    function (Application $app, PodcastPublisher $newInstance) {\n        \/\/\n    },\n);\n\n\/\/ New binding will trigger rebinding closure...\n$this->app->bind(PodcastPublisher::class, TransistorPublisher::class);<\/div><\/code><\/pre>\n<\/div>\nPSR-11<\/a><\/h2>\nLaravel's service container implements the PSR-11<\/a> interface. Therefore, you may type-hint the PSR-11 container interface to obtain an instance of the Laravel container:<\/p>\n\n1<\/span>use<\/span> App\\Services\\<\/span>Transistor<\/span>;<\/span><\/div>2<\/span>use<\/span> Psr\\Container\\<\/span>ContainerInterface<\/span>;<\/span><\/div>3<\/span> <\/div>4<\/span>Route<\/span>::<\/span>get<\/span>(<\/span>'<\/span>\/<\/span>'<\/span>, <\/span>function<\/span> <\/span>(<\/span>ContainerInterface<\/span> <\/span>$container<\/span>)<\/span> {<\/span><\/div>5<\/span>    <\/span>$service<\/span> <\/span>=<\/span> <\/span>$container<\/span>-><\/span>get<\/span>(<\/span>Transistor<\/span>::<\/span>class<\/span>);<\/span><\/div>6<\/span> <\/div>7<\/span>    <\/span>\/\/<\/span> ...<\/span><\/div>8<\/span>});<\/span><\/div>\nuse App\\Services\\Transistor;\nuse Psr\\Container\\ContainerInterface;\n\nRoute::get('\/', function (ContainerInterface $container) {\n    $service = $container->get(Transistor::class);\n\n    \/\/ ...\n});<\/div><\/code><\/pre>\n<\/div>\nAn exception is thrown if the given identifier can't be resolved. The exception will be an instance of Psr\\Container\\NotFoundExceptionInterface<\/code> if the identifier was never bound. If the identifier was bound but was unable to be resolved, an instance of Psr\\Container\\ContainerExceptionInterface<\/code> will be thrown.<\/p>\n","index":[{"title":"Prologue","active":false,"items":[{"title":"Release Notes","href":"\/docs\/13.x\/releases","active":false},{"title":"Upgrade Guide","href":"\/docs\/13.x\/upgrade","active":false},{"title":"Contribution Guide","href":"\/docs\/13.x\/contributions","active":false}]},{"title":"Getting Started","active":false,"items":[{"title":"Installation","href":"\/docs\/13.x\/installation","active":false},{"title":"Configuration","href":"\/docs\/13.x\/configuration","active":false},{"title":"Agentic Development","href":"\/docs\/13.x\/ai","active":false},{"title":"Directory Structure","href":"\/docs\/13.x\/structure","active":false},{"title":"Frontend","href":"\/docs\/13.x\/frontend","active":false},{"title":"Starter Kits","href":"\/docs\/13.x\/starter-kits","active":false},{"title":"Deployment","href":"\/docs\/13.x\/deployment","active":false}]},{"title":"Architecture Concepts","active":true,"items":[{"title":"Request Lifecycle","href":"\/docs\/13.x\/lifecycle","active":false},{"title":"Service Container","href":"\/docs\/13.x\/container","active":true},{"title":"Service Providers","href":"\/docs\/13.x\/providers","active":false},{"title":"Facades","href":"\/docs\/13.x\/facades","active":false}]},{"title":"The Basics","active":false,"items":[{"title":"Routing","href":"\/docs\/13.x\/routing","active":false},{"title":"Middleware","href":"\/docs\/13.x\/middleware","active":false},{"title":"CSRF Protection","href":"\/docs\/13.x\/csrf","active":false},{"title":"Controllers","href":"\/docs\/13.x\/controllers","active":false},{"title":"Requests","href":"\/docs\/13.x\/requests","active":false},{"title":"Responses","href":"\/docs\/13.x\/responses","active":false},{"title":"Views","href":"\/docs\/13.x\/views","active":false},{"title":"Blade Templates","href":"\/docs\/13.x\/blade","active":false},{"title":"Asset Bundling","href":"\/docs\/13.x\/vite","active":false},{"title":"URL Generation","href":"\/docs\/13.x\/urls","active":false},{"title":"Session","href":"\/docs\/13.x\/session","active":false},{"title":"Validation","href":"\/docs\/13.x\/validation","active":false},{"title":"Error Handling","href":"\/docs\/13.x\/errors","active":false},{"title":"Logging","href":"\/docs\/13.x\/logging","active":false}]},{"title":"Digging Deeper","active":false,"items":[{"title":"Artisan Console","href":"\/docs\/13.x\/artisan","active":false},{"title":"Broadcasting","href":"\/docs\/13.x\/broadcasting","active":false},{"title":"Cache","href":"\/docs\/13.x\/cache","active":false},{"title":"Collections","href":"\/docs\/13.x\/collections","active":false},{"title":"Concurrency","href":"\/docs\/13.x\/concurrency","active":false},{"title":"Context","href":"\/docs\/13.x\/context","active":false},{"title":"Contracts","href":"\/docs\/13.x\/contracts","active":false},{"title":"Events","href":"\/docs\/13.x\/events","active":false},{"title":"File Storage","href":"\/docs\/13.x\/filesystem","active":false},{"title":"Helpers","href":"\/docs\/13.x\/helpers","active":false},{"title":"HTTP Client","href":"\/docs\/13.x\/http-client","active":false},{"title":"Localization","href":"\/docs\/13.x\/localization","active":false},{"title":"Mail","href":"\/docs\/13.x\/mail","active":false},{"title":"Notifications","href":"\/docs\/13.x\/notifications","active":false},{"title":"Package Development","href":"\/docs\/13.x\/packages","active":false},{"title":"Processes","href":"\/docs\/13.x\/processes","active":false},{"title":"Queues","href":"\/docs\/13.x\/queues","active":false},{"title":"Rate Limiting","href":"\/docs\/13.x\/rate-limiting","active":false},{"title":"Search","href":"\/docs\/13.x\/search","active":false},{"title":"Strings","href":"\/docs\/13.x\/strings","active":false},{"title":"Task Scheduling","href":"\/docs\/13.x\/scheduling","active":false}]},{"title":"Security","active":false,"items":[{"title":"Authentication","href":"\/docs\/13.x\/authentication","active":false},{"title":"Authorization","href":"\/docs\/13.x\/authorization","active":false},{"title":"Email Verification","href":"\/docs\/13.x\/verification","active":false},{"title":"Encryption","href":"\/docs\/13.x\/encryption","active":false},{"title":"Hashing","href":"\/docs\/13.x\/hashing","active":false},{"title":"Password Reset","href":"\/docs\/13.x\/passwords","active":false}]},{"title":"Database","active":false,"items":[{"title":"Getting Started","href":"\/docs\/13.x\/database","active":false},{"title":"Query Builder","href":"\/docs\/13.x\/queries","active":false},{"title":"Pagination","href":"\/docs\/13.x\/pagination","active":false},{"title":"Migrations","href":"\/docs\/13.x\/migrations","active":false},{"title":"Seeding","href":"\/docs\/13.x\/seeding","active":false},{"title":"Redis","href":"\/docs\/13.x\/redis","active":false},{"title":"MongoDB","href":"\/docs\/13.x\/mongodb","active":false}]},{"title":"Eloquent ORM","active":false,"items":[{"title":"Getting Started","href":"\/docs\/13.x\/eloquent","active":false},{"title":"Relationships","href":"\/docs\/13.x\/eloquent-relationships","active":false},{"title":"Collections","href":"\/docs\/13.x\/eloquent-collections","active":false},{"title":"Mutators \/ Casts","href":"\/docs\/13.x\/eloquent-mutators","active":false},{"title":"API Resources","href":"\/docs\/13.x\/eloquent-resources","active":false},{"title":"Serialization","href":"\/docs\/13.x\/eloquent-serialization","active":false},{"title":"Factories","href":"\/docs\/13.x\/eloquent-factories","active":false}]},{"title":"AI","active":false,"items":[{"title":"AI SDK","href":"\/docs\/13.x\/ai-sdk","active":false},{"title":"MCP","href":"\/docs\/13.x\/mcp","active":false},{"title":"Boost","href":"\/docs\/13.x\/boost","active":false}]},{"title":"Testing","active":false,"items":[{"title":"Getting Started","href":"\/docs\/13.x\/testing","active":false},{"title":"HTTP Tests","href":"\/docs\/13.x\/http-tests","active":false},{"title":"Console Tests","href":"\/docs\/13.x\/console-tests","active":false},{"title":"Browser Tests","href":"\/docs\/13.x\/dusk","active":false},{"title":"Database","href":"\/docs\/13.x\/database-testing","active":false},{"title":"Mocking","href":"\/docs\/13.x\/mocking","active":false}]},{"title":"Packages","active":false,"items":[{"title":"Cashier (Stripe)","href":"\/docs\/13.x\/billing","active":false},{"title":"Cashier (Paddle)","href":"\/docs\/13.x\/cashier-paddle","active":false},{"title":"Dusk","href":"\/docs\/13.x\/dusk","active":false},{"title":"Envoy","href":"\/docs\/13.x\/envoy","active":false},{"title":"Fortify","href":"\/docs\/13.x\/fortify","active":false},{"title":"Folio","href":"\/docs\/13.x\/folio","active":false},{"title":"Homestead","href":"\/docs\/13.x\/homestead","active":false},{"title":"Horizon","href":"\/docs\/13.x\/horizon","active":false},{"title":"Mix","href":"\/docs\/13.x\/mix","active":false},{"title":"Octane","href":"\/docs\/13.x\/octane","active":false},{"title":"Passport","href":"\/docs\/13.x\/passport","active":false},{"title":"Pennant","href":"\/docs\/13.x\/pennant","active":false},{"title":"Pint","href":"\/docs\/13.x\/pint","active":false},{"title":"Precognition","href":"\/docs\/13.x\/precognition","active":false},{"title":"Prompts","href":"\/docs\/13.x\/prompts","active":false},{"title":"Pulse","href":"\/docs\/13.x\/pulse","active":false},{"title":"Reverb","href":"\/docs\/13.x\/reverb","active":false},{"title":"Sail","href":"\/docs\/13.x\/sail","active":false},{"title":"Sanctum","href":"\/docs\/13.x\/sanctum","active":false},{"title":"Scout","href":"\/docs\/13.x\/scout","active":false},{"title":"Socialite","href":"\/docs\/13.x\/socialite","active":false},{"title":"Telescope","href":"\/docs\/13.x\/telescope","active":false},{"title":"Valet","href":"\/docs\/13.x\/valet","active":false}]}],"tableOfContents":[{"text":"Introduction","href":"#introduction","children":[{"text":"Zero Configuration Resolution","href":"#zero-configuration-resolution"},{"text":"When to Utilize the Container","href":"#when-to-use-the-container"}]},{"text":"Binding","href":"#binding","children":[{"text":"Binding Basics","href":"#binding-basics"},{"text":"Binding Interfaces to Implementations","href":"#binding-interfaces-to-implementations"},{"text":"Contextual Binding","href":"#contextual-binding"},{"text":"Contextual Attributes","href":"#contextual-attributes"},{"text":"Binding Primitives","href":"#binding-primitives"},{"text":"Binding Typed Variadics","href":"#binding-typed-variadics"},{"text":"Tagging","href":"#tagging"},{"text":"Extending Bindings","href":"#extending-bindings"}]},{"text":"Resolving","href":"#resolving","children":[{"text":"The Make Method","href":"#the-make-method"},{"text":"Automatic Injection","href":"#automatic-injection"}]},{"text":"Method Invocation and Injection","href":"#method-invocation-and-injection","children":[]},{"text":"Container Events","href":"#container-events","children":[{"text":"Rebinding","href":"#rebinding"}]},{"text":"PSR-11","href":"#psr-11","children":[]}],"currentVersion":"13.x","versions":{"master":"Master","13.x":"13.x","12.x":"12.x","11.x":"11.x","10.x":"10.x","9.x":"9.x","8.x":"8.x","7.x":"7.x","6.x":"6.x","5.8":"5.8","5.7":"5.7","5.6":"5.6","5.5":"5.5","5.4":"5.4","5.3":"5.3","5.2":"5.2","5.1":"5.1","5.0":"5.0","4.2":"4.2"},"currentSection":"\/container","canonical":"docs\/13.x\/container","page":"container","isOldVersion":false,"isUpcomingVersion":false,"defaultVersion":"13.x","markdownUrl":"https:\/\/laravel.com\/docs\/13.x\/container.md"},"url":"\/docs\/13.x\/container","version":"174d4f81a9146d2b5d0d9803483b61da","sharedProps":["errors","events","featuredEvents","navPartners","featuredArticle","alerts","githubStars","footerNavigation","themeMode"]}
Home
⌘K
Skip to contentPrologue
Release Notes
Upgrade Guide
Contribution GuideGetting StartedInstallationConfiguration
Agentic Development
Directory Structure
Frontend
Starter Kits
DeploymentArchitecture ConceptsRequest LifecycleService Container
Service Providers
FacadesThe BasicsRouting
Middleware
CSRF Protection
Controllers
Requests
Responses
Views
Blade TemplatesAsset Bundling
URL Generation
Session
Validation
Error Handling
LoggingDigging DeeperArtisan Console
Broadcasting
Cache
Collections
Concurrency
Context
Contracts
Events
File Storage
HelpersHTTP Client
Localization
Mail
Notifications
Package Development
Processes
Queues
Rate Limiting
Search
Strings
Task Scheduling
Security
Authentication
Authorization
Email Verification
Encryption
Hashing
Password ResetDatabaseGetting Started
Query Builder
Pagination
Migrations
Seeding
Redis
MongoDB
Eloquent ORM
Getting Started
Relationships
Collections
Mutators / Casts
API Resources
Serialization
Factories
AI
AI SDK
MCP
BoostTestingGetting Started
HTTP Tests
Console TestsBrowser Tests
Database
MockingPackagesCashier (Stripe)
Cashier (Paddle)
Dusk
Envoy
Fortify
Folio
Homestead
Horizon
Mix
Octane
Passport
Pennant
Pint
Precognition
Prompts
Pulse
Reverb
Sail
Sanctum
ScoutSocialite
Telescope
Valet
API Documentation
ChangelogService Container

Introduction

Zero Configuration Resolution
When to Utilize the Container


Binding

Binding Basics
Binding Interfaces to Implementations
Contextual Binding
Contextual Attributes
Binding Primitives
Binding Typed Variadics
Tagging
Extending Bindings


Resolving

The Make Method
Automatic Injection


Method Invocation and Injection
Container Events

Rebinding


PSR-11

Introduction
The Laravel service container is a powerful tool for managing class dependencies and performing dependency injection. Dependency injection is a fancy phrase that essentially means this: class dependencies are "injected" into the class via the constructor or, in some cases, "setter" methods.
Let's look at a simple example:

 1<?php
 2 
 3namespace App\Http\Controllers;
 4 
 5use App\Services\AppleMusic;
 6use Illuminate\View\View;
 7 
 8class PodcastController extends Controller
 9{
10    /**
11     * Create a new controller instance.
12     */
13    public function __construct(
14        protected AppleMusic $apple,
15    ) {}
16 
17    /**
18     * Show information about the given podcast.
19     */
20    public function show(string $id): View
21    {
22        return view('podcasts.show', [
23            'podcast' => $this->apple->findPodcast($id)
24        ]);
25    }
26}

<?php

namespace App\Http\Controllers;

use App\Services\AppleMusic;
use Illuminate\View\View;

class PodcastController extends Controller
{
    /**
     * Create a new controller instance.
     */
    public function __construct(
        protected AppleMusic $apple,
    ) {}

    /**
     * Show information about the given podcast.
     */
    public function show(string $id): View
    {
        return view('podcasts.show', [
            'podcast' => $this->apple->findPodcast($id)
        ]);
    }
}

In this example, the PodcastController needs to retrieve podcasts from a data source such as Apple Music. So, we will inject a service that is able to retrieve podcasts. Since the service is injected, we are able to easily "mock", or create a dummy implementation of the AppleMusic service when testing our application.
A deep understanding of the Laravel service container is essential to building a powerful, large application, as well as for contributing to the Laravel core itself.
Zero Configuration Resolution
If a class has no dependencies or only depends on other concrete classes (not interfaces), the container does not need to be instructed on how to resolve that class. For example, you may place the following code in your routes/web.php file:

 1<?php
 2 
 3class Service
 4{
 5    // ...
 6}
 7 
 8Route::get('/', function (Service $service) {
 9    dd($service::class);
10});

<?php

class Service
{
    // ...
}

Route::get('/', function (Service $service) {
    dd($service::class);
});

In this example, hitting your application's / route will automatically resolve the Service class and inject it into your route's handler. This is game changing. It means you can develop your application and take advantage of dependency injection without worrying about bloated configuration files.
Thankfully, many of the classes you will be writing when building a Laravel application automatically receive their dependencies via the container, including controllers, event listeners, middleware, and more. Additionally, you may type-hint dependencies in the handle method of queued jobs. Once you taste the power of automatic and zero configuration dependency injection it feels impossible to develop without it.
When to Utilize the Container
Thanks to zero configuration resolution, you will often type-hint dependencies on routes, controllers, event listeners, and elsewhere without ever manually interacting with the container. For example, you might type-hint the Illuminate\Http\Request object on your route definition so that you can easily access the current request. Even though we never have to interact with the container to write this code, it is managing the injection of these dependencies behind the scenes:

1use Illuminate\Http\Request;
2 
3Route::get('/', function (Request $request) {
4    // ...
5});

use Illuminate\Http\Request;

Route::get('/', function (Request $request) {
    // ...
});

In many cases, thanks to automatic dependency injection and facades, you can build Laravel applications without ever manually binding or resolving anything from the container. So, when would you ever manually interact with the container? Let's examine two situations.
First, if you write a class that implements an interface and you wish to type-hint that interface on a route or class constructor, you must tell the container how to resolve that interface. Secondly, if you are writing a Laravel package that you plan to share with other Laravel developers, you may need to bind your package's services into the container.
Binding
Binding Basics
Simple Bindings
Almost all of your service container bindings will be registered within service providers, so most of these examples will demonstrate using the container in that context.
Within a service provider, you always have access to the container via the $this->app property. We can register a binding using the bind method, passing the class or interface name that we wish to register along with a closure that returns an instance of the class:

1use App\Services\Transistor;
2use App\Services\PodcastParser;
3use Illuminate\Contracts\Foundation\Application;
4 
5$this->app->bind(Transistor::class, function (Application $app) {
6    return new Transistor($app->make(PodcastParser::class));
7});

use App\Services\Transistor;
use App\Services\PodcastParser;
use Illuminate\Contracts\Foundation\Application;

$this->app->bind(Transistor::class, function (Application $app) {
    return new Transistor($app->make(PodcastParser::class));
});

Note that we receive the container itself as an argument to the resolver. We can then use the container to resolve sub-dependencies of the object we are building.
As mentioned, you will typically be interacting with the container within service providers; however, if you would like to interact with the container outside of a service provider, you may do so via the App facade:

1use App\Services\Transistor;
2use Illuminate\Contracts\Foundation\Application;
3use Illuminate\Support\Facades\App;
4 
5App::bind(Transistor::class, function (Application $app) {
6    // ...
7});

use App\Services\Transistor;
use Illuminate\Contracts\Foundation\Application;
use Illuminate\Support\Facades\App;

App::bind(Transistor::class, function (Application $app) {
    // ...
});

You may use the bindIf method to register a container binding only if a binding has not already been registered for the given type:

1$this->app->bindIf(Transistor::class, function (Application $app) {
2    return new Transistor($app->make(PodcastParser::class));
3});

$this->app->bindIf(Transistor::class, function (Application $app) {
    return new Transistor($app->make(PodcastParser::class));
});

For convenience, you may omit providing the class or interface name that you wish to register as a separate argument and instead allow Laravel to infer the type from the return type of the closure you provide to the bind method:

1App::bind(function (Application $app): Transistor {
2    return new Transistor($app->make(PodcastParser::class));
3});

App::bind(function (Application $app): Transistor {
    return new Transistor($app->make(PodcastParser::class));
});


    
        

    
    
There is no need to bind classes into the container if they do not depend on any interfaces. The container does not need to be instructed on how to build these objects, since it can automatically resolve these objects using reflection.

Binding A Singleton
The singleton method binds a class or interface into the container that should only be resolved one time. Once a singleton binding is resolved, the same object instance will be returned on subsequent calls into the container:

1use App\Services\Transistor;
2use App\Services\PodcastParser;
3use Illuminate\Contracts\Foundation\Application;
4 
5$this->app->singleton(Transistor::class, function (Application $app) {
6    return new Transistor($app->make(PodcastParser::class));
7});

use App\Services\Transistor;
use App\Services\PodcastParser;
use Illuminate\Contracts\Foundation\Application;

$this->app->singleton(Transistor::class, function (Application $app) {
    return new Transistor($app->make(PodcastParser::class));
});

You may use the singletonIf method to register a singleton container binding only if a binding has not already been registered for the given type:

1$this->app->singletonIf(Transistor::class, function (Application $app) {
2    return new Transistor($app->make(PodcastParser::class));
3});

$this->app->singletonIf(Transistor::class, function (Application $app) {
    return new Transistor($app->make(PodcastParser::class));
});

Singleton Attribute
Alternatively, you may mark an interface or class with the #[Singleton] attribute to indicate to the container that it should be resolved one time:

 1<?php
 2 
 3namespace App\Services;
 4 
 5use Illuminate\Container\Attributes\Singleton;
 6 
 7#[Singleton]
 8class Transistor
 9{
10    // ...
11}

<?php

namespace App\Services;

use Illuminate\Container\Attributes\Singleton;

#[Singleton]
class Transistor
{
    // ...
}

Binding Scoped Singletons
The scoped method binds a class or interface into the container that should only be resolved one time within a given Laravel request / job lifecycle. While this method is similar to the singleton method, instances registered using the scoped method will be flushed whenever the Laravel application starts a new "lifecycle", such as when a Laravel Octane worker processes a new request or when a Laravel queue worker processes a new job:

1use App\Services\Transistor;
2use App\Services\PodcastParser;
3use Illuminate\Contracts\Foundation\Application;
4 
5$this->app->scoped(Transistor::class, function (Application $app) {
6    return new Transistor($app->make(PodcastParser::class));
7});

use App\Services\Transistor;
use App\Services\PodcastParser;
use Illuminate\Contracts\Foundation\Application;

$this->app->scoped(Transistor::class, function (Application $app) {
    return new Transistor($app->make(PodcastParser::class));
});

You may use the scopedIf method to register a scoped container binding only if a binding has not already been registered for the given type:

1$this->app->scopedIf(Transistor::class, function (Application $app) {
2    return new Transistor($app->make(PodcastParser::class));
3});

$this->app->scopedIf(Transistor::class, function (Application $app) {
    return new Transistor($app->make(PodcastParser::class));
});

Scoped Attribute
Alternatively, you may mark an interface or class with the #[Scoped] attribute to indicate to the container that it should be resolved one time within a given Laravel request / job lifecycle:

 1<?php
 2 
 3namespace App\Services;
 4 
 5use Illuminate\Container\Attributes\Scoped;
 6 
 7#[Scoped]
 8class Transistor
 9{
10    // ...
11}

<?php

namespace App\Services;

use Illuminate\Container\Attributes\Scoped;

#[Scoped]
class Transistor
{
    // ...
}

Binding Instances
You may also bind an existing object instance into the container using the instance method. The given instance will always be returned on subsequent calls into the container:

1use App\Services\Transistor;
2use App\Services\PodcastParser;
3 
4$service = new Transistor(new PodcastParser);
5 
6$this->app->instance(Transistor::class, $service);

use App\Services\Transistor;
use App\Services\PodcastParser;

$service = new Transistor(new PodcastParser);

$this->app->instance(Transistor::class, $service);

Binding Interfaces to Implementations
A very powerful feature of the service container is its ability to bind an interface to a given implementation. For example, let's assume we have an EventPusher interface and a RedisEventPusher implementation. Once we have coded our RedisEventPusher implementation of this interface, we can register it with the service container like so:

1use App\Contracts\EventPusher;
2use App\Services\RedisEventPusher;
3 
4$this->app->bind(EventPusher::class, RedisEventPusher::class);

use App\Contracts\EventPusher;
use App\Services\RedisEventPusher;

$this->app->bind(EventPusher::class, RedisEventPusher::class);

This statement tells the container that it should inject the RedisEventPusher when a class needs an implementation of EventPusher. Now we can type-hint the EventPusher interface in the constructor of a class that is resolved by the container. Remember, controllers, event listeners, middleware, and various other types of classes within Laravel applications are always resolved using the container:

1use App\Contracts\EventPusher;
2 
3/**
4 * Create a new class instance.
5 */
6public function __construct(
7    protected EventPusher $pusher,
8) {}

use App\Contracts\EventPusher;

/**
 * Create a new class instance.
 */
public function __construct(
    protected EventPusher $pusher,
) {}

Bind Attribute
Laravel also provides a Bind attribute for added convenience. You can apply this attribute to any interface to tell Laravel which implementation should be automatically injected whenever that interface is requested. When using the Bind attribute, there is no need to perform any additional service registration in your application's service providers.
In addition, multiple Bind attributes may be placed on an interface in order to configure a different implementation that should be injected for a given set of environments:

 1<?php
 2 
 3namespace App\Contracts;
 4 
 5use App\Services\FakeEventPusher;
 6use App\Services\RedisEventPusher;
 7use Illuminate\Container\Attributes\Bind;
 8 
 9#[Bind(RedisEventPusher::class)]
10#[Bind(FakeEventPusher::class, environments: ['local', 'testing'])]
11interface EventPusher
12{
13    // ...
14}

<?php

namespace App\Contracts;

use App\Services\FakeEventPusher;
use App\Services\RedisEventPusher;
use Illuminate\Container\Attributes\Bind;

#[Bind(RedisEventPusher::class)]
#[Bind(FakeEventPusher::class, environments: ['local', 'testing'])]
interface EventPusher
{
    // ...
}

Furthermore, Singleton and Scoped attributes may be applied to indicate if the container bindings should be resolved once or once per request / job lifecycle:

 1use App\Services\RedisEventPusher;
 2use Illuminate\Container\Attributes\Bind;
 3use Illuminate\Container\Attributes\Singleton;
 4 
 5#[Bind(RedisEventPusher::class)]
 6#[Singleton]
 7interface EventPusher
 8{
 9    // ...
10}

use App\Services\RedisEventPusher;
use Illuminate\Container\Attributes\Bind;
use Illuminate\Container\Attributes\Singleton;

#[Bind(RedisEventPusher::class)]
#[Singleton]
interface EventPusher
{
    // ...
}

Contextual Binding
Sometimes you may have two classes that utilize the same interface, but you wish to inject different implementations into each class. For example, two controllers may depend on different implementations of the Illuminate\Contracts\Filesystem\Filesystem contract. Laravel provides a simple, fluent interface for defining this behavior:

 1use App\Http\Controllers\PhotoController;
 2use App\Http\Controllers\UploadController;
 3use App\Http\Controllers\VideoController;
 4use Illuminate\Contracts\Filesystem\Filesystem;
 5use Illuminate\Support\Facades\Storage;
 6 
 7$this->app->when(PhotoController::class)
 8    ->needs(Filesystem::class)
 9    ->give(function () {
10        return Storage::disk('local');
11    });
12 
13$this->app->when([VideoController::class, UploadController::class])
14    ->needs(Filesystem::class)
15    ->give(function () {
16        return Storage::disk('s3');
17    });

use App\Http\Controllers\PhotoController;
use App\Http\Controllers\UploadController;
use App\Http\Controllers\VideoController;
use Illuminate\Contracts\Filesystem\Filesystem;
use Illuminate\Support\Facades\Storage;

$this->app->when(PhotoController::class)
    ->needs(Filesystem::class)
    ->give(function () {
        return Storage::disk('local');
    });

$this->app->when([VideoController::class, UploadController::class])
    ->needs(Filesystem::class)
    ->give(function () {
        return Storage::disk('s3');
    });

Contextual Attributes
Since contextual binding is often used to inject implementations of drivers or configuration values, Laravel offers a variety of contextual binding attributes that allow to inject these types of values without manually defining the contextual bindings in your service providers.
For example, the Storage attribute may be used to inject a specific storage disk:

 1<?php
 2 
 3namespace App\Http\Controllers;
 4 
 5use Illuminate\Container\Attributes\Storage;
 6use Illuminate\Contracts\Filesystem\Filesystem;
 7 
 8class PhotoController extends Controller
 9{
10    public function __construct(
11        #[Storage('local')] protected Filesystem $filesystem
12    ) {
13        // ...
14    }
15}

<?php

namespace App\Http\Controllers;

use Illuminate\Container\Attributes\Storage;
use Illuminate\Contracts\Filesystem\Filesystem;

class PhotoController extends Controller
{
    public function __construct(
        #[Storage('local')] protected Filesystem $filesystem
    ) {
        // ...
    }
}

In addition to the Storage attribute, Laravel offers Auth, Cache, Config, Context, DB, Give, Log, RouteParameter, and Tag attributes:

 1<?php
 2 
 3namespace App\Http\Controllers;
 4 
 5use App\Contracts\UserRepository;
 6use App\Models\Photo;
 7use App\Repositories\DatabaseRepository;
 8use Illuminate\Container\Attributes\Auth;
 9use Illuminate\Container\Attributes\Cache;
10use Illuminate\Container\Attributes\Config;
11use Illuminate\Container\Attributes\Context;
12use Illuminate\Container\Attributes\DB;
13use Illuminate\Container\Attributes\Give;
14use Illuminate\Container\Attributes\Log;
15use Illuminate\Container\Attributes\RouteParameter;
16use Illuminate\Container\Attributes\Tag;
17use Illuminate\Contracts\Auth\Guard;
18use Illuminate\Contracts\Cache\Repository;
19use Illuminate\Database\Connection;
20use Psr\Log\LoggerInterface;
21 
22class PhotoController extends Controller
23{
24    public function __construct(
25        #[Auth('web')] protected Guard $auth,
26        #[Cache('redis')] protected Repository $cache,
27        #[Config('app.timezone')] protected string $timezone,
28        #[Context('uuid')] protected string $uuid,
29        #[Context('ulid', hidden: true)] protected string $ulid,
30        #[DB('mysql')] protected Connection $connection,
31        #[Give(DatabaseRepository::class)] protected UserRepository $users,
32        #[Log('daily')] protected LoggerInterface $log,
33        #[RouteParameter('photo')] protected Photo $photo,
34        #[Tag('reports')] protected iterable $reports,
35    ) {
36        // ...
37    }
38}

<?php

namespace App\Http\Controllers;

use App\Contracts\UserRepository;
use App\Models\Photo;
use App\Repositories\DatabaseRepository;
use Illuminate\Container\Attributes\Auth;
use Illuminate\Container\Attributes\Cache;
use Illuminate\Container\Attributes\Config;
use Illuminate\Container\Attributes\Context;
use Illuminate\Container\Attributes\DB;
use Illuminate\Container\Attributes\Give;
use Illuminate\Container\Attributes\Log;
use Illuminate\Container\Attributes\RouteParameter;
use Illuminate\Container\Attributes\Tag;
use Illuminate\Contracts\Auth\Guard;
use Illuminate\Contracts\Cache\Repository;
use Illuminate\Database\Connection;
use Psr\Log\LoggerInterface;

class PhotoController extends Controller
{
    public function __construct(
        #[Auth('web')] protected Guard $auth,
        #[Cache('redis')] protected Repository $cache,
        #[Config('app.timezone')] protected string $timezone,
        #[Context('uuid')] protected string $uuid,
        #[Context('ulid', hidden: true)] protected string $ulid,
        #[DB('mysql')] protected Connection $connection,
        #[Give(DatabaseRepository::class)] protected UserRepository $users,
        #[Log('daily')] protected LoggerInterface $log,
        #[RouteParameter('photo')] protected Photo $photo,
        #[Tag('reports')] protected iterable $reports,
    ) {
        // ...
    }
}

Furthermore, Laravel provides a CurrentUser attribute for injecting the currently authenticated user into a given route or class:

1use App\Models\User;
2use Illuminate\Container\Attributes\CurrentUser;
3 
4Route::get('/user', function (#[CurrentUser] User $user) {
5    return $user;
6})->middleware('auth');

use App\Models\User;
use Illuminate\Container\Attributes\CurrentUser;

Route::get('/user', function (#[CurrentUser] User $user) {
    return $user;
})->middleware('auth');

Defining Custom Attributes
You can create your own contextual attributes by implementing the Illuminate\Contracts\Container\ContextualAttribute contract. The container will call your attribute's resolve method, which should resolve the value that should be injected into the class utilizing the attribute. In the example below, we will re-implement Laravel's built-in Config attribute:

 1<?php
 2 
 3namespace App\Attributes;
 4 
 5use Attribute;
 6use Illuminate\Contracts\Container\Container;
 7use Illuminate\Contracts\Container\ContextualAttribute;
 8 
 9#[Attribute(Attribute::TARGET_PARAMETER)]
10class Config implements ContextualAttribute
11{
12    /**
13     * Create a new attribute instance.
14     */
15    public function __construct(public string $key, public mixed $default = null)
16    {
17    }
18 
19    /**
20     * Resolve the configuration value.
21     *
22     * @param  self  $attribute
23     * @param  \Illuminate\Contracts\Container\Container  $container
24     * @return mixed
25     */
26    public static function resolve(self $attribute, Container $container)
27    {
28        return $container->make('config')->get($attribute->key, $attribute->default);
29    }
30}

<?php

namespace App\Attributes;

use Attribute;
use Illuminate\Contracts\Container\Container;
use Illuminate\Contracts\Container\ContextualAttribute;

#[Attribute(Attribute::TARGET_PARAMETER)]
class Config implements ContextualAttribute
{
    /**
     * Create a new attribute instance.
     */
    public function __construct(public string $key, public mixed $default = null)
    {
    }

    /**
     * Resolve the configuration value.
     *
     * @param  self  $attribute
     * @param  \Illuminate\Contracts\Container\Container  $container
     * @return mixed
     */
    public static function resolve(self $attribute, Container $container)
    {
        return $container->make('config')->get($attribute->key, $attribute->default);
    }
}

Binding Primitives
Sometimes you may have a class that receives some injected classes, but also needs an injected primitive value such as an integer. You may easily use contextual binding to inject any value your class may need:

1use App\Http\Controllers\UserController;
2 
3$this->app->when(UserController::class)
4    ->needs('$variableName')
5    ->give($value);

use App\Http\Controllers\UserController;

$this->app->when(UserController::class)
    ->needs('$variableName')
    ->give($value);

Sometimes a class may depend on an array of tagged instances. Using the giveTagged method, you may easily inject all of the container bindings with that tag:

1$this->app->when(ReportAggregator::class)
2    ->needs('$reports')
3    ->giveTagged('reports');

$this->app->when(ReportAggregator::class)
    ->needs('$reports')
    ->giveTagged('reports');

If you need to inject a value from one of your application's configuration files, you may use the giveConfig method:

1$this->app->when(ReportAggregator::class)
2    ->needs('$timezone')
3    ->giveConfig('app.timezone');

$this->app->when(ReportAggregator::class)
    ->needs('$timezone')
    ->giveConfig('app.timezone');

Binding Typed Variadics
Occasionally, you may have a class that receives an array of typed objects using a variadic constructor argument:

 1<?php
 2 
 3use App\Models\Filter;
 4use App\Services\Logger;
 5 
 6class Firewall
 7{
 8    /**
 9     * The filter instances.
10     *
11     * @var array
12     */
13    protected $filters;
14 
15    /**
16     * Create a new class instance.
17     */
18    public function __construct(
19        protected Logger $logger,
20        Filter ...$filters,
21    ) {
22        $this->filters = $filters;
23    }
24}

<?php

use App\Models\Filter;
use App\Services\Logger;

class Firewall
{
    /**
     * The filter instances.
     *
     * @var array
     */
    protected $filters;

    /**
     * Create a new class instance.
     */
    public function __construct(
        protected Logger $logger,
        Filter ...$filters,
    ) {
        $this->filters = $filters;
    }
}

Using contextual binding, you may resolve this dependency by providing the give method with a closure that returns an array of resolved Filter instances:

1$this->app->when(Firewall::class)
2    ->needs(Filter::class)
3    ->give(function (Application $app) {
4          return [
5              $app->make(NullFilter::class),
6              $app->make(ProfanityFilter::class),
7              $app->make(TooLongFilter::class),
8          ];
9    });

$this->app->when(Firewall::class)
    ->needs(Filter::class)
    ->give(function (Application $app) {
          return [
              $app->make(NullFilter::class),
              $app->make(ProfanityFilter::class),
              $app->make(TooLongFilter::class),
          ];
    });

For convenience, you may also just provide an array of class names to be resolved by the container whenever Firewall needs Filter instances:

1$this->app->when(Firewall::class)
2    ->needs(Filter::class)
3    ->give([
4        NullFilter::class,
5        ProfanityFilter::class,
6        TooLongFilter::class,
7    ]);

$this->app->when(Firewall::class)
    ->needs(Filter::class)
    ->give([
        NullFilter::class,
        ProfanityFilter::class,
        TooLongFilter::class,
    ]);

Variadic Tag Dependencies
Sometimes a class may have a variadic dependency that is type-hinted as a given class (Report ...$reports). Using the needs and giveTagged methods, you may easily inject all of the container bindings with that tag for the given dependency:

1$this->app->when(ReportAggregator::class)
2    ->needs(Report::class)
3    ->giveTagged('reports');

$this->app->when(ReportAggregator::class)
    ->needs(Report::class)
    ->giveTagged('reports');

Tagging
Occasionally, you may need to resolve all of a certain "category" of binding. For example, perhaps you are building a report analyzer that receives an array of many different Report interface implementations. After registering the Report implementations, you can assign them a tag using the tag method:

1$this->app->bind(CpuReport::class, function () {
2    // ...
3});
4 
5$this->app->bind(MemoryReport::class, function () {
6    // ...
7});
8 
9$this->app->tag([CpuReport::class, MemoryReport::class], 'reports');

$this->app->bind(CpuReport::class, function () {
    // ...
});

$this->app->bind(MemoryReport::class, function () {
    // ...
});

$this->app->tag([CpuReport::class, MemoryReport::class], 'reports');

Once the services have been tagged, you may easily resolve them all via the container's tagged method:

1$this->app->bind(ReportAnalyzer::class, function (Application $app) {
2    return new ReportAnalyzer($app->tagged('reports'));
3});

$this->app->bind(ReportAnalyzer::class, function (Application $app) {
    return new ReportAnalyzer($app->tagged('reports'));
});

Extending Bindings
The extend method allows the modification of resolved services. For example, when a service is resolved, you may run additional code to decorate or configure the service. The extend method accepts two arguments, the service class you're extending and a closure that should return the modified service. The closure receives the service being resolved and the container instance:

1$this->app->extend(Service::class, function (Service $service, Application $app) {
2    return new DecoratedService($service);
3});

$this->app->extend(Service::class, function (Service $service, Application $app) {
    return new DecoratedService($service);
});

Resolving
The make Method
You may use the make method to resolve a class instance from the container. The make method accepts the name of the class or interface you wish to resolve:

1use App\Services\Transistor;
2 
3$transistor = $this->app->make(Transistor::class);

use App\Services\Transistor;

$transistor = $this->app->make(Transistor::class);

If some of your class's dependencies are not resolvable via the container, you may inject them by passing them as an associative array into the makeWith method. For example, we may manually pass the $id constructor argument required by the Transistor service:

1use App\Services\Transistor;
2 
3$transistor = $this->app->makeWith(Transistor::class, ['id' => 1]);

use App\Services\Transistor;

$transistor = $this->app->makeWith(Transistor::class, ['id' => 1]);

The bound method may be used to determine if a class or interface has been explicitly bound in the container:

1if ($this->app->bound(Transistor::class)) {
2    // ...
3}

if ($this->app->bound(Transistor::class)) {
    // ...
}

If you are outside of a service provider in a location of your code that does not have access to the $app variable, you may use the App facade or the app helper to resolve a class instance from the container:

1use App\Services\Transistor;
2use Illuminate\Support\Facades\App;
3 
4$transistor = App::make(Transistor::class);
5 
6$transistor = app(Transistor::class);

use App\Services\Transistor;
use Illuminate\Support\Facades\App;

$transistor = App::make(Transistor::class);

$transistor = app(Transistor::class);

If you would like to have the Laravel container instance itself injected into a class that is being resolved by the container, you may type-hint the Illuminate\Container\Container class on your class's constructor:

1use Illuminate\Container\Container;
2 
3/**
4 * Create a new class instance.
5 */
6public function __construct(
7    protected Container $container,
8) {}

use Illuminate\Container\Container;

/**
 * Create a new class instance.
 */
public function __construct(
    protected Container $container,
) {}

Automatic Injection
Alternatively, and importantly, you may type-hint the dependency in the constructor of a class that is resolved by the container, including controllers, event listeners, middleware, and more. Additionally, you may type-hint dependencies in the handle method of queued jobs. In practice, this is how most of your objects should be resolved by the container.
For example, you may type-hint a service defined by your application in a controller's constructor. The service will automatically be resolved and injected into the class:

 1<?php
 2 
 3namespace App\Http\Controllers;
 4 
 5use App\Services\AppleMusic;
 6 
 7class PodcastController extends Controller
 8{
 9    /**
10     * Create a new controller instance.
11     */
12    public function __construct(
13        protected AppleMusic $apple,
14    ) {}
15 
16    /**
17     * Show information about the given podcast.
18     */
19    public function show(string $id): Podcast
20    {
21        return $this->apple->findPodcast($id);
22    }
23}

<?php

namespace App\Http\Controllers;

use App\Services\AppleMusic;

class PodcastController extends Controller
{
    /**
     * Create a new controller instance.
     */
    public function __construct(
        protected AppleMusic $apple,
    ) {}

    /**
     * Show information about the given podcast.
     */
    public function show(string $id): Podcast
    {
        return $this->apple->findPodcast($id);
    }
}

Method Invocation and Injection
Sometimes you may wish to invoke a method on an object instance while allowing the container to automatically inject that method's dependencies. For example, given the following class:

 1<?php
 2 
 3namespace App;
 4 
 5use App\Services\AppleMusic;
 6 
 7class PodcastStats
 8{
 9    /**
10     * Generate a new podcast stats report.
11     */
12    public function generate(AppleMusic $apple): array
13    {
14        return [
15            // ...
16        ];
17    }
18}

<?php

namespace App;

use App\Services\AppleMusic;

class PodcastStats
{
    /**
     * Generate a new podcast stats report.
     */
    public function generate(AppleMusic $apple): array
    {
        return [
            // ...
        ];
    }
}

You may invoke the generate method via the container like so:

1use App\PodcastStats;
2use Illuminate\Support\Facades\App;
3 
4$stats = App::call([new PodcastStats, 'generate']);

use App\PodcastStats;
use Illuminate\Support\Facades\App;

$stats = App::call([new PodcastStats, 'generate']);

The call method accepts any PHP callable. The container's call method may even be used to invoke a closure while automatically injecting its dependencies:

1use App\Services\AppleMusic;
2use Illuminate\Support\Facades\App;
3 
4$result = App::call(function (AppleMusic $apple) {
5    // ...
6});

use App\Services\AppleMusic;
use Illuminate\Support\Facades\App;

$result = App::call(function (AppleMusic $apple) {
    // ...
});

Container Events
The service container fires an event each time it resolves an object. You may listen to this event using the resolving method:

 1use App\Services\Transistor;
 2use Illuminate\Contracts\Foundation\Application;
 3 
 4$this->app->resolving(Transistor::class, function (Transistor $transistor, Application $app) {
 5    // Called when container resolves objects of type "Transistor"...
 6});
 7 
 8$this->app->resolving(function (mixed $object, Application $app) {
 9    // Called when container resolves object of any type...
10});

use App\Services\Transistor;
use Illuminate\Contracts\Foundation\Application;

$this->app->resolving(Transistor::class, function (Transistor $transistor, Application $app) {
    // Called when container resolves objects of type "Transistor"...
});

$this->app->resolving(function (mixed $object, Application $app) {
    // Called when container resolves object of any type...
});

As you can see, the object being resolved will be passed to the callback, allowing you to set any additional properties on the object before it is given to its consumer.
Rebinding
The rebinding method allows you to listen for when a service is re-bound to the container, meaning it is registered again or overridden after its initial binding. This can be useful when you need to update dependencies or modify behavior each time a specific binding is updated:

 1use App\Contracts\PodcastPublisher;
 2use App\Services\SpotifyPublisher;
 3use App\Services\TransistorPublisher;
 4use Illuminate\Contracts\Foundation\Application;
 5 
 6$this->app->bind(PodcastPublisher::class, SpotifyPublisher::class);
 7 
 8$this->app->rebinding(
 9    PodcastPublisher::class,
10    function (Application $app, PodcastPublisher $newInstance) {
11        //
12    },
13);
14 
15// New binding will trigger rebinding closure...
16$this->app->bind(PodcastPublisher::class, TransistorPublisher::class);

use App\Contracts\PodcastPublisher;
use App\Services\SpotifyPublisher;
use App\Services\TransistorPublisher;
use Illuminate\Contracts\Foundation\Application;

$this->app->bind(PodcastPublisher::class, SpotifyPublisher::class);

$this->app->rebinding(
    PodcastPublisher::class,
    function (Application $app, PodcastPublisher $newInstance) {
        //
    },
);

// New binding will trigger rebinding closure...
$this->app->bind(PodcastPublisher::class, TransistorPublisher::class);

PSR-11
Laravel's service container implements the PSR-11 interface. Therefore, you may type-hint the PSR-11 container interface to obtain an instance of the Laravel container:

1use App\Services\Transistor;
2use Psr\Container\ContainerInterface;
3 
4Route::get('/', function (ContainerInterface $container) {
5    $service = $container->get(Transistor::class);
6 
7    // ...
8});

use App\Services\Transistor;
use Psr\Container\ContainerInterface;

Route::get('/', function (ContainerInterface $container) {
    $service = $container->get(Transistor::class);

    // ...
});

An exception is thrown if the given identifier can't be resolved. The exception will be an instance of Psr\Container\NotFoundExceptionInterface if the identifier was never bound. If the identifier was bound but was unable to be resolved, an instance of Psr\Container\ContainerExceptionInterface will be thrown.
On this pageIntroductionZero Configuration Resolution
When to Utilize the Container
BindingBinding Basics
Binding Interfaces to Implementations
Contextual Binding
Contextual Attributes
Binding Primitives
Binding Typed Variadics
Tagging
Extending Bindings
ResolvingThe Make Method
Automatic Injection
Method Invocation and InjectionContainer EventsRebinding
PSR-11
Laravel is the most productive way to
 build, deploy, and monitor software.
© 2026 Laravel
Legal
StatusProducts
Cloud
Forge
Nightwatch
Vapor
Nova
Packages
Cashier
Dusk
Horizon
Octane
Scout
Pennant
Pint
Sail
Sanctum
Socialite
Telescope
Pulse
Reverb
EchoResourcesDocumentation
Starter Kits
Release Notes
Blog
News
Community
Larabelles
Learn
JobsCareers
Trust
Partners
Jump24
Threadable
byte5
Kirschbaum
Tighten
64 Robots
UCodeSoft
Curotec
Steadfast Collective
CACI Limited
See All
Prologue

Introduction

Zero Configuration Resolution

When to Utilize the Container

Binding

Binding Basics

Simple Bindings

Binding A Singleton

Singleton Attribute

Binding Scoped Singletons

Scoped Attribute

Binding Instances

Binding Interfaces to Implementations

Bind Attribute

Contextual Binding

Contextual Attributes

Defining Custom Attributes

Binding Primitives

Binding Typed Variadics

Variadic Tag Dependencies

Tagging

Extending Bindings

Resolving

The `make` Method

Automatic Injection

Method Invocation and Injection

Container Events

Rebinding

PSR-11

On this page

`Products`

`Packages`

`Resources`

`Partners`
