web后端--Django学习笔记08

一、第七天作业

1.有两个单选按钮，选择“小猫”单选按钮，则下方显示小猫图片，选择“小狗”单选按钮，则下方显示小狗图片，要求使用jQuery实现Ajax，根据前台选择的数据从后台发送图片地址。

1.1代码演示

1、settings

STATIC_URL = '/yourpet/'

STATICFILES_DIRS = [
    os.path.join(BASE_DIR,'static_resources'),
    os.path.join(BASE_DIR,'upload'),
]

2、templates

<!animal.html>
<!DOCTYPE html>
{% load static %}
<html lang="en">
<head>
    <meta charset="UTF-8">
    <title>Ajax访问图片</title>
    <script src="{% static 'js/jquery-3.1.1.js' %}"></script>
    <script type="text/javascript">
        $(function(){
            $("input[name=animal]").change(function(){
                if($(this).prop("checked")){
                    $.ajax({
                        url:'/homework/animal/'+$(this).val()+"/",
                        success:function(data){
                             var pic_path=data.imgpath;
                             var color = data.color;
                             var info = data.info;
                             $("#animal_pic").prop("src",pic_path);
                             $("#msg").css("color",color).html(info);
                        }
                    });
                }
            });
        })
    </script>
</head>
<body>
    小猫：<input type="radio" name="animal" value="cat" checked="checked"/> &nbsp;&nbsp;
    小狗：<input type="radio" name="animal" value="dog"/> &nbsp;&nbsp; <br/>
    <img src="{% static 'images/cat.jpg' %}" id="animal_pic"/> <br/>
    <span id="msg"></span>
</body>
</html>

3、views

from django.http import JsonResponse
from django.shortcuts import render

def go_animal(request):
    return render(request,'homework/animal.html')

def send_animal(request,pet):
    if pet == "cat":
        return JsonResponse({"imgpath":"/yourpet/images/cat.jpg","color":"green","info":"可爱的小猫"}) #HttpRsponse子类，返回js对象
    else:
        return JsonResponse({"imgpath": "/yourpet/images/dog.jpg", "color": "blue","info":"漂亮的小狗"})

4、urls

#子路由
from django.urls import path
from homework.views import *

app_name = "homework"

urlpatterns = [
    path('go/',go_animal),
    path('animal/<pet>/',send_animal,name="pet"),
]
#总路由
 path('homework/',include('homework.urls',namespace="home")),

二、扩展Django自带认证系统

第一步：自定义一个模型类，继承AbstractUser，则该模型类既拥有Django认证系统的操作方法，又可以扩展自定义属性。

第二步：在settings.py中设置AUTH_USER_MODEL，将其设置为：AUTH_USER_MODEL = "app名称.自定义模型类名"
AUTH_USER_MODEL = "authapp.MyUser"
补充：使用@login_required装饰器装饰的视图函数，只有在用户登录的情况下才能调用，否则，则未登录用户被重定向到settings.py中配置的LOGIN_URL指定的路由地址；或者通过@login_required(login_url="未登录重定向地址")设置。
LOGIN_URL = "/authapp/nologin/"  # 未登录用户跳转路径

2.1 代码演示

1、models

from django.contrib.auth.models import AbstractUser
from django.db import models

class MyUser(AbstractUser):
    tel = models.CharField(max_length=20)
    qq = models.CharField(max_length=15)
    wechat = models.CharField(max_length=20)

    class Meta:
        db_table = "myusers"

2、views

from django.contrib.auth import authenticate, login, logout
from django.contrib.auth.decorators import login_required
from django.shortcuts import render, redirect
from django.urls import reverse

from authapp.models import MyUser

def go_register(request):
    return render(request,'authapp/register.html')

def go_login(request):
    return render(request, 'authapp/login.html')

def wrong_login(request,msg):
    return render(request, 'authapp/login.html',locals())

@login_required    #装饰器， 未登录不能调用该函数
def go_success(request):
    return render(request,'authapp/success.html')

def no_login(request):
    return render(request,'authapp/login.html',{"msg":"您还未登录，请先登录！"})

# 注册
def register(request):
    regname = request.POST["regname"]
    regpwd = request.POST["regpwd"]
    regtel = request.POST["regtel"]
    regqq = request.POST["regqq"]
    regwechat = request.POST["regwechat"]
    MyUser.objects.create_user(username=regname,password=regpwd,tel=regtel,qq=regqq,wechat=regwechat)
    return redirect(reverse("auth:gologin")) #重定向


# 登录
def myuser_login(request):
    logname = request.POST["logname"]
    logpwd = request.POST["logpwd"]
    user = authenticate(username=logname,password=logpwd)   # 验证用户名和密码是否正确
    if user is not None:
        login(request,user)   # 将用户与Session关联，登陆
        return redirect(reverse("auth:success")) #跳到成功页面
    else:
        return redirect(reverse("auth:wrong",args=("用户名或密码错误，请重新输入",)))


