（项目）生鲜超市（十一）

十四、首页、商品数量、缓存和限速功能开发

1、首页轮播图

　　为了方便测试，还是将pycharm的环境改成本地的，Vue中的host也改成本地地址，注意要修改数据库的地址。

　　然后在goods/serializers.py中加入轮播图字段的序列化：

class BannerSerializer(serializers.ModelSerializer):
    class Meta:
        model = Banner
        fields = '__all__'

　　在goods/views.py中编写轮播图的接口:

class BannerViewSet(mixins.ListModelMixin, viewsets.GenericViewSet):
    """首页轮播图"""

    queryset = Banner.objects.all().order_by('index')
    serializer_class = BannerSerializer

　　注册url：

router.register(r'banners', BannerViewSet, base_name='banners')  # 首页轮播图

　　在后台添加轮播图片，然后访问首页即可看到轮播图：

2、首页新品

　　我们之前在设计Goods的model的时候，有设计过一个字段is_new：is_new = models.BooleanField("是否新品", default=False)。

　　实现这个功能只需要在goods/filter/GoodsFilter中添加过滤即可：

class GoodsFilter(django_filters.rest_framework.FilterSet):
    """商品过滤"""

    # name是要过滤的字段，lookup是执行的行为
    pricemin = django_filters.NumberFilter(field_name="shop_price", lookup_expr='gte')
    pricemax = django_filters.NumberFilter(field_name="shop_price", lookup_expr='lte')
    top_category = django_filters.NumberFilter(field_name="category", method='top_category_filter')

    def top_category_filter(self, queryset, name, value):
        # 不管当前点击的是一级分类二级分类还是三级分类，都能找到
        return queryset.filter(Q(category_id=value) | Q(category__parent_category_id=value) | Q(
            category__parent_category__parent_category_id=value))

    class Meta:
        model = Goods
        fields = ['pricemin', 'pricemax', 'is_hot', 'is_new']

　　然后在后台添加几个新品即可：

3、首页商品分类

　　首先将商品广告位的字段进行序列化，还需要对商品大类下的分类及品牌进行序列化：

class BrandSerializer(serializers.ModelSerializer):
    class Meta:
        model = GoodsCategoryBrand
        fields = '__all__'


class IndexCategorySerializer(serializers.ModelSerializer):
    # 一个大类下可以有多个商标
    brands = BrandSerializer(many=True)
    # good有一个外键category指向三级类，直接反向通过外键category（三级类），取某个大类下面的商品是取不出来的
    goods = serializers.SerializerMethodField()
    # 取二级商品分类
    sub_cat = CategorySerializer2(many=True)
    # 广告商品
    ad_goods = serializers.SerializerMethodField()

    def get_ad_goods(self, obj):
        goods_json = {}
        ad_goods = IndexAd.objects.filter(category_id=obj.id)
        if ad_goods:
            good_ins = ad_goods[0].goods
            # 在serializer里面调用serializer，就要添加一个参数context（上下文request）,嵌套serializer必须加
            # serializer返回的时候一定要加'data'，这样才是json数据
            goods_json = GoodsSerializer(good_ins, many=False, context={'request': self.context['request']}).data
        return goods_json

    def get_goods(self, obj):
        # 让这个商品相关父类子类等都可以进行匹配
        all_goods = Goods.objects.filter(Q(category_id=obj.id) | Q(category__parent_category_id=obj.id) |
                                         Q(category__parent_category__parent_category_id=obj.id))
        goods_serializer = GoodsSerializer(all_goods, many=True, context={'request': self.context['request']})
        return goods_serializer.data

    class Meta:
        model = GoodsCategory
        fields = '__all__'

　　然后编写首页商品分类的接口：

class IndexCategoryViewSet(mixins.ListModelMixin, viewsets.GenericViewSet):
    """首页商品分类"""

    queryset = GoodsCategory.objects.filter(is_tab=True, name__in=["生鲜食品", "酒水饮料"])
    serializer_class = IndexCategorySerializer

　　注册url：

router.register(r'indexgoods', IndexCategoryViewSet, base_name='indexgoods')  # 首页系列商品分类

　　在后台添加宣传品牌和首页广告：

4、商品点击数和收藏数

4.1 点击数

　　GoodsListViewSet中继承了mixins.RetrieveModelMixin（获取商品详情），我们只需要重写这个类的retrieve方法即可：

