每天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.