283 lines
8.9 KiB
Python
283 lines
8.9 KiB
Python
import json
|
|
import logging
|
|
from typing import Any, Optional, List
|
|
|
|
from app.client.redis_client_manager import redis_client_manager
|
|
|
|
logger = logging.getLogger(__name__)
|
|
|
|
|
|
class RedisUtils:
|
|
@staticmethod
|
|
async def get(key: str) -> Optional[str]:
|
|
try:
|
|
return await redis_client_manager.client.get(key)
|
|
except Exception as e:
|
|
logger.error(f"Redis get error: {e}")
|
|
return None
|
|
|
|
@staticmethod
|
|
async def set(key: str, value: str, expire_seconds: Optional[int] = None) -> bool:
|
|
try:
|
|
if expire_seconds:
|
|
await redis_client_manager.client.set(key, value, ex=expire_seconds)
|
|
else:
|
|
await redis_client_manager.client.set(key, value)
|
|
return True
|
|
except Exception as e:
|
|
logger.error(f"Redis set error: {e}")
|
|
return False
|
|
|
|
@staticmethod
|
|
async def delete(key: str) -> bool:
|
|
try:
|
|
await redis_client_manager.client.delete(key)
|
|
return True
|
|
except Exception as e:
|
|
logger.error(f"Redis delete error: {e}")
|
|
return False
|
|
|
|
@staticmethod
|
|
async def exists(key: str) -> bool:
|
|
try:
|
|
return await redis_client_manager.client.exists(key) > 0
|
|
except Exception as e:
|
|
logger.error(f"Redis exists error: {e}")
|
|
return False
|
|
|
|
@staticmethod
|
|
async def expire(key: str, seconds: int) -> bool:
|
|
try:
|
|
return await redis_client_manager.client.expire(key, seconds)
|
|
except Exception as e:
|
|
logger.error(f"Redis expire error: {e}")
|
|
return False
|
|
|
|
@staticmethod
|
|
async def get_json(key: str) -> Optional[Any]:
|
|
try:
|
|
value = await redis_client_manager.client.get(key)
|
|
if value:
|
|
return json.loads(value)
|
|
return None
|
|
except json.JSONDecodeError:
|
|
logger.error(f"Redis get_json error: Invalid JSON")
|
|
return None
|
|
except Exception as e:
|
|
logger.error(f"Redis get_json error: {e}")
|
|
return None
|
|
|
|
@staticmethod
|
|
async def set_json(key: str, value: Any, expire_seconds: Optional[int] = None) -> bool:
|
|
try:
|
|
json_str = json.dumps(value, ensure_ascii=False)
|
|
return await RedisUtils.set(key, json_str, expire_seconds)
|
|
except Exception as e:
|
|
logger.error(f"Redis set_json error: {e}")
|
|
return False
|
|
|
|
@staticmethod
|
|
async def hget(key: str, field: str) -> Optional[str]:
|
|
try:
|
|
return await redis_client_manager.client.hget(key, field)
|
|
except Exception as e:
|
|
logger.error(f"Redis hget error: {e}")
|
|
return None
|
|
|
|
@staticmethod
|
|
async def hset(key: str, field: str, value: str) -> bool:
|
|
try:
|
|
await redis_client_manager.client.hset(key, field, value)
|
|
return True
|
|
except Exception as e:
|
|
logger.error(f"Redis hset error: {e}")
|
|
return False
|
|
|
|
@staticmethod
|
|
async def hgetall(key: str) -> Optional[dict]:
|
|
try:
|
|
return await redis_client_manager.client.hgetall(key)
|
|
except Exception as e:
|
|
logger.error(f"Redis hgetall error: {e}")
|
|
return None
|
|
|
|
@staticmethod
|
|
async def hdel(key: str, field: str) -> bool:
|
|
try:
|
|
await redis_client_manager.client.hdel(key, field)
|
|
return True
|
|
except Exception as e:
|
|
logger.error(f"Redis hdel error: {e}")
|
|
return False
|
|
|
|
@staticmethod
|
|
async def lpush(key: str, *values: Any) -> int:
|
|
try:
|
|
return await redis_client_manager.client.lpush(key, *values)
|
|
except Exception as e:
|
|
logger.error(f"Redis lpush error: {e}")
|
|
return 0
|
|
|
|
@staticmethod
|
|
async def rpush(key: str, *values: Any) -> int:
|
|
try:
|
|
return await redis_client_manager.client.rpush(key, *values)
|
|
except Exception as e:
|
|
logger.error(f"Redis rpush error: {e}")
|
|
return 0
|
|
|
|
@staticmethod
|
|
async def lpop(key: str) -> Optional[str]:
|
|
try:
|
|
return await redis_client_manager.client.lpop(key)
|
|
except Exception as e:
|
|
logger.error(f"Redis lpop error: {e}")
|
|
return None
|
|
|
|
@staticmethod
|
|
async def rpop(key: str) -> Optional[str]:
|
|
try:
|
|
return await redis_client_manager.client.rpop(key)
|
|
except Exception as e:
|
|
logger.error(f"Redis rpop error: {e}")
|
|
return None
|
|
|
|
@staticmethod
|
|
async def llen(key: str) -> int:
|
|
try:
|
|
return await redis_client_manager.client.llen(key)
|
|
except Exception as e:
|
|
logger.error(f"Redis llen error: {e}")
|
|
return 0
|
|
|
|
@staticmethod
|
|
async def lrange(key: str, start: int, end: int) -> List[str]:
|
|
try:
|
|
return await redis_client_manager.client.lrange(key, start, end)
|
|
except Exception as e:
|
|
logger.error(f"Redis lrange error: {e}")
|
|
return []
|
|
|
|
@staticmethod
|
|
async def incr(key: str) -> int:
|
|
try:
|
|
return await redis_client_manager.client.incr(key)
|
|
except Exception as e:
|
|
logger.error(f"Redis incr error: {e}")
|
|
return 0
|
|
|
|
@staticmethod
|
|
async def decr(key: str) -> int:
|
|
try:
|
|
return await redis_client_manager.client.decr(key)
|
|
except Exception as e:
|
|
logger.error(f"Redis decr error: {e}")
|
|
return 0
|
|
|
|
@staticmethod
|
|
async def sadd(key: str, *members: Any) -> int:
|
|
try:
|
|
return await redis_client_manager.client.sadd(key, *members)
|
|
except Exception as e:
|
|
logger.error(f"Redis sadd error: {e}")
|
|
return 0
|
|
|
|
@staticmethod
|
|
async def smembers(key: str) -> List[str]:
|
|
try:
|
|
return await redis_client_manager.client.smembers(key)
|
|
except Exception as e:
|
|
logger.error(f"Redis smembers error: {e}")
|
|
return []
|
|
|
|
@staticmethod
|
|
async def srem(key: str, *members: Any) -> int:
|
|
try:
|
|
return await redis_client_manager.client.srem(key, *members)
|
|
except Exception as e:
|
|
logger.error(f"Redis srem error: {e}")
|
|
return 0
|
|
|
|
@staticmethod
|
|
async def zadd(key: str, mapping: dict) -> int:
|
|
try:
|
|
return await redis_client_manager.client.zadd(key, mapping)
|
|
except Exception as e:
|
|
logger.error(f"Redis zadd error: {e}")
|
|
return 0
|
|
|
|
@staticmethod
|
|
async def zrange(key: str, start: int, end: int, withscores: bool = False) -> List[str]:
|
|
try:
|
|
return await redis_client_manager.client.zrange(key, start, end, withscores=withscores)
|
|
except Exception as e:
|
|
logger.error(f"Redis zrange error: {e}")
|
|
return []
|
|
|
|
@staticmethod
|
|
async def keys(pattern: str) -> List[str]:
|
|
try:
|
|
return await redis_client_manager.client.keys(pattern)
|
|
except Exception as e:
|
|
logger.error(f"Redis keys error: {e}")
|
|
return []
|
|
|
|
@staticmethod
|
|
async def flush_db() -> bool:
|
|
try:
|
|
await redis_client_manager.client.flushdb()
|
|
return True
|
|
except Exception as e:
|
|
logger.error(f"Redis flush_db error: {e}")
|
|
return False
|
|
|
|
|
|
class RedisSyncUtils:
|
|
@staticmethod
|
|
def get(key: str) -> Optional[str]:
|
|
try:
|
|
return redis_client_manager.sync_client.get(key)
|
|
except Exception as e:
|
|
logger.error(f"Redis sync get error: {e}")
|
|
return None
|
|
|
|
@staticmethod
|
|
def set(key: str, value: str, expire_seconds: Optional[int] = None) -> bool:
|
|
try:
|
|
if expire_seconds:
|
|
redis_client_manager.sync_client.set(key, value, ex=expire_seconds)
|
|
else:
|
|
redis_client_manager.sync_client.set(key, value)
|
|
return True
|
|
except Exception as e:
|
|
logger.error(f"Redis sync set error: {e}")
|
|
return False
|
|
|
|
@staticmethod
|
|
def delete(key: str) -> bool:
|
|
try:
|
|
redis_client_manager.sync_client.delete(key)
|
|
return True
|
|
except Exception as e:
|
|
logger.error(f"Redis sync delete error: {e}")
|
|
return False
|
|
|
|
@staticmethod
|
|
def get_json(key: str) -> Optional[Any]:
|
|
try:
|
|
value = redis_client_manager.sync_client.get(key)
|
|
if value:
|
|
return json.loads(value)
|
|
return None
|
|
except Exception as e:
|
|
logger.error(f"Redis sync get_json error: {e}")
|
|
return None
|
|
|
|
@staticmethod
|
|
def set_json(key: str, value: Any, expire_seconds: Optional[int] = None) -> bool:
|
|
try:
|
|
json_str = json.dumps(value, ensure_ascii=False)
|
|
return RedisSyncUtils.set(key, json_str, expire_seconds)
|
|
except Exception as e:
|
|
logger.error(f"Redis sync set_json error: {e}")
|
|
return False |