重构Redis缓存机制

app/core/cache.py

@@ -1,17 +1,14 @@
 import inspect
-import json
-import pickle
 import threading
 from abc import ABC, abstractmethod
 from functools import wraps
 from typing import Any, Dict, Optional
-from urllib.parse import quote
 
-import redis
 from cachetools import TTLCache
 from cachetools.keys import hashkey
 
 from app.core.config import settings
+from app.helper.redis import RedisHelper
 from app.log import logger
 
 # 默认缓存区
@@ -250,10 +247,6 @@ class RedisBackend(CacheBackend):
     - Pickle 反序列化可能存在安全风险，需进一步重构调用来源，避免复杂对象缓存
     """
 
-    # 类型缓存集合，针对非容器简单类型
-    _complex_serializable_types = set()
-    _simple_serializable_types = set()
-
     def __init__(self, redis_url: Optional[str] = "redis://localhost", ttl: Optional[int] = 1800):
         """
         初始化 Redis 缓存实例
@@ -261,101 +254,13 @@ class RedisBackend(CacheBackend):
         :param redis_url: Redis 服务的 URL
         :param ttl: 缓存的存活时间，单位秒
         """
-        self.redis_url = redis_url
         self.ttl = ttl
+        self._redis_helper = None
         try:
-            self.client = redis.Redis.from_url(
-                redis_url,
-                decode_responses=False,
-                socket_timeout=30,
-                socket_connect_timeout=5,
-                health_check_interval=60,
-            )
-            # 测试连接，确保 Redis 可用
-            self.client.ping()
-            logger.debug(f"Successfully connected to Redis")
-            self.set_memory_limit()
-        except Exception as e:
-            logger.error(f"Failed to connect to Redis: {e}")
-            raise RuntimeError("Redis connection failed") from e
-
-    def set_memory_limit(self, policy: Optional[str] = "allkeys-lru"):
-        """
-        动态设置 Redis 最大内存和内存淘汰策略
-        :param policy: 淘汰策略（如 'allkeys-lru'）
-        """
-        try:
-            # 如果有显式值，则直接使用，为 0 时说明不限制，如果未配置，开启 BIG_MEMORY_MODE 时为 "1024mb"，未开启时为 "256mb"
-            maxmemory = settings.CACHE_REDIS_MAXMEMORY or ("1024mb" if settings.BIG_MEMORY_MODE else "256mb")
-            self.client.config_set("maxmemory", maxmemory)
-            self.client.config_set("maxmemory-policy", policy)
-            logger.debug(f"Redis maxmemory set to {maxmemory}, policy: {policy}")
-        except Exception as e:
-            logger.error(f"Failed to set Redis maxmemory or policy: {e}")
-
-    @staticmethod
-    def is_container_type(t):
-        return t in (list, dict, tuple, set)
-
-    @classmethod
-    def serialize(cls, value: Any) -> bytes:
-        """
-        将值序列化为二进制数据，根据序列化方式标识格式
-        """
-        vt = type(value)
-        # 针对非容器类型使用缓存策略
-        if not cls.is_container_type(vt):
-            # 如果已知需要复杂序列化
-            if vt in cls._complex_serializable_types:
-                return b"PICKLE" + b"\x00" + pickle.dumps(value)
-            # 如果已知可以简单序列化
-            if vt in cls._simple_serializable_types:
-                json_data = json.dumps(value).encode("utf-8")
-                return b"JSON" + b"\x00" + json_data
-            # 对于未知的非容器类型，尝试简单序列化，如抛出异常，再使用复杂序列化
-            try:
-                json_data = json.dumps(value).encode("utf-8")
-                cls._simple_serializable_types.add(vt)
-                return b"JSON" + b"\x00" + json_data
-            except TypeError:
-                cls._complex_serializable_types.add(vt)
-                return b"PICKLE" + b"\x00" + pickle.dumps(value)
-        # 针对容器类型，每次尝试简单序列化，不使用缓存
-        else:
-            try:
-                json_data = json.dumps(value).encode("utf-8")
-                return b"JSON" + b"\x00" + json_data
-            except TypeError:
-                return b"PICKLE" + b"\x00" + pickle.dumps(value)
-
-    @classmethod
-    def deserialize(cls, value: bytes) -> Any:
-        """
-        将二进制数据反序列化为原始值，根据格式标识区分序列化方式
-        """
-        format_marker, data = value.split(b"\x00", 1)
-        if format_marker == b"JSON":
-            return json.loads(data.decode("utf-8"))
-        elif format_marker == b"PICKLE":
-            return pickle.loads(data)
-        else:
-            raise ValueError("Unknown serialization format")
-
-    # @staticmethod
-    # def serialize(value: Any) -> bytes:
-    #     return msgpack.packb(value, use_bin_type=True)
-    #
-    # @staticmethod
-    # def deserialize(value: bytes) -> Any:
-    #     return msgpack.unpackb(value, raw=False)
-
-    def get_redis_key(self, region: str, key: str) -> str:
-        """
-        获取缓存 Key
-        """
-        # 使用 region 作为缓存键的一部分
-        region = self.get_region(quote(region))
-        return f"{region}:key:{quote(key)}"
+            self.redis_helper = RedisHelper(redis_url=redis_url)
+        except RuntimeError as e:
+            logger.warning(f"Redis缓存初始化失败: {e}")
+            raise e
 
     def set(self, key: str, value: Any, ttl: Optional[int] = None,
             region: Optional[str] = DEFAULT_CACHE_REGION, **kwargs) -> None:
@@ -368,15 +273,8 @@ class RedisBackend(CacheBackend):
         :param region: 缓存的区
         :param kwargs: kwargs
         """
