django 之(三) --- 会话|关系|静态*

会话技术

　　HTTP在web开发中基本都是短连接[一个请求的生命周期都是从request开始到response结束]。

　　下次再来请求就是一个新的连接了。为了让服务器端记住用户端是否登陆过就出现了会话技术

　种类：

• Cookie： 客户端[浏览器端]会话技术。
• Session：服务端会话技术
• Token：  服务端会话技术

　总结：

• Cookie使用更简洁，服务器压力更小，数据不是很安全

• Session服务器要维护Session，相对安全

• Token拥有Session的所有优点，自己维护略微麻烦，支持更多的终端

Coookie

　简单介绍

• Cookie本身是由浏览器生成，客户端[浏览器端]会话技术。
• Cookie中的数据是以“键值对”方式存储在客户端的。
• Cookie是可以支持过期时间、默认不支持中文[加盐也不支持]
• Cookie不可跨域名、不可跨网站、不可跨浏览器使用
• 默认Cookie会携带本网站所有Cookie通过Response将cookie值写到浏览器端，下一次request访问时浏览器会携带cookie到服务器端验证身份。

　设置Cookie：

• response.set_cookie(key, value [,max_age=None,exprise=None]) 
  • response.set_cookie(key, value, max_age=None, exprise=None)
  • max_age：整数，指定cookie过期时间。[max_age和expries两个任选一个指定]  
    • max_age 设置为0浏览器关闭失效，设置为None永不过期
  • expries：整数，指定过期时间，还支持是datetime或timedelta，可以指定一个具体日期时间 
    • expires = timedelta(days=10) 10天后过期

　获取Cookie：

• request.COOKIES.get('key')

　简单使用：

• urls.py

from django.conf.urls import url, include
from django.contrib import admin

urlpatterns = [
    url(r'^admin/', admin.site.urls),
    url(r'App/',include('App.urls',namespace='App')),
]

• App/urls.py

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

urlpatterns=[
    url(r'^setcookie/',views.set_cookie,name='set_cookie'),
    url(r'^getcookie/',views.get_cookie,name='get_cookie'),
]

• App/views.py

# cookile 设置
def set_cookie(request):
    response = HttpResponse('设置cookie')
    response.set_cookie('username','gypls')
    return response


# coockie 获取
def get_cookie(request):
    username = request.COOKIES.get('username')
    return HttpResponse(username)

 　加密 [加盐]

• response.set_signed_cookie('key', value, '加盐密钥')

  • response.set_signed_cookie('content', uname, 'gypls')

　解密

• request.get_signed_cookie('key', salt='加盐的密钥')

  • request.get_signed_cookie('content', salt='gypls')

　删除

• response.delete_cookie('key')

  • response.delete_cookie('content')

　使用方法：

• App/urls.py 

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

urlpatterns=[
    #登陆
    url(r'^login/',views.login,name='login'),
    url(r'^mine/',views.mine,name='mine'),
    #退出
    url(r'^logout/',views.logout,name='logout'),
]

• App/views.py

# 登陆
def login(request):
    if request.method == "POST":
        uname = request.POST.get('uname')
        response = redirect(reverse('app:mine'))
        response.set_signed_cookie('content', uname, 'gypls')      # 加盐[加密]
        return response
    return render(request, 'login.html')

# 个人中心
def mine(request):
    try:
        uname = request.get_signed_cookie('content', salt='gypls')  # 解密
        if uname:
            return render(request, 'mine.html', context={'uname': uname})
    except Exception as e:
        print('获取失败')
    return redirect(reverse('app:login'))

def logout(request):
    response = redirect(reverse('app:login'))
    response.delete_cookie('content')
    return response

Session

 　简单介绍

• Session服务端会话技术，数据存储在服务器中。Session原本默认存储在内存[RAM]中,

• Django中会默认会把Session持久化[存]到数据库session表中，默认过期时间是14天

• 主键是字符串。数据是使用了数据安全[使用的base64，在前部添加了一个混淆串]

• Session依赖于Cookie，将Session的session_key赋值到Cookie中某个建传给服务器端。

• 下次请求的时候，服务器端通过Cookie中的session_key去数据库中查询，有则认证通过

• 「经验之谈：数据中以"="结尾，一般使用的是base64编码」

 　简单总结

　　Session是服务端会话技术，数据存储在服务端。当我们调用request.session['key']时，Django默认会帮我们将这个session键和值加密并持久化的

　　存到名为Django_session的数据库表中，"键"存储到一个session_key字段，我们的session数据会存到session_data字段中，同时会有一个过期时

