Come archiviare le chiamate API di Django Rest Framework?

Question

Sto usando Memcached come backend alla mia app django. Questo codice funziona bene in normale interrogazione django:

def get_myobj(): 
     cache_key = 'mykey' 
     result = cache.get(cache_key, None) 
     if not result: 
      result = Product.objects.all().filter(draft=False) 
      cache.set(cache_key, result) 
     return result 

Ma non funziona quando viene utilizzato con chiamate API django-resto-quadro:

class ProductListAPIView(generics.ListAPIView): 
    def get_queryset(self): 
     product_list = Product.objects.all() 
     return product_list 
    serializer_class = ProductSerializer 

sto per provare DRF-extensions che fornire funzionalità di caching:

https://github.com/chibisov/drf-extensions

ma lo status di compilazione su github è attualmente dicendo "costruire in mancanza".

La mia app è molto pesante su chiamate API. C'è un modo per mettere in cache queste chiamate?

Grazie.

Answer 1

Ok, quindi, al fine di utilizzare la cache per il vostro set di query:

class ProductListAPIView(generics.ListAPIView): 
    def get_queryset(self): 
     return get_myobj() 
    serializer_class = ProductSerializer 

si sarebbe probabilmente desidera impostare un timeout sulla cache set anche se (come 60 secondi):

cache.set(cache_key, result, 60) 

Se si desidera memorizzare nella cache l'intera vista:

from django.utils.decorators import method_decorator 
from django.views.decorators.cache import cache_page 

class ProductListAPIView(generics.ListAPIView): 
    serializer_class = ProductSerializer 

    @method_decorator(cache_page(60)) 
    def dispatch(self, *args, **kwargs): 
     return super(ProductListAPIView, self).dispatch(*args, **kwargs) 

Answer 2

ho appena implementato questa opzione per utilizzare le mie serializzatori

def cache_me(cache): 
    def true_decorator(f): 
     @wraps(f) 
     def wrapper(*args, **kwargs): 
      instance = args[1] 
      cache_key = '%s.%s' % (instance.facility, instance.id) 
      logger.debug('%s cache_key: %s' % (cache, cache_key)) 
      try: 
       data = caches[cache].get(cache_key) 
       if data is not None: 
        return data 
      except: 
       pass 
      logger.info('did not cache') 
      data = f(*args, **kwargs) 
      try: 
       caches[cache].set(cache_key, data) 
      except: 
       pass 
      return data 
     return wrapper 
    return true_decorator 

quindi sovrascrivo il metodo to_representation sui miei serializzatori, quindi memorizza l'output serializzato per istanza.

class MyModelSerializer(serializers.ModelSerializer): 

    class Meta: 
     model = MyModel 
     exclude = ('is_deleted', 'facility',) 

    @cache_me('mymodel') 
    def to_representation(self, instance): 
     return super(MyModelSerializer, self).to_representation(instance) 

Answer 3

Prova! Django https://github.com/Onyo/django-rest-framework-cache

from rest_framework import serializers 

# You must import the CachedSerializerMixin and cache_registry 
from rest_framework_cache.serializers import CachedSerializerMixin 
from rest_framework_cache.registry import cache_registry 
from .models import Comment 

class CommentSerializer(serializers.ModelSerializer, CachedSerializerMixin): 

    class Meta: 
     model = Comment 


cache_registry.register(CommentSerializer)