class GoodsListViewSet(mixins.ListModelMixin, mixins.RetrieveModelMixin, viewsets.GenericViewSet):
    """
    list:
        商品列表，分页，搜索，过滤，排序
    retrieve:
        获取商品详情
    """

    pagination_class = GoodsPagination
    queryset = Goods.objects.all().order_by('id')  # 必须定义一个默认的排序，否则会报错
    serializer_class = GoodsSerializer
    filter_backends = (DjangoFilterBackend, filters.SearchFilter, filters.OrderingFilter)

    # 自定义过滤类
    filter_class = GoodsFilter

    # 搜索，=name表示精确搜索，也可以使用正则
    search_fields = ('name', 'goods_brief', 'goods_desc')

    # 排序
    ordering_fields = ('sold_num', 'shop_price')

    # 重写retrieve方法，商品点击数加1
    def retrieve(self, request, *args, **kwargs):
        instance = self.get_object()
        instance.click_num += 1
        instance.save()
        serializer = self.get_serializer(instance)
        return Response(serializer.data)

　　点击某一个商品，在数据库中可以看到click_num加了1：

4.2 收藏数

　　在UserFavViewset接口中继承了mixins.CreateModelMixin，添加收藏实际就是创建数据库，这里重写它的perform_create方法即可：

class UserFavViewSet(mixins.ListModelMixin, mixins.CreateModelMixin, mixins.DestroyModelMixin,
                     mixins.RetrieveModelMixin, viewsets.GenericViewSet):
    """用户收藏"""

    # permission是权限验证 IsAuthenticated必须登录用户 IsOwnerOrReadOnly必须是当前登录的用户
    permission_classes = (IsAuthenticated, IsOwnerOrReadOnly)

    # authentication是用户认证
    authentication_classes = (JSONWebTokenAuthentication, SessionAuthentication)

    # 搜索的字段
    lookup_field = 'goods_id'

    # 动态选择serializer
    def get_serializer_class(self):
        if self.action == "list":
            return UserFavDetailSerializer
        elif self.action == "create":
            return UserFavSerializer
        return UserFavSerializer

    # 只能查看当前登录用户的收藏，不会获取所有用户的收藏
    def get_queryset(self):
        return UserFav.objects.filter(user=self.request.user)

    # 收藏数加1
    def perform_create(self, serializer):
        instance = serializer.save()
        # 这里instance相当于UserFav的model，通过它找到goods
        goods = instance.goods
        goods.fav_num += 1
        goods.save()

　　登录点击收藏之后，收藏数会增加：

4.3 信号量实现收藏数

　　用户在delete和create的时候django model都会发送一个信号量出来，可以通过信号量的方式修改收藏数，在user_operation下新建signal.py：

from django.dispatch import receiver
from django.db.models.signals import post_save, post_delete
from user_operation.models import UserFav

@receiver(post_save, sender=UserFav)
def create_UserFav(sender, instance=None, created=False, **kwargs):
    # update的时候也会进行post_save
    if created:
        goods = instance.goods
        goods.fav_num += 1
        goods.save()

@receiver(post_delete, sender=UserFav)
def delete_UserFav(sender, instance=None, created=False, **kwargs):
    goods = instance.goods
    goods.fav_num -= 1
    goods.save()

　　然后在apps.py中重写ready方法：

from django.apps import AppConfig


class UserOperationConfig(AppConfig):
    name = 'user_operation'
    verbose_name = '用户操作管理'

    def ready(self):
        import user_operation.signals

　　现在添加收藏，删除收藏：

5、商品库存和销量修改

5.1 库存数

　　我们在新增商品到购物车，修改购物车中的数量，删除购物车记录都会对商品库存数产生影响，在trade/views.py中对购物车接口中的相关操作做库存数修改的逻辑：

class ShoppingCartViewSet(viewsets.ModelViewSet):
    """
    购物车功能
    list:
        获取购物车详情
    create：
        加入购物车
    delete：
        删除购物记录
    """

    permission_classes = (IsAuthenticated, IsOwnerOrReadOnly)
    authentication_classes = (JSONWebTokenAuthentication, SessionAuthentication)

    # 把商品id传回去
    lookup_field = 'goods_id'

    def get_serializer_class(self):
        if self.action == 'list':
            return ShopCartDetailSerializer
        else:
            return ShopCartSerializer

    def get_queryset(self):
        return ShoppingCart.objects.filter(user=self.request.user)

    # 创建购物车，库存数减少
    def perform_create(self, serializer):
        shop_cart = serializer.save()
        goods = shop_cart.goods
        goods.goods_num -= shop_cart.nums
        goods.save()

    # 移除购物车，库存数增加
    def perform_destroy(self, instance):
        goods = instance.goods()
        goods.goods_num += instance.nums
        goods.save()
        instance.delete()

    # 跟新购物车，可能是增加也可能是减少
    def perform_update(self, serializer):
        # 先获取修改之前的库存数量
        existed_record = ShoppingCart.objects.get(id=serializer.instance.id)
        existed_nums = existed_record.nums
        
        # 先保存之前的数据existed_nums
        save_record = serializer.save()
        
        # 做更新操作
        nums = save_record.nums - existed_nums
        goods = save_record.goods
        goods.goods_num -= nums
        goods.save()

