特色栏目： python 批处理 net编程 Javascript Php Asp Css Html5 Android seo centos

当前位置 : 主页 > 编程语言 > 其它开发 >

Django-初见

来源：互联网收集：自由互联发布时间：2022-05-30

目录安装启动 HTTP请求URL路由项目APP 返回页面内容给浏览器路由路由子表创建数据库定义数据库表创建数据库表 Django Admin 读取数据库数据过滤条件对资源的增查改删处理 CRUD

安装&启动
HTTP请求URL路由
- 项目APP
- 返回页面内容给浏览器
- 路由
- 路由子表
创建数据库
- 定义数据库表
- 创建数据库表
- Django Admin
读取数据库数据
- 过滤条件
对资源的增查改删处理
- CRUD
- 临时取消 CSRF 校验
- 前端整合
实现登录
- session 方案
数据库表的关联
参考

安装&启动

IDEA 这里安装即可。安装后 new 一个新项目，在控制台使用

python manage.py runserver 0.0.0.0:80

出现 Django 的图标就说明好了。

manage.py：命令行工具，内置多种方式与项目进行交互。
_ _init _ _.py：初始化文件，一般情况下无需修改。
settings.py：项目配置文件，项目的所有功能都需要在该文件中进行配置。
urls.py：项目的路由设置，设置网站的具体内容。
wsgi.py：全称为 Python Web Server Gateway Interface ，即 Python 服务器网关接口，是 Python 应用与Web服务器之间的接口，用于Django项目在服务器上的部署和上线，一般不需要修改。

在Web部署的方案上，有一个方案是目前应用最广泛的：

部署一个Web服务器专门用来处理HTTP协议层面相关的事情，比如如何在一个物理机上提供多个不同的Web服务（单IP多域名，单IP多端口等）这种事情。
部署一个用各种语言编写（Java, PHP, Python, Ruby等）的应用程序，这个应用程序会从Web服务器上接收客户端的请求，处理完成后，再返回响应给Web服务器，最后由Web服务器返回给客户端。

要采用第2种方案，Web服务器和应用程序之间就要知道如何进行交互。

为了定义Web服务器和应用程序之间的交互过程，就形成了很多不同的规范。

比如改进CGI性能的FasgCGI，Java专用的Servlet规范，还有Python专用的WSGI规范等。

提出这些规范的目的就是为了定义统一的标准，提升程序的可移植性。

WSGI存在的目的有两个：

让Web服务器知道如何调用Python应用程序，并且把用户的请求告诉应用程序。
让Python应用程序知道用户的具体请求是什么，以及如何返回结果给Web服务器。

在WSGI中定义了两个角色，Web服务器端称为server或者gateway，应用程序端称为application或者framework（因为WSGI的应用程序端的规范一般都是由具体的框架来实现的）。

server端会先收到用户的请求，然后会根据规范的要求调用application端，调用的结果会被封装成HTTP响应后再发送给客户端。高效的 wsgi web sever 产品，例如：gunicorn，uwsgi等。

如果崇尚自由可定制，可以尝试wsgi web开发的信马由韁，如果坚守稳定可靠， servlet的规范一致给你足够的信心。好坏只在你的需求，无关对错。

HTTP请求URL路由项目APP

Django 中的一个app 就是项目里面的一个应用的意思。

一个项目包含多个app。一个app 通常就是一个相对独立的模块，实现相对独立的功能。

一个app 本质上就是一个 Python 包，里面包含了一些应用相关的代码文件。

当然所有功能放一起也可以，就是比较臃肿。

控制台 new 一个新项目：

django-admin startproject 项目名

控制台 new 一个新app：

python manage.py startapp app名字

app名字/
    __init__.py
    admin.py
    apps.py
    migrations/
    models.py
    views.py

这个目录其实就是一个python package

返回页面内容给浏览器

比如，我们设计凡是浏览器访问的http 请求的 url 地址是 /sales/orders/ , 就由 views.py 里面的函数 listorders 来处理，返回一段字符串给浏览器。

