PHP Container::singleton方法代码示例

 public function register(Container $container)
 {
     $container->singleton(Container::class, function () use($container) {
         return $container;
     });
     $container->singleton(ContainerInterface::class, LaravelContainer::class);
 }

 /**
  * @param Container $container
  */
 protected function registerContainerBindings(Container $container)
 {
     $container->singleton(FileFactoryContract::class, function () {
         return new FileFactory(File::class);
     });
     $container->singleton(FileStorageContract::class, function () {
         return new FileStorage();
     });
 }

 /**
  * @param $connection
  */
 public function addConnection($connection)
 {
     if (!$this->container->bound($this->getConnectionBindingName($connection))) {
         $this->container->singleton($this->getConnectionBindingName($connection), function () use($connection) {
             return $this->getManager($connection)->getConnection();
         });
         $this->connections[$connection] = $connection;
     }
 }

 /**
  * @param Container $container
  */
 protected function registerContainerBindings(Container $container)
 {
     $container->singleton(FileFactoryContract::class, function () {
         return new FileFactory(File::class);
     });
     $documentManager = $container->make(DocumentManager::class);
     $container->singleton(FileStorageContract::class, function () use($documentManager) {
         return new FileStorage($documentManager);
     });
 }

 /**
  * Handle an incoming request.
  *
  * @param \Illuminate\Http\Request $request
  * @param \Closure                 $next
  *
  * @return mixed
  */
 public function handle($request, Closure $next)
 {
     try {
         if ($this->validator->validateRequest($request)) {
             $this->app->singleton('Illuminate\\Contracts\\Debug\\ExceptionHandler', function ($app) {
                 return $app['Dingo\\Api\\Contract\\Debug\\ExceptionHandler'];
             });
             $request = $this->app->make('Dingo\\Api\\Contract\\Http\\Request')->createFromIlluminate($request);
             return $this->sendRequestThroughRouter($request);
         }
     } catch (Exception $exception) {
         return $this->exception->handle($exception);
     }
     return $next($request);
 }

 /**
  * Registers container bindings.
  *
  * @param Container        $container
  * @param ConfigRepository $config
  *
  * @return DocumentManager
  */
 protected function registerContainerBindings(Container $container, ConfigRepository $config)
 {
     $container->singleton('Doctrine\\ODM\\MongoDB\\DocumentManager', function () use($config) {
         Config::mergeWith($config);
         return $this->createDocumentManager($config);
     });
 }

 /**
  * Registers container bindings.
  *
  * @param Container        $container
  * @param ConfigRepository $config
  */
 protected function registerContainerBindings(Container $container, ConfigRepository $config)
 {
     $container->singleton('Doctrine\\ORM\\EntityManager', function () use($config) {
         return $this->createEntityManager($config);
     });
     $container->alias('Doctrine\\ORM\\EntityManager', 'Doctrine\\ORM\\EntityManagerInterface');
 }

 /**
  * Registers the container bindings.
  *
  * @param Container $container
  */
 protected function registerContainerBindings(Container $container)
 {
     $container->singleton('Nord\\Lumen\\Mandrill\\Mailer\\Contracts\\MandrillMailer', function () {
         $config = config('mandrillmailer', []);
         return new MandrillMailer($config);
     });
 }

 /**
  * @param Container        $container
  * @param ConfigRepository $config
  */
 protected function registerContainerBindings(Container $container, ConfigRepository $config)
 {
     $container->alias(ImageManager::class, ImageManagerContract::class);
     $container->singleton(ImageManagerContract::class, function () use($container, $config) {
         return $this->createManager($container, $config);
     });
 }

 /**
  * @param Container        $container
  * @param ConfigRepository $config
  */
 protected function registerBindings(Container $container, ConfigRepository $config)
 {
     $container->singleton(SparkPostService::class, function () use($config) {
         return new SparkPostService($config[self::CONFIG_KEY]);
     });
     $container->alias(SparkPostService::class, SparkPostServiceContract::class);
 }

 /**
  * Register the Authorization server with the IoC container.
  *
  * @param \Illuminate\Contracts\Container\Container $app
  *
  * @return void
  */
 public function registerAuthorizer(Application $app)
 {
     $app->singleton('oauth2-server.authorizer', function ($app) {
         $config = $app['config']->get('oauth2');
         $issuer = $app->make(AuthorizationServer::class)->setClientStorage($app->make(ClientInterface::class))->setSessionStorage($app->make(SessionInterface::class))->setAuthCodeStorage($app->make(AuthCodeInterface::class))->setAccessTokenStorage($app->make(AccessTokenInterface::class))->setRefreshTokenStorage($app->make(RefreshTokenInterface::class))->setScopeStorage($app->make(ScopeInterface::class))->requireScopeParam($config['scope_param'])->setDefaultScope($config['default_scope'])->requireStateParam($config['state_param'])->setScopeDelimiter($config['scope_delimiter'])->setAccessTokenTTL($config['access_token_ttl']);
         // add the supported grant types to the authorization server
         foreach ($config['grant_types'] as $grantIdentifier => $grantParams) {
             $grant = $app->make($grantParams['class']);
             $grant->setAccessTokenTTL($grantParams['access_token_ttl']);
             if (array_key_exists('callback', $grantParams)) {
                 list($className, $method) = array_pad(explode('@', $grantParams['callback']), 2, 'verify');
                 $verifier = $app->make($className);
                 $grant->setVerifyCredentialsCallback([$verifier, $method]);
             }
             if (array_key_exists('auth_token_ttl', $grantParams)) {
                 $grant->setAuthTokenTTL($grantParams['auth_token_ttl']);
             }
             if (array_key_exists('refresh_token_ttl', $grantParams)) {
                 $grant->setRefreshTokenTTL($grantParams['refresh_token_ttl']);
             }
             if (array_key_exists('rotate_refresh_tokens', $grantParams)) {
                 $grant->setRefreshTokenRotation($grantParams['rotate_refresh_tokens']);
             }
             $issuer->addGrantType($grant, $grantIdentifier);
         }
         $checker = $app->make(ResourceServer::class);
         $authorizer = new Authorizer($issuer, $checker);
         $authorizer->setRequest($app['request']);
         $authorizer->setTokenType($app->make($config['token_type']));
         $app->refresh('request', $authorizer, 'setRequest');
         return $authorizer;
     });
     $app->alias('oauth2-server.authorizer', Authorizer::class);
 }

 /**
  * Register the manager class.
  *
  * @param \Illuminate\Contracts\Container\Container $app
  *
  * @return void
  */
 protected function registerManager(Application $app)
 {
     $app->singleton('telegram', function ($app) {
         $config = $app['config'];
         return new BotsManager($config, $app);
     });
     $app->alias('telegram', BotsManager::class);
 }

 /**
  * Register the manager class.
  *
  * @param \Illuminate\Contracts\Container\Container $app
  *
  * @return void
  */
 protected function registerManager(Application $app)
 {
     $app->singleton('telegram', function ($app) {
         $config = (array) $app['config']['telegram'];
         return (new BotsManager($config))->setContainer($app);
     });
     $app->alias('telegram', BotsManager::class);
 }

 /**
  * @param Container        $container
  * @param ConfigRepository $config
  */
 protected function registerBindings(Container $container, ConfigRepository $config)
 {
     $container->singleton(FractalService::class, function () use($config) {
         $fractal = new FractalService();
         $this->configureService($fractal, $config[self::CONFIG_KEY]);
         return $fractal;
     });
     $container->alias(FractalService::class, FractalServiceContract::class);
 }

 /**
  * Initialise the IoC Service Container
  */
 protected function setupContainer()
 {
     // Only set the application on the Facade
     // if there is none yet set
     if (is_null(App::getFacadeApplication())) {
         App::setFacadeApplication(new Container());
     }
     $this->container = App::getFacadeApplication();
     $this->container->singleton('app', $this->container);
 }