php Zend-Cache-StorageFactory类(方法)实例源码

public function getServiceConfig()
 {
     return ['factories' => ['Cache' => function ($sm) {
         // Trabalhando com APC
         $config = $sm->get('Config');
         $cache = StorageFactory::factory(['adapter' => ['name' => $config['cache']['adapter'], 'options' => ['ttl' => $config['cache']['ttl']]], 'plugins' => ['Serializer', 'exception_handler' => ['throw_exceptions' => $config['cache']['throw_exceptions']]]]);
         return $cache;
         /* Trabalhando com memcached
         
                             $factory = [
                                 'adapter' => [
                                     'name'    => 'Memcached',
                                     'options' => [
                                         'ttl' => 10,
                                         'servers' => [
                                             ['127.0.0.1', 11211]
                                         ]
                                     ],
                                 ],
                                 'plugins' => [
                                     'Serializer',
                                     'exception_handler' => ['throw_exceptions' => true],// em produção false
                                 ],
                             ];
                             $cache = StorageFactory::factory($factory);
                             return $cache;
                             */
     }]];
 }

/**
  * Return the sed Cache adapter.
  *
  * @return mixed|StorageInterface
  */
 public function getCacheAdapter()
 {
     if (null == $this->storageAdapter) {
         $this->storageAdapter = StorageFactory::factory($this->options['cache']);
     }
     return $this->storageAdapter;
 }

public function registerFactories()
 {
     $this->createFactoryObject("Zend\\Cache\\Storage\\Adapter\\Memcached", function () {
         $memcached = $this->configManager->getMemcached();
         return StorageFactory::factory(array('adapter' => array('name' => 'memcached', 'options' => array('servers' => array(array($memcached['Host'], $memcached['Port']))))));
     });
 }

public function setup()
 {
     $sl = bootstrap::getServiceManager();
     $this->sitemap = $sl->get('NetgluePrismic\\Service\\Sitemap');
     $this->cache = StorageFactory::factory(array('adapter' => 'apc', 'options' => array()));
     $this->cache->flush();
 }

public function setUp()
 {
     $this->storage = StorageFactory::factory(array('adapter' => 'apc', 'options' => array()));
     $this->storage->flush();
     $services = bootstrap::getServiceManager();
     $services->setAllowOverride(true);
 }

/**
  * @param array $configuration
  * @throws \Zend\Cache\Exception\InvalidArgumentException
  * @throws \Zend\Cache\Exception\RuntimeException
  */
 public function __construct(array $configuration)
 {
     if (!isset($configuration['adapter'])) {
         $configuration['adapter'] = 'Filesystem';
     }
     if (!isset($configuration['adapterOptions'])) {
         $configuration['adapterOptions'] = [];
     }
     $cache = StorageFactory::factory(['adapter' => ['name' => $configuration['adapter'], 'options' => $configuration['adapterOptions']]]);
     $options = $cache->getOptions();
     $options->setNamespace('Shariff');
     $options->setTtl($configuration['ttl']);
     if ($options instanceof FilesystemOptions) {
         $options->setCacheDir(isset($configuration['cacheDir']) ? $configuration['cacheDir'] : sys_get_temp_dir());
     }
     if ($cache instanceof ClearExpiredInterface) {
         if (function_exists('register_postsend_function')) {
             // for hhvm installations: executing after response / session close
             register_postsend_function(function () use($cache) {
                 $cache->clearExpired();
             });
         } else {
             // default
             $cache->clearExpired();
         }
     }
     $this->cache = $cache;
 }

