PHP memcache_set函数代码示例

function getLoginCookie($openid)
{
    //数据库操作
    require_once 'utils/Mysql.class.php';
    $class_mysqlObj = new Class_mysql();
    $sql_state = "select studentid,IdCard from tb_studentInfo where openid='{$openid}'";
    $studentInfoArr = $class_mysqlObj->query_array($sql_state);
    //取出数据库里的 学号与身份证号
    $studentid = $studentInfoArr[0]['studentid'];
    $IdCard = $studentInfoArr[0]['IdCard'];
    //创建临时文件
    $cookieFile = SAE_TMP_PATH . '/personInfo_cookie.txt';
    $IdCardNum = substr($IdCard, 11, 6);
    if (strlen($IdCard) == 15) {
        $IdCardNum = substr($IdCard, 9, 6);
    }
    $login_url = "http://my.hpu.edu.cn/userPasswordValidate.portal";
    $login = "Login.Token1={$studentid}&Login.Token2={$IdCardNum}&goto=http%3A%2F%2Fmy.hpu.edu.cn%2FloginSuccess.portal&gotoOnFail=http%3A%2F%2Fmy.hpu.edu.cn%2FloginFailure.portal";
    $ch = curl_init($login_url);
    curl_setopt($ch, CURLOPT_POST, 1);
    curl_setopt($ch, CURLOPT_POSTFIELDS, $login);
    curl_setopt($ch, CURLOPT_COOKIEJAR, $cookieFile);
    // 把返回来的cookie信息保存在文件中
    curl_exec($ch);
    curl_close($ch);
    //读取文件内容
    $personInfo_cookie = file_get_contents($cookieFile);
    $mmc = memcache_init();
    // 初始化缓存
    memcache_set($mmc, $openid . "personInfo_cookie", $personInfo_cookie, 0, 600);
    return $personInfo_cookie;
}

function db_mysqli_query_fetch_list($mysqli, $query, $MYSQLI_TYPE)
{
    $config = getConfig();
    $params = $config['memcache'];
    $memcache = memcache_connect($params['host'], $params['port']);
    $memcacheQueryKey = 'QUERY' . $query['slow'];
    $data = memcache_get($memcache, $memcacheQueryKey);
    if (!empty($data)) {
    } else {
        if (!empty($query['fast'])) {
            $result = mysqli_query($mysqli, $query['fast']);
        } else {
            $result = mysqli_query($mysqli, $query['slow']);
        }
        $data = [];
        while ($row = mysqli_fetch_array($result, MYSQLI_ASSOC)) {
            $data[] = $row;
        }
        //another proc
        /* $pid = pcntl_fork();
           if ($pid == 0) {*/
        memcache_set($memcache, $memcacheQueryKey, $data, 0, 60 * 10);
        /*    posix_kill(posix_getpid(), SIGTERM);
              }*/
    }
    memcache_close($memcache);
    return $data;
}

 public function set($key, $value)
 {
     $this->check();
     if (memcache_set($this->connection, $key, $value, 0, Config::Get('cache_time')) === false) {
         throw new CacheException("Couldn't store data in cache");
     }
 }

 public static function set($key, $value, $name = 'default')
 {
     if (!App::instance()->get('cache_enable')) {
         return FALSE;
     }
     $client = self::client($key, $name);
     $ndx = self::$prefix . '_' . $key;
     $time = microtime(TRUE);
     // if ($cached = self::exist($key)){
     //     list($time, $ttl) = $cached;
     // }
     $data = App::instance()->serialize(array($value, $time, self::$ttl));
     switch (self::$engine) {
         case 'apc':
             return apc_store($ndx, $data, self::$ttl);
         case 'redis':
             // return $client->set($ndx, $data, array('ex' => self::$ttl));
             if (self::$ttl > 0) {
                 return $client->setex($ndx, self::$ttl, $data);
             } else {
                 return $client->set($ndx, $data);
             }
             break;
         case 'memcache':
             return memcache_set($client, $ndx, $data, 0, self::$ttl);
             break;
         default:
             return App::instance()->write($client . DS . $ndx, $data);
     }
     return FALSE;
 }

 public function setItem($key, $value)
 {
     if (empty($key)) {
         throw new CacheException('CACHE ERROR:key is empty');
     }
     return memcache_set($this->cache, $key, $value, self::COMP, $this->ttl);
 }

 public function requeue_snapshot()
 {
     ignore_user_abort(true);
     header("Connection: Close");
     flush();
     ob_end_flush();
     $m = memcache_connect('127.0.0.1', 11211);
     $urlkey = sha1($this->snapshot_url);
     if (isset($_GET['requeue']) && 'true' != $_GET['requeue']) {
         if (memcache_get($m, $urlkey)) {
             die;
         }
     }
     memcache_set($m, $urlkey, 1, 0, 300);
     $requeue_url = self::renderer . "/queue?url=" . rawurlencode($this->snapshot_url) . "&f=" . urlencode($this->snapshot_file);
     $retval = file_get_contents($requeue_url);
     $tries = 1;
     while (false === $retval && $tries <= 5) {
         sleep(1);
         // in the event that the failed call is due to a mShots.js service restart,
         // we need to be a little patient as the service comes back up
         $retval = file_get_contents($requeue_url);
         $tries++;
     }
 }

 public function removeObserver($conn)
 {
     if (isset($conn->token)) {
         $token = $conn->token;
         if (defined("PUBSUB_CHANNEL")) {
             $observers = memcache_get($this->mmc, 'channel.observers.' . (string) $token->user_id);
             if (!empty($observers)) {
                 $observers = unserialize($observers);
                 foreach ($observers as $key => $value) {
                     if ($conn->_connection_identifier == $value->_connection_identifier) {
                         unset($observers[$key]);
                         memcache_set($this->mmc, 'channel.observers.' . (string) $token->user_id, serialize($observers));
                         return true;
                     }
                 }
             }
         } else {
             if (isset($this->observers[(string) $token->user_id])) {
                 foreach ($this->observers[(string) $token->user_id] as $key => $value) {
                     if ($conn == $value) {
                         unset($this->observers[(string) $token->user_id][$key]);
                         return true;
                     }
                 }
             }
         }
     }
     return false;
 }

 function pmxCachePut($key, $value, $ttl, $useMember = false, $cleaner = null)
 {
     global $PortaMx_cache, $user_info, $mcache;
     $st = microtime(true);
     $ckey = $PortaMx_cache['key'] . ($useMember ? '-' . implode('_', $user_info['groups']) : '') . '-' . $key;
     if ($value !== null) {
         $value = serialize($value);
     } else {
         if ($cleaner !== null && $useMember) {
             $ckey = $PortaMx_cache['key'] . '-' . $cleaner . '-' . $key;
         }
     }
     // connected?
     if (empty($mcache)) {
         connect_mcache();
     }
     if ($mcache) {
         memcache_set($mcache, $ckey, $value, 0, $ttl);
         if ($value !== null) {
             $PortaMx_cache['vals']['saved'] += strlen($value);
         }
         $PortaMx_cache['vals']['time'] += microtime(true) - $st;
     }
     // handle member groups key?
     if ($useMember && $cleaner === null) {
         pmxCacheMemGroupAcs();
     }
 }

 public function insert($key = '', $var = '', $time = 60, $compressed = false)
 {
     if ($compressed !== true) {
         $var = array($var, time(), $time);
     }
     return memcache_set($key, $var, 0, $time);
 }

