web框架之Django<一、初识>

一、什么是web框架

框架，即framework，特指为解决一个开放性问题而设计的具有一定约束性的支撑结构，使用框架可以帮你快速开发特定的系统，简单地说，就是你用别人搭建好的舞台来做表演。

对于所有的Web应用，本质上其实就是一个socket服务端，用户的浏览器其实就是一个socket客户端。

import socket

def handle_request(client):

    buf = client.recv()
    client.send("HTTP/1.1 200 OK\r\n\r\n".encode("utf8"))
    client.send("<h1 style='color:red'>Hello, yuan</h1>".encode("utf8"))

def main():

    sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
    sock.bind(('localhost',))
    sock.listen()

    while True:
        connection, address = sock.accept()
        handle_request(connection)
        connection.close()

if __name__ == '__main__':

    main()

最简单的Web应用就是先把HTML用文件保存好，用一个现成的HTTP服务器软件，接收用户请求，从文件中读取HTML，返回。

如果要动态生成HTML，就需要把上述步骤自己来实现。不过，接受HTTP请求、解析HTTP请求、发送HTTP响应都是苦力活，如果我们自己来写这些底层代码，还没开始写动态HTML呢，就得花个把月去读HTTP规范。

正确的做法是底层代码由专门的服务器软件实现，我们用Python专注于生成HTML文档。因为我们不希望接触到TCP连接、HTTP原始请求和响应格式，所以，需要一个统一的接口，让我们专心用Python编写Web业务。

这个接口就是WSGI：Web Server Gateway Interface。

想了解详情点击我

from wsgiref.simple_server import make_server

def application(environ, start_response):
    start_response('200 OK', [('Content-Type', 'text/html')])
    return [b'<h1>Hello, web!</h1>']

httpd = make_server('', , application)

print('Serving HTTP on port 8000...')
# 开始监听HTTP请求:
httpd.serve_forever()

解析
整个application()函数本身没有涉及到任何解析HTTP的部分，也就是说，底层代码不需要我们自己编写，
我们只负责在更高层次上考虑如何响应请求就可以了。

application()函数必须由WSGI服务器来调用。有很多符合WSGI规范的服务器，我们可以挑选一个来用。

Python内置了一个WSGI服务器，这个模块叫wsgiref    

application()函数就是符合WSGI标准的一个HTTP处理函数，它接收两个参数：

        //environ：一个包含所有HTTP请求信息的dict对象；

        //start_response：一个发送HTTP响应的函数。

在application()函数中，调用：

start_response('200 OK', [('Content-Type', 'text/html')])

就发送了HTTP响应的Header，注意Header只能发送一次，也就是只能调用一次start_response()函数。
start_response()函数接收两个参数，一个是HTTP响应码，一个是一组list表示的HTTP Header，每
个Header用一个包含两个str的tuple表示。

通常情况下，都应该把Content-Type头发送给浏览器。其他很多常用的HTTP Header也应该发送。

然后，函数的返回值b'<h1>Hello, web!</h1>'将作为HTTP响应的Body发送给浏览器。

有了WSGI，我们关心的就是如何从environ这个dict对象拿到HTTP请求信息，然后构造HTML，
通过start_response()发送Header，最后返回Body。

二、再次引入MVC和MTV模式

著名的MVC模式：所谓MVC就是把web应用分为模型(M),控制器(C),视图(V)三层；他们之间以一种插件似的，松耦合的方式连接在一起。

模型负责业务对象与数据库的对象(ORM),视图负责与用户的交互(页面)，控制器(C)接受用户的输入调用模型和视图完成用户的请求。

Django的MTV模式本质上与MVC模式没有什么差别，也是各组件之间为了保持松耦合关系，只是定义上有些许不同，Django的MTV分别代表：

Model(模型)：负责业务对象与数据库的对象(ORM)

Template(模版)：负责如何把页面展示给用户

View(视图)：负责业务逻辑，并在适当的时候调用Model和Template

此外，Django还有一个url分发器，它的作用是将一个个URL的页面请求分发给不同的view处理，view再调用相应的Model和Template

1、用户访问页面。发送url到控制器

2、控制器决定请求由哪个函数去处理也就是到view

3、在view里面决定给用户显示什么内容

4、如果涉及到数据库，那么view去数据库处理数据返回到模板

对于大的项目可以分为 project工程，然后再往下分为多个app相当于多个部门，然后每个部门就写自己的代码就行了

