上一篇的练习实现用户认证
API没有任何的认证策略，但是可以有一些高级的行为来实现它
认证
是在as_view里的dispatch里认证，就意味dispatch着是在自己写的方法执行前
层级关系
认证
- 什么是认证？
- 用户身份登录验证
- 根据提供的令牌找到用户
- REST-Framework
- 根据令牌找到用户之后，把用户存在了Request上
- as_view
- dispatch
- initial
- perform_authentication
- request.user
- 函数 -> 使用@Property
- _authenticate()
- authenticators 是Request构建来的
- initialize_request 构建的Request
- get_authenticators 获取构建时的认证器
- authentication_classes 是APIView类属性
- 认证成功会将登陆用户和令牌作为一个元组返回，否则返回None
- request.user
- perform_authentication
- initial
- dispatch
0846.png
以后写认证器就可以在views里指定就可以了
12329.png
调的是一个函数authenticator()
如果认证成功返回的user_auth_tuple,里面是元祖，元祖里有两个元祖，一个是self.user，一个是self.auth（令牌）
自己实现，需要继承系统里的基类
6464.png
源码
里面有两个方法，一个是抽象的一个是通用，使用
authenticate方法会报错，因为他是一个抽象方法
如果自己想写一个认证器，首先继承BaseAuthentication(object)这个类，然后手动来实现authenticate这个方法
class BaseAuthentication(object):
"""
All authentication classes should extend BaseAuthentication.
"""
def authenticate(self, request):
"""
Authenticate the request and return a two-tuple of (user, token).
"""
raise NotImplementedError(".authenticate() must be overridden.")
def authenticate_header(self, request):
"""
Return a string to be used as the value of the `WWW-Authenticate`
header in a `401 Unauthenticated` response, or `None` if the
authentication scheme should return `403 Permission Denied` responses.
"""
pass
1.在自己项目中创建模块auth.py
auth.py(验证器)
继承自BaseAuthentication
alt+enter 来实现BaseAuthenticate里的抽象方法authenticate。
454531.png
authenticate方法认证成功后会返回一个元祖，元祖里有两个元素：一个是用户，一个是令牌
1.通过request.query_params.get('token')拿到token
2.通过token拿到user_id
3.同通过user_id找到use
from django.core.cache import cache
from rest_framework.authentication import BaseAuthentication
from AuthenticationAndPermission.models import User
class UserAuthentication(BaseAuthentication):
# 认证方法 认证成功会返回一个元组， 元组中包含两个元素，一个是用户，另外一个是令牌
def authenticate(self, request):
try:
token = request.query_params.get("token")
user_id = cache.get(token)
user = User.objects.get(pk=user_id)
except Exception as e:
print(e)
return None
return user, token
serializer.py
先只看Userserializer类
from rest_framework import serializers
from AuthenticationAndPermission.models import User, Blog, Address
class UserSerializer(serializers.ModelSerializer):
class Meta:
model = User
fields = ("id", "u_name", "u_password")
class BlogSerializer(serializers.ModelSerializer):
b_author = serializers.ReadOnlyField(source="b_author.u_name")
class Meta:
model = Blog
fields = ("id", "b_title", "b_content", "b_author")
class AddressSerializer(serializers.ModelSerializer):
class Meta:
model = Address
fields = ("id", "a_address")
view.py
添加验证器：
就是将代码给抽离出来了，变成了一个配置的方式
authentication_classes = ('auth.py创建的类')
get函数用来做后续判断
如果拿不到令牌，抛出异常
还是返回self.list(request, *args, **kwargs)
class BlogsAPIView(ListCreateAPIView):
queryset = Blog.objects.all()
serializer_class = BlogSerializer
# 验证
authentication_classes = (UserAuthentication)
# 后续判断
def get(self, request, *args, **kwargs):
if not request.auth:
raise APIException(detail='没有auth')
return self.list(request, *args, **kwargs)
不重写get函数，实现验证
下面就是权限，因为登录也是一种权限，登录和没有登录页面是不一样的
权限
- 什么是权限
- 代表操作某类，某种行为的一种限定
- REST-Framework
- 通过用户身份判定是否具有某权限
- as_view
- dispatch
- initial
- check_permissions
- get_permissions
- permission_classes
- 对权限检查进行遍历
- has_permission
- 如果能通过权限检测，所有权限均满足
- 有一个权限通不过，你就没有权限操作
- get_permissions
- check_permissions
- initial
- dispatch
3242345.png
dispatch里有一个initial，initial有一个执行认证函数
53.png
initial有一个执行认证函数perform_authentication(request)
下一步检查权限check_permission(request)点进去
屏幕快照 2018-11-17 下午9.23.23.png
get_permission():拿到权限进行遍历，如果有一个不通过所有就不通过，就直接拒绝。
has_permission()方法：如果能通过权限检测，所有权限均满足，有一个权限通不过，就没有权限操作
345436.png
get_peimission()是从我们自己提供的permission_classes类(就是自己定义的权限类)
21313.png
24234243.png
自定义权限
有两个方法，默认都返回True，默认都有权限
23419.png
通过request拿到user
user是User的 Model对象才能登陆的，否则就不是user，就登陆不了
from rest_framework.permissions import BasePermission
from AuthenticationAndPermission.models import User
class LoginPermission(BasePermission):
def has_permission(self, request, view):
try:
user = request.user
if isinstance(user, User):
return True
except Exception as e:
print(e)
return False
views.py
这里面的就可以将get方法去掉了
class BlogsAPIView(ListCreateAPIView):
queryset = Blog.objects.all()
serializer_class = BlogSerializer
# 验证
authentication_classes = (UserAuthentication)
# 权限
permission_calsses = (Loginpermission)
# 后续判断
# def get(self, request, *args, **kwargs):
# if not request.auth:
# raise APIException(detail='没有auth')
# return self.list(request, *args, **kwargs)
queryset = Models.objects.all()
要操作的数据，操作的数据是哪个
authentication_classes = ()
认证模块解决的问题：
必须登录才能访问，如果登录了，将登录的用户和登录的令牌存在request中
permission_classes = ()
权限：根据用户的级别，限定能不能访问这个接口
如果那个接口必须登录，给这个接口价格属性就可以了
class AddressesAPIView(ListCreateAPIView):
serializer_class = AddressSerializer
queryset = Address.objects.all()
authentication_classes = (UserAuthentication,)
permission_classes = (LoginPermission,)
eg:
serializer.py
class AddressSerializer(serializers.ModelSerializer):
class Meta:
model = Address
fields = ("id", "a_address")
views.py
authentication_classes是用户登陆状态的获取
permission_classes是用户登陆状态的判断
class AddressesAPIView(ListCreateAPIView):
serilizer_class = AddressSerializer
queryset = Address.objects.all()
# 用户登陆才能看
authentication_classes = (UserAuthentication,)
permission_classes = (LoginPermission,)
权限认证总结
- 为什么实现
- 因为它们的是在dispatch中执行的
- 在get，post，delete等之前执行的
- 提前做了检测，验证
- 和中间件有啥区别？
- 更具灵活性
- 在指定的类中使用
数据级联
views.py
需求在存储过程中将博客内容和用户级联在一起
分析：只要能进到authentication_classes和permission_classes中意味着已经登录了，所以只需要重写CreateAPIView，将博客内容和用户级联在一起就可以了
三个函数：
create函数：serializer：获取序列化数据，serializer_is_valid:可用的，self.perform_create(serializer):执行创建
preform_create函数：将序列化数据保存
直接修改序列化存储过程，需要重写perform_create函数,在save()的时候将user给传进去
eqqgggr07.png
重写
preform_create(self, serializer):
首先拿到user，self.request.user: self代表APIView，APIView有request属性
需求二
只查出自己发表的博客
只需重写
get_queryset()方法,现在的queryset是Blog，所以要根据b_author=self.request.user进行筛选
xzcz.png
如果父类里的判断功能也需要加上下面的代码:
query_set = super().get_queryset()super()是父类的代理对象
return query_set.filter(b_author=self.request.user)
这样获取就是当前用户的，
应用场景比如在做地址查询的时候，不可能查出所有地址，只能查出自己的地址
class BlogsAPIView(ListCreateAPIView):
serializer_class = BlogSerializer
queryset = Blog.objects.all()
authentication_classes = (UserAuthentication,)
permission_classes = (LoginPermission, )
# throttle_classes = (BlogThrottling,)
def perform_create(self, serializer):
serializer.save(b_author=self.request.user)
def get_queryset(self):
return self.queryset.filter(b_author=self.request.user)
# query_set = super().get_queryset()
# return query_set.filter(b_author=self.request.user)
serializer.py
需要在博客里加上b_author
在存的时候就可以在views.py里serializer.save(b_author=self.request.user),但是这样会报错：'This field is required',需要重写b_author字段改为只读。b_author = serializers.ReadOnlyField()
class BlogSerializer(serializer.ModelSerializer):
# 如果想将作者名字映射，加上下面这个字段
b_author = serializers.ReadOnlyField(source='b_author.u_name') # 只给一个名字就不涉及到序列化了
class Meta:
model = Blog
# 如果想将作者名字映射，加上下面这个字段
fields = ('id', 'b_title', 'b_content', 'b_author')
# 如果值返回博客内容不返回作者名字，加上下面这个字段
fields = ('id', 'b_title', 'b_content')
urls.py
from django.conf.urls import url
from AuthenticationAndPermission import views
urlpatterns = [
url(r'^users/', views.UsersAPIView.as_view()),
url(r'^blogs/', views.BlogsAPIView.as_view()),
url(r'^addresses/', views.AddressesAPIView.as_view()),
]
models.py
related_name='隐性属性的名字'可以不指定，如果不改就是blogs_set
from django.db import models
class User(models.Model):
u_name = models.CharField(max_length=32, unique=True)
u_password = models.CharField(max_length=256)
def check_password(self, password):
return self.u_password == password
class Blog(models.Model):
b_title = models.CharField(max_length=128)
b_content = models.TextField()
# related_name='隐性属性的名字'可以不指定，如果不改就是blogs_set
b_author = models.ForeignKey(User)
class Address(models.Model):
a_address = models.CharField(max_length=128)
a_user = models.ForeignKey(User)