-        try:
-            ttl = ttl or self.ttl
-            redis_key = self.get_redis_key(region, key)
-            # 对值进行序列化
-            serialized_value = self.serialize(value)
-            kwargs.pop("maxsize", None)
-            self.client.set(redis_key, serialized_value, ex=ttl, **kwargs)
-        except Exception as e:
-            logger.error(f"Failed to set key: {key} in region: {region}, error: {e}")
+        ttl = ttl or self.ttl
+        self.redis_helper.set(key, value, ttl=ttl, region=region, **kwargs)
 
     def exists(self, key: str, region: Optional[str] = DEFAULT_CACHE_REGION) -> bool:
         """
@@ -386,12 +284,7 @@ class RedisBackend(CacheBackend):
         :param region: 缓存的区
         :return: 存在返回 True，否则返回 False
         """
-        try:
-            redis_key = self.get_redis_key(region, key)
-            return self.client.exists(redis_key) == 1
-        except Exception as e:
-            logger.error(f"Failed to exists key: {key} region: {region}, error: {e}")
-            return False
+        return self.redis_helper.exists(key, region=region)
 
     def get(self, key: str, region: Optional[str] = DEFAULT_CACHE_REGION) -> Optional[Any]:
         """
@@ -401,15 +294,7 @@ class RedisBackend(CacheBackend):
         :param region: 缓存的区
         :return: 返回缓存的值，如果缓存不存在返回 None
         """
-        try:
-            redis_key = self.get_redis_key(region, key)
-            value = self.client.get(redis_key)
-            if value is not None:
-                return self.deserialize(value)  # noqa
-            return None
-        except Exception as e:
-            logger.error(f"Failed to get key: {key} in region: {region}, error: {e}")
-            return None
+        return self.redis_helper.get(key, region=region)
 
     def delete(self, key: str, region: Optional[str] = DEFAULT_CACHE_REGION) -> None:
         """
@@ -418,11 +303,7 @@ class RedisBackend(CacheBackend):
         :param key: 缓存的键
         :param region: 缓存的区
         """
-        try:
-            redis_key = self.get_redis_key(region, key)
-            self.client.delete(redis_key)
-        except Exception as e:
-            logger.error(f"Failed to delete key: {key} in region: {region}, error: {e}")
+        self.redis_helper.delete(key, region=region)
 
     def clear(self, region: Optional[str] = None) -> None:
         """
@@ -430,28 +311,13 @@ class RedisBackend(CacheBackend):
 
         :param region: 缓存的区
         """
-        try:
-            if region:
-                cache_region = self.get_region(quote(region))
-                redis_key = f"{cache_region}:key:*"
-                # self.client.delete(*self.client.keys(redis_key))
-                with self.client.pipeline() as pipe:
-                    for key in self.client.scan_iter(redis_key):
-                        pipe.delete(key)
-                    pipe.execute()
-                logger.info(f"Cleared Redis cache for region: {region}")
-            else:
-                self.client.flushdb()
-                logger.info("Cleared all Redis cache")
-        except Exception as e:
-            logger.error(f"Failed to clear cache, region: {region}, error: {e}")
+        self.redis_helper.clear(region=region)
 
     def close(self) -> None:
         """
         关闭 Redis 客户端的连接池
         """
-        if self.client:
-            self.client.close()
+        self.redis_helper.close()
 
 
 def get_cache_backend(maxsize: Optional[int] = 512, ttl: Optional[int] = 1800) -> CacheBackend: