Parsing Laravel's dependency injection through source code

This article mainly introduces you to how to parse Laravel's Dependency Injection through source code. The article introduces it in detail through sample code, which has certain reference learning value for everyone's study or work. , friends who are interested in the Laravel framework, please follow the editor to learn together.

Preface

As we all know, there are countless PHP frameworks. In recent years, a framework known for its elegance has gradually been known by domestic PHPers. , and started using it, but one obvious shortcoming of larave is that its documentation content is pitiful.

This article will give you a detailed introduction to Laravel dependency injection and share it for your reference and study. I won’t say much below, let’s take a look at the detailed introduction.

In Laravel's controller's constructor method or member method , you can use dependency injection through type constraints , such as:

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

The $request parameter here uses type constraints. Request is a class:\Illuminate\Http\Request, which means 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 addition, deletion, modification and query.

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

After obtaining the constraint type of the dependent object from the method parameters, 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:

Laravel framework + Blob implementation of multi-image upload function example

Build a Laravel application based on Docker from scratch

Seven Very Useful Carbon Methods in Laravel

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