5.2 销量

　　商品的销量只有在支付成功之后才能增加，也就是在AlipayView接口中订单支付成功加入增加销量的逻辑：

class AlipayView(APIView):
    """支付宝接口"""

    # 处理支付宝的return_url返回
    def get(self, request):
        processed_dict = {}

        # 获取GET中的参数
        for key, value in request.GET.items():
            processed_dict[key] = value

        # 从processed_dict中取出sign
        sign = processed_dict.pop("sign", None)

        # 生成AliPay对象
        alipay = AliPay(
            appid="2016092000557473",
            app_notify_url="http://148.70.2.75:8000/alipay/return/",
            app_private_key_path=private_key_path,
            alipay_public_key_path=ali_pub_key_path,  # 支付宝的公钥，验证支付宝回传消息使用，不是你自己的公钥,
            debug=True,  # 默认False,
            return_url="http://148.70.2.75:8000/alipay/return/"
        )

        # 验证签名
        verify_re = alipay.verify(processed_dict, sign)

        # 这里可以不做操作。因为不管发不发return url。notify url都会修改订单状态。
        if verify_re is True:
            order_sn = processed_dict.get('out_trade_no', None)
            trade_no = processed_dict.get('trade_no', None)
            trade_status = processed_dict.get('trade_status', None)

            existed_orders = OrderInfo.objects.filter(order_sn=order_sn)
            for existed_order in existed_orders:
                existed_order.pay_status = trade_status
                existed_order.trade_no = trade_no
                existed_order.pay_time = datetime.now()
                existed_order.save()

            # 支付完成跳转到首页
            response = redirect("index")
            response.set_cookie("nextPath", "pay", max_age=2)
            return response
        else:
            response = redirect("index")
            return response

    # 处理支付宝的notify_url
    def post(self, request):
        processed_dict = {}

        # 取出post里面的数据
        for key, value in request.POST.items():
            processed_dict[key] = value

        # 去掉sign
        sign = processed_dict.pop("sign", None)

        # 生成一个Alipay对象
        alipay = AliPay(
            appid="2016092000557473",
            app_notify_url="http://148.70.2.75:8000/alipay/return/",
            app_private_key_path=private_key_path,
            alipay_public_key_path=ali_pub_key_path,  # 支付宝的公钥，验证支付宝回传消息使用，不是你自己的公钥,
            debug=True,  # 默认False,
            return_url="http://148.70.2.75:8000/alipay/return/"
        )

        # 进行验证
        verify_re = alipay.verify(processed_dict, sign)

        if verify_re is True:
            # 商户网站唯一订单号
            order_sn = processed_dict.get('out_trade_no', None)
            # 支付宝系统交易流水号
            trade_no = processed_dict.get('trade_no', None)
            # 交易状态
            trade_status = processed_dict.get('trade_status', None)

            # 查询数据库中订单记录
            existed_orders = OrderInfo.objects.filter(order_sn=order_sn)
            for existed_order in existed_orders:
                # 订单商品项
                order_goods = existed_order.goods.all()
                # 商品销量增加
                for order_good in order_goods:
                    goods = order_good.goods
                    goods.sold_num += order_good.goods_num
                    goods.save()

                # 更新订单状态
                existed_order.pay_status = trade_status
                existed_order.trade_no = trade_no
                existed_order.pay_time = datetime.now()
                existed_order.save()
            # 需要返回一个'success'给支付宝，如果不返回，支付宝会一直发送订单支付成功的消息
            return Response("success")

6、drf的缓存设置

　　缓存的作用是为了加速用户访问某一资源的速度，将用户经常访问的数据加入缓存中，取数据的时候直接到缓存中去取，没有的话再去数据库，速度肯定会快很多。我们通过drf的一个扩展来实现缓存，github上有官方使用说明：http://chibisov.github.io/drf-extensions/docs/#caching。