public function getServiceConfig()
 {
     return array('factories' => array('MajesticExternalForms\\Models\\MajesticExternalFormsModel' => function ($sm) {
         $model_forms = new MajesticExternalFormsModel();
         return $model_forms;
     }, 'MajesticExternalForms\\Events\\MajesticExternalFormsEvents' => function ($sm) {
         $events_external_forms = new MajesticExternalFormsEvents();
         return $events_external_forms;
     }, 'MajesticExternalForms\\Models\\MajesticExternalFormsCacheModel' => function ($sm) {
         $arr_config = $sm->get("config");
         try {
             $cache = StorageFactory::factory($arr_config["cache_redis_config_common"]);
         } catch (\Exception $e) {
             $dir = "./data/cache/external_forms";
             if (!is_dir("./data/cache/external_forms")) {
                 mkdir($dir, 0777, TRUE);
             }
             //end if
             //try local file system
             try {
                 $arr_cache_config = $arr_config["cache_filesystem_config_common"];
                 $arr_cache_config["adapter"]["options"]["cache_dir"] = $dir;
                 $cache = StorageFactory::factory($arr_cache_config);
             } catch (\Exception $e) {
                 throw new \Exception(__CLASS__ . " Line " . __LINE__ . " : External Form Cache could not create Redis of Filesystem cache", 500);
             }
             //end catch
         }
         //end catch
         $model_core_forms_cache = new MajesticExternalFormsCacheModel($cache);
         return $model_core_forms_cache;
     }));
 }

/**
  * Create service
  *
  * @param ServiceLocatorInterface $serviceLocator
  * @return mixed
  */
 public function createService(ServiceLocatorInterface $serviceLocator)
 {
     $config = $serviceLocator->get('config');
     $cacheAdapterConfiguration = $config['validation_cache_adapter'];
     $cache = StorageFactory::factory($cacheAdapterConfiguration);
     return $cache;
 }

/**
  * Create service
  *
  * @param ServiceLocatorInterface $serviceLocator
  * @return null|StorageInterface
  */
 public function createService(ServiceLocatorInterface $serviceLocator)
 {
     $config = $serviceLocator->get('config');
     self::$cache = StorageFactory::factory(isset($config['cache']) ? $config['cache'] : array());
     //        self::$cache->flush();
     return self::$cache;
 }

/**
  * {@inheritDoc}
  *
  * @return ApiService
  */
 public function createService(ServiceLocatorInterface $serviceLocator)
 {
     $config = $serviceLocator->get('Config');
     $columnisConfig = isset($config['columnis']) ? $config['columnis'] : array();
     $apiConfig = isset($columnisConfig['api_settings']) ? $columnisConfig['api_settings'] : array();
     if (!isset($apiConfig['client_number'])) {
         throw new ClientNumberNotSetException("There is no client_number set in local.php config file.");
     }
     if (!isset($apiConfig['api_base_url'])) {
         throw new ApiBaseUrlNotSetException("There is no api_base_url set in local.php config file.");
     }
     $clientNumber = $apiConfig['client_number'];
     $apiUrl = $apiConfig['api_base_url'];
     $httpClient = new GuzzleClient(array('base_url' => $apiUrl));
     $cacheConfig = isset($config['guzzle_cache']) ? $config['guzzle_cache'] : array();
     if (isset($cacheConfig['adapter'])) {
         $cache = StorageFactory::factory($cacheConfig);
         $zfCacheAdapter = new ZfCacheAdapter($cache);
         $cacheSubscriber = new CacheSubscriber($zfCacheAdapter, function (RequestInterface $request) use($zfCacheAdapter) {
             return !$zfCacheAdapter->contains($request);
         });
         $httpClient->getEmitter()->attach($cacheSubscriber);
     }
     return new ApiService($httpClient, $clientNumber);
 }

/**
  * Create Service
  *
  * @param ServiceLocatorInterface $serviceLocator Zend Service Manager
  *
  * @return \Zend\Cache\Storage\StorageInterface
  */
 public function createService(ServiceLocatorInterface $serviceLocator)
 {
     $config = $serviceLocator->get('config');
     $extraOptions = ['namespace' => 'rcmRssCache', 'ttl' => '300'];
     $cache = StorageFactory::factory(['adapter' => ['name' => $config['rcmCache']['adapter'], 'options' => $config['rcmCache']['options'] + $extraOptions], 'plugins' => $config['rcmCache']['plugins']]);
     return $cache;
 }

