redis封装类

转载redis封装类

转载连接
(https://blog.csdn.net/weixin_40325128/article/details/82221149)

<?php 
class RedisService
{
	//默认配置参数,根据项目自行读取配置值
	private static $_connectInfo = array(
		'host'=>'127.0.0.1',
		'port'=>6379,
		'auth'=>'123123'
	);
	//报错设置，根据项目读取配置值
	private static $debug = true;
 
	//redis对象的存储变量
	private static  $redisObj;
 
	/**
	 * 实例化自动连接Redis服务
	 * @param array $connectInfo [自定义连接参数数组]
	 */
	public function __construct($connectInfo=array())
	{
		if(!empty($connectInfo))
		{
			self::$_connectInfo = $connectInfo;
		}
		self::RedisConnect();
	}
 
	/**
	 * Redis连接方法
	 */
	private static function RedisConnect()
	{
			
		$redis = new Redis();
		$connectResult=$redis->connect(self::$_connectInfo['host'],self::$_connectInfo['port']);
		if(!$connectResult)
		{
			self::error('Redis connect fail,please check the configure');
		}
		$authVerify=$redis->auth(self::$_connectInfo['auth']);
		if(!$authVerify)
		{
			self::error('The wrong auth ');
		}
		self::$redisObj = $redis;
		
	}
 
 
 
	/**
	 * [rangeToArray 工具函数：范围字符串转换成数组]
	 * @param  [string] $range [范围字符串]
	 * @return [array]        [范围数组]
	 */
	public function rangeToArray($range)
	{
		if(!substr_count($range,'->')||substr_count($range,'->')>1||strpos($range,'->') ==strlen($range)-1)
		{
			self::error("The range need to like a->b");
		}
		$rangeArr = explode('->',$range);
		return $rangeArr;
	}
 
	
	/**
	 * [is_array 是否为数组检查方法]
	 * @param  [array]  $var       [检查对象]
	 * @param  [string]  $methodName [请求方法]
	 * @return [boolean]             [检查结果]
	 */
	private function arrayCheck($var,$methodName)
	{	
		if(!is_array($var))
		{
			self::error("function $methodName : the param must be an array");
		}
	}
 
 
	/**
	 * [stringCheck 是否为字符串检查方法]
	 * @param  [number] $var        [检查对象]
	 * @param  [string] $methodName [请求方法]
	 * @return [boolean]             [检查结果]
	 */
	private function stringCheck($var,$methodName)
	{
		if(!is_string($var))
		{
			self::error("function $methodName : the param must be string type ");
		}
	}
 
	/**
	 * [numberCheck description]
	 * @param  [number] $var        [检查对象]
	 * @param  [string] $methodName [请求方法]
	 * @return [boolean]             [检查结果]
	 */
	private static function numberCheck($var,$methodName)
	{
 
		$preg="/^[0-9]+([.]{1}[0-9]+){0,1}$/";
		$matchResult=preg_match($preg,$var);
		if(!$matchResult)
		{
			self::error("function $methodName: the value for current key is not a number");
		}
	}
 
 
 
	/**
	 * [error 报错方法]
	 * @param  [string] $msg [报错信息]
	 */
	private static function error($msg)
	{
		if(self::$debug)
		{
			echo $msg;
		}
 
		die();
	}
	/**
	 * [set 字符串类型 key->value设置]
	 * @param [string] $key   [键名]
	 * @param [string] $value [键值]
	 * @param [int] $expire [过期时间]
	 * 
	 */
	public function set($key,$value,$expire=null)
	{
		if(!isset($key)||!isset($value))
		{
			self::error('function set lack of params');
		}
		self::stringCheck($key,__FUNCTION__)&&self::stringCheck($value,__FUNCTION__);
		if(!$expire)
		{
			return self::$redisObj->set($key,$value);
		}
		else
		{
			return self::$redisObj->setex($key,$expire,$value);
		}
	}
 
 
	/**
	 * [get 字符串类型 key->value获取]
	 * @param  [string] $key [键名]
	 * @return [string]      [返回值]
	 */
	public function get($key)
	{
		return self::$redisObj->get($key);
	}
 
	/**
	 * [mset 字符串类型 同时设置多个]
	 * @param  [array] $data [键值对数组]
	 * @return [boolean]       [返回值]
	 */
	public function mset($data)
	{
		self::arrayCheck($data,__FUNCTION__);
		foreach($data as $k => $v)
		{
			 $childResult = $this->set($k,$v);
			 if(!$childResult)
			 {
			 	self::error($k."->".$v."write fail,the program ends");
			 }
		}
		return true;
	}
 
 
	/**
	 * [mget 字符串类型根据多个键名获取值]
	 * @param  [array] $keys [key数组]
	 * @return [array]       [key=>value数组]
	 */
	public function mget($keys)
	{
		self::arrayCheck($keys,__FUNCTION__);
		$return=array();
		foreach($keys as $key)
		{
			if(!is_string($key))
			{
				self::error("function ".__FUNCTION__.": elements  all should be string type");
			}
			$value= $this->get($key);
			if($value)
			{
				$return[$key] = $value;
			}
		}
		return $return;
	}
 
	/**
	 * [delete 删除键统一操作函数]
	 * @param  [string] $key [键名]
	 * @return [int]      [受影响行]
	 */
	public function deleteKey($key)
	{
		self::stringCheck($key,__FUNCTION__);
		return self::$redisObj->delete($key);
	}
 
 
	/**
	 * [alterNumber 字符串类型修改数字键值]
	 * @param  [string] $key   [键名]
	 * @param  [int] $range [修改范围]
	 * @return [boolean]        [是否修改成功]
	 */
	public function alterNumber($key,$range=0)
	{
		self::stringCheck($key,__FUNCTION__);
		//变更范围不为0
		if(!$range)
		{
			self::error("function ".__FUNCTION__.": the changed range can not be 0 ");
		}
		$value=$this->get($key);
		if($value===false)
		{
			self::error("function ".__FUNCTION__.":the value for key ".$key." is no exist");
		}
		//是不是数字类型
		self::numberCheck(abs($value),__FUNCTION__);
		//统一使用incrByFloat
		$result=self::$redisObj->incrByFloat($key,$range);
		return boolval($result);
	}
 
 
	/**
	 * [hashSet 哈希类型设置函数]
	 * @param  [string] $key    [键名]
	 * @param  [array] $array  [hash array]
	 * @param  [int] $expire [过期时间,不传之默认永久]
	 * @return [boolean]         [是否成功]
	 */
	public function hashSet($key,$array,$expire=null)
	{
		self::stringCheck($key,__FUNCTION__);
		if(count($array)>=1)
		{	
			 $flag=true;
			 $keySet=self::$redisObj->hmset($key,$array);
			 if($expire)
			 {
			 	$flag=self::$redisObj->setTimeOut($key,$expire);
			 }
			 return $keySet&&$flag;
		}
	}
 
	/**
	 * [hashGet 获取哈希对象函数]
	 * @param  [type] $key        [键名]
	 * @param  array  $fieldArray [field数组 不传值获取全部]
	 * @return [type]             [结果数组]
	 */
	public function hashGet($key,$fieldArray=array())
	{
		self::stringCheck($key,__FUNCTION__);
		if(empty($fieldArray))
		{
			return self::$redisObj->hGetAll($key);
		}
		else
		{
			if(is_array($fieldArray)&&!empty($fieldArray))
			{
				return self::$redisObj->hmget($key,$fieldArray);
			}
		}
		
	}
 
 
	/**
	 * [hashAlterNumber hash数字类型修改函数]
	 * @param  [string]  $key   [键名]
	 * @param  [string]  $field [修改字段]
	 * @param  integer/float $range [修改范围]
	 * @return [boolean]         [是否修改成功]
	 */
	public function hashAlterNumber($key,$field,$range=0)
	{
		//变更范围不为0
		if(!$range)
		{
			self::error("function ".__FUNCTION__.": the changed range can not be 0 ");
		}
		$valueArray=$this->hashGet($key,array($field));
		//是否有值
		if($valueArray[$field]===false)
		{
			self::error("function ".__FUNCTION__.":the field <b>".$field."</b> is no exist in hash key <b>".$key."</b>");
		}
		//值是不是数字类型
		self::numberCheck(abs($valueArray[$field]),__FUNCTION__);
		//统一使用hIncrByFloat
		$result=self::$redisObj->hIncrByFloat($key,$field,$range);
		return boolval($result);
	}
 
 
	/**
	 * [RemoveHashField 哈希类型移除字段函数]
	 * @param [string] $key   [键名]
	 * @param [string] $field [字段名]
	 * @return [boolean] [是否移除成功]
	 */
	public function RemoveHashField($key,$field)
	{
		$valueArray=$this->hashGet($key,array($field));
		//是否有值
		if($valueArray[$field]===false)
		{
			self::error("function ".__FUNCTION__.":the field <b>".$field."</b> is no exist in hash key <b>".$key."</b>");
		}
		$result=self::$redisObj->hdel($key,$field);
		return boolval($result);
	}
 
 
	/**
	 * [push 列表添加函数]
	 * @param  [string] $key      [列表键名]
	 * @param  [string] $li       [元素值]
	 * @param  string $pushType [left/right]
	 * @return [boolean]           [是否添加成功]
	 */
	public function push($key,$li,$pushType='left')
	{
		self::stringCheck($key,__FUNCTION__);
		$action=$pushType=='right'?'rPush':'lPush';
		$result=self::$redisObj->$action($key,$li);
		return boolval($result);
	}	
 
	/**
	 * [getList 列表获取函数]
	 * @param  [string]  $key   [键名]
	 * @param  integer $range [索引范围]
	 * @return [array]         [结果数组]
	 */
	public function getList($key,$range="0->-1",$isSerialize=false)
	{
		$rangeArray=$this->rangeToArray($range);
		if(!$isSerialize)
		{
			return self::$redisObj->lrange($key,$rangeArray[0],$rangeArray[1]);
		}
		else
		{
			$result = self::$redisObj->lrange($key,$rangeArray[0],$rangeArray[1]);
			foreach($result as $value)
			{
				$return[]=unserialize($value);
			}
			return $return;
		}
		
	} 	
 
	/**
	 * [pop 列表弹出函数]
	 * @param  [string] $key     [键名]
	 * @param  string $popType [弹出类型 right/left]
	 * @return [string]          [弹出元素]
	 */
	public function pop($key,$popType="right",$waitingTime=false)
	{
		self::stringCheck($key,__FUNCTION__);
		if($waitingTime===false)
		{
			$action=$popType=='left'?'lPop':'rPop';
			return self::$redisObj->$action($key);
		}
		else
		{
			$action=$popType=='left'?'blPop':'brPop';
			return self::$redisObj->$action($key,$waitingTime);
		}
	}
	/**
	 * [getListLen 列表长度获取函数]
	 * @param  [string] $key [键名]
	 * @return [int]      [长度]
	 */
	public function getListLen($key)
	{
		self::stringCheck($key,__FUNCTION__);
		return self::$redisObj->llen($key);
	}
 
 
	/**
	 * [getEleByListIndex description]
	 * @param  [string] $key   [键名]
	 * @param  [int] $index [索引]
	 * @return [string]        [元素值]
	 */
	public function getEleByListIndex($key,$index)
	{
		self::stringCheck($key,__FUNCTION__);
		return self::$redisObj->lindex($key,$index);
	}
 
	/**
	 * [setEleByListIndex 根据索引设置list元素值函数]
	 * @param [string] $key   [键名]
	 * @param [int] $index [索引]
	 * @param [boolean] $value [是否设置成功]
	 */
	public function setEleByListIndex($key,$index,$value)
	{
		self::stringCheck($key,__FUNCTION__);
		return self::$redisObj->lSet($key,$index,$value);
	}
 
 
	/**
	 * [removeListEle 列表元素移除函数]
	 * @param  [string] $key       [键名]
	 * @param  [int] $removeNum [删除个数 >0:从表头开始N个  <0:从表尾开始N个 =0:所有 ]
	 * @param  [string] $eleValue  [删除元素的值]
	 * @return [int]            [实际删除的个数]
	 */
	public function removeListEle($key,$removeNum,$eleValue)
	{
		self::stringCheck($key,__FUNCTION__);
		return self::$redisObj->lrem($key,$eleValue,$removeNum);
	}
 
	/**
	 * [cutList 链表裁剪函数]
	 * @param  [string]  $key   [键名]
	 * @param  [integer]  $start [截取开始索引]
	 * @param  integer $end   [截取结束索引,默认-1截取到最后]
	 * @return [boolean]         [截取是否成功]
	 */
	public function cutList($key,$start,$end=-1)
	{
		self::stringCheck($key,__FUNCTION__);
		return self::$redisObj->ltrim($key,$start,$end);
	}
 
 
	/**
	 * [addSet 集合添加成员函数]
	 * @param [string] $key    [键名]
	 * @param [string] $member [成员]
	 */
	public function addSet($key,$member)
	{
		self::stringCheck($key,__FUNCTION__);
		$result = self::$redisObj->sAdd($key,$member);
		return boolval($result);
	}
 
 
 
	/**
	 * [getSet 获取集合成员函数]
	 * @param  [string] $key [键名]
	 * @return [array]      [成员数组]
	 */
	public function getSet($key)
	{
		self::stringCheck($key,__FUNCTION__);
		return self::$redisObj->sMembers($key);
	}
 
 
 
	/**
	 * [isInSet description]
	 * @param  [string]  $members [成员]
	 * @param  [string]  $key     [键名]
	 * @return boolean          [是否在集合中]
	 */
	public function isInSet($members,$key)
	{
		self::stringCheck($key,__FUNCTION__);
		return self::$redisObj->sismember($key,$members);
	}
 
 
 
	/**
	 * [countSet 集合成员数量统计函数]
	 * @param  [string] $key [键名]
	 * @return [integer]      [成员数量]
	 */
	public function countSet($key)
	{
		self::stringCheck($key,__FUNCTION__);
		return self::$redisObj->scard($key);
	}
 
 
	/**
	 * [randMemberFromSet description]
	 * @param  [string]  $key     [键名]
	 * @param  integer $numbers [数量]
	 * @return [array]           [成员数组]
	 */
	public function randMemberFromSet($key,$numbers=1)
	{
		self::stringCheck($key,__FUNCTION__);
		return self::$redisObj->sRandMember($key,$numbers);
	}
 
 
	/**
	 * [removeMemberFromSet 从集合中移除成员]
	 * @param  [string] $key    [键名]
	 * @param  [string] $member [成员]
	 * @return [boolean]         [是否移除成功]
	 */
	public function removeMemberFromSet($key,$member)
	{
		self::stringCheck($key,__FUNCTION__);
		$result = self::$redisObj->srem($key,$member);
		return boolval($result);
	}	
 
 
	/**
	 * [moveSetMemberTo 成员移动函数]
	 * @param  [string] $member    [成员]
	 * @param  [string] $sourceSet [源集合]
	 * @param  [string] $targetSet [目标集合]
	 * @return [boolean]            [是否成功]
	 */
	public function moveSetMemberTo($member,$sourceSet,$targetSet)
	{
		self::stringCheck($sourceSet,__FUNCTION__);
		self::stringCheck($targetSet,__FUNCTION__);
		$result = self::$redisObj->smove($sourceSet,$targetSet,$member);
		return boolval($result);
	}
 
 
	/**
	 * [getDiffFromSets 获取多个集合的差集函数]
	 * @param  [string] $sets [多个集合]
	 * @return [array]       [差集数组]
	 */
	public function getDiffFromSets(...$sets)
	{
		return self::$redisObj->sDiff(...$sets);
	}
 
 
	/**
	 * [getInterFromSets 获取多个集合交集函数]
	 * @param  [string] $sets [多个集合]
	 * @return [array]       [交集数组]
	 */
	public function getInterFromSets(...$sets)
	{
		return self::$redisObj->sInter(...$sets);
	}
 
 
	/**
	 * [getUnionFromSets 获取多个集合并集函数]
	 * @param  [string] $sets [多个集合]
	 * @return [array]       [并集数组]
	 */
	public function getUnionFromSets(...$sets)
	{
		return self::$redisObj->sUnion(...$sets);
	}
 
 
	/**
	 * [addZset 有序集合成员添加/更新 函数]
	 * @param [string] $key       [键名]
	 * @param [array] $zsetArray  [数组  键值=>分数]
	 */
	public function addZset($key,$zsetArray)
	{
		self::stringCheck($key,__FUNCTION__);
		$scoreArr=[$key];
		foreach($zsetArray as $k => $v)
		{
			array_push($scoreArr,$v,$k);
		}	
		$result = self::$redisObj->zAdd(...$scoreArr);
		return boolval($result);
	}
 
	/**
	 * [getZsetByIndexRange 根据索引获取有序集合函数  默认顺序 /倒序]
	 * @param  [string]  $key     [键名]
	 * @param  integer $range     [索引范围]
	 * @param  boolean $scoreShow [是否显示分数]
	 * @param  string  $order     [排序规则 默认顺序]
	 * @return [type]             [成员数组]
	 */
	public function getZsetByIndexRange($key,$range="0->-1",$scoreShow=false,$order="ASC")
	{
		self::stringCheck($key,__FUNCTION__);
		$rangeArray=$this->rangeToArray($range);
		$action = $order === 'ASC'? 'zRange':'zReverseRange';
		return self::$redisObj->$action($key,$rangeArray[0],$rangeArray[1],$scoreShow);
	}
 
 
 
	/**
	 * [getZsetByScoreRange 根据分数获取有序集合成员函数 ]
	 * @param  [type]  $key       [键名]
	 * @param  [type]  $start     [开始分数]
	 * @param  [type]  $end       [结束分数]
	 * @param  boolean $scoreShow [是否显示分数]
	 * @param  string  $order     [结果排序]
	 * @return [type]             [成员数组]
	 */
	public function getZsetByScoreRange($key,$range,$scoreShow=true,$order="ASC")
	{
		self::stringCheck($key,__FUNCTION__);
		$rangeArray=$this->rangeToArray($range);
		$scoreShow=$scoreShow?array("withscores"=>true) : array("withscores"=>false);
		if($order==='ASC')
		{
			return self::$redisObj->zRangeByScore($key,$rangeArray[0],$rangeArray[1],$scoreShow);
		}
		else
		{
			return self::$redisObj->zRevRangeByScore($key,$rangeArray[1],$rangeArray[0],$scoreShow);
		}
	}
 
 
	/**
	 * [countZset 获取有序集合总成员数量]
	 * @param  [string] $key [键名]
	 * @return [integer]      [成员数量]
	 */
	public function countZset($key)
	{
		self::stringCheck($key,__FUNCTION__);
		return self::$redisObj->zCard($key);
	}
 
 
 
	/**
	 * [countZsetByScoreRange 获取分数区间内成员数量]
	 * @param  [string] $key   [键名]
	 * @param  [string] $range [分数范围]
	 * @return [integer]        [成员数量]
	 */
	public function countZsetByScoreRange($key,$range)
	{
		self::stringCheck($key,__FUNCTION__);
		$rangeArray=$this->rangeToArray($range);
		return self::$redisObj->zCount($key,$rangeArray[0],$rangeArray[1]);
	}
 
 
 
	/**
	 * [getZsetScore 根据成员获取分数值]
	 * @param  [string] $key   [键名]
	 * @param  [string] $member [键值]
	 * @return [float]        [分数]
	 */
	public function getZsetScore($key,$member)
	{
		self::stringCheck($key,__FUNCTION__);
		return self::$redisObj->zScore($key,$member);
	}
 
 
	/**
	 * [getZsetIndex 获取成员排名(索引)]
	 * @param  [string] $key   [键名]
	 * @param  [string] $member [键值]
	 * @param  [string] $order [排序]
	 * @return [integer]       [排名(索引)]
	 */
	public function getZsetRank($key,$member,$order="ASC")
	{
		self::stringCheck($key,__FUNCTION__);
		$action = $order==='ASC'?'zRank':'zRevRank';
		return self::$redisObj->$action($key,$member);
	}
 
 
	/**
	 * [removeZsetMember 删除zSet成员函数]
	 * @param  [type] $key     [description]
	 * @param  [type] $members [description]
	 * @return [type]          [description]
	 */
	public function removeZsetMembers($key,$members)
	{
		self::stringCheck($key,__FUNCTION__);
		self::arrayCheck($members,__FUNCTION__);
		$memberArray[]=$key;
		foreach($members as $k => $v)
		{
			array_push($memberArray,$v);
		}
		$result = self::$redisObj->zRem(...$memberArray);
		return boolval($result);
	}
 
 
	/**
	 * [removeZsetMembersByScore zSet根据分数范围删除成员]
	 * @param  [string] $key        [键名]
	 * @param  [string] $scoreRange [分数范围]
	 * @return [boolean]             [是否删除成功]
	 */
	public function removeZsetMembersByScore($key,$scoreRange)
	{
		self::stringCheck($key,__FUNCTION__);
		$rangeArray=$this->rangeToArray($scoreRange);
		$result = self::$redisObj->zRemRangeByScore($key,$rangeArray[0],$rangeArray[1]);
		return boolval($result);
	}
 
	/**
	 * [alterZsetScore zSet分数操作函数]
	 * @param  [string] $key   [键名]
	 * @param  [string] $value [成员]
	 * @param  [integer] $range [变更范围]
	 * @return [float]        [修改后结果]
	 */
	public function alterZsetScore($key,$value,$range)
	{
		self::stringCheck($key,__FUNCTION__);
		if(!$range)
		{
			self::error("function ".__FUNCTION__.": the changed range can not be 0 ");
		}
		$score=$this->getZsetScore($key,$value);
		//是不是数字类型
		self::numberCheck(abs($value),__FUNCTION__);
		return self::$redisObj->zIncrBy($key,$range,$value);
	}
	
 
	/**
	 * [storeInterFromZsets 多个zSet求交集并存储,存储结果的score是交集每个成员score的和]
	 * 调用提示:
	 * $redis->storeInterFromZsets('myZsetAll',array('myZset1','myZset2'));
	 */
	
	public function storeInterFromZsets(...$zSets)
	{
		return self::$redisObj->zinterstore(...$zSets);
	}
	
 
	/**
	 * [storeUnionFromZsets 多个zSet求并集并存储,存储结果的score是并集成员score的和]
	 * @param  [type] $zSets [description]
	 * 调用提示
	 * $redis->storeUnionFromZsets('myZsetAll',array('myZset1','myZset2'));
	 */
	public function storeUnionFromZsets(...$zSets)
	{
		return self::$redisObj->zunionstore(...$zSets);
	}
}