Python 使用memcache覆盖按\u键\u name（）获取\u

用另一个使用memcache保存数据库查询的函数覆盖get_by_key_name有意义吗？像下面这样？在本例中，memcache键仅包含实体键\u名称，以使其简单

class Entity(db.Model):
   @classmethod
   def get_by_key_name(cls, key_name):
     entity = memcache.get(key_name)
     if entity is not None:
       return entity
     else:
       entity = cls.__super__.get_by_key_name(key_name)
       memcache.add(key_name, entity, 3600)
       return entity

---

它是否有意义取决于：

您的应用程序的性能是否不够好（您的性能目标是什么，您如何衡量它？）

数据库查询是否真的是应用程序的瓶颈（性能问题实际上可能存在于其他地方，您在分析之前无法知道）

memcache查询是否实际比数据库的缓存（如果有）快，以及快多少（对来自数据库的相同记录的重复查询很可能来自RAM）

应用程序的查询模式（如果记录不在memcache中，那么实际上每个查询都要做更多的工作，因此如果大多数查询都是唯一的，那么它甚至可能会更慢！——数据库的缓存也可能足够了）

可能有人已经为Google App Engine测量了其中的一些参数，但是#4仍然是您需要为应用程序计算的参数。换句话说：这不是一个没有更多数据就可以回答的问题。不过，希望我能给你一些地方开始调查

根据您对数据库和SQL的了解程度，您也可以通过更好地使用数据库来加快查询速度，而不会给应用程序增加缓存的复杂性（对GAE的了解还不够，不知道它能让您做多少）

---

至于您建议的实现，它看起来并不不合理，因为

get\u by\u key\u name（）

已经是一个类方法。您可以尝试将新方法直接注入现有的

Model

类（或者将整个子类替换回模块），这样就不需要更改任何使用

Model

的代码。但这也有其自身的危险。当然，你所拥有的足够好，你可以做一些测试，看看它是否真的有用。

它是否有意义取决于：

您的应用程序的性能是否不够好（您的性能目标是什么，您如何衡量它？）

数据库查询是否真的是应用程序的瓶颈（性能问题实际上可能存在于其他地方，您在分析之前无法知道）

memcache查询是否实际比数据库的缓存（如果有）快，以及快多少（对来自数据库的相同记录的重复查询很可能来自RAM）

应用程序的查询模式（如果记录不在memcache中，那么实际上每个查询都要做更多的工作，因此如果大多数查询都是唯一的，那么它甚至可能会更慢！——数据库的缓存也可能足够了）

可能有人已经为Google App Engine测量了其中的一些参数，但是#4仍然是您需要为应用程序计算的参数。换句话说：这不是一个没有更多数据就可以回答的问题。不过，希望我能给你一些地方开始调查

根据您对数据库和SQL的了解程度，您也可以通过更好地使用数据库来加快查询速度，而不会给应用程序增加缓存的复杂性（对GAE的了解还不够，不知道它能让您做多少）

---

至于您建议的实现，它看起来并不不合理，因为

get\u by\u key\u name（）

已经是一个类方法。您可以尝试将新方法直接注入现有的

Model

类（或者将整个子类替换回模块），这样就不需要更改任何使用

Model

的代码。但这也有其自身的危险。当然，你所拥有的足够好，你可以做一些测试，看看它是否真的有帮助。

我也使用memcache来缓存实体，我认为加速数据库操作是个好主意。 我选择向类模型添加一个get_key方法，因为memcache/datastore代理可以在许多类中重用

定义通用memcache db代理

#mydb.py
def get_cache(keys):
    """ not support async operation
    because Async operation conflict with cache logiclly 
    """
    if not isinstance(keys, list) and not isinstance(keys, tuple):
        keys = [keys]

    keys = [str(k) for k in keys]
    results = memcache.get_multi(keys) #@UndefinedVariable
    keys_not_in_cache = [k for k in keys if k not in results] 

    if keys_not_in_cache:
        values = db.get([db.Key(k) for k in keys_not_in_cache])
        results_from_db = dict(zip(keys_not_in_cache, values))
        results.update(results_from_db)
        memcache.set_multi(results_from_db) #@UndefinedVariable

    return [results[k] for k in keys]        