function pdb_get_data($key, $provider, $arguments = [])
{
    $mc_handler = memcache_pconnect(MC_HOST);
    $value = memcache_get($mc_handler, $key);
    if ($value !== false) {
        return $value;
    } else {
        $locking_key = 'lock_' . $key;
        $locking_value = microtime(true);
        for ($i = 0; $i < MC_LOCK_DELAY * 1000 / MC_SLEEP_TIME + 1; $i++) {
            $lock = memcache_add($mc_handler, $locking_key, $locking_value, 0, MC_LOCK_DELAY);
            if ($lock) {
                $value = call_user_func_array($provider, $arguments);
                memcache_set($mc_handler, $key, $value);
                memcache_delete($mc_handler, $locking_key);
                return $value;
            } else {
                usleep(MC_SLEEP_TIME);
                $value = memcache_get($mc_handler, $key);
                if ($value != false) {
                    return $value;
                }
            }
        }
    }
    return call_user_func_array($provider, $arguments);
}

 /**
  *	Store value in cache
  *	@return mixed|FALSE
  *	@param $key string
  *	@param $val mixed
  *	@param $ttl int
  **/
 function set($key, $val, $ttl = 0)
 {
     $fw = Base::instance();
     if (!$this->dsn) {
         return TRUE;
     }
     $ndx = $this->prefix . '.' . $key;
     $time = microtime(TRUE);
     if ($cached = $this->exists($key)) {
         list($time, $ttl) = $cached;
     }
     $data = $fw->serialize(array($val, $time, $ttl));
     $parts = explode('=', $this->dsn, 2);
     switch ($parts[0]) {
         case 'apc':
         case 'apcu':
             return apc_store($ndx, $data, $ttl);
         case 'redis':
             return $this->ref->set($ndx, $data, array('ex' => $ttl));
         case 'memcache':
             return memcache_set($this->ref, $ndx, $data, 0, $ttl);
         case 'wincache':
             return wincache_ucache_set($ndx, $data, $ttl);
         case 'xcache':
             return xcache_set($ndx, $data, $ttl);
         case 'folder':
             return $fw->write($parts[1] . $ndx, $data);
     }
     return FALSE;
 }

 public function set($name, $data, $ttl = 86400)
 {
     if (!is_resource($this->memcache)) {
         throw new \Exception("Memcached can't connect.");
     }
     return memcache_set($this->memcache, $name, $data, 0, $ttl);
 }

 public function insert($key, $var, $time, $compressed)
 {
     if ($compressed !== true) {
         $var = [$var, time(), $time];
     }
     return memcache_set($key, $var, 0, $time);
 }

function cache_set($key, $data, $expires)
{
    $connection = cache_connect();
    $res = memcache_set($connection, (string) $key, $data, false, (int) $expires);
    memcache_close($connection);
    return $res;
}

 function setValue($key, $value, $expire = 0)
 {
     if ($expire == 0) {
         memcache_set($this->mmc, $key, $value);
     } else {
         memcache_set($this->mmc, $key, $value, $expire);
     }
 }