　　首先安装drf-extensions库：pip install drf-extensions

　　然后在需要访问的数据的接口中加上缓存即可，我们在商品列表的接口中加入缓存，直接继承CacheResponseMixin即可：

class GoodsListViewSet(CacheResponseMixin, mixins.ListModelMixin, mixins.RetrieveModelMixin, viewsets.GenericViewSet):
    """
    list:
        商品列表，分页，搜索，过滤，排序
    retrieve:
        获取商品详情
    """

    pagination_class = GoodsPagination
    queryset = Goods.objects.all().order_by('id')  # 必须定义一个默认的排序，否则会报错
    serializer_class = GoodsSerializer
    filter_backends = (DjangoFilterBackend, filters.SearchFilter, filters.OrderingFilter)

    # 自定义过滤类
    filter_class = GoodsFilter

    # 搜索，=name表示精确搜索，也可以使用正则
    search_fields = ('name', 'goods_brief', 'goods_desc')

    # 排序
    ordering_fields = ('sold_num', 'shop_price')

    # 重写retrieve方法，商品点击数加1
    def retrieve(self, request, *args, **kwargs):
        instance = self.get_object()
        instance.click_num += 1
        instance.save()
        serializer = self.get_serializer(instance)
        return Response(serializer.data)

　　在settings中设置过期时间：

# 缓存配置
REST_FRAMEWORK_EXTENSIONS = {
    'DEFAULT_CACHE_RESPONSE_TIMEOUT': 5   # 5s过期
}

　　这个缓存使用的是内存，每次重启都会失效。

　　现在我们配置redis缓存，文档说明：http://django-redis-chs.readthedocs.io/zh_CN/latest/#id8

　　首先安装包：pip install django-redis

　　然后在settings中配置redis缓存：

# redis缓存
CACHES = {
    "default": {
        "BACKEND": "django_redis.cache.RedisCache",
        "LOCATION": "redis://127.0.0.1:6379",
        "OPTIONS": {
            "CLIENT_CLASS": "django_redis.client.DefaultClient",
        }
    }
}

　　使用redis缓存你得在服务器或者本地安装了redis才能使用。

7、def的throttle设置api的访问速率

　　为了防止爬虫或者黑客恶意攻击，对api的访问速率进行限制就显得非常重要的，官方文档说明：http://www.django-rest-framework.org/api-guide/throttling/

　　首先在settings中进行配置：

REST_FRAMEWORK = {
    'DEFAULT_AUTHENTICATION_CLASSES': (
        'rest_framework.authentication.BasicAuthentication',
        'rest_framework.authentication.SessionAuthentication',
        # 'rest_framework.authentication.TokenAuthentication'
    ),
    'DEFAULT_THROTTLE_CLASSES': (
            'rest_framework.throttling.AnonRateThrottle',   # 未登陆用户
            'rest_framework.throttling.UserRateThrottle'    # 登陆用户
        ),
    'DEFAULT_THROTTLE_RATES': {
        'anon': '3/minute',         # 每分钟可以请求两次
        'user': '5/minute'          # 每分钟可以请求五次
    }
}

　　然后在对应的api接口中加入访问速率限制即可，这里对商品列表接口进行配置：

class GoodsListViewSet(CacheResponseMixin, mixins.ListModelMixin, mixins.RetrieveModelMixin, viewsets.GenericViewSet):
    """
    list:
        商品列表，分页，搜索，过滤，排序
    retrieve:
        获取商品详情
    """

    pagination_class = GoodsPagination
    queryset = Goods.objects.all().order_by('id')  # 必须定义一个默认的排序，否则会报错
    serializer_class = GoodsSerializer
    filter_backends = (DjangoFilterBackend, filters.SearchFilter, filters.OrderingFilter)

    # 接口访问速率限制
    throttle_classes = (UserRateThrottle, AnonRateThrottle)

    # 自定义过滤类
    filter_class = GoodsFilter

    # 搜索，=name表示精确搜索，也可以使用正则
    search_fields = ('name', 'goods_brief', 'goods_desc')

    # 排序
    ordering_fields = ('sold_num', 'shop_price')

    # 重写retrieve方法，商品点击数加1
    def retrieve(self, request, *args, **kwargs):
        instance = self.get_object()
        instance.click_num += 1
        instance.save()
        serializer = self.get_serializer(instance)
        return Response(serializer.data)

　　然后在登录或者未登录状态下访问该接口，超出次数如下：