CI框架(CodeIgniter)操作redis的方法的详解

这篇文章主要介绍了CI框架(CodeIgniter)操作redis的方法,结合实例形式详细分析了CodeIgniter框架针对redis数据库操作的相关配置与使用技巧,需要的朋友可以参考下

本文实例讲述了CI框架(CodeIgniter)操作redis的方法。分享给大家供大家参考，具体如下：

1. 在autoload.php 中加入 如下配置行

$autoload['libraries'] = array('redis');

2. 在/application/config 中加入文件 redis.php

文件内容如下：

<?php
// Default connection group
$config[&#39;redis_default&#39;][&#39;host&#39;] = &#39;localhost&#39;;   // IP address or host
$config[&#39;redis_default&#39;][&#39;port&#39;] = &#39;6379&#39;;     // Default Redis port is 6379
$config[&#39;redis_default&#39;][&#39;password&#39;] = &#39;&#39;;     // Can be left empty when the server does not require AUTH
$config[&#39;redis_slave&#39;][&#39;host&#39;] = &#39;&#39;;
$config[&#39;redis_slave&#39;][&#39;port&#39;] = &#39;6379&#39;;
$config[&#39;redis_slave&#39;][&#39;password&#39;] = &#39;&#39;;
?>

3. 在 /application/libraries 中加入文件 Redis.php

文件来源：redis库文件包

文件内容：

<?php defined(&#39;BASEPATH&#39;) OR exit(&#39;No direct script access allowed&#39;);
/**
 * CodeIgniter Redis
 *
 * A CodeIgniter library to interact with Redis
 *
 * @package     CodeIgniter
 * @category    Libraries
 * @author     Joël Cox
 * @version     v0.4
 * @link      https://github.com/joelcox/codeigniter-redis
 * @link      http://joelcox.nl
 * @license     http://www.opensource.org/licenses/mit-license.html
 */
class CI_Redis {
  /**
   * CI
   *
   * CodeIgniter instance
   * @var   object
   */
  private $_ci;
  /**
   * Connection
   *
   * Socket handle to the Redis server
   * @var   handle
   */
  private $_connection;
  /**
   * Debug
   *
   * Whether we&#39;re in debug mode
   * @var   bool
   */
  public $debug = FALSE;
  /**
   * CRLF
   *
   * User to delimiter arguments in the Redis unified request protocol
   * @var   string
   */
  const CRLF = "\r\n";
  /**
   * Constructor
   */
  public function __construct($params = array())
  {
    log_message(&#39;debug&#39;, &#39;Redis Class Initialized&#39;);
    $this->_ci = get_instance();
    $this->_ci->load->config(&#39;redis&#39;);
    // Check for the different styles of configs
    if (isset($params[&#39;connection_group&#39;]))
    {
      // Specific connection group
      $config = $this->_ci->config->item(&#39;redis_&#39; . $params[&#39;connection_group&#39;]);
    }
    elseif (is_array($this->_ci->config->item(&#39;redis_default&#39;)))
    {
      // Default connection group
      $config = $this->_ci->config->item(&#39;redis_default&#39;);
    }
    else
    {
      // Original config style
      $config = array(
        &#39;host&#39; => $this->_ci->config->item(&#39;redis_host&#39;),
        &#39;port&#39; => $this->_ci->config->item(&#39;redis_port&#39;),
        &#39;password&#39; => $this->_ci->config->item(&#39;redis_password&#39;),
      );
    }
    // Connect to Redis
    $this->_connection = @fsockopen($config[&#39;host&#39;], $config[&#39;port&#39;], $errno, $errstr, 3);
    // Display an error message if connection failed
    if ( ! $this->_connection)
    {
      show_error(&#39;Could not connect to Redis at &#39; . $config[&#39;host&#39;] . &#39;:&#39; . $config[&#39;port&#39;]);
    }
    // Authenticate when needed
    $this->_auth($config[&#39;password&#39;]);
  }
  /**
   * Call
   *
   * Catches all undefined methods
   * @param  string method that was called
   * @param  mixed  arguments that were passed
   * @return mixed
   */
  public function __call($method, $arguments)
  {
    $request = $this->_encode_request($method, $arguments);
    return $this->_write_request($request);
  }
  /**
   * Command
   *
   * Generic command function, just like redis-cli
   * @param  string full command as a string
   * @return mixed
   */
  public function command($string)
  {
    $slices = explode(&#39; &#39;, $string);
    $request = $this->_encode_request($slices[0], array_slice($slices, 1));
    return $this->_write_request($request);
  }
  /**
   * Auth
   *
   * Runs the AUTH command when password is set
   * @param  string password for the Redis server
   * @return void
   */
  private function _auth($password = NULL)
  {
    // Authenticate when password is set
    if ( ! empty($password))
    {
      // See if we authenticated successfully
      if ($this->command(&#39;AUTH &#39; . $password) !== &#39;OK&#39;)
      {
        show_error(&#39;Could not connect to Redis, invalid password&#39;);
      }
    }
  }
  /**
   * Clear Socket
   *
   * Empty the socket buffer of theconnection so data does not bleed over
   * to the next message.
   * @return NULL
   */
  public function _clear_socket()
  {
    // Read one character at a time
    fflush($this->_connection);
    return NULL;
  }
  /**
   * Write request
   *
   * Write the formatted request to the socket
   * @param  string request to be written
   * @return mixed
   */
  private function _write_request($request)
  {
    if ($this->debug === TRUE)
    {
      log_message(&#39;debug&#39;, &#39;Redis unified request: &#39; . $request);
    }
    // How long is the data we are sending?
    $value_length = strlen($request);
    // If there isn&#39;t any data, just return
    if ($value_length <= 0) return NULL;
    // Handle reply if data is less than or equal to 8192 bytes, just send it over
    if ($value_length <= 8192)
    {
      fwrite($this->_connection, $request);
    }
    else
    {
      while ($value_length > 0)
      {
        // If we have more than 8192, only take what we can handle
        if ($value_length > 8192) {
          $send_size = 8192;
        }
        // Send our chunk
        fwrite($this->_connection, $request, $send_size);
        // How much is left to send?
        $value_length = $value_length - $send_size;
        // Remove data sent from outgoing data
        $request = substr($request, $send_size, $value_length);
      }
    }
    // Read our request into a variable
    $return = $this->_read_request();
    // Clear the socket so no data remains in the buffer
    $this->_clear_socket();
    return $return;
  }
  /**
   * Read request
   *
   * Route each response to the appropriate interpreter
   * @return mixed
   */
  private function _read_request()
  {
    $type = fgetc($this->_connection);
    // Times we will attempt to trash bad data in search of a
    // valid type indicator
    $response_types = array(&#39;+&#39;, &#39;-&#39;, &#39;:&#39;, &#39;$&#39;, &#39;*&#39;);
    $type_error_limit = 50;
    $try = 0;
    while ( ! in_array($type, $response_types) && $try < $type_error_limit)
    {
      $type = fgetc($this->_connection);
      $try++;
    }
    if ($this->debug === TRUE)
    {
      log_message(&#39;debug&#39;, &#39;Redis response type: &#39; . $type);
    }
    switch ($type)
    {
      case &#39;+&#39;:
        return $this->_single_line_reply();
        break;
      case &#39;-&#39;:
        return $this->_error_reply();
        break;
      case &#39;:&#39;:
        return $this->_integer_reply();
        break;
      case &#39;$&#39;:
        return $this->_bulk_reply();
        break;
      case &#39;*&#39;:
        return $this->_multi_bulk_reply();
        break;
      default:
        return FALSE;
    }
  }
  /**
   * Single line reply
   *
   * Reads the reply before the EOF
   * @return mixed
   */
  private function _single_line_reply()
  {
    $value = rtrim(fgets($this->_connection));
    $this->_clear_socket();
    return $value;
  }
  /**
   * Error reply
   *
   * Write error to log and return false
   * @return bool
   */
  private function _error_reply()
  {
    // Extract the error message
    $error = substr(rtrim(fgets($this->_connection)), 4);
    log_message(&#39;error&#39;, &#39;Redis server returned an error: &#39; . $error);
    $this->_clear_socket();
    return FALSE;
  }
  /**
   * Integer reply
   *
   * Returns an integer reply
   * @return int
   */
  private function _integer_reply()
  {
    return (int) rtrim(fgets($this->_connection));
  }
  /**
   * Bulk reply
   *
   * Reads to amount of bits to be read and returns value within
   * the pointer and the ending delimiter
   * @return string
   */
  private function _bulk_reply()
  {
    // How long is the data we are reading? Support waiting for data to
    // fully return from redis and enter into socket.
    $value_length = (int) fgets($this->_connection);
    if ($value_length <= 0) return NULL;
    $response = &#39;&#39;;
    // Handle reply if data is less than or equal to 8192 bytes, just read it
    if ($value_length <= 8192)
    {
      $response = fread($this->_connection, $value_length);
    }
    else
    {
      $data_left = $value_length;
        // If the data left is greater than 0, keep reading
        while ($data_left > 0 ) {
        // If we have more than 8192, only take what we can handle
        if ($data_left > 8192)
        {
          $read_size = 8192;
        }
        else
        {
          $read_size = $data_left;
        }
        // Read our chunk
        $chunk = fread($this->_connection, $read_size);
        // Support reading very long responses that don&#39;t come through
        // in one fread
        $chunk_length = strlen($chunk);
        while ($chunk_length < $read_size)
        {
          $keep_reading = $read_size - $chunk_length;
          $chunk .= fread($this->_connection, $keep_reading);
          $chunk_length = strlen($chunk);
        }
        $response .= $chunk;
        // Re-calculate how much data is left to read
        $data_left = $data_left - $read_size;
      }
    }
    // Clear the socket in case anything remains in there
    $this->_clear_socket();
  return isset($response) ? $response : FALSE;
  }
  /**
   * Multi bulk reply
   *
   * Reads n bulk replies and return them as an array
   * @return array
   */
  private function _multi_bulk_reply()
  {
    // Get the amount of values in the response
    $response = array();
    $total_values = (int) fgets($this->_connection);
    // Loop all values and add them to the response array
    for ($i = 0; $i < $total_values; $i++)
    {
      // Remove the new line and carriage return before reading
      // another bulk reply
      fgets($this->_connection, 2);
      // If this is a second or later pass, we also need to get rid
      // of the $ indicating a new bulk reply and its length.
      if ($i > 0)
      {
        fgets($this->_connection);
        fgets($this->_connection, 2);
      }
      $response[] = $this->_bulk_reply();
    }
    // Clear the socket
    $this->_clear_socket();
    return isset($response) ? $response : FALSE;
  }
  /**
   * Encode request
   *
   * Encode plain-text request to Redis protocol format
   * @link  http://redis.io/topics/protocol
   * @param  string request in plain-text
   * @param  string additional data (string or array, depending on the request)
   * @return string encoded according to Redis protocol
   */
  private function _encode_request($method, $arguments = array())
  {
    $request = &#39;$&#39; . strlen($method) . self::CRLF . $method . self::CRLF;
    $_args = 1;
    // Append all the arguments in the request string
    foreach ($arguments as $argument)
    {
      if (is_array($argument))
      {
        foreach ($argument as $key => $value)
        {
          // Prepend the key if we&#39;re dealing with a hash
          if (!is_int($key))
          {
            $request .= &#39;$&#39; . strlen($key) . self::CRLF . $key . self::CRLF;
            $_args++;
          }
          $request .= &#39;$&#39; . strlen($value) . self::CRLF . $value . self::CRLF;
          $_args++;
        }
      }
      else
      {
        $request .= &#39;$&#39; . strlen($argument) . self::CRLF . $argument . self::CRLF;
        $_args++;
      }
    }
    $request = &#39;*&#39; . $_args . self::CRLF . $request;
    return $request;
  }
  /**
   * Info
   *
   * Overrides the default Redis response, so we can return a nice array
   * of the server info instead of a nasty string.
   * @return array
   */
  public function info($section = FALSE)
  {
    if ($section !== FALSE)
    {
      $response = $this->command(&#39;INFO &#39;. $section);
    }
    else
    {
      $response = $this->command(&#39;INFO&#39;);
    }
    $data = array();
    $lines = explode(self::CRLF, $response);
    // Extract the key and value
    foreach ($lines as $line)
    {
      $parts = explode(&#39;:&#39;, $line);
      if (isset($parts[1])) $data[$parts[0]] = $parts[1];
    }
    return $data;
  }
  /**
   * Debug
   *
   * Set debug mode
   * @param  bool  set the debug mode on or off
   * @return void
   */
  public function debug($bool)
  {
    $this->debug = (bool) $bool;
  }
  /**
   * Destructor
   *
   * Kill the connection
   * @return void
   */
  function __destruct()
  {
    if ($this->_connection) fclose($this->_connection);
  }
}
?>

4. 然后你就可以 在文件中这样使用了

<?php
  if($this->redis->get(&#39;mark_&#39;.$gid) === null){ //如果未设置
    $this->redis->set(&#39;mark_&#39;.$gid, $giftnum); //设置
    $this->redis->EXPIRE(&#39;mark_&#39;.$gid, 30*60); //设置过期时间 （30 min）
  }else{
    $giftnum = $this->redis->get(&#39;mark_&#39;.$gid); //从缓存中直接读取对应的值
  }
?>

5. 重点是你所需要的 东东在这里很详细的讲解了

所有要用的函数只需要更改 $redis  ==> $this->redis

php中操作redis库函数功能与用法可参考本站//www.jb51.net/article/33887.htm

需要注意的是：

（1）你的本地需要安装 redis服务(windows安装)
（2）并开启redis 服务
（3）不管是windows 还是linux 都需要装 php对应版本的 redis扩展

您可能感兴趣的文章:

php使用imagecopymerge()函数创建半透明水印的详解

一个中高级PHP工程师所应该具备的能力

php实现mysql连接池效果实现代码的详解

Atas ialah kandungan terperinci CI框架(CodeIgniter)操作redis的方法的详解. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!