# 注销
def myuser_logout(request):
    logout(request)
    return redirect(reverse("auth:gologin"))

3、templates

<!register.html>
<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <title>注册页面</title>
</head>
<body>
    <form action="{% url 'auth:reg' %}" method="post">
        {% csrf_token %}
        注册用户名：<input type="text" name="regname"/>  <br/>
        注册密码：<input type="password" name="regpwd"/>  <br/>
        联系电话：<input type="text" name="regtel"/>  <br/>
        QQ：<input type="text" name="regqq"/>  <br/>
        微信号：<input type="text" name="regwechat"/>  <br/>
        <input type="submit" value="注册"/>
    </form>
</body>
</html>

<!goloin.html>
<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <title>登录页面</title>
</head>
<body>
    <h3 style="color:red"> {{ msg }} </h3>
    <form action="{% url 'auth:login' %}" method="post">
        {% csrf_token %}
        用户名：<input type="text" name="logname"/>  <br/>
        密码：<input type="password" name="logpwd"/>  <br/>
        <input type="submit" value="登录"/>
    </form>
</body>
</html>

<!succcess.html>
<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <title>成功页面</title>
</head>
<body>
    <h3>恭喜，<span style="color:blue">{{ request.user.username }},访问本网站~~~ </span></h3>
    <a href="{% url 'auth:logout' %}">注销</a>
</body>
</html>

4、urls

#子路由
from django.urls import path
from authapp.views import *

app_name = "authapp"

urlpatterns = [
    path('goreg/',go_register),
    path('gologin/',go_login,name="gologin"),
    path('wronglogin/<msg>/',wrong_login,name="wrong"),
    path('nologin/',no_login,name="nologin"),
    path('gosuccess/',go_success,name="success"),


    path('register/',register,name="reg"),
    path('login/',myuser_login,name='login'),
    path('logout/',myuser_logout,name="logout"),
]
#总路由
 from django.contrib import admin
from django.urls import path,include

urlpatterns = [
    path('admin/', admin.site.urls),
    path('authapp/',include('authapp.urls',namespace='auth')),
]

三、文件上传

1. 上传文件所在的表单必须设置enctype="multipart/form-data"。 2. 后台接收,获取上传文件对象：upload_file = request.FILES.get("文件域名称") 3. 分块写入服务器： for chunk in upload_file.chunks(): # 将上传文件分块写入目标路径目标文件.write(chunk) # 分块写入

1.1 发代码演示

1、views

from django.http import HttpResponse
from django.shortcuts import render, redirect
import os,uuid

from django.urls import reverse

BASE_DIR = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))

def go_upload(request):
    return render(request,'uploadapp/upload.html')

def go_success(request,picpath):
    return render(request,'uploadapp/success.html',locals())

def upload(request):
    upload_file = request.FILES.get("upload_file")  # 接收上传文件，通过表单域的名称获取上传文件
    dest_file_path = os.path.join(BASE_DIR,'upload','images',upload_file.name)  # 拼接上传到的目标文件路径
    with open(dest_file_path,'wb') as f:
        for chunk in upload_file.chunks():   # 将上传文件分块写入目标路径
            f.write(chunk)  # 分块写入

    pic_path = "images/" + upload_file.name
    return redirect(reverse("uploadapp:success",args=(pic_path,)))

2、templates

<!templates/uploadapp/upload.html>
<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <title>上传文件</title>
</head>
<body>
    <form action="{% url 'uploadapp:upload' %}" method="post" enctype="multipart/form-data"><!以数据流形式上传>
        {% csrf_token %}
        <input type="file" name="upload_file"/>  <br/>
        <input type="submit" value="点击上传"/>
    </form>
</body>
</html>

<!templates/uploadapp/success.html>
<!DOCTYPE html>
{% load static %}
<html lang="en">
<head>
    <meta charset="UTF-8">
    <title>上传成功页面</title>
</head>
<body>
    <h3>您上传的图片是：</h3>
    <img src="{% static picpath %}"/>
</body>
</html>

3、urls

#子路由
from django.urls import path
from uploadapp.views import *

app_name = "uploadapp"

urlpatterns = [
    path('goupload/',go_upload),
    path('gosuccess/<path:picpath>/',go_success,name="success"),
    path('uploadfile/',upload,name="upload"),
]
#总路由
from django.contrib import admin
from django.urls import path,include