请大家打开 views.py , 在里面加入如下内容

from django.http import HttpResponse

def listorders(request):
    return HttpResponse("下面是系统中所有的订单信息:test")

注意

这里面最终的返回结果是 HttpResponse 对象的参数字符串，也就是这句话

下面是系统中所有的订单信息。。。
listorders的参数 request 是Django中的 HttpRequest 对象，包含了HTTP请求中的信息。

光是定义了这样一个函数不行的，我们需要 告诉 Django ：

当前端发送过来的HTTP请求 url地址是 /sales/orders/ , 就由 views.py 里面的函数 listorders 来处理。

怎么告诉Django呢？

这就是 Django中的 url路由设置。

路由

urls.py 文件

打开该文件，在 urlpatterns 列表变量中添加一条路由信息，结果如下

from django.contrib import admin
from django.urls import path

# 别忘了导入 listorders 函数
from sales.views import listorders

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

    # 添加如下的路由记录
    path('sales/orders/', listorders),
]

urlpatterns 列表就是 Django 的 url 路由的入口。

所以，所谓 路由 就是指：根据 HTTP请求的url路径，设置由哪个函数来处理这个请求。

通常我们项目代码的修改， Django的测试服务可以自动检测到，并且重新加载，不需要我们重启 Django Web 服务。

路由子表

url 路由表就是可以像上面这样，一个请求对应一个处理函数。

但是有的时候，我们的项目比较大的时候，请求的url 会特别多。

比如我们的系统提供给客户、销售商、管理员访问的url是不一样的，如下

customer/
customer/orders/      

sales/
sales/orders/  

mgr/
mgr/customers/
mgr/medicines/
mgr/orders/

复杂的系统url条目多达几百甚至上千个，放在一个表中，查看时，要找一条路由记录就非常麻烦。

这时，我们通常可以将不同的路由记录按照功能分拆到不同的 url路由子表 文件中。

例如：

创建数据库

现在我们先使用另一种更简单的数据库 sqlite。

sqlite 没有独立的数据库服务进程，数据操作被做成库直接供应用程序调用。 Django中可以直接使用，无须先搭建数据服务。

后面要使用mysql 等其他数据库只需修改一些配置就可以了。

创建数据库

项目中数据库的配置在 bysms/settings.py 中，这里

# Database
# https://docs.djangoproject.com/en/2.0/ref/settings/#databases

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

记得导入 import os

首先我们需要创建数据库，执行如下命令

python manage.py migrate

就会在项目的根目录下面生成一个配置文件中指定的数据库文件 db.sqlite3。

Django 里面，数据库表的操作，包括表的定义、表中数据的增删改查，都可以通过 Model 类型的对象进行的。

通常，在Django中

定义一张数据库的表就是定义一个继承自 django.db.models.Model 的类
定义该表中的字段（列），就是定义该类里面的一些属性
类的方法就是对该表中数据的处理方法，包括数据的增删改查

这样，开发者对数据库的访问，从原来的使用底层的 sql 语句，变成面向对象的开发，通过一系列对象的类定义和方法调用就可以操作数据库。

这样做：

首先极大的简化了我们应用中的数据库开发，因为无需使用sql语句操作数据库了，提高了开发的效率；
其次屏蔽了不同的数据库访问的底层细节，基本做到了开发好代码后，如果要换数据库，几乎不需要改代码，修改几个配置项就可以了。

这种通过对象操作数据库的方法被称之为 ORM （object relational mapping）。

定义数据库表

python manage.py startapp common

就会创建一个目录名为 common，对应一个名为 common 的app。

我们要定义数据库的表，无需执行sql语句，只需要在app目录下面定义特殊的类就可以了。

数据库表的定义，一般是放在app目录中的 models.py里面的。

打开 common/models.py，发现里面是空的，因为我们还没有定义我们的业务所需要的表。

我们修改它，加入如下内容

from django.db import models

