PHP Container::callInjects方法代碼示例

 /**
  * Creates new presenter instance.
  *
  * @param  string presenter class name
  * @return Application\IPresenter
  */
 public function createPresenter($class)
 {
     $callInjects = $this->alwaysCallInjects;
     $services = array_keys($this->container->findByTag('nette.presenter'), $class);
     if (count($services) > 1) {
         throw new Application\InvalidPresenterException("Multiple services of type {$class} found: " . implode(', ', $services) . '.');
     } elseif (count($services)) {
         $presenter = $this->container->createService($services[0]);
         $callInjects = FALSE;
     } elseif (count($services = $this->container->findByType($class)) === 1) {
         $presenter = $this->container->createService($services[0]);
     } else {
         $presenter = $this->container->createInstance($class);
         $callInjects = TRUE;
     }
     if (!$presenter instanceof Application\IPresenter) {
         throw new UnexpectedValueException("Unable to create create presenter, returned value is not Nette\\Application\\IPresenter type.");
     }
     if ($callInjects) {
         $this->container->callInjects($presenter);
     }
     if ($presenter instanceof Application\UI\Presenter && $presenter->invalidLinkMode === NULL) {
         $presenter->invalidLinkMode = $this->invalidLinkMode;
     }
     return $presenter;
 }

 /**
  * @return VisualPaginator
  */
 public function create()
 {
     $paginator = new VisualPaginator();
     $this->container->callInjects($paginator);
     $this->paginatorStack[] = $paginator;
     return $paginator;
 }

 /**
  * Create new presenter instance.
  * @param  string  presenter name
  * @return IPresenter
  */
 public function createPresenter($name)
 {
     $presenter = $this->container->createInstance($this->getPresenterClass($name));
     $this->container->callInjects($presenter);
     if ($presenter instanceof UI\Presenter && $presenter->invalidLinkMode === NULL) {
         $presenter->invalidLinkMode = $this->container->parameters['debugMode'] ? UI\Presenter::INVALID_LINK_WARNING : UI\Presenter::INVALID_LINK_SILENT;
     }
     return $presenter;
 }

 /**
  * @param IRepository $repository
  * @internal param $IRepository
  * @return IMapper
  */
 public function createMapper(IRepository $repository)
 {
     $class = $this->getMapperClass($repository);
     /** @var Mappers\Mapper $mapper */
     $mapper = new $class($repository);
     $this->container->callInjects($mapper);
     $mapper->registerEvents($repository->getEvents());
     return $mapper;
 }

 public function execute(File $sql)
 {
     $version = (int) basename($sql->name, '.php');
     $class = "App\\Migrations\\Migration{$version}";
     extract($this->getParameters());
     include $sql->getPath();
     /** @var Migration $migration */
     $migration = new $class();
     $this->container->callInjects($migration);
     $migration->run();
 }

 /**
  * Creates new presenter instance.
  * @param  string  presenter name
  * @return IPresenter
  */
 public function createPresenter($name)
 {
     $class = $this->getPresenterClass($name);
     if (count($services = $this->container->findByType($class)) === 1) {
         $presenter = $this->container->createService($services[0]);
     } else {
         $presenter = $this->container->createInstance($class);
     }
     $this->container->callInjects($presenter);
     if ($presenter instanceof UI\Presenter && $presenter->invalidLinkMode === NULL) {
         $presenter->invalidLinkMode = $this->container->parameters['debugMode'] ? UI\Presenter::INVALID_LINK_WARNING : UI\Presenter::INVALID_LINK_SILENT;
     }
     return $presenter;
 }

 protected function doRunCommand(Command $command, InputInterface $input, OutputInterface $output)
 {
     if ($this->serviceLocator) {
         $this->serviceLocator->callInjects($command);
     }
     return parent::doRunCommand($command, $input, $output);
 }

 /**
  * @return Nette\Application\IPresenter
  */
 public function __invoke($class)
 {
     $services = array_keys($this->container->findByTag('nette.presenter'), $class);
     if (count($services) > 1) {
         throw new Nette\Application\InvalidPresenterException("Multiple services of type {$class} found: " . implode(', ', $services) . '.');
     } elseif (!$services) {
         if ($this->touchToRefresh) {
             touch($this->touchToRefresh);
         }
         $presenter = $this->container->createInstance($class);
         $this->container->callInjects($presenter);
         if ($presenter instanceof Nette\Application\UI\Presenter && $presenter->invalidLinkMode === NULL) {
             $presenter->invalidLinkMode = $this->invalidLinkMode;
         }
         return $presenter;
     }
     return $this->container->createService($services[0]);
 }

 public function runTest($name, array $args = [])
 {
     $this->container->callInjects($this);
     $this->setUp();
     try {
         call_user_func_array([$this, $name], $args);
     } catch (\Exception $e) {
         // method does not exist
     }
     try {
         $this->tearDown();
     } catch (\Exception $tearDownEx) {
         throw isset($e) ? $e : $tearDownEx;
     }
     if (isset($e)) {
         throw $e;
     }
 }

 /**
  * Creates new presenter instance.
  * @param  string  presenter name
  * @return IPresenter
  */
 public function createPresenter($name)
 {
     $class = $this->getPresenterClass($name);
     $services = array_keys($this->container->findByTag('nette.presenter'), $class);
     if (count($services) > 1) {
         throw new InvalidPresenterException("Multiple services of type {$class} found: " . implode(', ', $services) . '.');
     } elseif (!$services) {
         if ($this->autoRebuild) {
             $rc = new \ReflectionClass($this->container);
             @unlink($rc->getFileName());
             // @ file may not exists
         }
         $presenter = $this->container->createInstance($class);
         $this->container->callInjects($presenter);
         if ($presenter instanceof UI\Presenter && $presenter->invalidLinkMode === NULL) {
             $presenter->invalidLinkMode = $this->container->parameters['debugMode'] ? UI\Presenter::INVALID_LINK_WARNING : UI\Presenter::INVALID_LINK_SILENT;
         }
         return $presenter;
     }
     return $this->container->createService($services[0]);
 }

 public function injectDependencies(IEntity $entity)
 {
     $this->container->callInjects($entity);
     return $entity;
 }

 public function __construct(Nette\DI\Container $sl)
 {
     parent::__construct();
     $sl->callInjects($this);
     $this->run(new Nette\Application\Request('Front:LinkGenerator', 'GET', array('action' => 'default')));
 }