三、Django的流程和命令行工具

django
    #安装： pip3 install django

          添加环境变量

    #  创建project
       django-admin startproject mysite

       ---mysite

          ---settings.py
          ---url.py
          ---wsgi.py

       ---- manage.py(启动文件)  

    #  创建APP
       python mannage.py startapp  app01

    #  settings配置

       TEMPLATES

       STATICFILES_DIRS=(
            os.path.join(BASE_DIR,"statics"),
        )

       STATIC_URL = '/static/'
       #  我们只能用 STATIC_URL，但STATIC_URL会按着你的STATICFILES_DIRS去找#  根据需求设计代码
           url.py
           view.py

    #  使用模版
       render(req,"index.html")   

    #  启动项目
       python manage.py runserver  127.0.0.1:

    #  连接数据库，操作数据
       model.py

django的命令行工具

django-admin.py 是Django的一个用于管理任务的命令行工具，manage.py是对django－admin.py的简单包装,每一个Django Project里都会有一个mannage.py。

views：视图函数

《1》       创建一个django工程：命令行操作： django-admin startproject （名字）

如果要在django中创建第二个“部门”  python manage.py startapp app02(app02是文件夹名字)

示例：

D:\>django-admin startproject mysite

当前目录下生成的mysite的工程，目录结构如下：

• manage.py ----- Django项目里面的工具，通过它可以调用django shell和数据库等。
• settings.py ---- 包含了项目的默认设置，包括数据库信息，调试标志以及其他一些工作的变量。
• urls.py ----- 负责把URL模式映射到应用程序。

<2>在mysite目录下创建blog应用:python manage.py startapp blog  （黄色部分为自定义名字）

自动生成下面

进入blog

小试牛刀：

在blog下的views中写上函数

from django.shortcuts import render,HttpResponse

# Create your views here.
def cur_time(request):
    return HttpResponse("<h1>ok<h1>")

之后在mysite中的urls中写上路由系统

from django.conf.urls import url
from django.contrib import admin
from blog import  views
urlpatterns = [
    url(r'^admin/', admin.site.urls),
    url(r"^cur_time/",views.cur_time)
]

<3>启动django项目：

一种是在命令行中启动: python manage.py runserver 8080    后面是名字和端口，可以不指定端口，那么就默认是本地端口

第二种

启动访问页面http://127.0.0.1:8000/cur_time/

就出现了ok

实例：在django中创建添加用户信息显示在web界面上

用到的：1、在Mydjango中添加路由。2、在views中添加视图函数。3、templates添加前端

首先目录：

在mydjango包中urls

from django.conf.urls import url
from django.contrib import admin
from app01 import  views
urlpatterns = [
    url(r'^admin/', admin.site.urls),
    url(r"^cur_time/",views.cur_time),

    url(r"^userInfo/",views.userInfo)
]

在app01中的views

user_list=[]
#前端的信息(请求头等)全部封装到req
def userInfo(req):
    #这里的POST必须大写
    if req.method=="POST":
#里面封装的是字典,这里的username和前端form表单中的username是一样的
#req.POST是一个字典{"username":aa,"sex":bb}
        username=req.POST.get("username",None)
        sex=req.POST.get("sex",None)
        email=req.POST.get("email",None)
        user={"username":username,"sex":sex,"email":email}
        user_list.append(user)

    return render(req,"index.html",{"user_list":user_list})

index前端文件

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <title>Title</title>
</head>
<body>
<form action="/userInfo/" method="post">
    <p><input type="text" placeholder="姓名" name="username"/></p>
    <p><input type="text" placeholder="性别" name="sex"/></p>
    <p><input type="email" placeholder="邮箱" name="email"/></p>
    <p><input type="submit" value="submit"/></p>