class Customer(models.Model):
    # 客户名称
    name = models.CharField(max_length=200)

    # 联系电话
    phonenumber = models.CharField(max_length=200)

    # 地址
    address = models.CharField(max_length=200)

这个 Customer 类继承自 django.db.models.Model，就是用来定义数据库表的。

Djanog 有很多字段对象类型，对应不同的类型的数据库字段。

大家可以参考官方文档

创建数据库表

在项目的配置文件 settings.py 中， INSTALLED_APPS 配置项加入如下内容

INSTALLED_APPS = [
    'django.contrib.admin',
    'django.contrib.auth',
    'django.contrib.contenttypes',
    'django.contrib.sessions',
    'django.contrib.messages',
    'django.contrib.staticfiles',

    # 加入下面这行
    'common.apps.CommonConfig',
]

CommonConfig 是 AppConfig的子类，就表示这个是应用的配置类。

这里 name = ‘common’ ， name 是用来定义应用的python模块路径的。这里就是说应用模块路径为 common 。

关于其他的配置参数，大家可以参考官方文档

现在Django知道了我们的 common 应用，我们可以在项目根目录下执行命令

python manage.py makemigrations common

得到如下结果

Migrations for 'common':
  common\migrations\0001_initial.py
    - Create model Customer

这个命令，告诉Django ，去看看common这个app里面的models.py ，我们已经修改了数据定义，你现在去产生相应的更新脚本。

执行一下，会发现在 common\migrations 目录下面出现了0001_initial.py, 这个脚本就是相应要进行的数据库操作代码。

随即，执行如下命令

python manage.py migrate

Operations to perform:
  Apply all migrations: admin, auth, common, contenttypes, sessions
Running migrations:
  Applying common.0001_initial... OK

就真正去数据库创建表了。

如果以后我们修改了Models.py 里面的库表的定义，都需要再次运行 python manage.py makemigrations common 和 python manage.py migrate 命令，使数据库同步该修改结果。

Django Admin

Django提供了一个管理员操作界面可以方便的添加、修改、删除你定义的 model 表数据。

首先，我们需要创建一个超级管理员账号。

进入到项目的根目录，执行如下命令，依次输入你要创建的管理员的登录名、email、密码。

python manage.py createsuperuser
Username (leave blank to use 'root'): root
Email address: 1290267280@qq.com
Password:88888888
Password (again):88888888
Superuser created successfully.

然后我们需要修改应用里面的管理员配置文件 common/admin.py，注册我们定义的model类。这样Django才会知道。

from django.contrib import admin

from .models import Customer

admin.site.register(Customer)

好了，现在就可以访问 http://127.0.0.1/admin/ ，输入刚才注册的用户密码登录。

如果你是中文的操作系统，想使用中文的admin界面，应该在配置文件 settings.py 中 MIDDLEWARE 最后加入如下配置：

MIDDLEWARE = [
    'django.middleware.security.SecurityMiddleware',
    'django.contrib.sessions.middleware.SessionMiddleware',
    'django.middleware.common.CommonMiddleware',
    'django.contrib.auth.middleware.AuthenticationMiddleware',
    'django.contrib.messages.middleware.MessageMiddleware',
    'django.middleware.clickjacking.XFrameOptionsMiddleware',
    # admin界面语言本地化
    'django.middleware.locale.LocaleMiddleware',
]

读取数据库数据

现在我们来实现一个功能：浏览器访问 sales/customers/ ，我们的服务端就返回系统中所有的客户记录给浏览器。

在文件sales/views.py 中，定义一个listcustomers 函数，内容如下：

# 导入 Customer 对象定义
from  common.models import  Customer

def listcustomers(request):
    # 返回一个 QuerySet 对象 ，包含所有的表记录
    # 每条表记录都是是一个dict对象，
    # key 是字段名，value 是 字段值
    qs = Customer.objects.values()

    # 定义返回字符串
    retStr = ''
    for customer in  qs:
        for name,value in customer.items():
            retStr += f'{name} : {value} | '

        # <br> 表示换行
        retStr += '<br>'

    return HttpResponse(retStr)

