PHP ServiceManager::__construct方法代码示例

 /**
  * Constructor
  *
  * Add a default initializer to ensure the plugin is valid after instance
  * creation.
  *
  * @param null|ConfigInterface $configuration
  */
 public function __construct(ConfigInterface $configuration = null)
 {
     parent::__construct($configuration);
     $this->addInitializer(function ($instance) {
         if ($instance instanceof ServiceLocatorAwareInterface) {
             $instance->setServiceLocator($this);
         }
     });
 }

 /**
  * Constructor
  *
  * Add a default initializer to ensure the plugin is valid after instance
  * creation.
  *
  * @param  null|ConfigurationInterface $configuration
  * @return void
  */
 public function __construct(ConfigurationInterface $configuration = null)
 {
     parent::__construct($configuration);
     $self = $this;
     $this->addInitializer(function ($instance) use($self) {
         if ($instance instanceof ServiceManagerAwareInterface) {
             $instance->setServiceManager($self);
         }
     });
 }

 public function __construct(ConfigInterface $config = null)
 {
     parent::__construct($config);
     /*
      * @note Unfortunately we need this to allow 'response' key to be overridden.
      * Hopefully in a later version we can refactor and break Backwards
      * Compatibility and thus disable this feature.
      */
     $this->setAllowOverride(true);
 }

 /**
  * Constructor.
  *
  * Sets the provided $parentLocator as the creation context for all
  * factories; for $config, {@see \Zend\ServiceManager\ServiceManager::configure()}
  * for details on its accepted structure.
  *
  * @param null|ConfigInterface|ContainerInterface $configInstanceOrParentLocator
  * @param array $config
  */
 public function __construct($configInstanceOrParentLocator = null, array $config = [])
 {
     if (null !== $configInstanceOrParentLocator && !$configInstanceOrParentLocator instanceof ConfigInterface && !$configInstanceOrParentLocator instanceof ContainerInterface) {
         throw new Exception\InvalidArgumentException(sprintf('%s expects a ConfigInterface or ContainerInterface instance as the first argument; received %s', __CLASS__, is_object($configInstanceOrParentLocator) ? get_class($configInstanceOrParentLocator) : gettype($configInstanceOrParentLocator)));
     }
     if ($configInstanceOrParentLocator instanceof ConfigInterface) {
         trigger_error(sprintf('Usage of %s as a constructor argument for %s is now deprecated', ConfigInterface::class, get_class($this)), E_USER_DEPRECATED);
         $config = $configInstanceOrParentLocator->toArray();
     }
     parent::__construct($config);
     if (!$configInstanceOrParentLocator instanceof ContainerInterface) {
         trigger_error(sprintf('%s now expects a %s instance representing the parent container; please update your code', __METHOD__, ContainerInterface::class), E_USER_DEPRECATED);
     }
     $this->creationContext = $configInstanceOrParentLocator instanceof ContainerInterface ? $configInstanceOrParentLocator : $this;
 }

 /**
  * Constructor
  *
  * Add a default initializer to ensure the plugin is valid after instance
  * creation.
  *
  * Additionally, the constructor provides forwards compatibility with v3 by
  * overloading the initial argument. v2 usage expects either null or a
  * ConfigInterface instance, and will ignore any other arguments. v3 expects
  * a ContainerInterface instance, and will use an array of configuration to
  * seed the current instance with services. In most cases, you can ignore the
  * constructor unless you are writing a specialized factory for your plugin
  * manager or overriding it.
  *
  * @param null|ConfigInterface|ContainerInterface $configOrContainerInstance
  * @param array $v3config If $configOrContainerInstance is a container, this
  *     value will be passed to the parent constructor.
  * @throws Exception\InvalidArgumentException if $configOrContainerInstance
  *     is neither null, nor a ConfigInterface, nor a ContainerInterface.
  */
 public function __construct($configOrContainerInstance = null, array $v3config = [])
 {
     if (null !== $configOrContainerInstance && !$configOrContainerInstance instanceof ConfigInterface && !$configOrContainerInstance instanceof ContainerInterface) {
         throw new Exception\InvalidArgumentException(sprintf('%s expects a ConfigInterface instance or ContainerInterface instance; received %s', get_class($this), is_object($configOrContainerInstance) ? get_class($configOrContainerInstance) : gettype($configOrContainerInstance)));
     }
     if ($configOrContainerInstance instanceof ContainerInterface) {
         if (property_exists($this, 'serviceLocator')) {
             if (!empty($v3config)) {
                 parent::__construct(new Config($v3config));
             }
             $this->serviceLocator = $configOrContainerInstance;
         }
         if (property_exists($this, 'creationContext')) {
             if (!empty($v3config)) {
                 parent::__construct($v3config);
             }
             $this->creationContext = $configOrContainerInstance;
         }
     }
     if ($configOrContainerInstance instanceof ConfigInterface) {
         parent::__construct($configOrContainerInstance);
     }
     $this->addInitializer(function ($instance) {
         if ($instance instanceof ServiceLocatorAwareInterface) {
             $instance->setServiceLocator($this);
         }
     });
 }

 /**
  * Constructor
  *
  * Add a default initializer to ensure the plugin is valid after instance
  * creation.
  * 
  * @param  null|ConfigurationInterface $configuration 
  * @return void
  */
 public function __construct(ConfigurationInterface $configuration = null)
 {
     parent::__construct($configuration);
     $this->addInitializer(array($this, 'validatePlugin'), true);
 }

 /**
  * Create new container
  *
  * @param array $settings Associative array of settings. User settings are in a 'settings' sub-array
  */
 public function __construct($settings = [])
 {
     $userSettings = [];
     if (isset($settings['settings'])) {
         $userSettings = $settings['settings'];
         unset($settings['settings']);
     }
     // Add settings factory that also collects the default settings
     $defaultSettings = $this->defaultSettings;
     $settings['factories']['settings'] = function ($c) use($userSettings, $defaultSettings) {
         return array_merge($defaultSettings, $userSettings);
     };
     // Add default services if they aren't added already
     if (!isset($settings['environment'])) {
         $settings['factories']['environment'] = function ($c) {
             return new Environment($_SERVER);
         };
     }
     if (!isset($settings['request'])) {
         $settings['factories']['request'] = function ($c) {
             return Request::createFromEnvironment($c['environment']);
         };
     }
     if (!isset($settings['response'])) {
         $settings['factories']['response'] = function ($c) {
             $headers = new Headers(['Content-Type' => 'text/html']);
             $response = new Response(200, $headers);
             return $response->withProtocolVersion($c['settings']['httpVersion']);
         };
     }
     if (!isset($settings['router'])) {
         $settings['factories']['router'] = function ($c) {
             return new Router();
         };
     }
     if (!isset($settings['callableResolver'])) {
         $settings['factories']['callableResolver'] = function ($c) {
             return new CallableResolver($c);
         };
     }
     if (!isset($settings['foundHandler'])) {
         $settings['invokables']['foundHandler'] = RequestResponse::class;
     }
     if (!isset($settings['errorHandler'])) {
         $settings['factories']['errorHandler'] = function ($c) {
             return new Error($c->get('settings')['displayErrorDetails']);
         };
     }
     if (!isset($settings['notFoundHandler'])) {
         $settings['invokables']['notFoundHandler'] = NotFound::class;
     }
     if (!isset($settings['notAllowedHandler'])) {
         $settings['invokables']['notAllowedHandler'] = NotAllowed::class;
     }
     parent::__construct($settings);
 }

 /**
  * constructor
  * @param \Zend\ServiceManager\ConfigInterface $config
  */
 public function __construct(\Zend\ServiceManager\ConfigInterface $config = null)
 {
     parent::__construct($config);
 }

 /**
  * Constructor
  *
  * @param  null|ConfigInterface $configuration
  */
 public function __construct(ConfigInterface $configuration = null)
 {
     parent::__construct($configuration);
     $this->addInitializer('BlockManager\\BlockInitializer');
 }

 /**
  * Create new container
  *
  * @param array $userSettings Associative array of application settings
  */
 public function __construct(array $userSettings = [])
 {
     parent::__construct();
     $defaultSettings = $this->defaultSettings;
     /**
      * This service MUST return an array or an
      * instance of \ArrayAccess.
      *
      * @param Container $c
      *
      * @return array|\ArrayAccess
      */
     $this->setFactory('settings', function ($c) use($userSettings, $defaultSettings) {
         return array_merge($defaultSettings, $userSettings);
     });
     /**
      * This service MUST return a shared instance
      * of \Slim\Interfaces\Http\EnvironmentInterface.
      *
      * @param Container $c
      *
      * @return EnvironmentInterface
      */
     $this->setFactory('environment', function ($c) {
         return new Environment($_SERVER);
     });
     /**
      * \Psr\Http\Message\ServerRequestInterface.
      */
     $this->setFactory('request', function ($c) {
         return Request::createFromEnvironment($c['environment']);
     });
     /**
      * \Psr\Http\Message\ResponseInterface.
      */
     $this->setFactory('response', function ($c) {
         $headers = new Headers(['Content-Type' => 'text/html']);
         $response = new Response(200, $headers);
         return $response->withProtocolVersion($c['settings']['httpVersion']);
     });
     /**
      * This service MUST return a SHARED instance
      * of \Slim\Interfaces\RouterInterface.
      *
      * @param Container $c
      *
      * @return RouterInterface
      */
     $this->setFactory('router', function ($c) {
         return new Router();
     });
     /**
      * This service MUST return a SHARED instance
      * of \Slim\Interfaces\InvocationStrategyInterface.
      *
      * @param Container $c
      *
      * @return InvocationStrategyInterface
      */
     $this->setFactory('foundHandler', function ($c) {
         return new RequestResponse();
     });
     /**
      * This service MUST return a callable
      * that accepts three arguments:
      *
      * 1. Instance of \Psr\Http\Message\ServerRequestInterface
      * 2. Instance of \Psr\Http\Message\ResponseInterface
      * 3. Instance of \Exception
      *
      * The callable MUST return an instance of
      * \Psr\Http\Message\ResponseInterface.
      *
      * @param Container $c
      *
      * @return callable
      */
     $this->setFactory('errorHandler', function ($c) {
         return new Error();
     });
     /**
      * This service MUST return a callable
      * that accepts two arguments:
      *
      * 1. Instance of \Psr\Http\Message\ServerRequestInterface
      * 2. Instance of \Psr\Http\Message\ResponseInterface
      *
      * The callable MUST return an instance of
      * \Psr\Http\Message\ResponseInterface.
      *
      * @param Container $c
      *
      * @return callable
      */
     $this->setFactory('notFoundHandler', function ($c) {
//.........这里部分代码省略.........

 public function __construct(ConfigInterface $config = null)
 {
     parent::__construct($config);
 }

 public function __construct(ConfigInterface $config, MonologLoggerFactory $loggerFactory, MonologHandlerFactory $handlerFactory)
 {
     parent::__construct($config);
     $this->loggerFactory = $loggerFactory;
     $this->handlerFactory = $handlerFactory;
 }