django 之(四) --- 级联|截流

登陆注册

登陆注册实现

• settings.py

# redis配置
CACHES = {
    "default": {
        "BACKEND": "django_redis.cache.RedisCache",
        "LOCATION": "redis://127.0.0.1:6379/1",
        "TIMEOUT": 60 * 60 * 24,
        "OPTIONS": {
            "CLIENT_CLASS": "django_redis.client.DefaultClient",
        }
    }
}

• App/models.py

from django.db import models

class UserModel(models.Model):
    u_name = models.CharField(max_length=16, unique=True)
    u_password = models.CharField(max_length=256)

    def __str__(self):
        return self.u_name

• App/serializers.py

from rest_framework import serializers
from App.models import UserModel, Address

class UserSerializer(serializers.HyperlinkedModelSerializer):6 
    class Meta:
        model = UserModel
        fields = ('url', 'id', 'u_name', 'u_password', 'address_list')

• App/views.py

import uuid
from django.core.cache import cache
from rest_framework import exceptions
from rest_framework.generics import CreateAPIView, RetrieveAPIView
from rest_framework.response import Response
from App.models import UserModel
from App.serializers import UserSerializer


# 继承自CreateAPIView。。exceptions框架封装的状态码变量包文件
class UsersAPIView(CreateAPIView):
    serializer_class = UserSerializer
    queryset = UserModel.objects.all()

    # 重写post，获取其action动作
    def post(self, request, *args, **kwargs):
        action = request.query_params.get('action')
        if action == "login":  # 登陆动作
            u_name = request.data.get('u_name')
            u_password = request.data.get('u_password')
            try:
                user = UserModel.objects.get(u_name=u_name)
                if user.u_password != u_password:
                    raise exceptions.AuthenticationFailed
                token = uuid.uuid4().hex
                cache.set(token, user.id, timeout=60 * 60 * 24)
                data = {
                    'msg': 'login success',
                    'status': 200,
                    'token': token
                }
                return Response(data)
            except UserModel.DoesNotExist:
                raise exceptions.NotFound
        elif action == "register":  # 注册动作
            return self.create(request, *args, **kwargs)
        else:
            raise exceptions.ParseError


# 继承自RetrieveAPIView。
class UserAPIView(RetrieveAPIView):
    serializer_class = UserSerializer
    queryset = UserModel.objects.all()

• urls.py 和 App/urls.py

from django.conf.urls import url, include

urlpatterns = [
    url(r'^app/', include('App.urls')),
]
#------------------------------------------------------------------------------------------

from django.conf.urls import url
from App import views

urlpatterns = [
    url(r'^users/$', views.UsersAPIView.as_view()),
    # 继承自序列化HyperlinkedModelSerializer。需要加详情信息的url
    url(r'^users/(?P<pk>d+)/$', views.UserAPIView.as_view(), name='usermodel-detail'),

]

用户地址

登陆用户对地址添加

• App/models.py

from django.db import models

class UserModel(models.Model):
    u_name = models.CharField(max_length=16, unique=True)
    u_password = models.CharField(max_length=256)

    def __str__(self):
        return self.u_name

class Address(models.Model):
    a_address = models.CharField(max_length=128)
    a_user = models.ForeignKey(UserModel, related_name='address_list', null=True, blank=True)

    def __str__(self):
        return self.a_address

• App/serializers.py

from rest_framework import serializers
from App.models import UserModel, Address

class AddressSerializer(serializers.HyperlinkedModelSerializer):
    class Meta:
        model = Address
        fields = ('url', 'id', 'a_address')

class UserSerializer(serializers.HyperlinkedModelSerializer):
    address_list = AddressSerializer(many=True, read_only=True)

    class Meta:
        model = UserModel
        fields = ('url', 'id', 'u_name', 'u_password', 'address_list')

• App/views.py

import uuid
from django.core.cache import cache
from rest_framework import exceptions
from rest_framework.generics import CreateAPIView, RetrieveAPIView
from rest_framework.response import Response
from rest_framework import viewsets
from App.auth import LoginAuthentication
from App.models import UserModel, Address
from App.permissions import RequireLoginPermission
from App.serializers import UserSerializer, AddressSerializer


# 继承自CreateAPIView。。exceptions框架封装的状态码变量包文件
class UsersAPIView(CreateAPIView):
    serializer_class = UserSerializer
    queryset = UserModel.objects.all()

    # 重写post，获取其action动作
    def post(self, request, *args, **kwargs):
        action = request.query_params.get('action')
        if action == "login":  # 登陆动作
            u_name = request.data.get('u_name')
            u_password = request.data.get('u_password')
            try:
                user = UserModel.objects.get(u_name=u_name)
                if user.u_password != u_password:
                    raise exceptions.AuthenticationFailed
                token = uuid.uuid4().hex
                cache.set(token, user.id, timeout=60 * 60 * 24)
                data = {
                    'msg': 'login success',
                    'status': 200,
                    'token': token
                }
                return Response(data)
            except UserModel.DoesNotExist:
                raise exceptions.NotFound
        elif action == "register":  # 注册动作
            return self.create(request, *args, **kwargs)
        else:
            raise exceptions.ParseError