　　间字段expire_data，默认设置过期时间为14天。同时通过Cookie将这条数据的唯一标识session_key传给客户端，客户端给这个标识起了一个新的

　　名字叫session_id，就把session_key的值存到了cookie的session_id里面。以后再来请求服务器就会带着这个session_id，根据session_id中存放的

　　session_key就可以在数据库中的Django_session表中找到我们的session值，从而实现会话技术

　设置Session

• request.session['key'] = value  [存session是存在服务器端的，所以用request]

  • username = request.POST.get('username')

  • request.session['username'] = username 

　获取Session

• request.session.get('key')

  • request.session.get('username')

　删除Session 　

•  删除cookie的sessionid键值对来实现session退出登陆。response.delete_cookie('sessionid')
  • 缺陷：django_session表中的数据不会被删除
•  删除session直接来实现退出登陆。　del request.session['key']
  • 缺陷：django_session表中的数据不会被删除
  • del request.session['username']
• 全部删除数据 session 和 cookie。    request.session.flush()
  • 最优选择

　简单使用：

•  urls.py

from django.conf.urls import url, include
from django.contrib import admin

urlpatterns = [
    url(r'^admin/', admin.site.urls),
    url(r'Two/',include('Two.urls',namespace='two')),
]

• Two/urls.py

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

urlpatterns = [
    url(r'^login/',views.login,name='login'),
    url(r'^mine/',views.mine,name='mine'),
    url(r'^logout/',views.logout,name='logout'),
]

• Two/views.py

from django.shortcuts import render, redirect
from django.urls import reverse

# 登陆
def login(request):
    if request.method == "GET":
        return render(request,'two_login.html')
    elif request.method == "POST":
        username = request.POST.get('username')
        request.session['username'] = username
        return redirect(reverse('two:mine'))

def mine(request):
    username = request.session.get('username')
    # username = request.session['username']  此方法如果key不存在会抛异常,不建议使用
    return render(request,'two_mine.html',context=locals())

# 退出登陆的三种方式
def logout(request):
    response = redirect(reverse('two:login'))
    # 删除cookie 来实现退出登陆。缺陷，django_session表中还会有数据
    response.delete_cookie('sessionid')
    # 删除session 来实现退出登陆。缺陷，django_session表中还会有数据
    del request.session['username']
    # 全部删除数据 session 和 cookie。最优，django_session表中的数据也会被清除掉
    request.session.flush()
    return response 

总结

　常用操作

• get(key, default=None)根据键获取会话的值
• clear()清楚所有会话
• flush()删除当前的会话数据并删除会话的cookie
• delete request['session_id'] 删除会话
• session.session_key获取session的key

　设置数据

• request.session[‘user’] = username
• 数据存储到数据库中会进行编码使用的是Base64

Token

　简单介绍： 

• Token是服务器端会话技术，相当于自定义的session。
• Token如果在web开发中，使用起来基本和session一致，也是依赖于cookie。
• Token是在服务器端生成唯一标识"键"，真实开发中会Token当作"键"与用户信息当作"值"一起存储到缓存cache中，并设置过期时间。
  • 如果是使用在移动端类型的客户端开发中，通常将Token以json格式传输给移动端，然后移动端需要自己存储Token。
  • 移动端获取需要Token认证的相关数据的时候[如登陆后的界面]，主动将移动端存储的Token传递给服务器端进行验证。
  • 服务器端通过移动端传递过来的Token"键"，去缓存cache中查找对应的值"用户信息"，从而实现移动端和服务器端的会话技术。

　简单使用：

• Two/urls.py

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

urlpatterns = [
    url(r'^register/',views.register,name='register'),
    url(r'^studentlogin/',views.student_login,name='student_login'),
    url(r'^studentmine/',views.student_mine,name='student_mine'),
]

• Two/models.py

from django.db import models

class Student(models.Model):
    s_name = models.CharField(max_length=16,unique=True)
    s_password = models.CharField(max_length=128)

• Two/views.py

from django.core.cache import cache
from django.http import HttpResponse
from django.shortcuts import render, redirect
from django.urls import reverse
from Two.models import Student
import uuid

# token 会话。用户注册
def register(request):
    if request.method == 'GET':
        return render(request, 'student_register.html')
    elif request.method == 'POST':
        username = request.POST.get('username')
        password = request.POST.get('password')
        try:
            student = Student()
            student.s_name = username
            student.s_password = password
            student.save()
        except Exception as e:
            return redirect(reverse("two:register"))
        return redirect(reverse("two:student_login"))