我们只需修改 sales/urls.py 即可，添加如下记录

    path('customers/', views.listcustomers),

过滤条件

我们可以通过 filter 方法加入过滤条件，修改view里面的代码，如下所示：

def listcustomers(request):
    # 返回一个 QuerySet 对象 ，包含所有的表记录
    qs = Customer.objects.values()

    # 检查url中是否有参数phonenumber
    ph =  request.GET.get('phonenumber',None)

    # 如果有，添加过滤条件
    if ph:
        qs = qs.filter(phonenumber=ph)

    # 定义返回字符串
    retStr = ''
    for customer in  qs:
        for name,value in customer.items():
            retStr += f'{name} : {value} | '
        # <br> 表示换行
        retStr += '<br>'

    return HttpResponse(retStr)

Django 框架在 url 路由匹配到函数后，调用函数时，会传入一个 HttpRequest 对象给参数变量 request，该对象里面包含了请求的数据信息。

HTTP 的 Get 请求url里面的参数（术语叫 querystring 里面的参数），可以通过 HttpRequest对象的 GET 属性获取。这是一个类似dict的对象。

有了这个过滤条件，Django 会在底层执行数据库查询的SQL语句加上相应的 where 从句，进行过滤查询。

注意，参数名 phonenumber 是和定义的表 model 的属性名 phonenumber 一致的。

filter的过滤条件可以有多个，只要继续在后面的参数添加过滤条件即可。

对资源的增查改删处理

再为 管理员用户 专门创建一个应用 mgr 来处理相关的请求。

python manage.py startapp mgr

前面，我们都是在views.py 里面定义函数，处理 http请求的。

但是可以想象，以后，这个mgr应用要处理很多类型的http请求。

都用这个views.py 就会让这个文件非常的庞大，不好维护。所以，我们可以用不同的 py 文件处理不同类型的http请求。

比如，这里我们可以新增一个文件 customer.py，专门处理客户端对 customer 数据的操作。

将来如果客户端有对其他类型数据的操作，比如 order 数据，我们就可以添加 orders.py 来处理。

注意：Django 的 url路由功能 不支持 根据 HTTP 请求的方法和请求体里面的参数进行路由。

就是不能像下面这样，来根据请求是 post 还是 get 来路由

path('customers/', 'app.views.list_customer', method='get'),
path('customers/', 'app.views.add_customer',  method='post'),

自己编写一个函数，来根据 http请求的类型和请求体里面的参数分发（或者说路由）给不同的函数进行处理。

我们可以在 customer.py 中定义如下 dispatcher 函数：

from django.http import JsonResponse
import json


def dispatcher(request):
    # 将请求参数统一放入request 的 params 属性中，方便后续处理

    # GET请求 参数在url中，同过request 对象的 GET属性获取
    if request.method == 'GET':
        request.params = request.GET

    # POST/PUT/DELETE 请求 参数 从 request 对象的 body 属性中获取
    elif request.method in ['POST', 'PUT', 'DELETE']:
        # 根据接口，POST/PUT/DELETE 请求的消息体都是 json格式
        request.params = json.loads(request.body)

    # 根据不同的action分派给不同的函数进行处理
    action = request.params['action']
    if action == 'list_customer':
        return listcustomers(request)
    elif action == 'add_customer':
        return addcustomer(request)
    elif action == 'modify_customer':
        return modifycustomer(request)
    elif action == 'del_customer':
        return deletecustomer(request)

    else:
        return JsonResponse({'ret': 1, 'msg': '不支持该类型http请求'})

接下来，根据 API 接口，我们发现凡是 API 请求url为 /api/mgr/customers 的，都属于客户相关的API，都应该交由我们上面定义的dispatch函数进行分派处理。

那么我们需要在Django的url路由文件中加入对应的路由。

CRUD

