Django---Http协议简述和原理,HTTP请求码,HTTP请求格式和响应格式(重点),Django的安装与使用,Django项目的创建和运行(cmd和pycharm两种模式),Django的基础文件配置,Web框架的本质,服务器程序和应用程序(wsgiref服务端模块,jinja2模板渲染模块)的使用

Django---Http协议简述和原理,HTTP请求码,HTTP请求格式和响应格式(重点),Django的安装与使用,Django项目的创建和运行(cmd和pycharm两种模式),Django的基础文件配置,Web框架的本质,服务器程序和应用程序(wsgiref服务端模块,jinja2模板渲染模块)的使用

一丶Http协议

http协议简介

      超文本传输协议(hyper Text Transfer Protocol :HTTP),是一种用于分布式,协作式和超媒体信息系统的应用层协议.

      HTTP是万维网的数据通信的基础,http的有很多的应用,但最著名的是用于web浏览器和web服务区之间的双工通信(双工:即双通道)

      http协议使用最广泛的一个版本 --HTTP1.1 , 2015年http2.0版本发布

http协议概述

# 1. Http是一个客户端 和 服务端 ,请求和应答的标准.
# 2. 客户端发起一个http请求到服务端,服务端向客户端返回一些存放在服务器上的资源.
# 3. http协议存在'应用层',http需要可靠的传输,http是基于TCP/IP传输之上的协议

​      由HTTP客户端发起一个请求，创建一个到服务器指定端口（默认是80端口）的TCP连接。HTTP服务器则在那个端口监听客户端的请求。一旦收到请求，服务器会向客户端返回一个状态，比如"HTTP/1.1 200 OK"，以及返回的内容，如请求的文件、错误消息、或者其它信息。

http工作原理

      1.client端连接到WebServer端(建立一个基于tcp的套接字连接)

      2.客户端发起http请求(通过tcp套接字,向服务端发送一个文本的请求报文.报文包含:请求行,请求头,空行和请求数据)

​      3.Web服务器接收请求并返回HTTP响应(web服务器解析请求,定位请求资源. 通过tcp套接字向客户端发送响应,响应包含:响应状态行,响应头部,空行和响应数据)

​      4.释放tcp连接

#	若connection 模式为close，则服务器主动关闭TCP连接，客户端被动关闭连接，释放TCP连接;若connection 模式为keepalive，则该连接会保持一段时间，在该时间内可以继续接收请求;

​      5.客户端浏览器解析html数据

#	客户端浏览器首先解析状态行，查看表明请求是否成功的状态代码。然后解析每一个响应头，响应头告知以下为若干字节的HTML文档和文档的字符集。客户端浏览器读取响应数据HTML，根据HTML的语法对其进行格式化，并在浏览器窗口中显示

​      浏览器 url请求经历的事情

### 浏览器 url请求经历的事情
    # 1. 浏览器向 DNS 服务器请求解析该 URL 中的域名所对应的 IP 地址;

    # 2. 解析出 IP 地址后，根据该 IP 地址和默认端口 80，和服务器建立TCP连接;

    # 3. 浏览器发出读取文件(URL 中域名后面部分对应的文件)的HTTP 请求，该请求报文作为 TCP 三次握手的第三个报文的数据发送给服务器;

    # 4. 服务器对浏览器请求作出响应，并把对应的 html 文本发送给浏览器;

    # 5. 释放 TCP连接;

    # 6. 浏览器将该 html 文本内容显示; 

http请求方法

​      http/1.1协议定义了八种方法,最常用post和get方法

# 1. get	
	获取数据
    
# 2. post
	提交数据,数据封装在请求体里面
    
# 3. head
	与GET方法一样，都是向服务器发出指定资源的请求。只不过服务器将不传回资源的本文部分。它的好处在于，使用这个方法可以在不必传输全部内容的情况下，就可以获取其中“关于该资源的信息”（元信息或称元数据）。
    
# 4. put
	向指定资源位置上传其最新内容。
    
# 5. delete
	请求服务器删除Request-URI所标识的资源
    
# 6. trace
	回显服务器收到的请求，主要用于测试或诊断
    
# 7. options
	这个方法可使服务器传回该资源所支持的所有HTTP请求方法。用'*'来代替资源名称，向Web服务器发送OPTIONS请求，可以测试服务器功能是否正常运作。
    
# 8. connect
	HTTP/1.1协议中预留给能够将连接改为管道方式的代理服务器。通常用于SSL加密服务器的链接（经由非加密的HTTP代理服务器）
    注意事项：
       I. 方法名称是区分大小写的。当某个请求所针对的资源不支持对应的请求方法的时候，服务器应当返回状态码405（Method Not Allowed），当服务器不认识或者不支持对应的请求方法的时候，应当返回状态码501（Not Implemented）。
       II. HTTP服务器至少应该实现GET和HEAD方法，其他方法都是可选的。当然，所有的方法支持的实现都应当匹配下述的方法各自的语义定义。此外，除了上述方法，特定的HTTP服务器还能够扩展自定义的方法。例如PATCH（由 RFC 5789 指定的方法）用于将局部修改应用到资源。

http状态码

      http响应的第一行都是状态行,3位数字组成的状态码.状态码和状态描述端语由空格分隔

# 1XX信息---请求已被服务器接收
# 2XX成功---请求成功,请求已被服务器接收,解析,并响应
# 3XX重定向---重新请求别的url
# 4XX请求错误---请求含有错误,或资源不存在.
# 5XX服务器错误---服务器处理错误,或者是服务宕机,网速慢等影响

URL

​      统一资源定位符

# 1. 传送协议。

# 2. 层级URL标记符号(为[//],固定不变)

# 3. 访问资源需要的凭证信息（可省略）

# 4. 服务器。（通常为域名，有时为IP地址）

# 5. 端口号。（以数字方式表示，若为HTTP的默认值“:80”可省略）

# 6. 路径。（以“/”字符区别路径中的每一个目录名称）

# 7. 查询。（GET模式的窗体参数，以“?”字符为起点，每个参数以“&”隔开，再以“=”分开参数名称与数据，通常以UTF8的URL编码，避开字符冲突的问题）

# 8. 片段。以“#”字符为起点

      例子

// http://www.baidu.com:80/news/index.html?id=250&page=1 为例, 其中：
    http，是协议；
    www.baidu.com，是服务器；
    80，是服务器上的网络端口号；
    /news/index.html，是路径；
    ?id=250&page=1，是查询。

http请求格式

http响应格式

二丶Django的使用

下载安装

​      1.cmd安装

# 使用 pip 安装
	pip3 install django==1.11.23 -i https://pypi.tuna.tsinghua.edu.cn/simple

​      2.pycharm

# 1. 选择File
# 2. 选择settings配置
# 3. 选择 Project: PythonDjango,
# 4. 选择 Project Interpreter----> 选中使用的解释器---->点击 '+' 号 ---->搜索django,specify version 选择版本---->点击Install Package

创建项目

​      1.cmd

# 1. 在某文件下,进入cmd命令行
# 2. 输入: django-admin startproject 项目名 ,  如:django-admin startproject mySite
# 3. 创建项目成功,进入mySite
# 4. 启动项目: python manage.py runserver ip 端口  如: >python manage.py runserver 192.168.XXX.XXX:8001

​      2.pycharm

# 1. 选择Django项目
# 2. 填写此项目存在地址和项目名称
# 3. 创建成功
# 4. 点击绿色三角启动按钮

模板文件配置：

TEMPLATES = [
    {
        'BACKEND': 'django.template.backends.django.DjangoTemplates',
        'DIRS': [os.path.join(BASE_DIR, "template")],  #重点: template文件夹位置
        'APP_DIRS': True,
        'OPTIONS': {
            'context_processors': [
                'django.template.context_processors.debug',
                'django.template.context_processors.request',
                'django.contrib.auth.context_processors.auth',
                'django.contrib.messages.context_processors.messages',
            ],
        },
    },
]

静态文件配置

# settings文件配置
    STATIC_URL = '/static/'  # HTML中使用的静态文件夹前缀
    STATICFILES_DIRS = [
        os.path.join(BASE_DIR, "static"),  # 静态文件存放位置
    ]

​      静态资源配置过程如下图:👇

Django基础必备三件套：

# 导入语法
	from django.shortcuts import HttpResponse, render, redirect
    
# HttpReponse:这是一个类,把字符串参数传入,实例化一个对象.
	def index(request):
    # 业务逻辑代码
    return HttpResponse("OK")

# render:除request参数外还接受一个待渲染的模板文件和一个保存具体数据的字典参数
	def index(request):
    # 业务逻辑代码
    return render(request, "index.html", {"name": "alex", "hobby": ["烫头", "泡吧"]})