def put_cache(values):
    """ Not support async operation
    """
    if not isinstance(values, list):
        values = [values]

    db.put(values)

    keys_str = [(str(k.key()), k) for k in values]
    memcache.set_multi(dict(keys_str)) #@UndefinedVariable    

def delete_cache(values):
    """ Not Support Async Operation
    """
    if not isinstance(values, list):
        values = [values]

    db.delete(values)

    keys_str = [str(k.key()) for k in values]
    memcache.delete_multi(keys_str) #@UndefinedVariable

用法示例

# for the class want to use this feature
class User(db.Model):
    email = db.EmailProperty()

    @classmethod
    def get_key(cls, email):
        return db.Key.from_path(cls.__name__, email)

# Using memcache db proxy
user_keys = [User.get_key(USER_EMAIL_ADDRESS) for USER_EMAIL_ADDRESS in ALL_USER_EMAIL_ADDRESS]
users = mydb.get_cache(user_keys)

---

我也使用memcache来缓存实体，我认为加速数据库操作是个好主意。 我选择向类模型添加一个get_key方法，因为memcache/datastore代理可以在许多类中重用

定义通用memcache db代理

#mydb.py
def get_cache(keys):
    """ not support async operation
    because Async operation conflict with cache logiclly 
    """
    if not isinstance(keys, list) and not isinstance(keys, tuple):
        keys = [keys]

    keys = [str(k) for k in keys]
    results = memcache.get_multi(keys) #@UndefinedVariable
    keys_not_in_cache = [k for k in keys if k not in results] 

    if keys_not_in_cache:
        values = db.get([db.Key(k) for k in keys_not_in_cache])
        results_from_db = dict(zip(keys_not_in_cache, values))
        results.update(results_from_db)
        memcache.set_multi(results_from_db) #@UndefinedVariable

    return [results[k] for k in keys]        

def put_cache(values):
    """ Not support async operation
    """
    if not isinstance(values, list):
        values = [values]

    db.put(values)

    keys_str = [(str(k.key()), k) for k in values]
    memcache.set_multi(dict(keys_str)) #@UndefinedVariable    

def delete_cache(values):
    """ Not Support Async Operation
    """
    if not isinstance(values, list):
        values = [values]

    db.delete(values)

    keys_str = [str(k.key()) for k in values]
    memcache.delete_multi(keys_str) #@UndefinedVariable

用法示例

# for the class want to use this feature
class User(db.Model):
    email = db.EmailProperty()

    @classmethod
    def get_key(cls, email):
        return db.Key.from_path(cls.__name__, email)

# Using memcache db proxy
user_keys = [User.get_key(USER_EMAIL_ADDRESS) for USER_EMAIL_ADDRESS in ALL_USER_EMAIL_ADDRESS]
users = mydb.get_cache(user_keys)

---

缓存的想法很好（尽管其他人已经表明，您必须小心无效）。但是，我不会重写get_by_name（）来执行此操作。我将编写单独的函数来处理缓存，这样代码的读者就可以清楚地看到您没有使用标准的get_by_name（）。还要注意的是，get_by_name（）是get（）之上的一个非常薄的层，带有一个键对象——您可能也应该提供该API。

缓存的想法很好（尽管其他人已经表明，您必须小心无效）。但是，我不会重写get_by_name（）来执行此操作。我将编写单独的函数来处理缓存，这样代码的读者就可以清楚地看到您没有使用标准的get_by_name（）。还要注意的是，get\u by\u name（）是get（）之上的一个非常薄的层，带有一个关键对象——您可能也应该提供该API。

更好、更整洁的解决方案是使用它，它内置了对memcache和实例内存缓存的支持。

更好、更整洁的解决方案是使用，它内置了对memcache和实例内存缓存的支持。

cls.\uuuu super\uuuu.get\u by\u key\u name

拼写正确

super（实体，cls）。get\u by\u key\u name

。好心的家伙们，很快就完成了。如果没有什么