每天laravel-20160813| Container -16

   /**    * Get the contextual concrete binding for the given abstract.    *    * @param  string  $abstract    * @return string|null    */   protected function getContextualConcrete($abstract)   {       if (isset($this->contextual[end($this->buildStack)][$abstract])) {           return $this->contextual[end($this->buildStack)][$abstract];       }   }//has it then return it,// this array is too complex   /**    * Normalize the given class name by removing leading slashes.    *    * @param  mixed  $service    * @return mixed    */   protected function normalize($service)   {       return is_string($service) ? ltrim($service, '\\') : $service;// back the normal string like namespace   }// Normalize the given class name by removing leading slashes   /**    * Get the extender callbacks for a given type.    *    * @param  string  $abstract    * @return array    */   protected function getExtenders($abstract)   {       if (isset($this->extenders[$abstract])) {// has then return           return $this->extenders[$abstract];       }       return [];   }// Get the extender callbacks for a given type.   /**    * Instantiate a concrete instance of the given type.    *    * @param  string  $concrete    * @param  array   $parameters    * @return mixed    *    * @throws \Illuminate\Contracts\Container\BindingResolutionException    */// make a concrete instance of the given type live.   public function build($concrete, array $parameters = [])// like to make a floor   {       // 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, $parameters);       }// if it a concrete as Closure.       $reflector = new ReflectionClass($concrete);// else throw the concrete function to get the class name       // 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()) {// if it a abstract class so can not be instance           if (! empty($this->buildStack)) {// if has the buildStack               $previous = implode(', ', $this->buildStack);//implode the buildStack               $message = "Target [$concrete] is not instantiable while building [$previous].";// it is a trace           } else {               $message = "Target [$concrete] is not instantiable.";           }           throw new BindingResolutionException($message);// throw a Exception       }       $this->buildStack[] = $concrete;// add the concrete to the concrete       $constructor = $reflector->getConstructor();// get the Constructor       // 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);// if no has the array_pop  delete the concrete           return new $concrete;// return new concrete       }       $dependencies = $constructor->getParameters();//get parameters       // 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.       $parameters = $this->keyParametersByArgument(           $dependencies, $parameters       );// get       $instances = $this->getDependencies(           $dependencies, $parameters       );       array_pop($this->buildStack);       return $reflector->newInstanceArgs($instances);   }// build function is so powerful, can use a instance and a parameters to new a new instance.