Laravel 2.1 Container

Container 是 laravel 框架的核心之一，laravel 框架中类的实例化、存储和管理都是由 Container 来负责的。laravel 里面的 Container 本质上是一个 IOC (Inversion of Control / 控制反转) 容器，是用来实现依赖注入（DI/Dependency Injection）的。也有人把这种设计成为服务定位模式。简单的来说就是在 容器中绑定并保存各个类的抽象以及实例化的方法，在需要这个类的实例时，通过抽象访问类的实例化的方法，由容器自动实例化类，并返回

在Laravel中框架把自带的各种服务绑定到服务容器，我们也可以绑定自定义服务到容器。当应用程序需要使用某一个服务时，服务容器会讲服务解析出来同时自动解决服务之间的依赖然后交给应用程序使用

Container 的作用主要有两个，一个是服务绑定，一个是服务解析

服务绑定

主要有绑定类型：

1. 绑定一个单例，singleton
2. 绑定实例，instance
3. tag 标记绑定，tag

singleton

singleton 方法是bind方法的变种，绑定一个只需要解析一次的类或接口到容器，然后接下来对于容器的调用该服务将会返回同一个实例

主要利用参数 $share = true 来标记此时绑定为一个单例。

public function singleton($abstract, $concrete = null)
{
    $this->bind($abstract, $concrete, true);
}

instance

将一个已存在的对象绑定到服务容器里，随后通过名称解析该服务时，容器将总返回这个绑定的实例

$api = new HelpSpot\API(new HttpClient);
$this->app->instance('HelpSpot\Api', $api);

会把对象注册到服务容器的$instnces属性里，将 [$abstract, $instance]存储进数组 $instances 中

［
     'HelpSpot\Api' => $api//$api是API类的对象，这里简写了
 ］

tag

主要是将 $abstracts 数组放在同一组标签下，最后可以通过 tag，解析这一组 $abstracts

/**
 * Assign a set of tags to a given binding.
 *
 * @param  array|string  $abstracts
 * @param  array|mixed   ...$tags
 * @return void
 */
public function tag($abstracts, $tags)
{
    $tags = is_array($tags) ? $tags : array_slice(func_get_args(), 1);

    foreach ($tags as $tag) {
        if (! isset($this->tags[$tag])) {
            $this->tags[$tag] = [];
        }

        foreach ((array) $abstracts as $abstract) {
            $this->tags[$tag][] = $abstract;
        }
    }
}

bind

绑定服务到服务容器

有三种绑定方式:

1.绑定自身
$this->app->bind('HelpSpot\API', null);

2.绑定闭包
$this->app->bind('HelpSpot\API', function () {
    return new HelpSpot\API();
});//闭包直接提供类实现方式
$this->app->bind('HelpSpot\API', function ($app) {
    return new HelpSpot\API($app->make('HttpClient'));
});//闭包返回需要依赖注入的类

3. 绑定接口和实现
$this->app->bind('Illuminate\Tests\Container\IContainerContractStub', 'Illuminate\Tests\Container\ContainerImplementationStub');

针对第一种情况，其实在bind方法内部会在绑定服务之前通过getClosure()为服务生成闭包，我们来看一下bind方法源码

public function bind($abstract, $concrete = null, $shared = false)
{
    // If no concrete type was given, we will simply set the concrete type to the
    // abstract type. After that, the concrete type to be registered as shared
    // without being forced to state their classes in both of the parameters.
    $this->dropStaleInstances($abstract);

    // 如果传入的实现为空，则绑定 $concrete 自己
    if (is_null($concrete)) {
        $concrete = $abstract;
    }

    // If the factory is not a Closure, it means it is just a class name which is
    // bound into this container to the abstract type and we will just wrap it
    // up inside its own Closure to give us more convenience when extending.
    // 目的是将 $concrete 转成闭包函数
    //如果只提供$abstract，则在这里为其生成concrete闭包
    if (! $concrete instanceof Closure) {
        $concrete = $this->getClosure($abstract, $concrete);
    }

    // 存储到 $bindings 数组中，如果 $shared = true, 则表示绑定单例
    $this->bindings[$abstract] = compact('concrete', 'shared');

    // If the abstract type was already resolved in this container we'll fire the
    // rebound listener so that any objects which have already gotten resolved
    // can have their copy of the object updated via the listener callbacks.
    if ($this->resolved($abstract)) {
        $this->rebound($abstract);
    }
}

protected function getClosure($abstract, $concrete)
{
    // $c 就是$container，即服务容器，会在回调时传递给这个变量
    return function ($c, $parameters = []) use ($abstract, $concrete) {
        $method = ($abstract == $concrete) ? 'build' : 'make';
        return $c->$method($concrete, $parameters);
    };
}

bind把服务注册到服务容器的$bindings属性里类似这样

$bindings = [
    'HelpSpot\API' =>  [//闭包绑定
        'concrete' => function ($app, $paramters = []) {
            return $app->build('HelpSpot\API');
        },
        'shared' => false//如果是singleton绑定，这个值为true
    ]        

    'Illuminate\Tests\Container\IContainerContractStub' => [//接口实现绑定
        'concrete' => 'Illuminate\Tests\Container\ContainerImplementationStub',
        'shared' => false
    ]
]

alias

public function alias($abstract, $alias)
{
    $this->aliases[$alias] = $this->normalize($abstract);
}