# token 会话。用户登陆
def student_login(request):
    if request.method == 'GET':
        return render(request, 'student_login.html')
    elif request.method == 'POST':
        username = request.POST.get('username')
        password = request.POST.get('password')
        students = Student.objects.filter(s_name=username).filter(s_password=password)
        if students.exists():
            student = students.first()
            names = student.s_name
            # 生成唯一表示Token
            token = generate_token()
            # 将token存到缓存中。cache.set(键[Token],值,过期时间)
            cache.set(token, names, 60 * 60 * 24)
            # pc端的请求返回方式
            response = HttpResponse('用户登陆成功')
            # 依赖于cookie将token返回给pc浏览器端
            response.set_cookie('token', token)
            return response
        # pc端返回
        return redirect(reverse('two:student_login'))
        # 移动端登陆成功返回数据的方法，仅为样式不可执行
        #     data = {
        #         'status':200,
        #         'msg':'login success',
        #         'token':token
        #     }
        #     return JsonResponse(data=data)

        # 移动端登陆验证失败返回数据的方法，仅为样式不可以执行
        # data = {
        #     'status':800,
        #     'msg':'verify fail',
        # }
        # return JsonResponse(data=data)

# 自定义tokon
def generate_token():
    # 使用uuid设置token[键]的唯一值
    token = uuid.uuid4().hex
    return token

def student_mine(request):
    token = request.COOKIES.get('token')
    try:
        # 验证是否有token值[是否是登陆状态]
        sname = cache.get(token)
        print(sname)
        print(type(sname))  # str
    except Exception as e:
        return redirect(reverse('two:student_login'))
    # pc浏览器端返回
    return HttpResponse("用户的姓名:", sname)
    # 移动端返回数据样式。此处代码仅为样式不可执行
    # data = {
    #     'msg':'ok',
    #     'status':200,
    #     'data':{
    #         'username':student.s_name,
    #     }
    # }
    # return JsonResponse(data=data)

---

模型关系

　常见的几种数据关系，django都提供了很好的支持。主从表定义：当系统遭遇不可避免的毁灭时多张只能保留一张表，保留的就是主表。[如用户表]

　在企业开发中，一般主表数据不会被随意删除，因为其可能及联好多从表的数据，主表数据一旦删除从表数据也会被及联删除，可能导致系统崩溃

一对一 [1：1]

　业务场景： 

• 拆分：
  • 比如一张用户表，其功能过于强大，一张用户表中就可能会出现两百多个字段甚至更多，管理起来很麻烦，查询效率也会大大降低。
  • 这时就需要将其表中的数据拆分开，将一张用户表拆分成一张主表和若干张从表，这样每张表有十几个字段，每张表负责不同的功能。
• 级联：
  • 比如在已经设计好的一张用户表中，开发过程中功能是增量式的操作，需要增加新的字段来实现增加新的功能，比如token认证。
  • 就可以新建一张表来设置这些字段，然后和原来的用户表进行一对一的绑定，就可以实现不改变原来表的基础上增加新字段。

　使用实现：

• 实现： 
  • 在Django模型中使用 models.OneToOneField(要关联表的模型名，其他约束) 进行关联。谁声明关系谁是从表
  • 其实还是借助外键实现的。使用外键实现，对外键添加唯一约束。主表数据删除时，从表数据会被及联删除；从表数据删除时，主表数据不会被及联删除
  • 在DDL中 从表声明一个外键和主表进行绑定，开始其实是从表是多对主表是一的关系。之后在从表对多的上面添加了唯一约束，从而实现一对一的约束。
• 约束：

  • p_id = models.OneToOneField(Person, null=True, blank=True, on_delete=models.PROTECT)

  • on_delete = 以下约束字段

  • models.CASCADE 默认模式。主表数据删除时，从表数据及联删除；从表数据删除，主表数据不受影响

  • models.PROTECT 保护模式。

    • 主表数据删除时，如果主表无从表，主表数据可以删除成功。如果主表有级联从表，从表数据受到保护删除请求会抛出保护异常

    • 开发中为了防止误操作，通常设置成此模式。若必须删除主表数据时，需要提前将主表对应的所有从表的对应数据删除。然后再操作删除主表相应数据
  • models.SET_NULL       置空模式。主表删除时将从表的外键关系设置为空值[前提是此字段允许为NULL]。在一对一关系中常用此设置
  • models.SET_DEFAULT 置默认值。主表删除时将从表的外键关系设置为一个默认值[前提是存在设置的默认值]
  • models.SET()              删除的时候重新动态指向一个实体

from django.db import models

