From 90886c62a62ecbd64c9b229b48e4ef2cf600ae43 Mon Sep 17 00:00:00 2001
From: Administrator <admin@example.com>
Date: 星期四, 03 八月 2023 16:34:21 +0800
Subject: [PATCH] redis上级缓存添加

---
 code_attribute/gpcode_manager.py |  186 +++++++++++++++++++++++++++-------------------
 1 files changed, 109 insertions(+), 77 deletions(-)

diff --git a/code_attribute/gpcode_manager.py b/code_attribute/gpcode_manager.py
index 40ca2a9..3c53c02 100644
--- a/code_attribute/gpcode_manager.py
+++ b/code_attribute/gpcode_manager.py
@@ -129,85 +129,114 @@
 
 # 棣栨澘浠g爜绠$悊
 class FirstCodeManager:
-    redisManager = redis_manager.RedisManager(0)
+    __instance = None
 
-    @classmethod
-    def __get_redis(cls):
-        return cls.redisManager.getRedis()
+    def __new__(cls, *args, **kwargs):
+        if not cls.__instance:
+            cls.__instance = super(FirstCodeManager, cls).__new__(cls, *args, **kwargs)
+            # 鍒濆鍖栬缃�
+            # 鑾峰彇浜ゆ槗绐楀彛鐨勯攣
+            cls.__instance.redisManager = redis_manager.RedisManager(0)
+            cls.__instance.__first_code_record_cache = RedisUtils.smembers(cls.__instance.__get_redis(),
+                                                                           "first_code_record")
+            cls.__instance.__first_code_limited_up_record_cache = RedisUtils.smembers(cls.__instance.__get_redis(),
+                                                                                      "first_code_limited_up_record")
+        return cls.__instance
+
+    def __get_redis(self):
+        return self.redisManager.getRedis()
 
     # 鍔犲叆棣栨澘鍘嗗彶璁板綍
-    @classmethod
-    def add_record(cls, codes):
+    def add_record(self, codes):
+        hasChanged = False
         for code in codes:
-            RedisUtils.sadd(cls.__get_redis(), "first_code_record", code)
-        RedisUtils.expire(cls.__get_redis(), "first_code_record", tool.get_expire())
+            if code not in self.__first_code_record_cache:
+                RedisUtils.sadd(self.__get_redis(), "first_code_record", code)
+                hasChanged = True
+            self.__first_code_record_cache.add(code)
+        if hasChanged:
+            RedisUtils.expire(self.__get_redis(), "first_code_record", tool.get_expire())
 
-    @classmethod
-    def is_in_first_record(cls, code):
-        if RedisUtils.sismember(cls.__get_redis(), "first_code_record", code):
+    def is_in_first_record(self, code):
+        if RedisUtils.sismember(self.__get_redis(), "first_code_record", code):
             return True
         else:
             return False
+
+    def is_in_first_record_cache(self, code):
+        return code in self.__first_code_record_cache
 
     # 鍔犲叆棣栨澘娑ㄥ仠杩囦唬鐮侀泦鍚�
-    @classmethod
-    def add_limited_up_record(cls, codes):
+    def add_limited_up_record(self, codes):
+        hasChanged = False
         for code in codes:
-            RedisUtils.sadd(cls.__get_redis(), "first_code_limited_up_record", code)
-        RedisUtils.expire(cls.__get_redis(), "first_code_limited_up_record", tool.get_expire())
+            if code not in self.__first_code_limited_up_record_cache:
+                RedisUtils.sadd(self.__get_redis(), "first_code_limited_up_record", code)
+                hasChanged = True
+            self.__first_code_limited_up_record_cache.add(code)
+        if hasChanged:
+            RedisUtils.expire(self.__get_redis(), "first_code_limited_up_record", tool.get_expire())
 
     # 鏄惁娑ㄥ仠杩�
-    @classmethod
-    def is_limited_up(cls, code):
-        if RedisUtils.sismember(cls.__get_redis(), "first_code_limited_up_record", code):
+    def is_limited_up(self, code):
+        if RedisUtils.sismember(self.__get_redis(), "first_code_limited_up_record", code):
             return True
         else:
             return False
+
+    def is_limited_up_cache(self, code):
+        return code in self.__first_code_limited_up_record_cache
 
 
 # 鎯宠涔扮殑浠g爜
 class WantBuyCodesManager:
-    redisManager = redis_manager.RedisManager(0)
-    __redis_key = "want_buy_codes"
+    __instance = None
+
+    def __new__(cls, *args, **kwargs):
+        if not cls.__instance:
+            cls.__instance = super(WantBuyCodesManager, cls).__new__(cls, *args, **kwargs)
+            # 鍒濆鍖栬缃�
+            # 鑾峰彇浜ゆ槗绐楀彛鐨勯攣
+            cls.__instance.redisManager = redis_manager.RedisManager(0)
+            cls.__instance.__redis_key = "want_buy_codes"
+            cls.__instance.__want_buy_codes_cache = RedisUtils.smembers(cls.__instance.__get_redis(),
+                                                                        cls.__instance.__redis_key)
+        return cls.__instance
+
     __want_buy_codes_cache = set()
 
-    @classmethod
-    def __get_redis(cls):
-        return cls.redisManager.getRedis()
+    def __get_redis(self):
+        return self.redisManager.getRedis()
 
-    @classmethod
-    def clear(cls):
-        RedisUtils.delete(cls.__get_redis(), cls.__redis_key)
+    def clear(self):
+        RedisUtils.delete(self.__get_redis(), self.__redis_key)
 
