中文正文版 Laravel 容器类（Container）
将 Laravel 的 illuminate/container 移除掉 illuminate/contracts 依赖，便于灵便的在非 Laravel 框架中应用，顺便机翻了一下 illuminate/container 的正文，便于了解 Laravel 的容器。
相干链接
- https://github.com/guanguans/di
- https://github.com/illuminate/container
代码
<?php/* * This file is part of the guanguans/di. * * (c) guanguans <ityaozm@gmail.com> * * This source file is subject to the MIT license that is bundled. */namespace Guanguans\Di;use ArrayAccess;use Closure;use LogicException;use Psr\Container\ContainerInterface;use ReflectionClass;use ReflectionParameter;/** * This file is modified from `illuminate/container`. * * @see https://github.com/illuminate/container */class Container implements ArrayAccess, ContainerInterface{ /** * The current globally available container (if any). * 以后的全局可用容器（如果有）。 * * @var static */ protected static $instance; /** * An array of the types that have been resolved. * 已解析类型的数组。 * * @var array */ protected $resolved = []; /** * The container's bindings. * 容器的绑定。 * * @var array */ protected $bindings = []; /** * The container's method bindings. * 容器的办法绑定。 * * @var array */ protected $methodBindings = []; /** * The container's shared instances. * 容器的共享实例。 * * @var array */ protected $instances = []; /** * The registered type aliases. * 注册的类型别名。 * * @var array */ protected $aliases = []; /** * The registered aliases keyed by the abstract name. * 以形象名称为关键字的注册别名。 * * @var array */ protected $abstractAliases = []; /** * The extension closures for services. * 服务的扩展名闭包。 * * @var array */ protected $extenders = []; /** * All of the registered tags. * 所有注册的标签。 * * @var array */ protected $tags = []; /** * The stack of concretions currently being built. * 目前正在构建的堆栈。 * * @var array */ protected $buildStack = []; /** * The parameter override stack. * 参数笼罩堆栈。 * * @var array */ protected $with = []; /** * The contextual binding map. * 上下文绑定图。 * * @var array */ public $contextual = []; /** * All of the registered rebound callbacks. * 所有已注册的反弹回调。 * * @var array */ protected $reboundCallbacks = []; /** * All of the global resolving callbacks. * 所有全局解析回调。 * * @var array */ protected $globalResolvingCallbacks = []; /** * All of the global after resolving callbacks. * 解决回调后的所有全局变量。 * * @var array */ protected $globalAfterResolvingCallbacks = []; /** * All of the resolving callbacks by class type. * 按类类型的所有解析回调。 * * @var array */ protected $resolvingCallbacks = []; /** * All of the after resolving callbacks by class type. * 所有按类类型解析后的回调。 * * @var array */ protected $afterResolvingCallbacks = []; /** * Define a contextual binding. * 定义上下文绑定。 * * @param string $concrete * @return \Guanguans\Di\ContextualBindingBuilder */ public function when($concrete) { return new ContextualBindingBuilder($this, $this->getAlias($concrete)); } /** * Determine if the given abstract type has been bound. * 确定给定的形象类型是否已绑定。 * * @param string $abstract * @return bool */ public function bound($abstract) { return isset($this->bindings[$abstract]) || isset($this->instances[$abstract]) || $this->isAlias($abstract); } /** * Determine if the given abstract type has been resolved. * 确定给定的形象类型是否已解析。 * * @param string $abstract * @return bool */ public function resolved($abstract) { if ($this->isAlias($abstract)) { $abstract = $this->getAlias($abstract); } return isset($this->resolved[$abstract]) || isset($this->instances[$abstract]); } /** * Determine if a given type is shared. * 确定给定类型是否共享。 * * @param string $abstract * @return bool */ public function isShared($abstract) { return isset($this->instances[$abstract]) || (isset($this->bindings[$abstract]['shared']) && $this->bindings[$abstract]['shared'] === true); } /** * Determine if a given string is an alias. * 确定给定的字符串是否为别名 * * @param string $name * @return bool */ public function isAlias($name) { return isset($this->aliases[$name]); } /** * Register a binding with the container. * 在容器中注册绑定 * * @param string|array $abstract * @param \Closure|string|null $concrete * @param bool $shared * @return void */ 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); 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. // 如果工厂不是 Closure，则意味着它只是一个类名称， // 该类名称绑定到此容器中，与形象类型绑定， // 咱们将其包装在本人的 Closure 中，以便在扩大时为咱们提供更多便当。 if (! $concrete instanceof Closure) { $concrete = $this->getClosure($abstract, $concrete); } $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); } } /** * Get the Closure to be used when building a type. * 获取要在构建类型时应用的闭包。 * * @param string $abstract * @param string $concrete * @return \Closure */ protected function getClosure($abstract, $concrete) { return function ($container, $parameters = []) use ($abstract, $concrete) { if ($abstract == $concrete) { return $container->build($concrete); } return $container->makeWith($concrete, $parameters); }; } /** * Determine if the container has a method binding. * 确定容器是否具备办法绑定。 * * @param string $method * @return bool */ public function hasMethodBinding($method) { return isset($this->methodBindings[$method]); } /** * Bind a callback to resolve with Container::call. * 绑定回调以应用 Container::call 进行解析。 * * @param string $method * @param \Closure $callback * @return void */ public function bindMethod($method, $callback) { $this->methodBindings[$method] = $callback; } /** * Get the method binding for the given method. * 获取给定办法的办法绑定。 * * @param string $method * @param mixed $instance * @return mixed */ public function callMethodBinding($method, $instance) { return call_user_func($this->methodBindings[$method], $instance, $this); } /** * Add a contextual binding to the container. * 将上下文绑定增加到容器。 * * @param string $concrete * @param string $abstract * @param \Closure|string $implementation * @return void */ public function addContextualBinding($concrete, $abstract, $implementation) { $this->contextual[$concrete][$this->getAlias($abstract)] = $implementation; } /** * Register a binding if it hasn't already been registered. * 注册绑定（如果尚未注册）。 * * @param string $abstract * @param \Closure|string|null $concrete * @param bool $shared * @return void */ public function bindIf($abstract, $concrete = null, $shared = false) { if (! $this->bound($abstract)) { $this->bind($abstract, $concrete, $shared); } } /** * Register a shared binding in the container. * 在容器中注册共享绑定。 * * @param string|array $abstract * @param \Closure|string|null $concrete * @return void */ public function singleton($abstract, $concrete = null) { $this->bind($abstract, $concrete, true); } /** * "Extend" an abstract type in the container. * “扩大”容器中的形象类型。 * * @param string $abstract * @param \Closure $closure * @return void * * @throws \InvalidArgumentException */ public function extend($abstract, Closure $closure) { $abstract = $this->getAlias($abstract); if (isset($this->instances[$abstract])) { $this->instances[$abstract] = $closure($this->instances[$abstract], $this); $this->rebound($abstract); } else { $this->extenders[$abstract][] = $closure; if ($this->resolved($abstract)) { $this->rebound($abstract); } } } /** * Register an existing instance as shared in the container. * 将现有实例注册为在容器中共享的实例。 * * @param string $abstract * @param mixed $instance * @return void */ public function instance($abstract, $instance) { $this->removeAbstractAlias($abstract); $isBound = $this->bound($abstract); unset($this->aliases[$abstract]); // We'll check to determine if this type has been bound before, and if it has // we will fire the rebound callbacks registered with the container and it // can be updated with consuming classes that have gotten resolved here. // 咱们将查看以确定此类型是否以前已绑定， // 如果曾经绑定，将触发在容器中注册的反弹回调， // 并且能够应用在这里已解决的耗费类进行更新。 $this->instances[$abstract] = $instance; if ($isBound) { $this->rebound($abstract); } } /** * Remove an alias from the contextual binding alias cache. * 从上下文绑定别名缓存中删除别名。 * * @param string $searched * @return void */ protected function removeAbstractAlias($searched) { if (! isset($this->aliases[$searched])) { return; } foreach ($this->abstractAliases as $abstract => $aliases) { foreach ($aliases as $index => $alias) { if ($alias == $searched) { unset($this->abstractAliases[$abstract][$index]); } } } } /** * 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; } } } /** * Resolve all of the bindings for a given tag. * 解决给定标签的所有绑定。 * * @param string $tag * @return array */ public function tagged($tag) { $results = []; if (isset($this->tags[$tag])) { foreach ($this->tags[$tag] as $abstract) { $results[] = $this->make($abstract); } } return $results; } /** * Alias a type to a different name. * 将别名别名为另一个名称。 * * @param string $abstract * @param string $alias * @return void */ public function alias($abstract, $alias) { $this->aliases[$alias] = $abstract; $this->abstractAliases[$abstract][] = $alias; } /** * Bind a new callback to an abstract's rebind event. * 绑定一个新的回调到形象的从新绑定事件。 * * @param string $abstract * @param \Closure $callback * @return mixed */ public function rebinding($abstract, Closure $callback) { $this->reboundCallbacks[$abstract = $this->getAlias($abstract)][] = $callback; if ($this->bound($abstract)) { return $this->make($abstract); } } /** * Refresh an instance on the given target and method. * 在给定的指标和办法上刷新实例。 * * @param string $abstract * @param mixed $target * @param string $method * @return mixed */ public function refresh($abstract, $target, $method) { return $this->rebinding($abstract, function ($app, $instance) use ($target, $method) { $target->{$method}($instance); }); } /** * Fire the "rebound" callbacks for the given abstract type. * 为给定的形象类型触发“反弹”回调。 * * @param string $abstract * @return void */ protected function rebound($abstract) { $instance = $this->make($abstract); foreach ($this->getReboundCallbacks($abstract) as $callback) { call_user_func($callback, $this, $instance); } } /** * Get the rebound callbacks for a given type. * 获取给定类型的反弹回调 * * @param string $abstract * @return array */ protected function getReboundCallbacks($abstract) { if (isset($this->reboundCallbacks[$abstract])) { return $this->reboundCallbacks[$abstract]; } return []; } /** * Wrap the given closure such that its dependencies will be injected when executed. * 包装给定的闭包，以便在执行时注入其依赖项。 * * @param \Closure $callback * @param array $parameters * @return \Closure */ public function wrap(Closure $callback, array $parameters = []) { return function () use ($callback, $parameters) { return $this->call($callback, $parameters); }; } /** * Call the given Closure / class@method and inject its dependencies. * 调用给定的 Closure / class@method 并注入其依赖项。 * * @param callable|string $callback * @param array $parameters * @param string|null $defaultMethod * @return mixed */ public function call($callback, array $parameters = [], $defaultMethod = null) { return BoundMethod::call($this, $callback, $parameters, $defaultMethod); } /** * Get a closure to resolve the given type from the container. * 获取一个容器来解析给定类型的闭包。 * * @param string $abstract * @return \Closure */ public function factory($abstract) { return function () use ($abstract) { return $this->make($abstract); }; } /** * Resolve the given type with the given parameter overrides. * 应用给定的参数笼罩解析给定的类型。 * * @param string $abstract * @param array $parameters * @return mixed */ public function makeWith($abstract, array $parameters) { return $this->resolve($abstract, $parameters); } /** * Resolve the given type from the container. * 从容器解析给定类型。 * * @param string $abstract * @return mixed */ public function make($abstract) { return $this->resolve($abstract); } /** * Resolve the given type from the container. * 从容器解析给定类型。 * * @param string $abstract * @param array $parameters * @return mixed */ protected function resolve($abstract, $parameters = []) { $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; $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. // 咱们曾经筹备好实例化为绑定注册的具体类型的实例。 // 这将实例化类型，并以递归形式解析其“嵌套”依赖项中的任何一个，直到全副解析结束。 if ($this->isBuildable($concrete, $abstract)) { $object = $this->build($concrete); } 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. // 如果将申请的类型注册为单例，咱们将将实例缓存在“内存”中， // 这样咱们当前就能够返回它，而无需在随后的每次申请上都创建对象的全新实例。 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. // 在返回之前，咱们还将解析标记设置为 “true”，并弹出此版本的参数代替。 // 实现这两件事之后，咱们将筹备好返回残缺结构的类实例。 $this->resolved[$abstract] = true; array_pop($this->with); return $object; } /** * Get the concrete type for a given abstract. * 获取给定摘要的具体类型。 * * @param string $abstract * @return mixed $concrete */ protected function getConcrete($abstract) { if (! is_null($concrete = $this->getContextualConcrete($abstract))) { return $concrete; } // If we don't have a registered resolver or concrete for the type, we'll just // assume each type is a concrete name and will attempt to resolve it as is // since the container should be able to resolve concretes automatically. // 如果咱们没有该类型的注册解析器或具体对象，咱们将假如每种类型都是具体名称， // 并尝试按原样解析它，因为容器应该可能主动解析具体对象。 if (isset($this->bindings[$abstract])) { return $this->bindings[$abstract]['concrete']; } return $abstract; } /** * Get the contextual concrete binding for the given abstract. * 获取给定摘要的上下文具体绑定。 * * @param string $abstract * @return string|null */ protected function getContextualConcrete($abstract) { if (! is_null($binding = $this->findInContextualBindings($abstract))) { return $binding; } // Next we need to see if a contextual binding might be bound under an alias of the // given abstract type. So, we will need to check if any aliases exist with this // type and then spin through them and check for contextual bindings on these. // 接下来，咱们须要查看是否能够在给定形象类型的别名下绑定上下文绑定。 // 因而，咱们将须要查看此类型是否存在别名，而后旋转它们并查看这些别名的上下文绑定。 if (empty($this->abstractAliases[$abstract])) { return; } foreach ($this->abstractAliases[$abstract] as $alias) { if (! is_null($binding = $this->findInContextualBindings($alias))) { return $binding; } } } /** * Find the concrete binding for the given abstract in the contextual binding array. * 在上下文绑定数组中找到给定摘要的具体绑定 * * @param string $abstract * @return string|null */ protected function findInContextualBindings($abstract) { if (isset($this->contextual[end($this->buildStack)][$abstract])) { return $this->contextual[end($this->buildStack)][$abstract]; } } /** * Determine if the given concrete is buildable. * 确定给定的具体是否可构建。 * * @param mixed $concrete * @param string $abstract * @return bool */ protected function isBuildable($concrete, $abstract) { return $concrete === $abstract || $concrete instanceof Closure; } /** * Instantiate a concrete instance of the given type. * 实例化给定类型的具体实例。 * * @param string $concrete * @return mixed * * @throws \Guanguans\Di\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. // 如果具体类型实际上是 Closure，咱们将间接执行它并返回函数的后果， // 这容许将函数用作解析器，以便对这些对象进行更精密的解析。 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. // 如果类型不是可实例化的，则开发人员正尝试解析形象类型， // 例如 Abstract Class 的接口，并且没有为形象注册任何绑定，因而咱们须要纾困。 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(); // 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 dependencies from the ReflectionParameters. * 从 ReflectionParameters 解析所有依赖项。 * * @param array $dependencies * @return array */ protected function resolveDependencies(array $dependencies) { $results = []; foreach ($dependencies as $dependency) { // If this dependency has a override for this particular build we will use // that instead as the value. Otherwise, we will continue with this run // of resolutions and let reflection attempt to determine the result. // 如果此依赖项对此特定构建具备代替，咱们将应用作为值。 // 否则，咱们将继续执行的分辨率，并让反射尝试确定后果。 if ($this->hasParameterOverride($dependency)) { $results[] = $this->getParameterOverride($dependency); continue; } // 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. // 如果该类为 null，则示意依赖项是字符串或其余类型的原始类型， // 因为它不是类，因而咱们无奈解析，并且因为没有地位，咱们将抛出谬误去。 $results[] = is_null($class = $dependency->getClass()) ? $this->resolvePrimitive($dependency) : $this->resolveClass($dependency); } return $results; } /** * Determine if the given dependency has a parameter override from makeWith. * 确定给定的依赖项是否具备来自 makeWith 的参数重写。 * * @param \ReflectionParameter $dependency * @return bool */ protected function hasParameterOverride($dependency) { return array_key_exists( $dependency->name, $this->getLastParameterOverride() ); } /** * Get a parameter override for a dependency. * 获取依赖项的参数笼罩。 * * @param \ReflectionParameter $dependency * @return mixed */ protected function getParameterOverride($dependency) { return $this->getLastParameterOverride()[$dependency->name]; } /** * Get the last parameter override. * 获取最初一个参数笼罩。 * * @return array */ protected function getLastParameterOverride() { return count($this->with) ? end($this->with) : []; } /** * Resolve a non-class hinted primitive dependency. * 解析非类提醒的原始依赖项。 * * @param \ReflectionParameter $parameter * @return mixed * * @throws \Guanguans\Di\BindingResolutionException */ protected function resolvePrimitive(ReflectionParameter $parameter) { if (! is_null($concrete = $this->getContextualConcrete('$'.$parameter->name))) { return $concrete instanceof Closure ? $concrete($this) : $concrete; } if ($parameter->isDefaultValueAvailable()) { return $parameter->getDefaultValue(); } $this->unresolvablePrimitive($parameter); } /** * Resolve a class based dependency from the container. * 解析容器中基于类的依赖关系。 * * @param \ReflectionParameter $parameter * @return mixed * * @throws \Guanguans\Di\BindingResolutionException */ protected function resolveClass(ReflectionParameter $parameter) { try { return $this->make($parameter->getClass()->name); } // If we can not resolve the class instance, we will check to see if the value // is optional, and if it is we will return the optional parameter value as // the value of the dependency, similarly to how we do this with scalars. // 如果无奈解析类实例，则将查看该值是否为可选，如果为可选， // 们将返回可选参数 value 作为依赖项的值，相似于执行此操作的形式标量。 catch (BindingResolutionException $e) { if ($parameter->isOptional()) { return $parameter->getDefaultValue(); } throw $e; } } /** * Throw an exception that the concrete is not instantiable. * 抛出一个具体无奈实例化的异样。 * * @param string $concrete * @return void * * @throws \Guanguans\Di\BindingResolutionException */ protected function notInstantiable($concrete) { if (! empty($this->buildStack)) { $previous = implode(', ', $this->buildStack); $message = "Target [$concrete] is not instantiable while building [$previous]."; } else { $message = "Target [$concrete] is not instantiable."; } throw new BindingResolutionException($message); } /** * Throw an exception for an unresolvable primitive. * 为无奈解析的原语抛出异样。 * * @param \ReflectionParameter $parameter * @return void * * @throws \Guanguans\Di\BindingResolutionException */ protected function unresolvablePrimitive(ReflectionParameter $parameter) { $message = "Unresolvable dependency resolving [$parameter] in class {$parameter->getDeclaringClass()->getName()}"; throw new BindingResolutionException($message); } /** * Register a new resolving callback. * 注册一个新的解析回调。 * * @param string $abstract * @param \Closure|null $callback * @return void */ public function resolving($abstract, Closure $callback = null) { if (is_string($abstract)) { $abstract = $this->getAlias($abstract); } if (is_null($callback) && $abstract instanceof Closure) { $this->globalResolvingCallbacks[] = $abstract; } else { $this->resolvingCallbacks[$abstract][] = $callback; } } /** * Register a new after resolving callback for all types. * 在解析所有类型的回调之后注册一个新的。 * * @param string $abstract * @param \Closure|null $callback * @return void */ public function afterResolving($abstract, Closure $callback = null) { if (is_string($abstract)) { $abstract = $this->getAlias($abstract); } if ($abstract instanceof Closure && is_null($callback)) { $this->globalAfterResolvingCallbacks[] = $abstract; } else { $this->afterResolvingCallbacks[$abstract][] = $callback; } } /** * Fire all of the resolving callbacks. * 触发所有解析的回调。 * * @param string $abstract * @param mixed $object * @return void */ protected function fireResolvingCallbacks($abstract, $object) { $this->fireCallbackArray($object, $this->globalResolvingCallbacks); $this->fireCallbackArray( $object, $this->getCallbacksForType($abstract, $object, $this->resolvingCallbacks) ); $this->fireAfterResolvingCallbacks($abstract, $object); } /** * Fire all of the after resolving callbacks. * 解决回调后，请执行所有操作。 * * @param string $abstract * @param mixed $object * @return void */ protected function fireAfterResolvingCallbacks($abstract, $object) { $this->fireCallbackArray($object, $this->globalAfterResolvingCallbacks); $this->fireCallbackArray( $object, $this->getCallbacksForType($abstract, $object, $this->afterResolvingCallbacks) ); } /** * Get all callbacks for a given type. * 获取给定类型的所有回调。 * * @param string $abstract * @param object $object * @param array $callbacksPerType * * @return array */ protected function getCallbacksForType($abstract, $object, array $callbacksPerType) { $results = []; foreach ($callbacksPerType as $type => $callbacks) { if ($type === $abstract || $object instanceof $type) { $results = array_merge($results, $callbacks); } } return $results; } /** * Fire an array of callbacks with an object. * 触发带有对象的回调数组。 * * @param mixed $object * @param array $callbacks * @return void */ protected function fireCallbackArray($object, array $callbacks) { foreach ($callbacks as $callback) { $callback($object, $this); } } /** * Get the container's bindings. * 获取容器的绑定。 * * @return array */ public function getBindings() { return $this->bindings; } /** * Get the alias for an abstract if available. * 获取摘要的别名（如果有）。 * * @param string $abstract * @return string * * @throws \LogicException */ public function getAlias($abstract) { if (! isset($this->aliases[$abstract])) { return $abstract; } if ($this->aliases[$abstract] === $abstract) { throw new LogicException("[{$abstract}] is aliased to itself."); } return $this->getAlias($this->aliases[$abstract]); } /** * Get the extender callbacks for a given type. * 获取给定类型的扩大程序回调。 * * @param string $abstract * @return array */ protected function getExtenders($abstract) { $abstract = $this->getAlias($abstract); if (isset($this->extenders[$abstract])) { return $this->extenders[$abstract]; } return []; } /** * Remove all of the extender callbacks for a given type. * 删除给定类型的所有扩展器回调。 * * @param string $abstract * @return void */ public function forgetExtenders($abstract) { unset($this->extenders[$this->getAlias($abstract)]); } /** * Drop all of the stale instances and aliases. * 删除所有过期的实例和别名。 * * @param string $abstract * @return void */ protected function dropStaleInstances($abstract) { unset($this->instances[$abstract], $this->aliases[$abstract]); } /** * Remove a resolved instance from the instance cache. * 从实例缓存中删除已解析的实例。 * * @param string $abstract * @return void */ public function forgetInstance($abstract) { unset($this->instances[$abstract]); } /** * Clear all of the instances from the container. * 从容器中革除所有实例。 * * @return void */ public function forgetInstances() { $this->instances = []; } /** * Flush the container of all bindings and resolved instances. * 刷新容器中的所有绑定和已解决的实例。 * * @return void */ public function flush() { $this->aliases = []; $this->resolved = []; $this->bindings = []; $this->instances = []; $this->abstractAliases = []; } /** * Set the globally available instance of the container. * 设置容器的全局可用实例。 * * @return static */ public static function getInstance() { if (is_null(static::$instance)) { static::$instance = new static; } return static::$instance; } /** * Set the shared instance of the container. * 设置容器的共享实例。 * * @param \Guanguans\Di\Container|null $container * @return static */ public static function setInstance(Container $container = null) { return static::$instance = $container; } /** * Determine if a given offset exists. * 确定是否存在给定的 key 。 * * @param string $key * @return bool */ public function offsetExists($key) { return $this->bound($key); } /** * Get the value at a given offset. * 获取给定 key 的值。 * * @param string $key * @return mixed */ public function offsetGet($key) { return $this->make($key); } /** * Set the value at a given offset. * 将值设置为给定的 key 。 * * @param string $key * @param mixed $value * @return void */ public function offsetSet($key, $value) { $this->bind($key, $value instanceof Closure ? $value : function () use ($value) { return $value; }); } /** * Unset the value at a given offset. * 以给定 key 勾销设置值。 * * @param string $key * @return void */ public function offsetUnset($key) { unset($this->bindings[$key], $this->instances[$key], $this->resolved[$key]); } /** * Dynamically access container services. * 动静拜访容器服务。 * * @param string $key * @return mixed */ public function __get($key) { return $this[$key]; } /** * Dynamically set container services. * 动静设置容器服务。 * * @param string $key * @param mixed $value * @return void */ public function __set($key, $value) { $this[$key] = $value; } /** * 通过其标识符查找容器的条目并返回它。 * * @inheritDoc */ public function has($id) { return $this->offsetExists($id); } /** * 如果容器能够返回给定标识符的条目，则返回 true 。 否则返回 false 。 * * @inheritDoc */ public function get($id) { return $this[$id]; }}