本文目录导读：
我来详细说明Python脚本中缓存键值命名的规范规则：
基本原则
命名格式
[prefix]:[entity]:[field]:[identifier]:[version/suffix]示例
# 通用格式 "app:user:profile:12345:v1" "cache:product:price:67890" "session:token:abc123"
具体规范规则
使用分隔符
# 推荐使用冒号(:)作为分隔符
KEY_TEMPLATE = "{prefix}:{entity}:{action}:{id}"
# 不推荐
"user_12345_profile" # 使用下划线和数字混合难以解析
"user12345" # 缺乏结构化信息
支持命名空间
class CacheKeys:
"""缓存键管理类"""
@staticmethod
def user_profile(user_id: int) -> str:
return f"user:profile:{user_id}:v1"
@staticmethod
def product_detail(product_id: int) -> str:
return f"product:detail:{product_id}:v2"
@staticmethod
def order_list(user_id: int, page: int) -> str:
return f"user:{user_id}:orders:page:{page}"
实际应用示例
使用函数生成键
import hashlib
from typing import Optional
class CacheKeyGenerator:
"""缓存键生成器"""
def __init__(self, prefix: str = "app"):
self.prefix = prefix
self.version = "v1"
def user_key(self, user_id: int, field: str = "profile") -> str:
"""用户相关缓存键"""
return f"{self.prefix}:user:{field}:{user_id}:{self.version}"
def product_key(self, product_id: int) -> str:
"""产品缓存键"""
return f"{self.prefix}:product:detail:{product_id}:{self.version}"
def list_key(self, entity: str, filters: dict) -> str:
"""列表缓存键（根据参数生成唯一键）"""
# 对过滤条件进行排序和哈希
sorted_filters = sorted(filters.items())
filter_hash = hashlib.md5(
str(sorted_filters).encode()
).hexdigest()[:8]
return f"{self.prefix}:{entity}:list:{filter_hash}:{self.version}"
使用枚举管理键名
from enum import Enum
class CacheNamespace(str, Enum):
"""缓存命名空间枚举"""
USER = "user"
PRODUCT = "product"
ORDER = "order"
SESSION = "session"
class CacheField(str, Enum):
"""缓存字段枚举"""
PROFILE = "profile"
DETAIL = "detail"
LIST = "list"
TOKEN = "token"
class CacheKeys:
"""统一的缓存键生成"""
@staticmethod
def generate(
namespace: CacheNamespace,
field: CacheField,
identifier: str,
version: str = "v1"
) -> str:
return f"{namespace.value}:{field.value}:{identifier}:{version}"
# 使用示例
@staticmethod
def user_profile(user_id: int) -> str:
return CacheKeys.generate(
CacheNamespace.USER,
CacheField.PROFILE,
str(user_id)
)
高级命名策略
版本控制
class VersionedCacheKey:
"""带版本控制的缓存键"""
def __init__(self, prefix: str, version: int = 1):
self.base_prefix = prefix
self.cache_version = version
def get_key(self, entity: str, identifier: str) -> str:
"""获取带版本的缓存键"""
return f"{self.base_prefix}:{entity}:{identifier}:v{self.cache_version}"
def invalidate_old_keys(self, entity: str) -> None:
"""使旧版本键失效"""
old_version = self.cache_version - 1
pattern = f"{self.base_prefix}:{entity}:*:v{old_version}"
# 调用缓存删除操作
# redis_client.delete_by_pattern(pattern)
复合键处理
from dataclasses import dataclass
from typing import Dict, Any
@dataclass
class CompositeCacheKey:
"""复合缓存键"""
namespace: str
entity: str
identifiers: Dict[str, Any]
version: str = "v1"
def __str__(self) -> str:
# 对标识符进行排序确保一致性
sorted_ids = sorted(self.identifiers.items())
id_parts = [f"{k}:{v}" for k, v in sorted_ids]
return f"{self.namespace}:{self.entity}:" + ":".join(id_parts) + f":{self.version}"
@classmethod
def from_params(cls, **kwargs) -> 'CompositeCacheKey':
"""从参数创建缓存键"""
version = kwargs.pop('_version', 'v1')
namespace = kwargs.pop('_namespace', 'app')
entity = kwargs.pop('_entity', 'default')
return cls(namespace, entity, kwargs, version)
# 使用示例
key = CompositeCacheKey.from_params(
_entity="user",
user_id=123,
role="admin",
status="active",
_version="v2"
)
print(str(key)) # app:user:role:admin:status:active:user_id:123:v2
最佳实践总结
命名规则清单
- 使用小写字母：
"user:profile:123" - 使用冒号分隔：
"app:user:profile:123" - 包含版本信息：
"user:profile:123:v2" - 适当的长度控制：不超过128字符
- 避免特殊字符：只使用字母、数字、冒号
工具函数示例
import re
from typing import List
class CacheKeyValidator:
"""缓存键验证器"""
@staticmethod
def validate(key: str) -> bool:
"""验证缓存键格式"""
pattern = r'^[a-z]+:[a-z]+:[a-z0-9_-]+(:[a-z0-9]+)*$'
return bool(re.match(pattern, key))
@staticmethod
def parse(key: str) -> List[str]:
"""解析缓存键返回各部分"""
return key.split(':')
@staticmethod
def sanitize(key_part: str) -> str:
"""清理键的某一部分"""
# 只保留字母、数字、下划线和连字符
return re.sub(r'[^a-z0-9_-]', '', key_part.lower())
# 使用示例
validator = CacheKeyValidator()
key = "user:profile:123:v1"
if validator.validate(key):
parts = validator.parse(key)
print(f"命名空间: {parts[0]}")
print(f"实体: {parts[1]}")
print(f"ID: {parts[2]}")
print(f"版本: {parts[3]}")
这样的命名规则确保了缓存键的可读性、可维护性和可扩展性,同时也便于进行缓存管理和调试。