urlpatterns = [
    path('admin/', admin.site.urls),
    path('uploadapp/',include('uploadapp.urls',namespace="uploadapp")),

四、Memcached缓存

文件安装下载地址：http://www.runoob.com/Memcached/window-install-memcached.html

1、memcached <1.4.5 版本安装

1、解压下载的安装包到指定目录。

2、在 1.4.5 版本以前 memcached 可以作为一个服务安装，使用管理员权限运行以下命令：

c:\memcached\memcached.exe -d install

注意：你需要使用真实的路径替代 c:\memcached\memcached.exe。

3、然后我们可以使用以下命令来启动和关闭 memcached 服务：

c:\memcached\memcached.exe -d start
c:\memcached\memcached.exe -d stop

4、如果要修改 memcached 的配置项, 可以在命令行中执行 regedit.exe 命令打开注册表并找到 "HKEY_LOCAL_MACHINE\SYSTEM\CurrentControlSet\Services\memcached" 来进行修改。

如果要提供 memcached 使用的缓存配置可以修改 ImagePath 为:

"c:\memcached\memcached.exe" -d runservice -m 512

-m 512 意思是设置 memcached 最大的缓存配置为512M。

此外我们还可以通过使用 "c:\memcached\memcached.exe -h" 命令查看更多的参数配置。

5、如果我们需要卸载 memcached ，可以使用以下命令：

c:\memcached\memcached.exe -d uninstall

2、memcached >= 1.4.5 版本安装

1、解压下载的安装包到指定目录。

2、在 memcached1.4.5 版本之后，memcached 不能作为服务来运行，需要使用任务计划中来开启一个普通的进程，在 window 启动时设置 memcached自动执行。

我们使用管理员身份执行以下命令将 memcached 添加来任务计划表中：

schtasks /create /sc onstart /tn memcached /tr "'c:\memcached\memcached.exe' -m 512"

注意：你需要使用真实的路径替代 c:\memcached\memcached.exe。

注意：**-m 512** 意思是设置 memcached 最大的缓存配置为512M。

注意：我们可以通过使用 "c:\memcached\memcached.exe -h" 命令查看更多的参数配置。

3、如果需要删除 memcached 的任务计划可以执行以下命令：

schtasks /delete /tn memcached

3、python安装memcached


Memcached是一个基于内存的缓存框架（服务）。
   1.安装Windows版的Memcached:
    切换到含有memcached.exe文件的目录，执行命令：
    memcached -d install
   2.启动memcached服务
     net start "Memcached Server"

   3.安装Python操作Memcached的绑定程序
     pip install python-memcached

   4.在Django配置文件setttings.py中添加配置：
     CACHES = {
         'default': {
              'BACKEND': 'django.core.cache.backends.memcached.MemcachedCache',
              'LOCATION': '127.0.0.1:11211',
        }
    }

#注意：Memcached可以在多台服务器上共享缓存，通过LOCATION指定多台机器的地址和端口
#例如：
CACHES = {
       'default': {
              'BACKEND': 'django.core.cache.backends.memcached.MemcachedCache',
              'LOCATION': [
                     '172.19.26.240:11211',
                     '172.19.26.242:11211', 
               ]
        }
}

1.1 代码演示

1、views

import memcache
from django.shortcuts import render

from memcachedapp.models import Product


def get_product(request,product_id):
    mc = memcache.Client(["localhost:11211",]) # 获取代表memcache服务器的连接池对象
    product = mc.get("product:"+product_id)  # 从Memcache获取一个Product对象
    if product:
        msg = "缓存命中了，以下为从缓存中查出的数据："
    else:
        product = Product.objects.get(id=product_id)  # 从MySQL数据库中查数据
        mc.set("product:"+str(product.id),product,30)  # 将数据存储到Memcached
        msg = "以下是从MySQL中查询的："

    return render(request, 'memcachedapp/product.html', locals())

2、templates

<!/teplates/memcached/products.html>
<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <title>产品信息</title>
</head>
<body>
    <h3 style="color:red"> {{ msg }} </h3>
    <ul>
        <li>产品编号：{{ product.id }} </li>
        <li>产品名称：{{ product.name }} </li>
        <li>产品价格：{{ product.price }} </li>
    </ul>
</body>
</html>

3、models

from django.db import models

class Product(models.Model):
    name = models.CharField(max_length=20,verbose_name="产品名称")
    price = models.FloatField(verbose_name="价格")

    def __str__(self):
        return self.name

    class Meta:
        db_table = "products"
        verbose_name_plural = "产品模型"

4、urls

#子路由
from django.urls import path
from memcachedapp.views import *

urlpatterns = [
    path('product/<product_id>/',get_product),
]
#总路由
from django.contrib import admin
from django.urls import path,include

urlpatterns = [
    path('admin/', admin.site.urls),
    path('memcached/',include('memcachedapp.urls')),