当前位置：首页 > CMS教程 > 其它CMS > 列表

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

发布:smiling　来源: PHP粉丝网 　添加日期：2021-08-31 11:37:22　浏览: 评论：0　

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

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

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

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

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

文件内容如下：

  1. <?php 
  2. // Default connection group 
  3. $config['redis_default']['host'] = 'localhost';   // IP address or host 
  4. $config['redis_default']['port'] = '6379';     // Default Redis port is 6379 
  5. $config['redis_default']['password'] = '';     // Can be left empty when the server does not require AUTH 
  6. $config['redis_slave']['host'] = ''; 
  7. $config['redis_slave']['port'] = '6379'; 
  8. $config['redis_slave']['password'] = ''; 
  9. ?> 

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

文件来源：redis库文件包

文件内容：

  1. <?php defined('BASEPATH') OR exit('No direct script access allowed'); 
  2. /** 
  3.  * CodeIgniter Redis 
  4.  * 
  5.  * A CodeIgniter library to interact with Redis 
  6.  * 
  7.  * @package     CodeIgniter 
  8.  * @category    Libraries 
  9.  * @author     Joël Cox 
  10.  * @version     v0.4 
  11.  * @link      https://github.com/joelcox/codeigniter-redis 
  12.  * @link      http://joelcox.nl 
  13.  * @license     http://www.opensource.org/licenses/mit-license.html 
  14.  */ 
  15. class CI_Redis { 
  16.   /** 
  17.    * CI 
  18.    * 
  19.    * CodeIgniter instance 
  20.    * @var   object 
  21.    */ 
  22.   private $_ci; 
  23.   /** 
  24.    * Connection 
  25.    * 
  26.    * Socket handle to the Redis server 
  27.    * @var   handle 
  28.    */ 
  29.   private $_connection; 
  30.   /** 
  31.    * Debug 
  32.    * 
  33.    * Whether we're in debug mode 
  34.    * @var   bool 
  35.    */ 
  36.   public $debug = FALSE; 
  37.   /** 
  38.    * CRLF 
  39.    * 
  40.    * User to delimiter arguments in the Redis unified request protocol 
  41.    * @var   string 
  42.    */ 
  43.   const CRLF = "\r\n"; 
  44.   /** 
  45.    * Constructor 
  46.    */ 
  47.   public function __construct($params = array()) 
  48.   { 
  49.     log_message('debug', 'Redis Class Initialized'); 
  50.     $this->_ci = get_instance(); 
  51.     $this->_ci->load->config('redis'); 
  52.     // Check for the different styles of configs 
  53.     if (isset($params['connection_group'])) 
  54.     { 
  55.       // Specific connection group 
  56.       $config = $this->_ci->config->item('redis_' . $params['connection_group']); 
  57.     } 
  58.     elseif (is_array($this->_ci->config->item('redis_default'))) 
  59.     { 
  60.       // Default connection group 
  61.       $config = $this->_ci->config->item('redis_default'); 
  62.     } 
  63.     else 
  64.     { 
  65.       // Original config style 
  66.       $config = array( 
  67.         'host' => $this->_ci->config->item('redis_host'), 
  68.         'port' => $this->_ci->config->item('redis_port'), 
  69.         'password' => $this->_ci->config->item('redis_password'), 
  70.       ); 
  71.     } 
  72.     // Connect to Redis 
  73.     $this->_connection = @fsockopen($config['host'], $config['port'], $errno, $errstr, 3); 
  74.     // Display an error message if connection failed 
  75.     if ( ! $this->_connection) 
  76.     { 
  77.       show_error('Could not connect to Redis at ' . $config['host'] . ':' . $config['port']); 
  78.     } 
  79.     // Authenticate when needed 
  80.     $this->_auth($config['password']); 
  81.   } 
  82.   /** 
  83.    * Call 
  84.    * 
  85.    * Catches all undefined methods 
  86.    * @param  string method that was called 
  87.    * @param  mixed  arguments that were passed 
  88.    * @return mixed 
  89.    */ 
  90.   public function __call($method, $arguments) 
  91.   { 
  92.     $request = $this->_encode_request($method, $arguments); 
  93.     return $this->_write_request($request); 
  94.   } 
  95.   /** 
  96.    * Command 
  97.    * 
  98.    * Generic command function, just like redis-cli 
  99.    * @param  string full command as a string 
  100.    * @return mixed 
  101.    */ 
  102.   public function command($string) 
  103.   { 
  104.     $slices = explode(' ', $string); 
  105.     $request = $this->_encode_request($slices[0], array_slice($slices, 1)); 
  106.     return $this->_write_request($request); 
  107.   } 
  108.   /** 
  109.    * Auth 
  110.    * 
  111.    * Runs the AUTH command when password is set 
  112.    * @param  string password for the Redis server 
  113.    * @return void 
  114.    */ 
  115.   private function _auth($password = NULL) 
  116.   { 
  117.     // Authenticate when password is set 
  118.     if ( ! emptyempty($password)) 
  119.     { 
  120.       // See if we authenticated successfully 
  121.       if ($this->command('AUTH ' . $password) !== 'OK') 
  122.       { 
  123.         show_error('Could not connect to Redis, invalid password'); 
  124.       } 
  125.     } 
  126.   } 
  127.   /** 
  128.    * Clear Socket 
  129.    * 
  130.    * Empty the socket buffer of theconnection so data does not bleed over 
  131.    * to the next message. 
  132.    * @return NULL 
  133.    */ 
  134.   public function _clear_socket() 
  135.   { 
  136.     // Read one character at a time 
  137.     fflush($this->_connection); 
  138.     return NULL; 
  139.   } 
  140.   /** 
  141.    * Write request 
  142.    * 
  143.    * Write the formatted request to the socket 
  144.    * @param  string request to be written 
  145.    * @return mixed 
  146.    */ 
  147.   private function _write_request($request) 
  148.   { 
  149.     if ($this->debug === TRUE) 
  150.     { 
  151.       log_message('debug', 'Redis unified request: ' . $request); 
  152.     } 
  153.     // How long is the data we are sending? 
  154.     $value_length = strlen($request); 
  155.     // If there isn't any data, just return 
  156.     if ($value_length <= 0) return NULL; 
  157.     // Handle reply if data is less than or equal to 8192 bytes, just send it over 
  158.     if ($value_length <= 8192) 
  159.     { 
  160.       fwrite($this->_connection, $request); 
  161.     } 
  162.     else 
  163.     { 
  164.       while ($value_length > 0) 
  165.       { 
  166.         // If we have more than 8192, only take what we can handle 
  167.         if ($value_length > 8192) { 
  168.           $send_size = 8192; 
  169.         } 
  170.         // Send our chunk 
  171.         fwrite($this->_connection, $request, $send_size); 
  172.         // How much is left to send? 
  173.         $value_length = $value_length - $send_size; 
  174.         // Remove data sent from outgoing data 
  175.         $request = substr($request, $send_size, $value_length); 
  176.       } 
  177.     } 
  178.     // Read our request into a variable 
  179.     $return = $this->_read_request(); 
  180.     // Clear the socket so no data remains in the buffer 
  181.     $this->_clear_socket(); 
  182.     return $return; 
  183.   } 
  184.   /** 
  185.    * Read request 
  186.    * 
  187.    * Route each response to the appropriate interpreter 
  188.    * @return mixed 
  189.    */ 
  190.   private function _read_request() 
  191.   { 
  192.     $type = fgetc($this->_connection); 
  193.     // Times we will attempt to trash bad data in search of a 
  194.     // valid type indicator 
  195.     $response_types = array('+', '-', ':', '$', '*'); 
  196.     $type_error_limit = 50; 
  197.     $try = 0; 
  198.     while ( ! in_array($type, $response_types) && $try < $type_error_limit) 
  199.     { 
  200.       $type = fgetc($this->_connection); 
  201.       $try++; 
  202.     } 
  203.     if ($this->debug === TRUE) 
  204.     { 
  205.       log_message('debug', 'Redis response type: ' . $type); 
  206.     } 
  207.     switch ($type) 
  208.     { 
  209.       case '+': 
  210.         return $this->_single_line_reply(); 
  211.         break; 
  212.       case '-': 
  213.         return $this->_error_reply(); 
  214.         break; 
  215.       case ':': 
  216.         return $this->_integer_reply(); 
  217.         break; 
  218.       case '$': 
  219.         return $this->_bulk_reply(); 
  220.         break; 
  221.       case '*': 
  222.         return $this->_multi_bulk_reply(); 
  223.         break; 
  224.       default: 
  225.         return FALSE; 
  226.     } 
  227.   } 
  228.   /** 
  229.    * Single line reply 
  230.    * 
  231.    * Reads the reply before the EOF 
  232.    * @return mixed 
  233.    */ 
  234.   private function _single_line_reply() 
  235.   { 
  236.     $value = rtrim(fgets($this->_connection)); 
  237.     $this->_clear_socket(); 
  238.     return $value; 
  239.   } 
  240.   /** 
  241.    * Error reply 
  242.    * 
  243.    * Write error to log and return false 
  244.    * @return bool 
  245.    */ 
  246.   private function _error_reply() 
  247.   { 
  248.     // Extract the error message 
  249.     $error = substr(rtrim(fgets($this->_connection)), 4); 
  250.     log_message('error', 'Redis server returned an error: ' . $error); 
  251.     $this->_clear_socket(); 
  252.     return FALSE; 
  253.   } 
  254.   /** 
  255.    * Integer reply 
  256.    * 
  257.    * Returns an integer reply 
  258.    * @return int 
  259.    */ 
  260.   private function _integer_reply() 
  261.   { 
  262.     return (int) rtrim(fgets($this->_connection)); 
  263.   } 
  264.   /** 
  265.    * Bulk reply 
  266.    * 
  267.    * Reads to amount of bits to be read and returns value within 
  268.    * the pointer and the ending delimiter 
  269.    * @return string 
  270.    */ 
  271.   private function _bulk_reply() 
  272.   { 
  273.     // How long is the data we are reading? Support waiting for data to 
  274.     // fully return from redis and enter into socket. 
  275.     $value_length = (int) fgets($this->_connection); 
  276.     if ($value_length <= 0) return NULL; 
  277.     $response = ''; 
  278.     // Handle reply if data is less than or equal to 8192 bytes, just read it 
  279.     if ($value_length <= 8192) 
  280.     { 
  281.       $response = fread($this->_connection, $value_length); 
  282.     } 
  283.     else 
  284.     { 
  285.       $data_left = $value_length; 
  286.         // If the data left is greater than 0, keep reading 
  287.         while ($data_left > 0 ) { 
  288.         // If we have more than 8192, only take what we can handle 
  289.         if ($data_left > 8192) 
  290.         { 
  291.           $read_size = 8192; 
  292.         } 
  293.         else 
  294.         { 
  295.           $read_size = $data_left; 
  296.         } 
  297.         // Read our chunk 
  298.         $chunk = fread($this->_connection, $read_size); 
  299.         // Support reading very long responses that don't come through 
  300.         // in one fread 
  301.         $chunk_length = strlen($chunk); 
  302.         while ($chunk_length < $read_size) 
  303.         { 
  304.           $keep_reading = $read_size - $chunk_length; 
  305.           $chunk .= fread($this->_connection, $keep_reading); 
  306.           $chunk_length = strlen($chunk); 
  307.         } 
  308.         $response .= $chunk; 
  309.         // Re-calculate how much data is left to read 
  310.         $data_left = $data_left - $read_size; 
  311.       } 
  312.     } 
  313.     // Clear the socket in case anything remains in there 
  314.     $this->_clear_socket(); 
  315.   return isset($response) ? $response : FALSE; 
  316.   } 
  317.   /** 
  318.    * Multi bulk reply 
  319.    * 
  320.    * Reads n bulk replies and return them as an array 
  321.    * @return array 
  322.    */ 
  323.   private function _multi_bulk_reply() 
  324.   { 
  325.     // Get the amount of values in the response 
  326.     $response = array(); 
  327.     $total_values = (int) fgets($this->_connection); 
  328.     // Loop all values and add them to the response array 
  329.     for ($i = 0; $i < $total_values; $i++) 
  330.     { 
  331.       // Remove the new line and carriage return before reading 
  332.       // another bulk reply 
  333.       fgets($this->_connection, 2); 
  334.       // If this is a second or later pass, we also need to get rid 
  335.       // of the $ indicating a new bulk reply and its length. 
  336.       if ($i > 0) 
  337.       { 
  338.         fgets($this->_connection); 
  339.         fgets($this->_connection, 2); 
  340.       } 
  341.       $response[] = $this->_bulk_reply(); 
  342.     } 
  343.     // Clear the socket 
  344.     $this->_clear_socket(); 
  345.     return isset($response) ? $response : FALSE; 
  346.   } 
  347.   /** 
  348.    * Encode request 
  349.    * 
  350.    * Encode plain-text request to Redis protocol format 
  351.    * @link  http://redis.io/topics/protocol 
  352.    * @param  string request in plain-text 
  353.    * @param  string additional data (string or array, depending on the request) 
  354.    * @return string encoded according to Redis protocol 
  355.    */ 
  356.   private function _encode_request($method, $arguments = array()) 
  357.   { 
  358.     $request = '$' . strlen($method) . self::CRLF . $method . self::CRLF; 
  359.     $_args = 1; 
  360.     // Append all the arguments in the request string 
  361.     foreach ($arguments as $argument) 
  362.     { 
  363.       if (is_array($argument)) 
  364.       { 
  365.         foreach ($argument as $key => $value) 
  366.         { 
  367.           // Prepend the key if we're dealing with a hash 
  368.           if (!is_int($key)) 
  369.           { 
  370.             $request .= '$' . strlen($key) . self::CRLF . $key . self::CRLF; 
  371.             $_args++; 
  372.           } 
  373.           $request .= '$' . strlen($value) . self::CRLF . $value . self::CRLF; 
  374.           $_args++; 
  375.         } 
  376.       } 
  377.       else 
  378.       { 
  379.         $request .= '$' . strlen($argument) . self::CRLF . $argument . self::CRLF; 
  380.         $_args++; 
  381.       } 
  382.     } 
  383.     $request = '*' . $_args . self::CRLF . $request; 
  384.     return $request; 
  385.   } 
  386.   /** 
  387.    * Info 
  388.    * 
  389.    * Overrides the default Redis response, so we can return a nice array 
  390.    * of the server info instead of a nasty string. 
  391.    * @return array 
  392.    */ 
  393.   public function info($section = FALSE) 
  394.   { 
  395.     if ($section !== FALSE) 
  396.     { 
  397.       $response = $this->command('INFO '. $section); 
  398.     } 
  399.     else 
  400.     { 
  401.       $response = $this->command('INFO'); 
  402.     } 
  403.     $data = array(); 
  404.     $lines = explode(self::CRLF, $response); 
  405.     // Extract the key and value 
  406.     foreach ($lines as $line) 
  407.     { 
  408.       $parts = explode(':', $line); 
  409.       if (isset($parts[1])) $data[$parts[0]] = $parts[1]; 
  410.     } 
  411.     return $data; 
  412.   } 
  413.   /** 
  414.    * Debug 
  415.    * 
  416.    * Set debug mode 
  417.    * @param  bool  set the debug mode on or off 
  418.    * @return void 
  419.    */ 
  420.   public function debug($bool) 
  421.   { 
  422.     $this->debug = (bool) $bool; 
  423.   } 
  424.   /** 
  425.    * Destructor 
  426.    * 
  427.    * Kill the connection 
  428.    * @return void 
  429.    */ 
  430.   function __destruct() 
  431.   { 
  432.     if ($this->_connection) fclose($this->_connection); 
  433.   } 
  434. } 
  435. ?> 
  436.  

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

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

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

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

需要注意的是：

（1）你的本地需要安装 redis服务(windows安装)

（2）并开启redis 服务

（3）不管是windows 还是linux 都需要装 php对应版本的 redis扩展

Tags: CI框架 CodeIgniter redis

分享到：

相关文章

推荐文章

热门文章

最新评论文章