Example parsing Laravel's dependency injection

As we all know, there are countless PHP frameworks. In recent years, a framework known for its elegance has gradually been known and started to be used by domestic PHPers. However, one obvious shortcoming of larave is that its document content is pitiful. . This article mainly introduces you to the relevant information on how to parse Laravel's dependency injection through source code. The article introduces it in great detail through sample code. It has certain reference learning value for everyone's study or work. I hope it can help everyone.

In the constructor or member method of Laravel's controller, dependency injection can be used through type constraints, such as:

public function store(Request $request)
{
 //TODO
}

The $request parameter here uses type constraints, and Request is A class:\Illuminate\Http\Request, indicating that the parameter must be this class or a subclass.

This article analyzes the source code of Laravel to see why Request can be used directly without passing in an instance in the method? It’s just that the framework automatically instantiates and passes parameters for us.

1. Route definition

Looking from the source, such a route is defined in the route definition file:

Route::resource('/role', 'Admin\RoleController');

This is a resource-based route, Laravel will Automatically generate routing entries for additions, deletions, modifications and queries.

The store method at the beginning of this article is a controller method. The Action defined by the route visible in the figure is also: App\Http\Controllers\Admin\RoleController@store

Routing method analysis

Find the controller and method according to the routing definition, and execute the specific method in the dispatch method.

(File: vendor/laravel/framework/src/Illuminate/Routing/ControllerDispatcher.php)

public function dispatch(Route $route, $controller, $method)
{
 $parameters = $this->resolveClassMethodDependencies(
  $route->parametersWithoutNulls(), $controller, $method
 );
 
 if (method_exists($controller, 'callAction')) {
  return $controller->callAction($method, $parameters);
 }
 
 return $controller->{$method}(...array_values($parameters));
}

First resolveClassMethodDependencies method, "as the name suggests" is to obtain dependent objects based on the method parameters of the class, and then Then call the class method and inject the object parameters.

If there are multiple dependent objects, they will be parsed out by foreach in turn and injected as parameters.

Get the code for the dependent object example:

protected function resolveClassMethodDependencies(array $parameters, $instance, $method)
{
 if (! method_exists($instance, $method)) {
  return $parameters;
 }
 
 return $this->resolveMethodDependencies(
  $parameters, new ReflectionMethod($instance, $method)
 );
}

The key point here is the use of PHP reflection. Pay attention to the RelectionMethod method. It obtains the method parameter list of the class and can know the type constraints of the parameters. Name etc.

The $instance parameter here is the RoleController controller class, and the $method parameter is the method name store.

2. Example of obtaining dependent objects

Get it from the parameters of the method Once you know the constraint type of the dependent object, you can instantiate the dependent object.

protected function transformDependency(ReflectionParameter $parameter, $parameters)
{
 $class = $parameter->getClass(); 
 // If the parameter has a type-hinted class, we will check to see if it is already in
 // the list of parameters. If it is we will just skip it as it is probably a model
 // binding and we do not want to mess with those; otherwise, we resolve it here.
 if ($class && ! $this->alreadyInParameters($class->name, $parameters)) {
  return $parameter->isDefaultValueAvailable()
   ? $parameter->getDefaultValue()
   : $this->container->make($class->name);
 }
}

Obtain the object from the container based on the class name. The process of binding the object instance is first defined in the service provider.

Then pass the instantiated object into the store method, and you can use the dependent object.

3. About PHP reflection

Give an example of using ReflectionMethod.

class Demo
{
 private $request;
 public function store(Request $request)
 {
 }
}

Print out the content of new ReflectionMethod(Demo::class, 'store') as shown in the figure:

##You can get the parameter list of this method, The constraint type of the parameter, such as typeHint, Illuminate\Http\Request.

The instance initially bound through the service provider can be obtained from the container according to the class name.

Related recommendations:

A brief discussion on custom dependency injection of lumen framework

PHP implements automatic dependency injection based on reflection mechanism Detailed explanation of the method_php skills

How to use js to implement dependency injection

The above is the detailed content of Example parsing Laravel's dependency injection. For more information, please follow other related articles on the PHP Chinese website!