framework: [5.0] Contextual binding doesn't work with method injection.

+1 I would love to use contextual binding in a job’s handle() method.

@redgenie for 2 months I did not work with laravel, but if you want some real example about contextual binding in laravel ( >5), you can refer this article http://longkyanh.info/blog/2016/04/29/contextual-binding-in-laravel-and-o-in-solid-principles/

It would be great to have something like this.

$app->when('PostController@store')
     ->needs('PostRepositoryInterface')
     ->give('EloquentPostRepository');

You can do it easily with bindMethod

Example:

AppServiceProvider.php

\App::bindMethod('App\Jobs\MyJob@handle', function ($job, $app) {
    return $job->handle(
        \App::make(Depdency1::class),
        \App::make(Depdency2::class),
        config('my-config'),
        env('SOMETHING')
    );
}

+1 I would like to see contextual binding - when->needs->give working on controllers too. I think it is a valid use case @taylorotwell. Thanks for bringing this up @smallhadroncollider.

I also posted the same question on Stack Overflow.

Consider the following scenario, which is what I’m currently using for my project’s API:

I have a base API controller which implements the CRUD functionalities for various entities (e.g. User, Address, Phone, etc.).

As a simplified example, here is the code for the base controller:

abstract class ApiController {

    protected $repo;

    public function __construct(RepositoryInterface $repo)
    {
        $this->repo = $repo;
    }

    public function index()
    {
        // return a list of records/models (e.g. $this->repo->getAll())
    }

    /**
     * This is using route model (repository to be precise) binding
     */
    public function show($repo)
    {
        // return a record/model (e.g. $repo->getModel())
    }

    /**
     * This is also using route model (repository to be precise) binding
     */
    public function delete($repo)
    {
        // delete a record/model (e.g. $repo->delete())
    }        

}

Each entity’s controller (e.g. UsersController) would extend the base controller, inheriting the CRUD functionalities. In the above, I’m using contextual bindings to inject the relevant repository into the __constructor() method (e.g. when UsersController needs RepositoryInterface, give UserRepository). It works beautifully for the index(), show() and delete() methods.

In order to implement store() and update() methods, I would need to inject object for the relevant request class (I have one for create and one for update operation, for each entity).

The problem is, I cannot inject object of the relevant request class into the constructor due to a couple of reasons:

• Automatic validation would be run as described in the request class on each request (e.g. even for index() method!). This is clearly wrong, and validation would obviously fail for index(), show()and delete()methods, since no user input is supplied for them.
• I have different classes for create and update requests, which means I would need to inject object for the relevant class depending on the method (i.e. store() or update()) being run. This cannot be achieved using constructor injection.

If contextual binding also worked for controller methods other than the constructor, I could just inject the relevant request object directly into the method. For example, I could do something like the following:

   ...

    public function store(CreateRequestInterface $request)
    {
        // create a record (e.g. $this->repo->create($request->all()))
    }

    public function update($repo, UpdateRequestInterface $request)
    {
        // create a record (e.g. $repo->update($request->all()))
    }

   ...

Since this doesn’t work as of now, I’m using a workaround by declaring a couple of properties $createRequestClass and $updateRequestClass, which I override in children controllers to the relevant request classes. Then, within the store() and update() methods, I manually create the instance of the relevant request class using something like $request = App::make($this->createRequestClass).

If contextual bindings would have worked for methods, even this bit of code would not be been needed and everything would have been beautiful 😃

Can you please add a real-life example where you need different implementations of the same parent type injected in different methods of the same class? Thanks!

@reyezstef I found a work around solution for this, hope this help

$this->app->addContextualBinding(
    "API\Http\Controllers\SquaresController"
    "API\Http\Requests\RequestInterface"
    "API\Http\Requests\SquareRequest"
);

+1 Not only in controllers but it would be very useful in some Jobs for example. Jobs rely on the injection only in the handle() method. Sometimes, you might want to give different instances of the interface to different jobs.

@smallhadroncollider @hannesvdvreken
I have the same issue. use bind() works, but use when->needs->give not working

I can’t get this to work.

The following works (but isn’t useful):

$this->app->bind("API\Http\Requests\RequestInterface", "API\Http\Requests\SquareRequest");

This does not:

$this->app->when("API\Http\Controllers\SquaresController")
    ->needs("API\Http\Requests\RequestInterface")
    ->give("API\Http\Requests\SquareRequest");

@robinmitra Hi! Is it working? Because I have the same issue.

Why was this silently closed without further discussion?