武汉市交通管理局,cz3991航班,113003
为了方便测试，还是将pycharm的环境改成本地的，vue中的host也改成本地地址，注意要修改数据库的地址。
然后在goods/serializers.py中加入轮播图字段的序列化：
1 class bannerserializer(serializers.modelserializer): 2 class meta: 3 model = banner 4 fields = '__all__'
在goods/views.py中编写轮播图的接口:
我要评论1 class bannerviewset(mixins.listmodelmixin, viewsets.genericviewset):
2 """首页轮播图"""
3
4 queryset = banner.objects.all().order_by('index')
5 serializer_class = bannerserializer
注册url：
1 router.register(r'banners', bannerviewset, base_name='banners') # 首页轮播图
在后台添加轮播图片，然后访问首页即可看到轮播图：
我们之前在设计goods的model的时候，有设计过一个字段is_new：is_new = models.booleanfield("是否新品", default=false)。
实现这个功能只需要在goods/filter/goodsfilter中添加过滤即可：
1 class goodsfilter(django_filters.rest_framework.filterset): 2 """商品过滤""" 3 4 # name是要过滤的字段，lookup是执行的行为 5 pricemin = django_filters.numberfilter(field_name="shop_price", lookup_expr='gte') 6 pricemax = django_filters.numberfilter(field_name="shop_price", lookup_expr='lte') 7 top_category = django_filters.numberfilter(field_name="category", method='top_category_filter') 8 9 def top_category_filter(self, queryset, name, value): 10 # 不管当前点击的是一级分类二级分类还是三级分类，都能找到 11 return queryset.filter(q(category_id=value) | q(category__parent_category_id=value) | q( 12 category__parent_category__parent_category_id=value)) 13 14 class meta: 15 model = goods 16 fields = ['pricemin', 'pricemax', 'is_hot', 'is_new']
然后在后台添加几个新品即可：
首先将商品广告位的字段进行序列化，还需要对商品大类下的分类及品牌进行序列化：
1 class brandserializer(serializers.modelserializer):
2 class meta:
3 model = goodscategorybrand
4 fields = '__all__'
5
6
7 class indexcategoryserializer(serializers.modelserializer):
8 # 一个大类下可以有多个商标
9 brands = brandserializer(many=true)
10 # good有一个外键category指向三级类，直接反向通过外键category（三级类），取某个大类下面的商品是取不出来的
11 goods = serializers.serializermethodfield()
12 # 取二级商品分类
13 sub_cat = categoryserializer2(many=true)
14 # 广告商品
15 ad_goods = serializers.serializermethodfield()
16
17 def get_ad_goods(self, obj):
18 goods_json = {}
19 ad_goods = indexad.objects.filter(category_id=obj.id)
20 if ad_goods:
21 good_ins = ad_goods[0].goods
22 # 在serializer里面调用serializer，就要添加一个参数context（上下文request）,嵌套serializer必须加
23 # serializer返回的时候一定要加'data'，这样才是json数据
24 goods_json = goodsserializer(good_ins, many=false, context={'request': self.context['request']}).data
25 return goods_json
26
27 def get_goods(self, obj):
28 # 让这个商品相关父类子类等都可以进行匹配
29 all_goods = goods.objects.filter(q(category_id=obj.id) | q(category__parent_category_id=obj.id) |
30 q(category__parent_category__parent_category_id=obj.id))
31 goods_serializer = goodsserializer(all_goods, many=true, context={'request': self.context['request']})
32 return goods_serializer.data
33
34 class meta:
35 model = goodscategory
36 fields = '__all__'
然后编写首页商品分类的接口：
1 class indexcategoryviewset(mixins.listmodelmixin, viewsets.genericviewset): 2 """首页商品分类""" 3 4 queryset = goodscategory.objects.filter(is_tab=true, name__in=["生鲜食品", "酒水饮料"]) 5 serializer_class = indexcategoryserializer
注册url：
1 router.register(r'indexgoods', indexcategoryviewset, base_name='indexgoods') # 首页系列商品分类
在后台添加宣传品牌和首页广告：
goodslistviewset中继承了mixins.retrievemodelmixin（获取商品详情），我们只需要重写这个类的retrieve方法即可：
1 class goodslistviewset(mixins.listmodelmixin, mixins.retrievemodelmixin, viewsets.genericviewset):
2 """
3 list:
4 商品列表，分页，搜索，过滤，排序
5 retrieve:
6 获取商品详情
7 """
8
9 pagination_class = goodspagination
10 queryset = goods.objects.all().order_by('id') # 必须定义一个默认的排序，否则会报错
11 serializer_class = goodsserializer
12 filter_backends = (djangofilterbackend, filters.searchfilter, filters.orderingfilter)
13
14 # 自定义过滤类
15 filter_class = goodsfilter
16
17 # 搜索，=name表示精确搜索，也可以使用正则
18 search_fields = ('name', 'goods_brief', 'goods_desc')
19
20 # 排序
21 ordering_fields = ('sold_num', 'shop_price')
22
23 # 重写retrieve方法，商品点击数加1
24 def retrieve(self, request, *args, **kwargs):
25 instance = self.get_object()
26 instance.click_num += 1
27 instance.save()
28 serializer = self.get_serializer(instance)
29 return response(serializer.data)
点击某一个商品，在数据库中可以看到click_num加了1：
在userfavviewset接口中继承了mixins.createmodelmixin，添加收藏实际就是创建数据库，这里重写它的perform_create方法即可：
1 class userfavviewset(mixins.listmodelmixin, mixins.createmodelmixin, mixins.destroymodelmixin, 2 mixins.retrievemodelmixin, viewsets.genericviewset): 3 """用户收藏""" 4 5 # permission是权限验证 isauthenticated必须登录用户 isownerorreadonly必须是当前登录的用户 6 permission_classes = (isauthenticated, isownerorreadonly) 7 8 # authentication是用户认证 9 authentication_classes = (jsonwebtokenauthentication, sessionauthentication) 10 11 # 搜索的字段 12 lookup_field = 'goods_id' 13 14 # 动态选择serializer 15 def get_serializer_class(self): 16 if self.action == "list": 17 return userfavdetailserializer 18 elif self.action == "create": 19 return userfavserializer 20 return userfavserializer 21 22 # 只能查看当前登录用户的收藏，不会获取所有用户的收藏 23 def get_queryset(self): 24 return userfav.objects.filter(user=self.request.user) 25 26 # 收藏数加1 27 def perform_create(self, serializer): 28 instance = serializer.save() 29 # 这里instance相当于userfav的model，通过它找到goods 30 goods = instance.goods 31 goods.fav_num += 1 32 goods.save()
登录点击收藏之后，收藏数会增加：
用户在delete和create的时候django model都会发送一个信号量出来，可以通过信号量的方式修改收藏数，在user_operation下新建signal.py：
1 from django.dispatch import receiver 2 from django.db.models.signals import post_save, post_delete 3 from user_operation.models import userfav 4 5 @receiver(post_save, sender=userfav) 6 def create_userfav(sender, instance=none, created=false, **kwargs): 7 # update的时候也会进行post_save 8 if created: 9 goods = instance.goods 10 goods.fav_num += 1 11 goods.save() 12 13 @receiver(post_delete, sender=userfav) 14 def delete_userfav(sender, instance=none, created=false, **kwargs): 15 goods = instance.goods 16 goods.fav_num -= 1 17 goods.save()
然后在apps.py中重写ready方法：
1 from django.apps import appconfig 2 3 4 class useroperationconfig(appconfig): 5 name = 'user_operation' 6 verbose_name = '用户操作管理' 7 8 def ready(self): 9 import user_operation.signals
现在添加收藏，删除收藏：
我们在新增商品到购物车，修改购物车中的数量，删除购物车记录都会对商品库存数产生影响，在trade/views.py中对购物车接口中的相关操作做库存数修改的逻辑：
1 class shoppingcartviewset(viewsets.modelviewset): 2 """ 3 购物车功能 4 list: 5 获取购物车详情 6 create： 7 加入购物车 8 delete： 9 删除购物记录 10 """ 11 12 permission_classes = (isauthenticated, isownerorreadonly) 13 authentication_classes = (jsonwebtokenauthentication, sessionauthentication) 14 15 # 把商品id传回去 16 lookup_field = 'goods_id' 17 18 def get_serializer_class(self): 19 if self.action == 'list': 20 return shopcartdetailserializer 21 else: 22 return shopcartserializer 23 24 def get_queryset(self): 25 return shoppingcart.objects.filter(user=self.request.user) 26 27 # 创建购物车，库存数减少 28 def perform_create(self, serializer): 29 shop_cart = serializer.save() 30 goods = shop_cart.goods 31 goods.goods_num -= shop_cart.nums 32 goods.save() 33 34 # 移除购物车，库存数增加 35 def perform_destroy(self, instance): 36 goods = instance.goods() 37 goods.goods_num += instance.nums 38 goods.save() 39 instance.delete() 40 41 # 跟新购物车，可能是增加也可能是减少 42 def perform_update(self, serializer): 43 # 先获取修改之前的库存数量 44 existed_record = shoppingcart.objects.get(id=serializer.instance.id) 45 existed_nums = existed_record.nums 46 47 # 先保存之前的数据existed_nums 48 save_record = serializer.save() 49 50 # 做更新操作 51 nums = save_record.nums - existed_nums 52 goods = save_record.goods 53 goods.goods_num -= nums 54 goods.save()
商品的销量只有在支付成功之后才能增加，也就是在alipayview接口中订单支付成功加入增加销量的逻辑：
1 class alipayview(apiview):
2 """支付宝接口"""
3
4 # 处理支付宝的return_url返回
5 def get(self, request):
6 processed_dict = {}
7
8 # 获取get中的参数
9 for key, value in request.get.items():
10 processed_dict[key] = value
11
12 # 从processed_dict中取出sign
13 sign = processed_dict.pop("sign", none)
14
15 # 生成alipay对象
16 alipay = alipay(
17 appid="2016092000557473",
18 app_notify_url="http://148.70.2.75:8000/alipay/return/",
19 app_private_key_path=private_key_path,
20 alipay_public_key_path=ali_pub_key_path, # 支付宝的公钥，验证支付宝回传消息使用，不是你自己的公钥,
21 debug=true, # 默认false,
22 return_url="http://148.70.2.75:8000/alipay/return/"
23 )
24
25 # 验证签名
26 verify_re = alipay.verify(processed_dict, sign)
27
28 # 这里可以不做操作。因为不管发不发return url。notify url都会修改订单状态。
29 if verify_re is true:
30 order_sn = processed_dict.get('out_trade_no', none)
31 trade_no = processed_dict.get('trade_no', none)
32 trade_status = processed_dict.get('trade_status', none)
33
34 existed_orders = orderinfo.objects.filter(order_sn=order_sn)
35 for existed_order in existed_orders:
36 existed_order.pay_status = trade_status
37 existed_order.trade_no = trade_no
38 existed_order.pay_time = datetime.now()
39 existed_order.save()
40
41 # 支付完成跳转到首页
42 response = redirect("index")
43 response.set_cookie("nextpath", "pay", max_age=2)
44 return response
45 else:
46 response = redirect("index")
47 return response
48
49 # 处理支付宝的notify_url
50 def post(self, request):
51 processed_dict = {}
52
53 # 取出post里面的数据
54 for key, value in request.post.items():
55 processed_dict[key] = value
56
57 # 去掉sign
58 sign = processed_dict.pop("sign", none)
59
60 # 生成一个alipay对象
61 alipay = alipay(
62 appid="2016092000557473",
63 app_notify_url="http://148.70.2.75:8000/alipay/return/",
64 app_private_key_path=private_key_path,
65 alipay_public_key_path=ali_pub_key_path, # 支付宝的公钥，验证支付宝回传消息使用，不是你自己的公钥,
66 debug=true, # 默认false,
67 return_url="http://148.70.2.75:8000/alipay/return/"
68 )
69
70 # 进行验证
71 verify_re = alipay.verify(processed_dict, sign)
72
73 if verify_re is true:
74 # 商户网站唯一订单号
75 order_sn = processed_dict.get('out_trade_no', none)
76 # 支付宝系统交易流水号
77 trade_no = processed_dict.get('trade_no', none)
78 # 交易状态
79 trade_status = processed_dict.get('trade_status', none)
80
81 # 查询数据库中订单记录
82 existed_orders = orderinfo.objects.filter(order_sn=order_sn)
83 for existed_order in existed_orders:
84 # 订单商品项
85 order_goods = existed_order.goods.all()
86 # 商品销量增加
87 for order_good in order_goods:
88 goods = order_good.goods
89 goods.sold_num += order_good.goods_num
90 goods.save()
91
92 # 更新订单状态
93 existed_order.pay_status = trade_status
94 existed_order.trade_no = trade_no
95 existed_order.pay_time = datetime.now()
96 existed_order.save()
97 # 需要返回一个'success'给支付宝，如果不返回，支付宝会一直发送订单支付成功的消息
98 return response("success")
缓存的作用是为了加速用户访问某一资源的速度，将用户经常访问的数据加入缓存中，取数据的时候直接到缓存中去取，没有的话再去数据库，速度肯定会快很多。我们通过drf的一个扩展来实现缓存，github上有官方使用说明：http://chibisov.github.io/drf-extensions/docs/#caching。
首先安装drf-extensions库：pip install drf-extensions
然后在需要访问的数据的接口中加上缓存即可，我们在商品列表的接口中加入缓存，直接继承cacheresponsemixin即可：
1 class goodslistviewset(cacheresponsemixin, mixins.listmodelmixin, mixins.retrievemodelmixin, viewsets.genericviewset):
2 """
3 list:
4 商品列表，分页，搜索，过滤，排序
5 retrieve:
6 获取商品详情
7 """
8
9 pagination_class = goodspagination
10 queryset = goods.objects.all().order_by('id') # 必须定义一个默认的排序，否则会报错
11 serializer_class = goodsserializer
12 filter_backends = (djangofilterbackend, filters.searchfilter, filters.orderingfilter)
13
14 # 自定义过滤类
15 filter_class = goodsfilter
16
17 # 搜索，=name表示精确搜索，也可以使用正则
18 search_fields = ('name', 'goods_brief', 'goods_desc')
19
20 # 排序
21 ordering_fields = ('sold_num', 'shop_price')
22
23 # 重写retrieve方法，商品点击数加1
24 def retrieve(self, request, *args, **kwargs):
25 instance = self.get_object()
26 instance.click_num += 1
27 instance.save()
28 serializer = self.get_serializer(instance)
29 return response(serializer.data)
在settings中设置过期时间：
1 # 缓存配置
2 rest_framework_extensions = {
3 'default_cache_response_timeout': 5 # 5s过期
4 }
这个缓存使用的是内存，每次重启都会失效。
现在我们配置redis缓存，文档说明：http://django-redis-chs.readthedocs.io/zh_cn/latest/#id8
首先安装包：pip install django-redis
然后在settings中配置redis缓存：
1 # redis缓存
2 caches = {
3 "default": {
4 "backend": "django_redis.cache.rediscache",
5 "location": "redis://127.0.0.1:6379",
6 "options": {
7 "client_class": "django_redis.client.defaultclient",
8 }
9 }
10 }
使用redis缓存你得在服务器或者本地安装了redis才能使用。
为了防止爬虫或者黑客恶意攻击，对api的访问速率进行限制就显得非常重要的，官方文档说明：http://www.django-rest-framework.org/api-guide/throttling/
首先在settings中进行配置：
1 rest_framework = {
2 'default_authentication_classes': (
3 'rest_framework.authentication.basicauthentication',
4 'rest_framework.authentication.sessionauthentication',
5 # 'rest_framework.authentication.tokenauthentication'
6 ),
7 'default_throttle_classes': (
8 'rest_framework.throttling.anonratethrottle', # 未登陆用户
9 'rest_framework.throttling.userratethrottle' # 登陆用户
10 ),
11 'default_throttle_rates': {
12 'anon': '3/minute', # 每分钟可以请求两次
13 'user': '5/minute' # 每分钟可以请求五次
14 }
15 }
然后在对应的api接口中加入访问速率限制即可，这里对商品列表接口进行配置：
1 class goodslistviewset(cacheresponsemixin, mixins.listmodelmixin, mixins.retrievemodelmixin, viewsets.genericviewset):
2 """
3 list:
4 商品列表，分页，搜索，过滤，排序
5 retrieve:
6 获取商品详情
7 """
8
9 pagination_class = goodspagination
10 queryset = goods.objects.all().order_by('id') # 必须定义一个默认的排序，否则会报错
11 serializer_class = goodsserializer
12 filter_backends = (djangofilterbackend, filters.searchfilter, filters.orderingfilter)
13
14 # 接口访问速率限制
15 throttle_classes = (userratethrottle, anonratethrottle)
16
17 # 自定义过滤类
18 filter_class = goodsfilter
19
20 # 搜索，=name表示精确搜索，也可以使用正则
21 search_fields = ('name', 'goods_brief', 'goods_desc')
22
23 # 排序
24 ordering_fields = ('sold_num', 'shop_price')
25
26 # 重写retrieve方法，商品点击数加1
27 def retrieve(self, request, *args, **kwargs):
28 instance = self.get_object()
29 instance.click_num += 1
30 instance.save()
31 serializer = self.get_serializer(instance)
32 return response(serializer.data)
然后在登录或者未登录状态下访问该接口，超出次数如下：
如对本文有疑问，请在下面进行留言讨论，广大热心网友会与你互动！！ 点击进行留言回复
python求numpy中array按列非零元素的平均值案例
网友评论