def listcustomers(request):
    # 返回一个 QuerySet 对象 ，包含所有的表记录
    qs = Customer.objects.values()

    # 将 QuerySet 对象 转化为 list 类型
    # 否则不能 被 转化为 JSON 字符串
    retlist = list(qs)

    return JsonResponse({'ret': 0, 'retlist': retlist})


def addcustomer(request):
    info = request.params['data']

    # 从请求消息中 获取要添加客户的信息
    # 并且插入到数据库中
    # 返回值 就是对应插入记录的对象
    record = Customer.objects.create(name=info['name'],
                                     phonenumber=info['phonenumber'],
                                     address=info['address'])

    return JsonResponse({'ret': 0, 'id': record.id})


def modifycustomer(request):
    # 从请求消息中 获取修改客户的信息
    # 找到该客户，并且进行修改操作

    customerid = request.params['id']
    newdata = request.params['newdata']

    try:
        # 根据 id 从数据库中找到相应的客户记录
        customer = Customer.objects.get(id=customerid)
    except Customer.DoesNotExist:
        return {
            'ret': 1,
            'msg': f'id 为`{customerid}`的客户不存在'
        }

    if 'name' in newdata:
        customer.name = newdata['name']
    if 'phonenumber' in newdata:
        customer.phonenumber = newdata['phonenumber']
    if 'address' in newdata:
        customer.address = newdata['address']

    # 注意，一定要执行save才能将修改信息保存到数据库
    customer.save()

    return JsonResponse({'ret': 0})


def deletecustomer(request):
    customerid = request.params['id']

    try:
        # 根据 id 从数据库中找到相应的客户记录
        customer = Customer.objects.get(id=customerid)
    except Customer.DoesNotExist:
        return {
            'ret': 1,
            'msg': f'id 为`{customerid}`的客户不存在'
        }

    # delete 方法就将该记录从数据库中删除了
    customer.delete()

    return JsonResponse({'ret': 0})

当然在文件的开头，我们需要先导入 Customer 定义，像下面这样

# 导入 Customer 
from common.models import Customer

临时取消 CSRF 校验

注意，缺省创建的项目， Django 会启用一个 CSRF （跨站请求伪造）安全防护机制。

在这种情况下，所有的Post、PUT 类型的请求都必须在HTTP请求头中携带用于校验的数据。

为了简单起见，我们先临时取消掉CSRF的校验机制，等以后有需要再打开。

要临时取消掉CSRF的校验机制，非常简单，只需要在项目的配置文件 项目/settings.py 中 MIDDLEWARE 配置项里注释掉 ‘django.middleware.csrf.CsrfViewMiddleware’ 即可。

前端整合

资源下载：点击这里下载

下载好以后，可以解压该 z_dist.zip 文件到项目根目录下面，形成一个目录 z_dist。

该目录下面就是前端的代码资源文件。

但是前端文件都是静态文件，需要我们配置一下Django的配置文件，指定http请求如果访问静态文件，Django在哪个目录下查找。

注意，接下来我们配置 Django 静态文件服务，是 开发时 使用的一种 临时方案 ，性能很低，这是方便我们调试程序用的。

现在，请打开 项目/urls.py 文件，在末尾添加一个

+  static("/", document_root="./z_dist")

并添加如下声明

# 静态文件服务
from django.conf.urls.static import static

就是在url 路由中加入前端静态文件的查找路径。

这样如果 http请求的url 不是以 admin/ sales/ api/mgr/ 开头， Django 就会认为是要访问 z_dist目录下面的静态文件。

实现登录

我们可以在mgr目录里面创建一个代码文件 sign_in_out.py

这个代码文件就是用来处理 管理员登录和登出 的API 请求的。

Django中有个内置app 名为 django.contrib.auth ，缺省包含在项目Installed App设置中。

这个app 的 models 定义中包含了一张用户表，名为 auth_user 。

当我们执行 migrate 创建数据库表时，根据，就会为我们创建用户表 auth_user，如下所示：

django.contrib.auth 这个app 已经 为我们做好了登录验证功能。