# redirect:接受一个URL参数，表示跳转到指定的URL。
	def index(request):
    # 业务逻辑代码
    return redirect("/home/")

三丶Web框架的本质

      所有的Web应用本质上就是一个socket服务端，而用户的浏览器就是一个socket客户端。 这样我们就可以自己实现Web框架了。

## socket 服务端
import socket  
  
sk = socket.socket()  
sk.bind(("127.0.0.1", 80))  
sk.listen()  
  
  
while True:  
    conn, addr = sk.accept()  
    data = conn.recv(8096)  
    print(data)  # 将浏览器发来的消息打印出来  
    conn.send(b"OK")  
    conn.close()  
    
    
### 输出的结果
    GET / HTTP/1.1  
    Host: 127.0.0.1:8080  
    Connection: keep-alive  
    Cache-Control: max-age=0  
    Upgrade-Insecure-Requests: 1  
    User-Agent: Mozilla/5.0 (Windows NT 6.1; WOW64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/66.0.3355.4 Safari/537.36  
    Accept: text/html,application/xhtml+xml,application/xml;q=0.9,image/webp,image/apng,*/*;q=0.8  
    Accept-Encoding: gzip, deflate, br  
    Accept-Language: zh-CN,zh;q=0.9  
    Cookie: csrftoken=CtHePYARJOKNx5oNVwxIteOJXpNyJ29L4bW4506YoVqFaIFFaHm0EWDZqKmw6Jm8 

HTTP GET请求的格式：

HTTP响应的格式：

自定义web框架

import socket    
    
sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)    
sock.bind(('127.0.0.1', 8000))    
sock.listen()    
    
while True:    
    conn, addr = sock.accept()    
    data = conn.recv(8096)    
    # 给回复的消息加上响应状态行    
    conn.send(b"HTTP/1.1 200 OK\r\n\r\n")    
    conn.send(b"OK")    
    conn.close() 

根据不同的路径返回不同的内容

""" 
根据URL中不同的路径返回不同的内容 
"""  
  
import socket  
  
sk = socket.socket()  
sk.bind(("127.0.0.1", 8080))  # 绑定IP和端口  
sk.listen()  # 监听  
  
while True:  
    # 等待连接  
    conn, add = sk.accept()  
    data = conn.recv(8096)  # 接收客户端发来的消息  
    # 从data中取到路径  
    data = str(data, encoding="utf8")  # 把收到的字节类型的数据转换成字符串  
    # 按\r\n分割  
    data1 = data.split("\r\n")[0]  
    url = data1.split()[1]  # url是我们从浏览器发过来的消息中分离出的访问路径  
    conn.send(b'HTTP/1.1 200 OK\r\n\r\n')  # 因为要遵循HTTP协议，所以回复的消息也要加状态行  
    # 根据不同的路径返回不同内容  
    if url == "/index/":  
        response = b"index"  
    elif url == "/home/":  
        response = b"home"  
    else:  
        response = b"404 not found!"  
  
    conn.send(response)  
    conn.close()  

根据不同的路径返回不同的内容--函数版

""" 
根据URL中不同的路径返回不同的内容--函数版 
"""  
  
import socket  
  
sk = socket.socket()  
sk.bind(("127.0.0.1", 8080))  # 绑定IP和端口  
sk.listen()  # 监听  
  
  
# 将返回不同的内容部分封装成函数  
def func(url):  
    s = "这是{}页面！".format(url)  
    return bytes(s, encoding="utf8")  
  
  
while True:  
    # 等待连接  
    conn, add = sk.accept()  
    data = conn.recv(8096)  # 接收客户端发来的消息  
    # 从data中取到路径  
    data = str(data, encoding="utf8")  # 把收到的字节类型的数据转换成字符串  
    # 按\r\n分割  
    data1 = data.split("\r\n")[0]  
    url = data1.split()[1]  # url是我们从浏览器发过来的消息中分离出的访问路径  
    conn.send(b'HTTP/1.1 200 OK\r\n\r\n')  # 因为要遵循HTTP协议，所以回复的消息也要加状态行  
    # 根据不同的路径返回不同内容，response是具体的响应体  
    if url == "/index/":  
        response = func(url)  
    elif url == "/home/":  
        response = func(url)  
    else:  
        response = b"404 not found!"  
  
    conn.send(response)  
    conn.close()  

返回具体的HTML文件

""" 
根据URL中不同的路径返回不同的内容--函数进阶版 
返回独立的HTML页面 
"""  
  
import socket  
  
sk = socket.socket()  
sk.bind(("127.0.0.1", 8080))  # 绑定IP和端口  
sk.listen()  # 监听  
  
  
# 将返回不同的内容部分封装成不同的函数  
def index(url):  
    # 读取index.html页面的内容  
    with open("index.html", "r", encoding="utf8") as f:  
        s = f.read()  
    # 返回字节数据  
    return bytes(s, encoding="utf8")  
  
  
def home(url):  
    with open("home.html", "r", encoding="utf8") as f:  
        s = f.read()  
    return bytes(s, encoding="utf8")  
  
  
# 定义一个url和实际要执行的函数的对应关系  
list1 = [  
    ("/index/", index),  
    ("/home/", home),  
]  
  
while True:  
    # 等待连接  
    conn, add = sk.accept()  
    data = conn.recv(8096)  # 接收客户端发来的消息  
    # 从data中取到路径  
    data = str(data, encoding="utf8")  # 把收到的字节类型的数据转换成字符串  
    # 按\r\n分割  
    data1 = data.split("\r\n")[0]  
    url = data1.split()[1]  # url是我们从浏览器发过来的消息中分离出的访问路径  
    conn.send(b'HTTP/1.1 200 OK\r\n\r\n')  # 因为要遵循HTTP协议，所以回复的消息也要加状态行  
    # 根据不同的路径返回不同内容  
    func = None  # 定义一个保存将要执行的函数名的变量  
    for item in list1:  
        if item[0] == url:  
            func = item[1]  
            break  
    if func:  
        response = func(url)  
    else:  
        response = b"404 not found!"  
  
    # 返回具体的响应消息  
    conn.send(response)  
    conn.close() 

网页动态

""" 
根据URL中不同的路径返回不同的内容--函数进阶版 
返回独立的HTML页面 
"""  
  
import socket  
  
sk = socket.socket()  
sk.bind(("127.0.0.1", 8080))  # 绑定IP和端口  
sk.listen()  # 监听  
  
  
# 将返回不同的内容部分封装成不同的函数  
def index(url):  
    # 读取index.html页面的内容  
    with open("index.html", "r", encoding="utf8") as f:  
        s = f.read()  
    # 返回字节数据  
    return bytes(s, encoding="utf8")  
  
  
def home(url):  
    with open("home.html", "r", encoding="utf8") as f:  
        s = f.read()  
    return bytes(s, encoding="utf8")  
  
  
def timer(url):  
    import time  
    with open("time.html", "r", encoding="utf8") as f:  
        s = f.read()  
        s = s.replace('@@time@@', time.strftime("%Y-%m-%d %H:%M:%S"))  
    return bytes(s, encoding="utf8")  
  
  
# 定义一个url和实际要执行的函数的对应关系  
list1 = [  
    ("/index/", index),  
    ("/home/", home),  
    ("/time/", timer),  
]  
  
while True:  
    # 等待连接  
    conn, add = sk.accept()  
    data = conn.recv(8096)  # 接收客户端发来的消息  
    # 从data中取到路径  
    data = str(data, encoding="utf8")  # 把收到的字节类型的数据转换成字符串  
    # 按\r\n分割  
    data1 = data.split("\r\n")[0]  
    url = data1.split()[1]  # url是我们从浏览器发过来的消息中分离出的访问路径  
    conn.send(b'HTTP/1.1 200 OK\r\n\r\n')  # 因为要遵循HTTP协议，所以回复的消息也要加状态行  
    # 根据不同的路径返回不同内容  
    func = None  # 定义一个保存将要执行的函数名的变量  
    for item in list1:  
        if item[0] == url:  
            func = item[1]  
            break  
    if func:  
        response = func(url)  
    else:  
        response = b"404 not found!"  
  
    # 返回具体的响应消息  
    conn.send(response)  
    conn.close()  

四丶服务器程序和应用程序

      python web程序来说，一般会分为两部分：服务器程序和应用程序。

	服务器程序负责对socket服务端进行封装，并在请求到来时，对请求的各种数据进行整理。

	应用程序则负责具体的逻辑处理。为了方便应用程序的开发，就出现了众多的Web框架，例如：Django、Flask、web.py 等。不同的框架有不同的开发方式，但是无论如何，开发出的应用程序都要和服务器程序配合，才能为用户提供服务。

      WSGI（Web Server Gateway Interface）就是一种规范，它定义了使用Python编写的web应用程序与web服务器程序之间的接口格式，实现web应用程序与web服务器程序间的解耦。

    常用的WSGI服务器有uWSGI、Gunicorn。而Python标准库提供的独立WSGI服务器叫wsgiref，Django开发环境用的就是这个模块来做服务器。

wsgiref:python原生模块实现服务端

"""  
根据URL中不同的路径返回不同的内容--函数进阶版  
返回HTML页面  
让网页动态起来  
wsgiref模块版  
"""   
     
from wsgiref.simple_server import make_server   
     
     
# 将返回不同的内容部分封装成函数   
def index(url):   
    # 读取index.html页面的内容   
    with open("index.html", "r", encoding="utf8") as f:   
        s = f.read()   
    # 返回字节数据   
    return bytes(s, encoding="utf8")   
     
     
def home(url):   
    with open("home.html", "r", encoding="utf8") as f:   
        s = f.read()   
    return bytes(s, encoding="utf8")   
     
     
def timer(url):   
    import time   
    with open("time.html", "r", encoding="utf8") as f:   
        s = f.read()   
        s = s.replace('@@time@@', time.strftime("%Y-%m-%d %H:%M:%S"))   
    return bytes(s, encoding="utf8")   
     
     
# 定义一个url和实际要执行的函数的对应关系   
list1 = [   
    ("/index/", index),   
    ("/home/", home),   
    ("/time/", timer),   
]   
     
     
def run_server(environ, start_response):   
    start_response('200 OK', [('Content-Type', 'text/html;charset=utf8'), ])  # 设置HTTP响应的状态码和头信息   
    url = environ['PATH_INFO']  # 取到用户输入的url   
    func = None   
    for i in list1:   
        if i[0] == url:   
            func = i[1]   
            break   
    if func:   
        response = func(url)   
    else:   
        response = b"404 not found!"   
    return [response, ]   
     
     
if __name__ == '__main__':   
    httpd = make_server('127.0.0.1', 8090, run_server)   
    print("我在8090等你哦...")   
    httpd.serve_forever()  

jinja2:浏览器html渲染模块

​      HTML模板渲染数据,本质上就是HTML内容中利用一些特殊的符号来替换要展示的数据

      安装:pip install jinja2

// index2.html页面

<!DOCTYPE html>
<html lang="zh-CN">
<head>
  <meta charset="UTF-8">
  <meta http-equiv="x-ua-compatible" content="IE=edge">
  <meta name="viewport" content="width=device-width, initial-scale=1">
  <title>Title</title>
</head>
<body>
    <h1>姓名：{{name}}</h1>
    <h1>爱好：</h1>
    <ul>
        {% for hobby in hobby_list %}
        <li>{{hobby}}</li>
        {% endfor %}
    </ul>
</body>
</html>

from wsgiref.simple_server import make_server  
from jinja2 import Template  
  
  
def index(url):  
    # 读取HTML文件内容  
    with open("index2.html", "r", encoding="utf8") as f:  
        data = f.read()  
        template = Template(data)   # 生成模板文件  
        ret = template.render({'name': 'alex', 'hobby_list': ['抽烟', '喝酒', '烫头']})   # 把数据填充到模板中  
    return bytes(ret, encoding="utf8")  
  
  
def home(url):  
    with open("home.html", "r", encoding="utf8") as f:  
        s = f.read()  
    return bytes(s, encoding="utf8")  
  
  
# 定义一个url和实际要执行的函数的对应关系  
list1 = [  
    ("/index/", index),  
    ("/home/", home),  
]  
  
  
def run_server(environ, start_response):  
    start_response('200 OK', [('Content-Type', 'text/html;charset=utf8'), ])  # 设置HTTP响应的状态码和头信息  
    url = environ['PATH_INFO']  # 取到用户输入的url  
    func = None  
    for i in list1:  
        if i[0] == url:  
            func = i[1]  
            break  
    if func:  
        response = func(url)  
    else:  
        response = b"404 not found!"  
    return [response, ]  
  
  
if __name__ == '__main__':  
    httpd = make_server('127.0.0.1', 8090, run_server)  
    print("我在8090等你哦...")  
    httpd.serve_forever()  

      模板的原理就是字符串替换，我们只要在HTML页面中遵循jinja2的语法规则写上，其内部就会按照指定的语法进行相应的替换，从而达到动态的返回内容。