</form>
<hr>
<h1>数据展示</h1>
<table border="1px">
    <tr>
        <td>姓名</td>
        <td>性别</td>
        <td>邮箱</td>
    </tr>
{#    这里传过来的user_list中会有很多内容[{},{},{}...]#}
    {% for i in user_list %}
    <tr>
        <td>{{ i.username }}</td>
        <td>{{ i.sex }}</td>
        <td>{{ i.email }}</td>
    </tr>
    {% endfor %}
</table>
</body>
</html>

用户连接http://127.0.0.1:8000/userInfo/

这里用到的模板语言类似jinjia2.这里前端的模板语言是在后台渲染之后发送到浏览器中

连接数据库

1、首先下载db

下面在settings中，这个就是数据库的配置。

ENGINE对应的就是数据库连接生成，配置下面的之后就需要创建表，在models里面创建

DATABASES = {
    'default': {
        'ENGINE': 'django.db.backends.sqlite3',
        'NAME': os.path.join(BASE_DIR, 'db.sqlite3'),
    }
}

一、创建数据库。在models中

from django.db import models

# Create your models here.
#创建表，之后要继承Model
class UserInfo(models.Model):
    username=models.CharField(max_length=)
    sex=models.CharField(max_length=)
    email=models.CharField(max_length=)

二、创建数据库之后让数据库表生成操作

重启并且创建表

python manage.py makemigrations
python manage.py migrate

三、让db.sqlite3拉到Database里面显示，如果前面没有下载，可以在这个时候下载

四、在view视图函数中链接数据库并且把前端内容传入到数据库中并且显示

from app01 import models
#前端的信息(请求头等)全部封装到req
def userInfo(req):
    #这里的POST必须大写
    if req.method=="POST":
#里面封装的是字典,这里的username和前端form表单中的username是一样的
#req.POST是一个字典{"username":aa,"sex":bb}
        u=req.POST.get("username",None)
        s=req.POST.get("sex",None)
        e=req.POST.get("email",None)
    #数据库添加数据
        models.UserInfo.objects.create(
            username=u,
            sex=s,
            email=e,
        )
    #数据库获取数据
    user_list=models.UserInfo.objects.all()

    return render(req,"index.html",{"user_list":user_list})

连接前端页面http://127.0.0.1:8000/userInfo/ 填入数据然后submit，数据就会在数据展示中显示

数据库中显示内容如下

django文件作用讲解

首先自己的“部门” app文件详细如下：

admin：后台管理可以看到各种各样的表

apps：对当前app做配置

models：创建数据库

tests：单元测试用

urls：路由系统这里是在和项目名字相同的。用来存放全局的

views：视图函数

小结

一、创建以及运行  分为命令行和IDE创建

a)         创建project  django-admin startproject mysite

b)         创建app   cd mysite  python3 startapp app01

c)         运行程序     python3 manage.py runserver 127..

二 目录结构

三、操作

a)         配置路由，对应函数

b)          def test(request):

i.              return HttpResponse(“xx”)  相当于self.write

ii.              return render(request,”test.html”)  #相当于tornadoself.render

iii.              return render_to_response(“test.html”)  #这个和上面的一样只不过这个不能做csrf

iv.              return redirect(“/index/”) # 这里跳转的是url

c)         配置文件  首先配置模板路径

i.              配置模板路径，在settings里面

TEMPLATE_DIRS = (

os.path.join(BASE_DIR,'templates'),

)

ii.              配置静态文件，并且下面的必须要加逗号

STATIC_URL = '/abc/'#由于静态文件在后端，后端会经常更改文件名，所以这个时候就需要用这个设置别名的方式用来避免这个繁琐的操作
STATICFILES_DIRS=(
    os.path.join(BASE_DIR,"statics"),
)

static_url: 
配置前缀

staticfiles_dirs:配置前缀

Django配置文件settings

1、模板相关

TEMPLATES = [
    {
        'BACKEND': 'django.template.backends.django.DjangoTemplates',
        'DIRS': [os.path.join(BASE_DIR, 'templates')]  #模板去哪里找
        ,
        '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',
            ],
        },
    },
]

2、配置静态文件

STATIC_URL = '/static/'#由于静态文件在后端，后端会经常更改文件名，所以这个时候就需要用这个设置别名的方式用来避免这个繁琐的操作

STATICFILES_DIRS=(
    os.path.join(BASE_DIR,"statics"),
)

例子：

首先在settings里面设置

STATIC_URL = '/abc/'#由于静态文件在后端，后端会经常更改文件名，所以这个时候就需要用这个设置别名的方式用来避免这个繁琐的操作
STATICFILES_DIRS=(
    os.path.join(BASE_DIR,"statics"),
)

之后在index.html中设置静态文件路径

注意  STARTICFILES_DIRS里面必须要有逗号，要不然会出错

运行

上面流程：

1、  在settings中设置静态文件路径，并且让静态文件路径设置别名

2、  在前端页面中添加以别名为开头的静态文件的路径，这个路径如果有多个文件夹要显示