我们只需要使用这个app库里面的方法就可以了。

from django.http import JsonResponse

from django.contrib.auth import authenticate, login, logout


# 登录处理
def signin(request):
    # 从 HTTP POST 请求中获取用户名、密码参数
    userName = request.POST.get('username')
    passWord = request.POST.get('password')

    # 使用 Django auth 库里面的 方法校验用户名、密码
    user = authenticate(username=userName, password=passWord)

    # 如果能找到用户，并且密码正确
    if user is not None:
        if user.is_active:
            if user.is_superuser:
                login(request, user)
                # 在session中存入用户类型
                request.session['usertype'] = 'mgr'

                return JsonResponse({'ret': 0})
            else:
                return JsonResponse({'ret': 1, 'msg': '请使用管理员账户登录'})
        else:
            return JsonResponse({'ret': 0, 'msg': '用户已经被禁用'})

    # 否则就是用户名、密码有误
    else:
        return JsonResponse({'ret': 1, 'msg': '用户名或者密码错误'})


# 登出处理
def signout(request):
    # 使用登出方法
    logout(request)
    return JsonResponse({'ret': 0})

创建URl

们只需要在mgr 目录下面的子路由文件 urls.py 里添加如下内容：

urlpatterns = [

    path('signin', sign_in_out.signin),
    path('signout', sign_in_out.signout),

]

session 方案

Django 中该表名字就叫 django_session, 如下所示：

# 在session中存入用户类型
request.session['usertype'] = 'mgr'

这行代码的作用就是在登录认证后，将用户类型保存到session数据中，也就是存入前面数据库的那张图的会话数据记录中。

Django 框架会自动在 HTTP 响应消息头中加入类似下面的 sessionid cookie。后续的HTTP请求就会携带这个sessionid。

前面实现的代码中，这些请求都是在dispatcher入口函数处理的，我们就只需在该dispatch中进行验证。

修改 mgr/customer.py 的dispatcher 函数，在前面加上如下代码：

    # 根据session判断用户是否是登录的管理员用户
    if 'usertype' not in request.session:
        return JsonResponse({
            'ret': 302,
            'msg': '未登录',
            'redirect': '/mgr/sign.html'}, 
            status=302)

    if request.session['usertype'] != 'mgr' :
        return JsonResponse({
            'ret': 302,
            'msg': '用户非mgr类型',
            'redirect': '/mgr/sign.html'} ,
            status=302)

注意request对象里面的session属性对应的就是 session记录里面的数据。

该数据对象类似字典，所以检查是否有usertype类型为mgr的信息，就是这样写

if request.session['usertype'] != 'mgr'

数据库表的关联

python manage.py makemigrations common
python manage.py migrate

以后我们修改了models.py 里面的库表的定义，都需要再次运行 python manage.py makemigrations common 和 python manage.py migrate 命令，使数据库同步该修改结果。

Django中定义外键的方法就是 Model类的该属性字段值为 ForeignKey 对象。

另外一个参数 on_delete 指定了当我们想 删除 外键指向的主键记录时，系统的行为。

class Order(models.Model):
    # 订单名
    name = models.CharField(max_length=200,null=True,blank=True)

    # 创建日期
    create_date = models.DateTimeField(default=datetime.datetime.now)

    # 客户
    customer = models.ForeignKey(Customer,on_delete=models.PROTECT)

Django是通过 ManyToManyField 对象表示多对多的关系的。

像这样

medicines = models.ManyToManyField(Medicine, through='OrderMedicine')

指定Order表和 Medicine 表的多对多关系，其实Order表中并不会产生一个叫 medicines 的字段。

基础功能大致就是这些，有新坑，也有新的感悟。

参考

https://docs.djangoproject.com/
https://www.byhy.net/
wsgi vs servlet https://www.cnblogs.com/jackiesteed/articles/4287223.html

上一篇：【算法题】最小公倍数
下一篇：没有了

Django-初见

相关文章