# 继承自RetrieveAPIView
class UserAPIView(RetrieveAPIView):
    serializer_class = UserSerializer
    queryset = UserModel.objects.all()

class AddressAPIView(viewsets.ModelViewSet):
    serializer_class = AddressSerializer
    queryset = Address.objects.all()
    # 登陆认证。判断用户是否登陆成功的
    authentication_classes = (LoginAuthentication,)
    # 权限认证。只有登陆的用户才有权限
    permission_classes = (RequireLoginPermission,)

• App/auth

# 登陆认证。判断用户是否是登陆状态、是否是合法用户
from django.core.cache import cache
from rest_framework.authentication import BaseAuthentication
from App.models import UserModel

# 登陆认证器。继承自BaseAuthentication
class LoginAuthentication(BaseAuthentication):

    def authenticate(self, request):
        try:
            token = request.query_params.get('token')
            user_id = cache.get(token)
            user = UserModel.objects.get(pk=user_id)
            return user, token
        except Exception:
            return

• App/permissions.py

# 权限认证。只有登陆用户的对象是此模型类的实例才有权限对地址信息进行操作
from rest_framework.permissions import BasePermission
from App.models import UserModel

class RequireLoginPermission(BasePermission):
　　 # 重写has_permission方法，判断是否有权限
    def has_permission(self, request, view):
        # isinstance判断此用户是否是此模型的实例。如果是返回True；不是返回False
        return isinstance(request.user, UserModel)

• urls.py 和 App/urls.py

from django.conf.urls import url
from App import views

urlpatterns = [
    url(r'^users/$', views.UsersAPIView.as_view()),
    # 继承自序列化HyperlinkedModelSerializer。需要加详情的url
    url(r'^users/(?P<pk>d+)/$', views.UserAPIView.as_view(), name='usermodel-detail'),

    # 视图类继承自viewsets.ModelViewSet。
    url(r'^address/$', views.AddressAPIView.as_view(
        {
            'post': 'create',  # 参数：post对应create类方法
            'get': 'list',     # 参数：get对应list类方法
        }
    )),
    # 继承自序列化HyperlinkedModelSerializer。需要加详情的url
    url(r'^address/(?P<pk>d+)/$', views.AddressAPIView.as_view(
        {
            'get': 'retrieve',
        }
    ), name='address-detail'),
]

查询操作

认证登陆用户权限查询

• App/views.py

import uuid
from django.core.cache import cache
from rest_framework import exceptions, status
from rest_framework.generics import CreateAPIView, RetrieveAPIView
from rest_framework.response import Response
from rest_framework import viewsets
from App.auth import LoginAuthentication
from App.models import UserModel, Address
from App.permissions import RequireLoginPermission
from App.serializers import UserSerializer, AddressSerializer


# 继承自CreateAPIView。。exceptions框架封装的状态码变量包文件
class UsersAPIView(CreateAPIView):
    serializer_class = UserSerializer
    queryset = UserModel.objects.all()

    # 重写post，获取其action动作
    def post(self, request, *args, **kwargs):
        action = request.query_params.get('action')
        if action == "login":  # 登陆动作
            u_name = request.data.get('u_name')
            u_password = request.data.get('u_password')
            try:
                user = UserModel.objects.get(u_name=u_name)
                if user.u_password != u_password:
                    raise exceptions.AuthenticationFailed
                token = uuid.uuid4().hex
                cache.set(token, user.id, timeout=60 * 60 * 24)
                data = {
                    'msg': 'login success',
                    'status': 200,
                    'token': token
                }
                return Response(data)
            except UserModel.DoesNotExist:
                raise exceptions.NotFound
        elif action == "register":  # 注册动作
            return self.create(request, *args, **kwargs)
        else:
            raise exceptions.ParseError


# 继承自RetrieveAPIView
class UserAPIView(RetrieveAPIView):
    serializer_class = UserSerializer
    queryset = UserModel.objects.all()