# 1:1 人员表和身份证表一对一关联
# 人员的表
class Person(models.Model):
    p_name = models.CharField(max_length=16)
    p_sex = models.BooleanField(default=False)

# 身份证表
class IDCard(models.Model):
    id_num = models.CharField(max_length=18, unique=True)
    id_person = models.OneToOneField(Person, null=True, blank=True, on_delete=models.PROTECT)

• 注意：
  • 在迁移同步到mysql数据库中时从表身份证表中声明的外键属性id_person会自动被生成名为id_person_id字段。
  • 当 ‘从表对象.从表模型中定义的外键字段[属性]名’ 时，获取到的是主表的对象，拿着此对象去获取主表中的字段

•  获取
• 由主表对象获取从表对象的字段数据：主表对象 . 从表在数据库中的名[隐性属性] . 从表相应的字段名
• 由从表对象获取主表对象的字段数据：从表对象 . 从表外键字段属性名[显性属性] . 主表相应的字段名

def get_person(request):
    idcard = IDCard.objects.last()
    person = idcard.id_person
    return HttpResponse(person.p_name)


def get_idcard(request):
    person = Person.objects.last()
    idcard = person.idcard
    return HttpResponse(idcard.id_num)

---

一对多 [1：N]

　使用实现：

• 实现：
  • 在django中使用 models.ForeignKey(要关联表的模型名，其他约束字段) 进行关联，多是从表。

• 获取

  • 主获取从： [隐性属性]级联模型对应数据库中的表名_set

    • 如 班级[主]和学生[从]关系模型：student_set

    • 也是Manager的子类，Manager上能使用的函数在这都能使用。如：all、filter、exclude、切片

  • 从获取主： [显性属性]

• 删除
  • 同一对一操作 

---

多对多 [N：M]

　使用实现：

• 实现：
  • 在django中使用 models.ManyToManyField(要关联的表的模型名，其他约束字段)
  • 实际上关系最复杂。开发中很少直接使用多对多属性，而是自己维护多对多的关系[如自己创建一个购物车表存放客户和商品的主键]
  • 迁移同步时，数据库会自己新建一张额外的关系表，关系表中的多个外键字段是需要关联关系的各表的主键，以及和一些自己的字段。

# N : M 一类商品可以被多个人购买；一个人可以购买多类商品。产生的关系表就是典型购物车模型
class Customer(models.Model):
    c_name = models.CharField(max_length=16)


class Goods(models.Model):
    g_name = models.CharField(max_length=16)
    g_customer = models.ManyToManyField(Customer)

• 注意：

  • 迁移同步在数据库中生成表的时候会单独的生成一张关系表。关系表中的各外键字段不能同时相等

  • 关系表中存储有关联各表的主键，通过多个外键实现的。约束是同时加在各外键上的，多个外键值不能同时相等

  • 在ManyToManyField中，删除一个不存在的数据不会报错，添加一个已存在的数据，不会被添加成功也不报错

• 获取

  • 主获取从：[隐性属性] 也是Manager子类，操作和从操作主完全一样

• • 从获取主：[显性属性] 也是Manager子类，支持all、filter、exclude、切片使用

  • 方法：级连数据操作的方法有：add、remove、clear、set

def add_to_cart(request):
    customer = Customer.objects.last()
    goods = Goods.objects.last()
    goods.g_customer.add(customer)# 由商品添加顾客，从设置主
    customer.goods_set.add(goods) # 由顾客添加商品，主设置从
    return HttpResponse('添加成功')


# 获取级连数据
def get_goods_list(request, customerid):
    customer = Customer.objects.get(pk=customerid)
    goods_list = customer.goods_set.all() # 主获取从
    return render(request, 'goods_list.html', context=locals())

# 注意
def add_to_cart(request):
    customer = Customer.objects.last()
    goods = Goods.objects.last()
    print(goods.g_customer)       # App.Customer.None
    print(type(goods.g_customer)) # <class 'django.db.models.fields.related_descriptors.create_forward_many_to_many_manager.<locals>.ManyRelatedManager'>
    return HttpResponse('添加成功')

　　注意：ManyRelatedManager 函数中定义的类，并且父类是一个函数的参数，此方法叫做动态创建。

　　

静态

静态资源

• 配置　　

　　　　在settings.py中的底部配置static的文件夹，用来加载些模板中用到的资源提供给全局使用，这个静态文件主要用来配置CSS、HTML、图片、字体文件等。

　　　　和Template的区别在于，不需要MTV渲染就可以显示，只能支持原生的HTML，里面的东西是静态的。

