매일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.