class AddressAPIView(viewsets.ModelViewSet):
    serializer_class = AddressSerializer
    queryset = Address.objects.all()
    # 登陆认证
    authentication_classes = (LoginAuthentication,)
    # 权限认证
    permission_classes = (RequireLoginPermission,)

    # 重写create。地址信息关联用户
    def create(self, request, *args, **kwargs):
        serializer = self.get_serializer(data=request.data)
        serializer.is_valid(raise_exception=True)
        self.perform_create(serializer)
        headers = self.get_success_headers(serializer.data)
        # 对用户和地址进行绑定操作
        user = request.user
        a_id = serializer.data.get('id')
        address = Address.objects.get(pk=a_id)
        address.a_user = user
        address.save()
        return Response(serializer.data, status=status.HTTP_201_CREATED, headers=headers)

    # 重写list方法。实现get请求时只显示当前用户对应的地址信息的及联操作
    def list(self, request, *args, **kwargs):# 根据用户查询地址信息。其他代码都是源码内容
        queryset = self.filter_queryset(self.queryset.filter(a_user=request.user))

        page = self.paginate_queryset(queryset)
        if page is not None:
            serializer = self.get_serializer(page, many=True)
            return self.get_paginated_response(serializer.data)

        serializer = self.get_serializer(queryset, many=True)
        return Response(serializer.data)

---

# 继承自RetrieveAPIView。用户信息查询，只有登陆认证的用户才可以查看自己的信息
class UserAPIView(RetrieveAPIView):
    serializer_class = UserSerializer
    queryset = UserModel.objects.all()

 6     authentication_classes = (LoginAuthentication,)
 7     permission_classes = (RequireLoginPermission,)

    # 判定是本人。登陆认证后，只能查看自己的信息。[限制请求接口：路径里面的参数和用户是同一个用户才可查询]
    def retrieve(self, request, *args, **kwargs):
        if kwargs.get('pk') != str(request.user.id):
            raise exceptions.AuthenticationFailed
        instance = self.get_object()
        serializer = self.get_serializer(instance)
        return Response(serializer.data)

及联查询

• 路由url：http://127.0.0.1:8000/app/users/1/?token=7fc732d30b5e4f5ebfde8e59e1938e22
• App/models.py

from django.db import models

class UserModel(models.Model):
    u_name = models.CharField(max_length=16, unique=True)
    u_password = models.CharField(max_length=256)

    def __str__(self):
        return self.u_name

class Address(models.Model):
    a_address = models.CharField(max_length=128)
    a_user = models.ForeignKey(UserModel, related_name='address_list', null=True, blank=True)

    def __str__(self):
        return self.a_address

• App/serializers.py

from rest_framework import serializers
from App.models import UserModel, Address

class AddressSerializer(serializers.HyperlinkedModelSerializer):
    class Meta:
        model = Address
        fields = ('url', 'id', 'a_address')
 8 # 及联操作。
class UserSerializer(serializers.HyperlinkedModelSerializer):
    # 此处变量名要和模型中related_name='address_list'定义的名字对应。
    # 如果模型中没有定义related_name字段，默认系统识别的名字是address_set
    address_list = AddressSerializer(many=True, read_only=True)

    class Meta:
        model = UserModel
        fields = ('url', 'id', 'u_name', 'u_password', 'address_list')

截流控制 [频率控制]

• settings.py 截流注册。配置全局截流，若想对某一个类视图截流，可以在此视图中设置

# 配置全局截流
REST_FRAMEWORK = {
    "DEFAULT_THROTTLE_CLASSES": (
        # 限制用户的频率。用户类名
        "App.throttles.UserThrottle",
        # 限制游客的频率：AnonRateThrottle
    ),
    # 限制的【频率
    "DEFAULT_THROTTLE_RATES": {
        "user": "5/m",  　# 登陆的用户每分钟5次
    }
}

• App/throttles 自定义截流

from rest_framework.throttling import SimpleRateThrottle
from App.models import UserModel


class UserThrottle(SimpleRateThrottle):
    scope = 'user'

    def get_cache_key(self, request, view):
        if isinstance(request.user, UserModel):
            ident = request.auth
        else:
            ident = self.get_ident(request)

        return self.cache_format % {
            'scope': self.scope,
            'ident': ident
        }

 

　　HTTP_X_FORWARDED_FOR：获取你的原始IP，通过的普通的代理发送请求的请求；如果获取REMOTE_ADDR获取到的是代理IP

 截流器源码分析

节流器

• BaseThrottle

  • allow_request：[抽象未实现]是否允许的请求的核心

  • get_ident：获取客户端唯一标识

• • wait：默认是None

• SimpleRateThrottle

  • get_cache_key：获取缓存标识

  • get_rate：获取频率

  • parse_rate：转换频率。num/duration[s、m、h、d]

  • allow_request：是否允许请求，重写的方法

  • throttle_success：允许请求，进行请求记录

  • throttle_failure：不允许请求

  • wait：还有多少时间之后允许

• AnonRateThrottle

  • get_cache_key：获取缓存key的原则

• UserRateThrottle

  • 和上面一模一样

• ScopedRateThrottle

  • 和上面一样。多写了从属性中获取频率