PHP Configuration::setSecondLevelCacheConfiguration方法代码示例

 /**
  * @group DDC-2183
  */
 public function testSetGetSecondLevelCacheConfig()
 {
     $mockClass = $this->getMock('Doctrine\\ORM\\Cache\\CacheConfiguration');
     $this->assertNull($this->configuration->getSecondLevelCacheConfiguration());
     $this->configuration->setSecondLevelCacheConfiguration($mockClass);
     $this->assertEquals($mockClass, $this->configuration->getSecondLevelCacheConfiguration());
 }

 /**
  * {@inheritDoc}
  *
  * @return Configuration
  */
 public function __invoke(ContainerInterface $container, $requestedName, array $options = null)
 {
     /** @var $options \DoctrineORMModule\Options\Configuration */
     $options = $this->getOptions($container);
     $config = new Configuration();
     $config->setAutoGenerateProxyClasses($options->getGenerateProxies());
     $config->setProxyDir($options->getProxyDir());
     $config->setProxyNamespace($options->getProxyNamespace());
     $config->setEntityNamespaces($options->getEntityNamespaces());
     $config->setCustomDatetimeFunctions($options->getDatetimeFunctions());
     $config->setCustomStringFunctions($options->getStringFunctions());
     $config->setCustomNumericFunctions($options->getNumericFunctions());
     $config->setClassMetadataFactoryName($options->getClassMetadataFactoryName());
     foreach ($options->getNamedQueries() as $name => $query) {
         $config->addNamedQuery($name, $query);
     }
     foreach ($options->getNamedNativeQueries() as $name => $query) {
         $config->addNamedNativeQuery($name, $query['sql'], new $query['rsm']());
     }
     foreach ($options->getCustomHydrationModes() as $modeName => $hydrator) {
         $config->addCustomHydrationMode($modeName, $hydrator);
     }
     foreach ($options->getFilters() as $name => $class) {
         $config->addFilter($name, $class);
     }
     $config->setMetadataCacheImpl($container->get($options->getMetadataCache()));
     $config->setQueryCacheImpl($container->get($options->getQueryCache()));
     $config->setResultCacheImpl($container->get($options->getResultCache()));
     $config->setHydrationCacheImpl($container->get($options->getHydrationCache()));
     $config->setMetadataDriverImpl($container->get($options->getDriver()));
     if ($namingStrategy = $options->getNamingStrategy()) {
         if (is_string($namingStrategy)) {
             if (!$container->has($namingStrategy)) {
                 throw new InvalidArgumentException(sprintf('Naming strategy "%s" not found', $namingStrategy));
             }
             $config->setNamingStrategy($container->get($namingStrategy));
         } else {
             $config->setNamingStrategy($namingStrategy);
         }
     }
     if ($quoteStrategy = $options->getQuoteStrategy()) {
         if (is_string($quoteStrategy)) {
             if (!$container->has($quoteStrategy)) {
                 throw new InvalidArgumentException(sprintf('Quote strategy "%s" not found', $quoteStrategy));
             }
             $config->setQuoteStrategy($container->get($quoteStrategy));
         } else {
             $config->setQuoteStrategy($quoteStrategy);
         }
     }
     if ($repositoryFactory = $options->getRepositoryFactory()) {
         if (is_string($repositoryFactory)) {
             if (!$container->has($repositoryFactory)) {
                 throw new InvalidArgumentException(sprintf('Repository factory "%s" not found', $repositoryFactory));
             }
             $config->setRepositoryFactory($container->get($repositoryFactory));
         } else {
             $config->setRepositoryFactory($repositoryFactory);
         }
     }
     if ($entityListenerResolver = $options->getEntityListenerResolver()) {
         if ($entityListenerResolver instanceof EntityListenerResolver) {
             $config->setEntityListenerResolver($entityListenerResolver);
         } else {
             $config->setEntityListenerResolver($container->get($entityListenerResolver));
         }
     }
     $secondLevelCache = $options->getSecondLevelCache();
     if ($secondLevelCache->isEnabled()) {
         $regionsConfig = new RegionsConfiguration($secondLevelCache->getDefaultLifetime(), $secondLevelCache->getDefaultLockLifetime());
         foreach ($secondLevelCache->getRegions() as $regionName => $regionConfig) {
             if (isset($regionConfig['lifetime'])) {
                 $regionsConfig->setLifetime($regionName, $regionConfig['lifetime']);
             }
             if (isset($regionConfig['lock_lifetime'])) {
                 $regionsConfig->setLockLifetime($regionName, $regionConfig['lock_lifetime']);
             }
         }
         // As Second Level Cache caches queries results, we reuse the result cache impl
         $cacheFactory = new DefaultCacheFactory($regionsConfig, $config->getResultCacheImpl());
         $cacheFactory->setFileLockRegionDirectory($secondLevelCache->getFileLockRegionDirectory());
         $cacheConfiguration = new CacheConfiguration();
         $cacheConfiguration->setCacheFactory($cacheFactory);
         $cacheConfiguration->setRegionsConfiguration($regionsConfig);
         $config->setSecondLevelCacheEnabled();
         $config->setSecondLevelCacheConfiguration($cacheConfiguration);
     }
     if ($className = $options->getDefaultRepositoryClassName()) {
         $config->setDefaultRepositoryClassName($className);
     }
     $this->setupDBALConfiguration($container, $config);
     return $config;
 }

 /**
  * {@inheritdoc}
  */
 protected function createWithConfig(ContainerInterface $container, $configKey)
 {
     $config = $this->retrieveConfig($container, $configKey, 'configuration');
     $configuration = new Configuration();
     $configuration->setProxyDir($config['proxy_dir']);
     $configuration->setProxyNamespace($config['proxy_namespace']);
     $configuration->setAutoGenerateProxyClasses($config['auto_generate_proxy_classes']);
     $configuration->setEntityNamespaces($config['entity_namespaces']);
     $configuration->setCustomDatetimeFunctions($config['datetime_functions']);
     $configuration->setCustomStringFunctions($config['string_functions']);
     $configuration->setCustomNumericFunctions($config['numeric_functions']);
     $configuration->setCustomHydrationModes($config['custom_hydration_modes']);
     $configuration->setClassMetadataFactoryName($config['class_metadata_factory_name']);
     foreach ($config['named_queries'] as $name => $dql) {
         $configuration->addNamedQuery($name, $dql);
     }
     foreach ($config['named_native_queries'] as $name => $query) {
         $configuration->addNamedNativeQuery($name, $query['sql'], $query['rsm']);
     }
     foreach ($config['filters'] as $name => $className) {
         $configuration->addFilter($name, $className);
     }
     $configuration->setMetadataCacheImpl($this->retrieveDependency($container, $config['metadata_cache'], 'cache', CacheFactory::class));
     $configuration->setQueryCacheImpl($this->retrieveDependency($container, $config['query_cache'], 'cache', CacheFactory::class));
     $configuration->setResultCacheImpl($this->retrieveDependency($container, $config['result_cache'], 'cache', CacheFactory::class));
     $configuration->setHydrationCacheImpl($this->retrieveDependency($container, $config['hydration_cache'], 'cache', CacheFactory::class));
     $configuration->setMetadataDriverImpl($this->retrieveDependency($container, $config['driver'], 'driver', DriverFactory::class));
     if (is_string($config['naming_strategy'])) {
         $configuration->setNamingStrategy($container->get($config['naming_strategy']));
     } elseif (null !== $config['naming_strategy']) {
         $configuration->setNamingStrategy($config['naming_strategy']);
     }
     if (is_string($config['repository_factory'])) {
         $configuration->setRepositoryFactory($container->get($config['repository_factory']));
     } elseif (null !== $config['repository_factory']) {
         $configuration->setRepositoryFactory($config['repository_factory']);
     }
     if (is_string($config['entity_listener_resolver'])) {
         $configuration->setEntityListenerResolver($container->get($config['entity_listener_resolver']));
     } elseif (null !== $config['entity_listener_resolver']) {
         $configuration->setEntityListenerResolver($config['entity_listener_resolver']);
     }
     if (null !== $config['default_repository_class_name']) {
         $configuration->setDefaultRepositoryClassName($config['default_repository_class_name']);
     }
     if ($config['second_level_cache']['enabled']) {
         $regionsConfig = new RegionsConfiguration($config['second_level_cache']['default_lifetime'], $config['second_level_cache']['default_lock_lifetime']);
         foreach ($config['second_level_cache']['regions'] as $regionName => $regionConfig) {
             if (array_key_exists('lifetime', $regionConfig)) {
                 $regionsConfig->setLifetime($regionName, $regionConfig['lifetime']);
             }
             if (array_key_exists('lock_lifetime', $regionConfig)) {
                 $regionsConfig->setLockLifetime($regionName, $regionConfig['lock_lifetime']);
             }
         }
         $cacheFactory = new DefaultCacheFactory($regionsConfig, $configuration->getResultCacheImpl());
         $cacheFactory->setFileLockRegionDirectory($config['second_level_cache']['file_lock_region_directory']);
         $cacheConfiguration = new CacheConfiguration();
         $cacheConfiguration->setCacheFactory($cacheFactory);
         $cacheConfiguration->setRegionsConfiguration($regionsConfig);
         $configuration->setSecondLevelCacheEnabled(true);
         $configuration->setSecondLevelCacheConfiguration($cacheConfiguration);
     }
     if (is_string($config['sql_logger'])) {
         $configuration->setSQLLogger($container->get($config['sql_logger']));
     } elseif (null !== $config['sql_logger']) {
         $configuration->setSQLLogger($config['sql_logger']);
     }
     return $configuration;
 }