//.........這裏部分代碼省略.........
             // just in case
             if (!$request->hasFlag(Nette\Application\Request::SECURED) && $this->isInProductionMode()) {
                 $this->tokenManager->invalidateToken($tokenHash);
                 $this->terminateWithError(self::ERROR_INVALID_REQUEST, "Secured connection required", 400);
             }
             if (!$this->attemptLogger->getRemainingAttempts(self::ATTEMPT_IP_TOKEN, $this->httpRequest->getRemoteAddress())) {
                 $this->terminateWithError(OAuth2ResourceProvider::ERROR_MAXIMUM_ATTEMPTS_EXCEEDED, 'Maximum number of authorization attempts exceeded.', 403);
             }
             $token = $this->tokenManager->getToken($tokenHash);
             if (!$token) {
                 $this->attemptLogger->logFail(self::ATTEMPT_IP_TOKEN, $this->httpRequest->getRemoteAddress());
                 $this->httpResponse->addHeader('WWW-Authenticate', 'Bearer realm="' . $this->link() . '"');
                 $this->terminateWithError(OAuth2ResourceProvider::ERROR_INVALID_GRANT, 'Given authorization token is not valid.', 401);
             }
             $this->attemptLogger->logSuccess(self::ATTEMPT_IP_TOKEN, $this->httpRequest->getRemoteAddress());
             if (isset($token->parameters->userIdentity)) {
                 $this->user->login(User::AUTHN_METHOD_INVALID, User::AUTHN_SOURCE_ALL, $token->parameters->userIdentity);
             }
             if (isset($token->parameters->client)) {
                 $this->client = $token->parameters->client;
             }
         }
     }
     // Find request handler ------------------------------------------------
     // Gather resource path
     $parameters = $request->getParameters();
     $resourcePath = isset($parameters[self::PARAM_KEY_PATH]) ? trim($parameters[self::PARAM_KEY_PATH]) : NULL;
     if (!$resourcePath) {
         $this->terminateWithError(self::ERROR_INVALID_REQUEST, "No resource path given.", 400);
     }
     // Request router expects leading slash
     if ($resourcePath[0] != '/') {
         $resourcePath = "/{$resourcePath}";
     }
     // Request router: find resource handler
     try {
         /** @var vBuilder\RestApi\Request */
         $this->resourceRequest = $handlerRequest = $this->requestRouter->createRequest($this->httpRequest->getMethod(), $resourcePath);
     } catch (RequestException $e) {
         $this->terminateWithError(self::ERROR_INVALID_REQUEST, $e->getMessage(), $e->getCode() == RequestException::METHOD_NOT_ALLOWED ? 405 : 404);
     }
     // Request authorization -----------------------------------------------
     $handlerMethodAnnotations = $handlerRequest->getMethodReflection()->getAnnotations();
     if (!isset($handlerMethodAnnotations['NoAuthorization']) || !$handlerMethodAnnotations['NoAuthorization'][0]) {
         if (!$this->client) {
             $this->httpResponse->addHeader('WWW-Authenticate', 'Bearer realm="' . $this->link() . '"');
             $this->terminateWithError(self::ERROR_UNAUTHORIZED, 'Requested resource requires authorization. Please add Authorization header with correct security token.', 401);
         }
     }
     // Decode POST data ----------------------------------------------------
     if ($this->httpRequest->isPost()) {
         $cType = $this->httpRequest->getHeader('Content-Type');
         if (strcasecmp($cType, 'application/json') === 0) {
             try {
                 $this->postData = Nette\Utils\Json::decode(file_get_contents('php://input'), Nette\Utils\Json::FORCE_ARRAY);
             } catch (Nette\Utils\JsonException $e) {
                 $this->terminateWithError(self::ERROR_INVALID_REQUEST, "Malformed POST data (JSON expected).", 400);
             }
         } elseif (strcasecmp($cType, 'application/x-www-form-urlencoded') === 0) {
             $this->postData = $this->httpRequest->getPost();
         } elseif ($cType === NULL) {
             $this->terminateWithError(self::ERROR_INVALID_REQUEST, "Missing Content-Type header, which is mandatory for POST requests.", 400);
         } else {
             $this->terminateWithError(self::ERROR_INVALID_REQUEST, "Request content type of POST data is not supported.", 415);
         }
     }
     // Create resource instance and prepare all dependencies ---------------
     $class = $handlerRequest->getResourceClassName();
     $resource = new $class();
     $resource->presenter = $this;
     $this->systemContainer->callInjects($resource);
     // Prepare and order invoke parameters ---------------------------------
     $mReflection = $handlerRequest->getMethodReflection();
     $invokeParams = array();
     $requestParams = $handlerRequest->getParameters();
     $definedParams = $mReflection->getParameters();
     $index = 0;
     foreach ($definedParams as $pReflection) {
         $index++;
         // Parameter not given in URL?
         if (!isset($requestParams[$pReflection->getName()])) {
             // Default value where available
             if ($pReflection->isDefaultValueAvailable()) {
                 $invokeParams[$pReflection->getName()] = $pReflection->getDefaultValue();
                 continue;
             }
             $this->terminateWithError(self::ERROR_INVALID_REQUEST, "Missing #{$index} parameter for resource handler {$class}::" . $mReflection->getName() . '().', 400);
         }
         $invokeParams[$pReflection->getName()] = $requestParams[$pReflection->getName()];
     }
     // Perform startup
     $resource->startup();
     // Invoke handler method on resource instance
     $responsePayload = $mReflection->invokeArgs($resource, $invokeParams);
     // Automatically set HTTP 204 No Content if necessary
     if ($responsePayload === NULL && $this->httpResponse->getCode() == 200) {
         $this->httpResponse->setCode(204);
     }
     return $responsePayload === NULL ? $this->createResponse() : $this->createResponse($responsePayload);
 }