[置顶] Laravel 框架 容器解析具体的某一个类 的执行 流程

$kernel = $app->make(Illuminate\Contracts\Http\Kernel::class);

以laravel 框架中入口文件的一行代码进行分析。由于Illuminate\Contracts\Http\Kernel::class  绑定的具体的类为App\Http\Kernel ，所以其实就是对App\Http\Kernel的解析，结合http://blog.csdn.net/qq_16877261/article/details/78053512  这篇文章，我们直接从容器中 build函数进行分析。

/**
* Instantiate a concrete instance of the given type.
*    实例化一个具体的对象
* @param  string  $concrete
* @return mixed
*
* @throws \Illuminate\Contracts\Container\BindingResolutionException
*/
public function build($concrete)
{
// If the concrete type is actually a Closure, we will just execute it and
// hand back the results of the functions, which allows functions to be
// used as resolvers for more fine-tuned resolution of these objects.
//是否是闭包（匿名函数）
if ($concrete instanceof Closure) {
return $concrete($this);
}

$reflector = new ReflectionClass($concrete);
// If the type is not instantiable, the developer is attempting to resolve
// an abstract type such as an Interface of Abstract Class and there is
// no binding registered for the abstractions so we need to bail out.
//检查类是否可实例化    接口或抽象类
if (! $reflector->isInstantiable()) {
return $this->notInstantiable($concrete);
}

$this->buildStack[] = $concrete;

$constructor = $reflector->getConstructor();

// If there are no constructors, that means there are no dependencies then
// we can just resolve the instances of the objects right away, without
// resolving any other types or dependencies out of these containers.
if (is_null($constructor)) {
array_pop($this->buildStack);

return new $concrete;
}
$dependencies = $constructor->getParameters();

if($concrete == 'App\Http\Kernel'){

dd($dependencies);

}

// Once we have all the constructor's parameters we can create each of the
// dependency instances and then use the reflection instances to make a
// new instance of this class, injecting the created dependencies in.
//解析构造函数中的变量，如果有依赖类，也会自动解析。
$instances = $this->resolveDependencies(
$dependencies
);
array_pop($this->buildStack);
//从给出的参数创建一个新的类实例
return $reflector->newInstanceArgs($instances);
}

打印$dependencies 结果如下：



这里利用了PHP的反射类获取 所要实例化类的构造函数的参数。在laravel中，构造函数中一般会使用依赖注入，所以在获取的参数中包含有依赖的类，应该如何处理呢？

laravel 中 在resolveDependencies函数进行了处理。

/**
* Resolve all of the dependencies from the ReflectionParameters.
*
* @param  array $dependencies
* @return array
*/
protected function resolveDependencies(array $dependencies)
{
$results = [];

foreach ($dependencies as $dependency) {
// If the class is null, it means the dependency is a string or some other
// primitive type which we can not resolve since it is not a class and
// we will just bomb out with an error since we have no-where to go.
$results[] = is_null($class = $dependency->getClass())
? $this->resolvePrimitive($dependency)
: $this->resolveClass($dependency);//参数 如果依赖的是一个类，会执行这个
}                                          //函数，解析依赖的类。这就是依赖注入

return $results;                          //原理，发现很简单啊}

最后根据给出的参数实例化类。在本例中就是App\Http\Kernel。于是我们就去查看这个类，发现这个类只有三个属性数组，当然你不知道它们是用来做什么的，于是查看父类

Illuminate\Foundation\Http\Kernel 。父类的构造函数中没有特别的操作（只是进行一些属性的操作和一些中间件的注册），可以自行查看。至此该类的实例化完成。

于是我们接着查看入口文件

$response = $kernel->handle(
$request = Illuminate\Http\Request::capture()
);

所以接着查看Illuminate\Foundation\Http\Kernel中的handle函数。

public function handle($request)
{
try {
$request->enableHttpMethodParameterOverride();

$response = $this->sendRequestThroughRouter($request);
} catch (Exception $e) {
$this->reportException($e);

$response = $this->renderException($request, $e);
} catch (Throwable $e) {
$this->reportException($e = new FatalThrowableError($e));

$response = $this->renderException($request, $e);
}

event(new Events\RequestHandled($request, $response));

return $response;
}

查看这个函数发现我只需要看sendRequestThroughRouter 这个函数就可以了。

protected function sendRequestThroughRouter($request)
{      // 实例化一个已经存在的实例
 $this->app->instance('request', $request);

Facade::clearResolvedInstance('request');

$this->bootstrap();

return (new Pipeline($this->app))
->send($request)
->through($this->app->shouldSkipMiddleware() ? [] : $this->middleware)
->then($this->dispatchToRouter());
}

我们查看bootstrap，又去查看bootstrapWith 函数如下：

public function bootstrapWith(array $bootstrappers)
{
$this->hasBeenBootstrapped = true;
//dd($this['events']);
foreach ($bootstrappers as $bootstrapper) {
//events 对应绑定的类为 Dispatcher类
$this['events']->fire('bootstrapping: '.$bootstrapper, [$this]);

//     从容器解析引导类，并且执行引导类的bootstrap方法

$this->make($bootstrapper)->bootstrap($this); $this['events']->fire('bootstrapped: '.$bootstrapper, [$this]); }}
又查看fire函数如下：

public function fire($event, $payload = [], $halt = false)
{
return $this->dispatch($event, $payload, $halt);
}

最终查看dispatch 函数如下：

public function dispatch($event, $payload = [], $halt = false)
{
// When the given "event" is actually an object we will assume it is an event
// object and use the class as the event name and this event itself as the
// payload to the handler, which makes object based events quite simple.
list($event, $payload) = $this->parseEventAndPayload(
$event, $payload
);
//引导程序不执行这部分
if ($this->shouldBroadcast($payload)) {
$this->broadcastEvent($payload[0]);
}
$responses = [];
// dd($this->getListeners($event));

//引导程序不执行这部分
foreach ($this->getListeners($event) as $listener) {
$response = $listener($event, $payload);
// If a response is returned from the listener and event halting is enabled
// we will just return this response, and not call the rest of the event
// listeners. Otherwise we will add the response on the response list.
if (! is_null($response) && $halt) {
return $response;
}
// If a boolean false is returned from a listener, we will stop propagating
// the event to any further listeners down in the chain, else we keep on
// looping through the listeners and firing every one in our sequence.
if ($response === false) {
break;
}

$responses[] = $response;
}

return $halt ? null : $responses;
}

发现引导类第一次执行后返回是一个空数组。

于是    $this->bootstrap(); 这句其实就是执行对应引导类的bootstrap方法。

最后关于管道的理解请参考
http://www.jianshu.com/p/3c2791a525d0
zheyu方法