PHP Redis::get方法代码示例

 /**
  * Returns cached value by key
  *
  * @param string $key
  * @return bool|mixed
  */
 public function get($key)
 {
     if (false === ($value = $this->cache->get($this->prepareKey($key)))) {
         return false;
     }
     return $this->unserializeCompound($value);
 }

 /**
  * @inheritDoc
  */
 public function read($id)
 {
     if ($data = $this->_redis->get($this->getPrefixKey($id))) {
         return unserialize($data);
     }
     return null;
 }

 /**
  * @inheritdoc
  */
 public function retrieve($key)
 {
     if (!$this->exists($key)) {
         return null;
     }
     return unserialize($this->redis->get($this->prefix . $key));
 }

 public static function increment($host)
 {
     $count = self::$redis->incrBy(self::$prefix . $host, 1);
     if (self::$redis->get(self::$prefix . $host) == 1) {
         self::$redis->setTimeout(self::$prefix . $host, self::$ttl);
     }
     return $count;
 }

 /**
  * Attempt to retrieve a value from the cache server, if not set it.
  *
  * @param string $key Key we can use to retrieve the data.
  *
  * @return bool|string False on failure or String, data belonging to the key.
  * @access public
  */
 public function get($key)
 {
     if ($this->connected === true && $this->ping() === true) {
         $data = $this->server->get($key);
         return $this->isRedis ? $this->IgBinarySupport ? igbinary_unserialize($data) : unserialize($data) : $data;
     }
     return false;
 }

 /**
  * Loads item by cache key.
  * 
  * @param string $key
  * @return mixed
  * 
  * @throws StorageException if storage error occurs, handler can not be used
  */
 protected function load($key)
 {
     try {
         return $this->redis->get($key);
     } catch (\Exception $e) {
         throw new StorageException("Failed to load redis key: {$key}", 1, $e);
     }
 }

 /**
  * Get cache
  *
  * @param	string	Cache ID
  * @return	mixed
  */
 public function get($key)
 {
     $value = $this->_redis->get($key);
     if ($value !== FALSE && isset($this->_serialized[$key])) {
         return unserialize($value);
     }
     return $value;
 }

 /**
  * Get a cache variable
  *
  * Retrieve a variable from the cache and return it's
  * value to the user.
  *
  * @param  string $name  The name of the cache variable to retrieve.
  *
  * @return mixed         The value of the retrieved variable or false if
  *                       variable isn't found.
  */
 public function get($name)
 {
     $key = $this->redis->get($name);
     if ($key !== false) {
         return unserialize($key);
     }
     return false;
 }

 /**
  * get var
  * @param $key
  * @param null $default
  * @return bool|mixed
  */
 public function get($key, $default = null)
 {
     $result = $this->redis->get($key);
     if ($result) {
         return $result;
     }
     return $default;
 }

 /**
  * @param $key
  * @return Option
  */
 public static function getMy($key)
 {
     $hash = self::hash($key);
     if (self::$redis->exists(self::myPrefix() . ":" . $hash)) {
         return Option::Some(unserialize(self::$redis->get(self::myPrefix() . ":" . $hash)));
     } else {
         return Option::None();
     }
 }

 public function get($key)
 {
     $result = self::$cache->get($this->getNamespace() . $key);
     if ($result === false && !self::$cache->exists($this->getNamespace() . $key)) {
         return null;
     } else {
         return json_decode($result, true);
     }
 }

 public function get($id, $default = NULL)
 {
     // Get the value from Redis
     $value = $this->_redis->get($id);
     if ($value == false) {
         $value = $default;
     }
     // Return the value
     return $value;
 }

 /**
  * @param int $provider
  * @param int $providerUserId
  *
  * @return bool|User
  *
  */
 public function loadUserByOauth($provider, $providerUserId)
 {
     if (!($userName = $this->redis->get('credentials:' . implode(':', array($provider, $providerUserId))))) {
         return false;
     }
     if (!($user = $this->loadUserByUsername($userName))) {
         return false;
     }
     return new User($user);
 }

 public function testStdClass()
 {
     $data = new \stdClass();
     $data->a = 'a';
     $data->b = 'b';
     $key = new CacheKey('test', rand(1, 1000));
     $this->cache->set($key, $data);
     $val = $this->cache->get($key);
     $this->assertEquals($data, $val);
 }

 public function __construct()
 {
     $redis = new Redis();
     try {
         $redis->connect('127.0.0.1', 6379);
         $this->data = array('count' => $redis->get('cobbler:count'), 'speed' => $redis->get('cobbler:speed'));
         $redis->close();
     } catch (Exception $e) {
         $this->error(500, $e->getMessage());
     }
 }