PHP Container::make方法代码示例

 public function make(RequestContainer $requestContainer, Container $app)
 {
     if ($requestContainer->getId()) {
         return new InstanceQuery($app->make('query_builders'), $requestContainer);
     }
     return new CollectionQuery($app->make('query_builders'), $requestContainer);
 }

 /**
  * Get the IoC Container
  *
  * @param string $make A dependency to fetch
  *
  * @return Container
  */
 public static function getContainer($make = null)
 {
     if ($make) {
         return static::$container->make($make);
     }
     return static::$container;
 }

 /**
  * Get the validator instance for the request.
  *
  * @param array $rules
  * @param array $messages
  * @param array $customAttributes
  * @return Validator
  */
 protected function getValidatorInstance(array $rules, array $messages = array(), array $customAttributes = array())
 {
     $factory = $this->app->make('Illuminate\\Contracts\\Validation\\Factory');
     $validator = $factory->make([], $rules, $messages, $customAttributes);
     $validator->addCustomAttributes($customAttributes);
     return $validator;
 }

 /**
  * ExtensionRegistrar constructor.
  */
 public function __construct()
 {
     $this->container = $this->getContainer();
     $this->events = $this->container->make('events');
     $this->router = $this->container->make('router');
     $this->setting = $this->container->make('setting');
 }

 /**
  * Execute the required command against the command handler.
  *
  * @param Command $command
  * @return mixed
  */
 public function execute(Command $command)
 {
     $handler = $this->commandTranslator->getCommandHandler($command);
     $commandName = $this->getCommandName($command);
     $this->log->info("New command [{$commandName}]", get_object_vars($command));
     return $this->app->make($handler)->handle($command);
 }

 /**
  * @param array $keys
  * @return \LW\Statistics\StatisticsProviderCollection
  */
 protected function makeProvidersCollection($keys)
 {
     $collection = new StatisticsProviderCollection();
     foreach ($keys as $name) {
         $collection->add($name, $this->container->make($this->providerMap[$name]));
     }
     return $collection;
 }

 /**
  * Refresh modal object.
  *
  * @throws RepositoryException
  *
  * @return Model
  */
 public function makeModel()
 {
     $model = $this->app->make($this->model());
     if (!$model instanceof Model) {
         throw new RepositoryException("Class {$this->model()} must be an instance of Illuminate\\Database\\Eloquent\\Model");
     }
     return $this->model = $model;
 }

 /**
  * Call the given controller instance method.
  *
  * @param  \Illuminate\Routing\Controller  $instance
  * @param  \Illuminate\Routing\Route  $route
  * @param  \Illuminate\Http\Request  $request
  * @param  string  $method
  * @return mixed
  */
 protected function callWithinStack($instance, $route, $request, $method)
 {
     $middleware = $this->getMiddleware($instance, $method);
     $shouldSkipMiddleware = $this->container->bound('middleware.disable') && $this->container->make('middleware.disable') === true;
     return (new Pipeline($this->container))->send($request)->through($shouldSkipMiddleware ? [] : $middleware)->then(function ($request) use($instance, $route, $method) {
         return $this->router->prepareResponse($request, $this->call($instance, $route, $method));
     });
 }

 /**
  * Get the validator instance for the request.
  *
  * @return \Illuminate\Contracts\Validation\Validator
  */
 protected function getValidatorInstance()
 {
     $factory = $this->container->make(ValidationFactory::class);
     if (method_exists($this, 'validator')) {
         return $this->container->call([$this, 'validator'], compact('factory'));
     }
     return $factory->make($this->all(), $this->container->call([$this, 'rules']), $this->messages(), $this->attributes());
 }

 /**
  * Get the validator instance for the request.
  *
  * @return \Illuminate\Validation\Validator
  */
 protected function getValidatorInstance()
 {
     $factory = $this->container->make('Illuminate\\Validation\\Factory');
     if (method_exists($this, 'validator')) {
         return $this->container->call([$this, 'validator'], compact('factory'));
     }
     return $factory->make($this->all(), $this->container->call([$this, 'rules']), $this->messages());
 }

 /**
  * @param       $class
  * @param array $args
  * @return mixed
  * @throws RepositoryException
  */
 protected function makeCriteria($class, array $args)
 {
     $criteria = $this->app->make($class, $args);
     if (!$criteria instanceof CriteriaContract) {
         throw new RepositoryException("Class {$class} must be an instance of GuilhermeGonzaga\\Repository\\Criteria\\Criteria");
     }
     return $criteria;
 }

 /**
  * @return $this
  */
 protected function parseIncludes()
 {
     $request = $this->application->make('Illuminate\\Http\\Request');
     $paramIncludes = Config::get('reloquent.fractal.params.include', 'include');
     if ($request->has($paramIncludes)) {
         $this->fractal->parseIncludes($request->get($paramIncludes));
     }
     return $this;
 }

 /**
  * Constructor.
  *
  * @param array     $viewPaths
  * @param string    $cachePath
  * @param Container $container
  */
 public function __construct($viewPaths, $cachePath, ContainerInterface $container = null)
 {
     $this->viewPaths = $viewPaths;
     $this->cachePath = $cachePath;
     $this->container = $container ?: new Container();
     $this->setupContainer();
     (new ViewServiceProvider($this->container))->register();
     $this->engineResolver = $this->container->make('view.engine.resolver');
 }

 /**
  * Resolve an instance of the given seeder class.
  *
  * @param  string  $class
  * @return \Illuminate\Database\Seeder
  */
 protected function resolve($class)
 {
     if (isset($this->container)) {
         $instance = $this->container->make($class);
         return $instance->setContainer($this->container)->setCommand($this->command);
     } else {
         return new $class();
     }
 }

 /**
  * @test
  */
 public function it_should_auto_inject_dependencies_from_parent_container()
 {
     $this->parent->singleton(Helper::class, function () {
         return new Helper(uniqid());
     });
     /** @var Service $service */
     $service = $this->local->make(Service::class);
     $this->assertInstanceOf(Service::class, $service);
     $this->assertEquals($this->parent->make(Helper::class)->key, $service->helper->key);
 }