alias 方法在上面讲bind方法里有用到过，它会把把服务别名和服务类的对应关系注册到服务容器的$aliases属性里。
例如:

$this->app->alias('\Illuminate\ServiceName', 'service_alias');

绑定完服务后在使用时就可以通过

$this->app->make('service_alias');

将服务对象解析出来，这样make的时候就不用写那些比较长的类名称了，对make方法的使用体验上有很大提升。

服务解析

make

从服务容器中解析出服务对象，该方法接收你想要解析的类名或接口名作为参数

public function make($abstract, array $parameters = [])
{
    return $this->resolve($abstract, $parameters);
}

protected function resolve($abstract, $parameters = [])
{
    //getAlias方法会假定$abstract是绑定的别名，从$aliases找到映射的真实类型名
    //如果没有映射则$abstract即为真实类型名，将$abstract原样返回
    $abstract = $this->getAlias($abstract);
    //该方法主要是区分，解析的对象是否有参数，如果有参数，还需要对参数做进一步的分析，因为传入的参数，也可能是依赖注入的，所以还需要对传入的参数进行解析；这个后面再分析。
    $needsContextualBuild = ! empty($parameters) || ! is_null(
        $this->getContextualConcrete($abstract)
    );

    // If an instance of the type is currently being managed as a singleton we'll
    // just return an existing instance instead of instantiating new instances
    // so the developer can keep using the same objects instance every time.
    //如果是绑定的单例，并且不需要上面的参数依赖。我们就可以直接返回
    if (isset($this->instances[$abstract]) && ! $needsContextualBuild) {
        return $this->instances[$abstract];
    }

    $this->with[] = $parameters;
    //这一步主要是先从绑定的上下文找，是不是可以找到绑定类；如果没有，则再从 `$bindings[]` 中找关联的实现类；最后还没有找到的话，就直接返回 `$abstract` 本身。
    $concrete = $this->getConcrete($abstract);

    // We're ready to instantiate an instance of the concrete type registered for
    // the binding. This will instantiate the types, as well as resolve any of
    // its "nested" dependencies recursively until all have gotten resolved.
    //如果之前找到的 $concrete 返回的是 $abstract 值，或者 $concrete 是个闭包，则执行 $this->build($concrete)，否则，表示存在嵌套依赖的情况，则采用递归的方法执行 $this->make($concrete)，直到所有的都解析完为止
    if ($this->isBuildable($concrete, $abstract)) {
        $object = $this->build($concrete);//看build方法
    } else {
        $object = $this->make($concrete);
    }

    // If we defined any extenders for this type, we'll need to spin through them
    // and apply them to the object being built. This allows for the extension
    // of services, such as changing configuration or decorating the object.
    //判断是否存在扩展，是则相应扩展功能；
    foreach ($this->getExtenders($abstract) as $extender) {
        $object = $extender($object, $this);
    }

    // If the requested type is registered as a singleton we'll want to cache off
    // the instances in "memory" so we can return it later without creating an
    // entirely new instance of an object on each subsequent request for it.
    //如果是绑定单例，则将解析的结果存到 $this->instances 数组中
    if ($this->isShared($abstract) && ! $needsContextualBuild) {
        $this->instances[$abstract] = $object;
    }
    //后面是一些解析的工作
    $this->fireResolvingCallbacks($abstract, $object);

    // Before returning, we will also set the resolved flag to "true" and pop off
    // the parameter overrides for this build. After those two things are done
    // we will be ready to return back the fully constructed class instance.
    $this->resolved[$abstract] = true;

    array_pop($this->with);

    return $object;
}

build

通过对make方法的梳理我们发现，build方法的职能是构建解析出来的服务的对象的，下面看一下构建对象的具体流程。（构建过程中用到了PHP类的反射来实现服务的依赖注入）

此方法分成两个分支：如果 $concrete instanceof Closure，则直接调用闭包函数，返回结果：$concrete()；另一种分支就是，传入的就是一个 $concrete === $abstract === 类名，通过反射方法，解析并 new 该类。

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, $this->getLastParameterOverride());
    }

    // 利用反射机制，解析该类。
    $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)) {
        // 将 build 过程的内容 pop，然后直接构造对象输出。
        array_pop($this->buildStack);

        return new $concrete;
    }

    // 获取构造函数的参数
    $dependencies = $constructor->getParameters();

    // 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);
}

/**
 * Resolve all of the bindings for a given tag.
 *
 * @param  string  $tag
 * @return array
 * 如果传入的 tag 标签值存在 tags 数组中，则遍历所有 $abstract, 一一解析，将结果保存数组输出
 */
public function tagged($tag)
{
    $results = [];

    if (isset($this->tags[$tag])) {
        foreach ($this->tags[$tag] as $abstract) {
            $results[] = $this->make($abstract);
        }
    }

    return $results;
}

服务容器就是laravel的核心， 它通过依赖注入很好的替我们解决对象之间的相互依赖关系，而又通过控制反转让外部来来定义具体的行为（Route, Eloquent这些都是外部模块，它们自己定义了行为规范，这些类从注册到实例化给你使用才是服务容器负责的）。

一个类要被容器所能够提取，必须要先注册至这个容器。既然 laravel 称这个容器叫做服务容器，那么我们需要某个服务，就得先注册、绑定这个服务到容器，那么提供服务并绑定服务至容器的东西，就是服务提供器（ServiceProvider）

本作品采用《CC 协议》，转载必须注明作者和本文链接