Enables the use of a cache for the definitions.
public setDefinitionCache ( Doctrine\Common\Cache\Cache $cache ) : |
||
$cache | Doctrine\Common\Cache\Cache | Cache backend to use |
return |
/** * @param $env * @return Container */ public function getContainer($env) { $container = null; $builder = new ContainerBuilder(Container::class); // $builder = new ContainerBuilder(); foreach (glob(APP_HOME . '/conf/conf.d/*.conf.php') as $filename) { $builder->addDefinitions($filename); } $definitionsEnumFile = APP_HOME . '/conf/config.' . $env . '.php'; if (file_exists($definitionsEnumFile)) { $builder->addDefinitions($definitionsEnumFile); } $builder->useAnnotations(false); $builder->useAutowiring(true); switch ($env) { case EnvironmentEnum::DEV: $builder->setDefinitionCache(new ArrayCache()); break; case EnvironmentEnum::PROD: default: $cache = $this->getCache(); $builder->setDefinitionCache($cache); $builder->writeProxiesToFile(true, APP_HOME . '/var/cache/proxies'); break; } $container = $builder->build(); return $container; }
public function withCache(CacheProvider $cacheProvider = null) { if ($cacheProvider != null) { $this->builder->setDefinitionCache($cacheProvider); } return $this; }
/** * @param $env * @return \DI\Container */ public function getContainer($env) { $builder = new ContainerBuilder(); foreach (glob(APP_HOME . '/conf/conf.d/*.conf.php') as $filename) { $builder->addDefinitions($filename); } $builder->addDefinitions(APP_HOME . '/conf/config.' . $env . '.php'); switch ($env) { case EnvironmentEnum::DEV: $builder->setDefinitionCache(new ArrayCache()); break; case EnvironmentEnum::PROD: $redis = new Redis(); $redis->pconnect('localhost'); $redis->setOption(Redis::OPT_PREFIX, 'homeservice:cache:di:'); $cache = new RedisCache(); $cache->setRedis($redis); $builder->setDefinitionCache($cache); $builder->writeProxiesToFile(true, APP_HOME . '/var/cache/proxies'); break; } $builder->useAnnotations(true); $container = $builder->build(); return $container; }
/** * @link http://php-di.org/doc/container-configuration.html * @throws \Exception * @return Container */ public function create() { $builder = new ContainerBuilder(); $builder->useAnnotations(false); $builder->setDefinitionCache(new ArrayCache()); // INI config $builder->addDefinitions(new IniConfigDefinitionSource(Config::getInstance())); // Global config $builder->addDefinitions(PIWIK_USER_PATH . '/config/global.php'); // Plugin configs $this->addPluginConfigs($builder); // Development config if (Development::isEnabled()) { $builder->addDefinitions(PIWIK_USER_PATH . '/config/environment/dev.php'); } // User config if (file_exists(PIWIK_USER_PATH . '/config/config.php')) { $builder->addDefinitions(PIWIK_USER_PATH . '/config/config.php'); } // Environment config $this->addEnvironmentConfig($builder); if (!empty($this->definitions)) { $builder->addDefinitions($this->definitions); } return $builder->build(); }
protected function createContainer() { $builder = new ContainerBuilder(); $builder->setDefinitionCache(new \Doctrine\Common\Cache\ArrayCache()); $builder->addDefinitions(dirname(__DIR__) . '/DI/config.php'); $this->container = $builder->build(); }
/** * @link http://php-di.org/doc/container-configuration.html * @throws \Exception * @return Container */ public function create() { $builder = new ContainerBuilder(); $builder->useAnnotations(false); $builder->setDefinitionCache(new ArrayCache()); // INI config $builder->addDefinitions(new IniConfigDefinitionSource($this->settings)); // Global config $builder->addDefinitions(PIWIK_USER_PATH . '/config/global.php'); // Plugin configs $this->addPluginConfigs($builder); // Development config if ($this->isDevelopmentModeEnabled()) { $builder->addDefinitions(PIWIK_USER_PATH . '/config/environment/dev.php'); } // User config if (file_exists(PIWIK_USER_PATH . '/config/config.php')) { $builder->addDefinitions(PIWIK_USER_PATH . '/config/config.php'); } // Environment config foreach ($this->environments as $environment) { $this->addEnvironmentConfig($builder, $environment); } if (!empty($this->definitions)) { foreach ($this->definitions as $definitionArray) { $builder->addDefinitions($definitionArray); } } $container = $builder->build(); $container->set('Piwik\\Application\\Kernel\\PluginList', $this->pluginList); $container->set('Piwik\\Application\\Kernel\\GlobalSettingsProvider', $this->settings); return $container; }
/** * Configure and create a container using all configuration files registered under * the `php-di/configuration` binding type in Puli. * * @return Container */ public function createContainer() { if (!self::$puliFactoryClass && !defined('PULI_FACTORY_CLASS')) { throw new \RuntimeException('Puli is not installed'); } // Create Puli objects $factoryClass = self::$puliFactoryClass ?: PULI_FACTORY_CLASS; $puli = new $factoryClass(); /** @var ResourceRepository $repository */ $repository = $puli->createRepository(); $containerBuilder = new ContainerBuilder(); $cache = $this->getContainerCache(); if ($cache) { $containerBuilder->setDefinitionCache($cache); } // Puli objects $containerBuilder->addDefinitions(['puli.factory' => $puli, ResourceRepository::class => $repository, Discovery::class => function (ContainerInterface $c) { $puli = $c->get('puli.factory'); return $puli->createDiscovery($c->get(ResourceRepository::class)); }]); foreach ($this->modules as $module) { $this->loadModule($containerBuilder, $repository, $module); } if (!empty($this->config)) { $containerBuilder->addDefinitions($this->config); } $this->configureContainerBuilder($containerBuilder); return $containerBuilder->build(); }
private function createOptimizedBuilder() { $cache = new ArrayCache($this->cacheDir); $builder = new ContainerBuilder(); $builder->setDefinitionCache($cache); $builder->addDefinitions(array('bicycle_factory' => \DI\object('PhpBench\\Benchmarks\\Container\\Acme\\BicycleFactory'))); return $builder; }
public function setUp($useReflection = true, $useAnnotations = true, Cache $cache = null) { parent::setUp(); $builder = new ContainerBuilder(); $builder->useReflection($useReflection)->useAnnotations($useAnnotations); if (!is_null($cache)) { $builder->setDefinitionCache($cache); } $this->DIContainer = $builder->build(); $this->registerMocks(); }
/** * Returns the dependency injection container * * @return \DI\Container */ public function getDiContainer() { if (!$this->diContainer) { $builder = new ContainerBuilder(); // $builder->setDefinitionCache(new ArrayCache()); $builder->setDefinitionCache(new FilesystemCache(ConfigurationManager::getSharedInstance()->getConfigurationForKeyPath('cachePath'))); $this->diContainer = $builder->build(); $builder->addDefinitions(__DIR__ . '/Configuration/dependencyInjectionConfiguration.php'); $this->diContainer = $builder->build(); // $this->diContainer = ContainerBuilder::buildDevContainer(); } return $this->diContainer; }
/** * Returns the dependency injection container * * @return \DI\Container */ public function getDiContainer() { if (!$this->diContainer) { $builder = new ContainerBuilder(); // $builder->setDefinitionCache(new \Doctrine\Common\Cache\ArrayCache()); $builder->setDefinitionCache(new FilesystemCache(__DIR__ . '/../../var/Cache/')); $builder->addDefinitions(__DIR__ . '/../../Classes/Configuration/dependencyInjectionConfiguration.php'); $this->diContainer = $builder->build(); // $this->diContainer = ContainerBuilder::buildDevContainer(); $this->diContainer->get('Cundd\\PersistentObjectStore\\Event\\SharedEventEmitter'); } return $this->diContainer; }
/** * {@inheritdoc} */ public function init() { parent::init(); $environment = Config::getSystemConfig()->get("general")->get("environment"); // Set up dependency injection container $builder = new ContainerBuilder(); $builder->useAnnotations(true); // Configure the container $builder->addDefinitions(PIMCORE_WEBSITE_PATH . "/config/container.php"); if ($environment !== "local") { // Use whatever cache Pimcore has configured (if it has one configured) to cache object // definitions in the container $builder->setDefinitionCache(new PimcoreCache()); } else { // For development, or debugging we don't want to cache the container $builder->setDefinitionCache(new ArrayCache()); } $environmentConfigFile = DefinitionFileLocator::getPath($environment); $parametersFile = ParametersFileLocator::getPath(); if (file_exists($environmentConfigFile)) { $builder->addDefinitions($environmentConfigFile); } if (file_exists($parametersFile)) { $builder->addDefinitions($parametersFile); } $container = $builder->build(); /** @var \Zend_Controller_Dispatcher_Interface $currentDispatcher */ $currentDispatcher = \Zend_Controller_Front::getInstance()->getDispatcher(); $dispatcher = new Dispatcher(); $dispatcher->setContainer($container); $dispatcher->setControllerDirectory($currentDispatcher->getControllerDirectory()); $dispatcher->setDefaultModule($currentDispatcher->getDefaultModule()); $dispatcher->setDefaultAction($currentDispatcher->getDefaultAction()); $dispatcher->setDefaultControllerName($currentDispatcher->getDefaultControllerName()); \Zend_Controller_Front::getInstance()->setDispatcher($dispatcher); }
public function register(Application $app) { $app['di.definitions'] = array(); $app['di.options'] = array(); $app['di.default_options'] = array('cache' => null, 'container_class' => 'DI\\Container', 'useAnnotations' => true, 'useAutowiring' => true, 'writeProxiesToFile' => false, 'proxyDirectory' => null, 'silexAliases' => true, 'injectOnControllers' => true); $app['di'] = $app->share(function () use($app) { $acclimator = new ContainerAcclimator(); $container = new CompositeContainer(); $builder = $app['di.builder']; $builder->wrapContainer($container); $phpdi = $builder->build(); $phpdi->set('Silex\\Application', $app); $container->addContainer($acclimator->acclimate($phpdi)); $container->addContainer($acclimator->acclimate($app)); return $container; }); $app['di.builder'] = $app->share(function () use($app) { $options = $app['di.options_merged']; $builder = new ContainerBuilder($options['container_class']); $builder->useAnnotations((bool) $options['useAnnotations']); $builder->useAutowiring((bool) $options['useAutowiring']); $builder->writeProxiesToFile($options['writeProxiesToFile'], $options['proxyDirectory']); if ($options['cache']) { $builder->setDefinitionCache($options['cache']); } $definitions = (array) $app['di.definitions']; if ($options['silexAliases']) { $definitions[] = __DIR__ . '/config.php'; } foreach ($definitions as $file) { $builder->addDefinitions($file); } return $builder; }); $app['di.raw'] = $app->share(function () use($app) { return $app['di']->get($app['di.options_merged']['container_class']); }); $app['di.options_merged'] = $app->share(function () use($app) { return array_merge($app['di.default_options'], $app['di.options']); }); $app['resolver'] = $app->share($app->extend('resolver', function ($resolver, $app) { if ($app['di.options_merged']['injectOnControllers']) { return new PhpDiControllerResolver($app['di.raw'], $resolver); } return $resolver; })); }
/** * Boots the dependency injection container. * * @param \Domynation\Config\ConfigInterface $config * @param \Domynation\Session\SessionInterface $session * * @return \DI\Container */ private function bootContainer(ConfigInterface $config, SessionInterface $session) { $builder = new ContainerBuilder(); $builder->useAnnotations(false); // Cache the definitions in production if (IS_PRODUCTION) { $builder->setDefinitionCache(new ApcuCache()); } // Load all global services $builder->addDefinitions(array_merge(require_once __DIR__ . '/Files/container.php', [ConfigInterface::class => $config, SessionInterface::class => $session])); // First pass: Instanciate each providers and load their container definitions $providers = array_reduce($config->get('providers'), function ($accumulator, $name) use($builder) { if (!class_exists($name)) { return $accumulator; } // Instanciate the provider $reflection = new \ReflectionClass($name); $provider = $reflection->newInstanceArgs(); // Load the provider's container definitions $builder->addDefinitions($provider->registerContainerDefinitions()); $accumulator[] = $provider; return $accumulator; }); // Build the container $container = $builder->build(); // Second pass: Boot each service foreach ($providers as $provider) { // Start the provider $provider->start($container->get(Router::class), $container->get(ViewFactoryInterface::class), $container->get(EventDispatcherInterface::class)); // Use reflection to get a closure copy of the `boot` method $reflection = new \ReflectionClass(get_class($provider)); $closure = $reflection->getMethod('boot')->getClosure($provider); // Let the container inject the dependency needed by the closure $container->call($closure); } return $container; }
/** * Create service * * @param ServiceLocatorInterface $serviceLocator * @return Container */ public function createService(ServiceLocatorInterface $serviceLocator) { if ($this->container !== null) { return $this->container; } $builder = new ContainerBuilder(); $config = $this->getConfig($serviceLocator); $configFile = $this->getDefinitionsFilePath($config); $builder->addDefinitions($configFile); $useAnnotations = $this->shouldUseAnnotations($config); $builder->useAnnotations($useAnnotations); $acclimator = new ContainerAcclimator(); $zfContainer = $acclimator->acclimate($serviceLocator); $builder->wrapContainer($zfContainer); /** * @var $cache Cache */ $cache = $this->getCache($serviceLocator, $config); if ($cache) { $builder->setDefinitionCache($cache); } $this->container = $builder->build(); return $this->container; }
$builder = new ContainerBuilder(); // We will enable @Inject annotation support. Between autowiring & // annotations I am hoping we won't need to have much in the way of // custom definitions in the ```container.php``` file. // http://php-di.org/doc/annotations.html $builder->useAnnotations(true); // Add our definitions from ```container.php```. $definitions = import(__DIR__ . '/container.php'); $builder->addDefinitions($definitions); // Grab the config object so we can use it to build the container. $config = $definitions['config']->__invoke(); // Add definitions from a child theme that might exist. $parentThemePath = $config->paths->theme->parent->root; $childThemePath = $config->paths->theme->child->root; if ($parentThemePath != $childThemePath) { $childContainer = $childThemePath . '/container.php'; if (file_exists($childContainer)) { $builder->addDefinitions(import($childContainer)); } } // If running on staging or production we will make // sure the container is cached for maximum performance. if (s::create($config->hosting->env)->containsAny(['staging', 'production'])) { $builder->setDefinitionCache($config->cache->container->driver->__invoke($config)); // NOTE: This would only be used in the case there are lazy injections. // see: http://php-di.org/doc/lazy-injection.html $builder->writeProxiesToFile(true, $config->paths->cache . '/proxies'); } // Boot our theme kernel. $builder->build()->get(IKernel::class)->boot(); });
<?php use DI\ContainerBuilder; use Doctrine\Common\Cache\ArrayCache; require __DIR__ . '/../vendor/autoload.php'; $containerBuilder = new ContainerBuilder(); $containerBuilder->setDefinitionCache(new ArrayCache()); $containerBuilder->addDefinitions(__DIR__ . '/di-config.php'); $containerBuilder->useAutowiring(true); $container = $containerBuilder->build(); return $container;
/** * Configure container's cache system. * * @param \DI\ContainerBuilder $containerBuilder * @param array $settings * * @return \DI\ContainerBuilder */ private static function configureContainerCache(DIContainerBuilder $containerBuilder, array $settings) { if (array_key_exists('definitions_cache', $settings)) { $containerBuilder->setDefinitionCache($settings['definitions_cache']); } return $containerBuilder; }