-    @classmethod
-    def add_code(cls, code):
-        cls.__want_buy_codes_cache.add(code)
-        RedisUtils.sadd(cls.__get_redis(), cls.__redis_key, code)
-        RedisUtils.expire(cls.__get_redis(), cls.__redis_key, tool.get_expire())
+    def add_code(self, code):
+        self.__want_buy_codes_cache.add(code)
+        RedisUtils.sadd(self.__get_redis(), self.__redis_key, code)
+        RedisUtils.expire(self.__get_redis(), self.__redis_key, tool.get_expire())
 
-    @classmethod
-    def remove_code(cls, code):
-        cls.__want_buy_codes_cache.discard(code)
-        RedisUtils.srem(cls.__get_redis(), cls.__redis_key, code)
+    def remove_code(self, code):
+        self.__want_buy_codes_cache.discard(code)
+        RedisUtils.srem(self.__get_redis(), self.__redis_key, code)
 
-    @classmethod
-    def sync(cls):
-        cls.__want_buy_codes_cache.clear()
-        codes = RedisUtils.smembers(cls.__get_redis(), cls.__redis_key)
+    def sync(self):
+        self.__want_buy_codes_cache.clear()
+        codes = RedisUtils.smembers(self.__get_redis(), self.__redis_key)
         if codes:
-            cls.__want_buy_codes_cache += set(codes)
+            self.__want_buy_codes_cache += set(codes)
 
-    @classmethod
-    def is_in(cls, code):
-        return RedisUtils.sismember(cls.__get_redis(), cls.__redis_key, code)
+    def is_in(self, code):
+        return RedisUtils.sismember(self.__get_redis(), self.__redis_key, code)
 
-    @classmethod
-    def is_in_cache(cls, code):
-        return code in cls.__want_buy_codes_cache
+    def is_in_cache(self, code):
+        return code in self.__want_buy_codes_cache
 
-    @classmethod
-    def list_code(cls):
-        return RedisUtils.smembers(cls.__get_redis(), cls.__redis_key)
+    def list_code(self):
+        return RedisUtils.smembers(self.__get_redis(), self.__redis_key)
+
+    def list_code_cache(self):
+        return self.__want_buy_codes_cache
 
 
 # 鏆傚仠涓嬪崟浠g爜绠$悊
@@ -432,35 +461,38 @@
     return list
 
 
-# 鑾峰彇鏀剁洏浠�
-def get_price_pre(code):
-    redis_instance = __redisManager.getRedis()
-    result = RedisUtils.get(redis_instance, "price-pre-{}".format(code))
-    if result is not None:
-        return float(result)
-    return None
+class CodePrePriceManager:
+    __price_pre_cache = {}
+    __redisManager = redis_manager.RedisManager(0)
 
+    # 鑾峰彇鏀剁洏浠�
+    @classmethod
+    def get_price_pre(cls, code):
+        redis_instance = cls.__redisManager.getRedis()
+        result = RedisUtils.get(redis_instance, "price-pre-{}".format(code))
+        if result is not None:
+            return float(result)
+        return None
 
-__price_pre_cache = {}
+    # 鑾峰彇缂撳瓨
+    @classmethod
+    def get_price_pre_cache(cls, code):
+        if code in cls.__price_pre_cache:
+            return float(cls.__price_pre_cache[code])
+        val = cls.get_price_pre(code)
+        if val:
+            cls.__price_pre_cache[code] = val
+        return val
 
-
-# 鑾峰彇缂撳瓨
-def get_price_pre_cache(code):
-    if code in __price_pre_cache:
-        return __price_pre_cache[code]
-    val = get_price_pre(code)
-    if val:
-        __price_pre_cache[code] = val
-    return val
-
-
-# 璁剧疆鏀剁洏浠�
-def set_price_pre(code, price, force=False):
-    codes = get_gp_list()
-    if code not in codes and not FirstCodeManager.is_in_first_record(code) and not force:
-        return
-    redis_instance = __redisManager.getRedis()
-    RedisUtils.setex(redis_instance, "price-pre-{}".format(code), tool.get_expire(), str(price))
+    # 璁剧疆鏀剁洏浠�
+    @classmethod
+    def set_price_pre(cls, code, price, force=False):
+        codes = get_gp_list()
+        if code not in codes and not FirstCodeManager().is_in_first_record_cache(code) and not force:
+            return
+        redis_instance = cls.__redisManager.getRedis()
+        RedisUtils.setex(redis_instance, "price-pre-{}".format(code), tool.get_expire(), str(price))
+        cls.__price_pre_cache[code] = float(price)
 
 
 __limit_up_price_dict = {}
@@ -471,7 +503,7 @@
     # 璇诲彇鍐呭瓨涓殑鍊�
     if code in __limit_up_price_dict:
         return __limit_up_price_dict[code]
-    price = get_price_pre_cache(code)
+    price = CodePrePriceManager.get_price_pre_cache(code)
     if price is None:
         return None
     limit_up_price = tool.to_price(decimal.Decimal(str(price)) * decimal.Decimal("1.1"))
@@ -487,7 +519,7 @@
 
 # 鑾峰彇璺屽仠浠�
 def get_limit_down_price(code):
-    price = get_price_pre_cache(code)
+    price = CodePrePriceManager.get_price_pre_cache(code)
     if price is None:
         return None
     return tool.to_price(decimal.Decimal(str(price)) * decimal.Decimal("0.9"))

--
Gitblit v1.8.0