python - restful - django rest framework with django 2

¿Cómo almacenar en caché las llamadas a la API de Django Rest Framework?

Question

Estoy usando Memcached como backend para mi aplicación django. Este código funciona bien en la consulta normal de 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

Pero no funciona cuando se usa con las llamadas de la API de django-rest-framework:

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

Estoy a punto de probar las extensiones DRF que proporcionan funcionalidad de almacenamiento en caché:

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

pero el estado de compilación en github actualmente dice "falla de compilación".

Mi aplicación es muy leída en las llamadas de api. ¿Hay una manera de almacenar estas llamadas?

Gracias.

Answer 1

Acabo de implementar esto para usar en mis serializadores.

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

Luego anulo el método to_representation en mis serializadores, por lo que almacena en caché la salida serializada por instancia.

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 2

Ok, entonces, para usar el almacenamiento en caché para su queryset:

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

Es probable que desees establecer un tiempo de espera en el conjunto de caché (como 60 segundos):

cache.set(cache_key, result, 60)

Si desea almacenar en caché toda la 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 3

Pruebe esta aplicación 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)