/**
  * {@inheritDoc}
  */
 public function createService(ServiceLocatorInterface $serviceLocator)
 {
     /** @var $options \StrokerCache\Options\ModuleOptions */
     $options = $serviceLocator->get('StrokerCache\\Options\\ModuleOptions');
     $adapterOptions = array('adapter' => $options->getStorageAdapter());
     return StorageFactory::factory($adapterOptions);
 }

public function __invoke(ContainerInterface $container, $requestedName, array $options = null)
 {
     $this->prepareStorageFactory($container);
     $config = $container->get('config');
     $cacheConfig = isset($config['cache']) ? $config['cache'] : [];
     return StorageFactory::factory($cacheConfig);
 }

/**
  * Defined by Zend\Authentication\Storage\StorageInterface
  *
  * @return void
  */
 public function cacheClear()
 {
     $userId = $this->session->{$this->member}->userId;
     $cache = StorageFactory::factory(array('adapter' => array('name' => 'filesystem', 'options' => array('cache_dir' => './data/cache', 'ttl' => 3600)), 'plugins' => array('exception_handler' => array('throw_exceptions' => false), 'serializer')));
     foreach ($this->remove_caches as $cache_ns) {
         $cache->removeItem($cache_ns . $userId);
     }
 }

public function __construct($path = '../cache')
 {
     if (!is_dir($path) && !mkdir($path, 0755, true)) {
         throw new \Exception('Cache path doesn\'t exist');
     }
     $this->path = $path;
     $this->cache = StorageFactory::factory(array('adapter' => array('name' => 'filesystem', 'options' => array('ttl' => 3600, 'cache_dir' => $path, 'dir_level' => 1, 'dir_permission' => 0755, 'file_permission' => 0644)), 'plugins' => array('exception_handler' => array('throw_exceptions' => false), 'serializer')));
 }

public function __construct($options = array())
 {
     if (is_array($options)) {
         if (isset($options['cache'])) {
             $this->setCacheStorage(StorageFactory::factory($options['cache']));
         }
     }
 }

/**
  * @param ServiceLocatorInterface $serviceLocator
  *
  * @return CacheStorageFactory
  */
 public function createService(ServiceLocatorInterface $serviceLocator)
 {
     /** @var OptionsHelper $options */
     $options = $serviceLocator->get('DmMailer\\Helper\\Options');
     $cacheOptions = $options->getCacheStorage();
     $cacheStorage = CacheStorageFactory::factory($cacheOptions);
     return $cacheStorage;
 }

/**
  * @return \Zend\Cache\Storage\StorageInterface
  */
 public function getCache()
 {
     if (!$this->cache) {
         $cache = StorageFactory::factory(array('adapter' => array('name' => 'filesystem', 'options' => array('cache_dir' => './data/cache', 'ttl' => 3600)), 'plugins' => array('exception_handler' => array('throw_exceptions' => false), 'serializer')));
         $this->cache = $cache;
     }
     return $this->cache;
 }

public function testMemcachedStorageNormalizesKey()
 {
     $adapter = StorageFactory::factory(array('adapter' => 'memcached', 'options' => array('ttl' => 2 * 60 * 60, 'servers' => array(array('host' => 'localhost', 'port' => 11211)))));
     $facade = new Facade($adapter);
     $key = str_repeat('http://www.foo.bar.com/Blah?=foo&baz=bat', 20);
     $expect = md5($key);
     $this->assertSame($expect, $facade->normalizeKey($key));
 }

protected function setUp()
 {
     if (!class_exists('\\Zend\\Cache\\StorageFactory')) {
         $this->markTestSkipped('StorageFactory is not available');
     }
     $memoryCache = StorageFactory::factory(array('adapter' => array('name' => 'memory', 'options' => array('ttl' => 100)), 'plugins' => array('exception_handler' => array('throw_exceptions' => false))));
     $this->cache = new ZendCache($memoryCache);
 }