• • STATIC_URL = '/static/'    
  • STATICFILES_DIRS = [os.path.join(BASE_DIR,'static')]   
• 使用

　　　　之后在模板中，首先加载静态文件，之后调用静态，就不用写绝对全路径了

• • 模板中的声明：{% load static%} 或 {% load staticfiles %}
  • 引用资源时使用：{% static 'xxx' %}    [xxx就是相对于staticfiles_dirs的一个位置]

 文件上传 [头像上传]

　　注意 要使用POST方式上传

• urls.py 

# 主路由
from django.conf.urls import url, include
from django.contrib import admin

urlpatterns = [
    url(r'^admin/', admin.site.urls),
    url(r'^App/',include('App.urls',namespace='app')),
]

# 子路由
from django.conf.urls import url
from App import views

urlpatterns = [
    url(r'^uploadfile/', views.upload_file, name='upload_file'),
    url(r'^imagefield/', views.image_field, name='image_filed'),
]

•  原生写法
  •  views.py

from django.http import HttpResponse
from django.shortcuts import render

def upload_file(request):
    if request.method == 'GET':
        return render(request,'upload.html')
    elif request.method == 'POST':
        icon = request.FILES.get('icon')
        # 存储
        with open('/Users/guoyapeng/pyword/1django1.11/django05/SqlToModel/static/icon.jpg','wb') as save_file:
            # chunks()函数 是将文件打成一块一块的
            for part in icon.chunks():
                save_file.write(part)
                save_file.flush()
        return HttpResponse('文件上传成功')

• • upload.html

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <title>文件上传</title>
</head>
<body>
{# enctype="multipart/form-data 意思是将图片包打碎加密传输 #}
<form action="{% url 'app:upload_file' %}" method="post" enctype="multipart/form-data">
   {% csrf_token %}
    <span>文件：</span>
    <input type="file" name="icon">
    <br>
    <input type="submit" value="上传">
</form>

</body>
</html>

• 封装实现 
  • 在settings.py中配置指定相对路径位置：MEDIA_ROOT = os.path.join(BASE_DIR,'static/upload')
  • 安装pillow：pip install pillow -i https://pypi.douban.com
  • models.py

from django.db import models

class UserModel(models.Model):
    u_name = models.CharField(max_length=16)
    # upload_to是相对于settions.py配置的MEDIA_ROOT媒体路径的相对路径
    u_icon = models.ImageField(upload_to='%Y/%m/%d/icon')

• • views.py

from django.http import HttpResponse
from django.shortcuts import render
from App.models import UserModel
# 上传到数据库中
def image_field(request):
    if request.method == 'GET':
        return render(request,'image_filed.html')
    elif request.method == 'POST':
        username = request.POST.get('usernmae')
        icon = request.FILES.get('icon')

        user = UserModel()
        user.u_name = username
        user.u_icon = icon
        user.save()

    return HttpResponse('上传成功')

• • image_filed.html

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <title>Title</title>
</head>
<body>

<form action="{% url 'app:image_filed' %}" method="post" enctype="multipart/form-data">
   {% csrf_token %}
    <span>用户名：</span><input type="text" name="username" placeholder="请输入用户名">
    <br>
    <span>头像：</span><input type="file" name="icon">
    <br>
    <input type="submit" value="上传">
</form>

</body>
</html>

• •  views.py

from django.http import HttpResponse
from django.shortcuts import render
from App.models import UserModel


# 获取文件信息[比如头像]
def mine(request):
    username = request.GET.get("username")
    user = UserModel.objects.get(u_name=username)
    print("/static/upload/" + user.u_icon.url)
    data = {
        "username": username,
        "icon_url": "/static/upload/" + user.u_icon.url,
    }
    return render(request, "mine.html", context=data)

• • mine.html

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <title>Mine</title>
</head>
<body>
<h3>{{ username }}</h3>
<img src="{{ icon_url }}" alt="{{ username }}">
</body>
</html>

补充

常用算法

　常用算法：Base64、urlencode

　算法种类：

• 摘要算法，指纹算法，杂凑算法：
  • MD5：默认是128位的，四位一组变32位
  • SHA：当向不可逆，不叫加密解密、不管输入多长，输出都是固定长度、只要输入有任意的变更，输出都会发生很大的变化
• 加密算法
  • 对称加密：DES、AES。可以用同一把钥匙加密解密。加密效率高，钥匙一旦丢失数据就全部丢失。
  • 非对称加密：RSA、PGP。一对钥匙，相互制约，公钥加密的数据只有私钥可解开，私钥加密的数据只有公钥才可解开。安全性高，算法复杂需要时间长