Django介绍与框架整合，并使用MySQL实现增删改查

Django简介

django是一个开放源代码的Python web应用框架。采用MTV模式，即模型M，模板T和视图V。他最初是被开发用于管理劳伦斯出版社集团下的一些以新闻内容为主的网站，即：CMS（内容管理系统）软甲。并于2005年七月在BSD许可证下发布，并于2008年九月发布了第一个正式版本1.0。这套框架是以比利时的吉普赛爵士吉他手Django Reinhardt来命名的。

MVC和MTV

MVC并不是一种技术，而是一种开发模式，一种软件的设计典范。将一套业务分到不同的层次来处理，这样降低了代码的耦合度，并提高了代码的可重用性。
MVC开始是存在于桌面程序中的，M是指业务模型，V是指用户界面，C则是控制器，使用MVC的目的是将M和V的实现代码分离，从而使同一个程序可以使用不同的表现形式。比如一批统计数据可以分别用柱状图、饼图来表示。C存在的目的则是确保M和V的同步，一旦M改变，V应该同步更新。

Django其实就是一个基于MVC构造的框架。但是在Django中，控制器接受用户输入的部分由框架自行处理，所以 Django 里更关注的是模型（Model）、模板(Template)和视图（Views），所以就称为 MTV模式。MTV模式不过就是MVC模式的一种衍生体。

对于模型、视图、模板我会在以后的文章中做详细介绍，本篇文章的主要目的是认识了解Django，并搭建起Django的开发环境。

Django安装

在安装django之前，请确保已经安装了Python，但是更要注意的是一定要明确使用的django的版本和Python的版本是否兼容，因为Python2在2020年1月就已经不在支持，所以建议学习与使用Python3，使用Django-1.11.x长期支持版本。

# 使用如下的命令对django的指定版本安装，如果我们想安装最新版只需要执行pip install django命令即可。
PS C:\Users\admin> pip install django==1.11.11
...
# 当我们安装完毕之后，我们在控制台输入python命令进入到Python控制台
PS C:\Users\admin> python
# 在python的交互界面下引入django模块，并获取版本信息，如果以下两个命令能够正确执行，则表示我们的django安装成功了
>>> import django
>>> django.get_version()

使用Django构建web工程

使用框架最重要的一点就是构建工程，把整体框架搭建完成之后，明确了开发流程，其实写代码都是一些简单的工作。好了，过多的废话不说，我们捞干的来。

创建工程

创建一个我们的工程，这个工程就是存储我们以后所有的代码的地方，一定要挑一个好地方放哦。

我就将他放到D盘的根目录下吧。在windows的控制台下执行以下的命令，当执行命令后什么状态都没有的时候，你应该庆幸，你是对的，你的工程已经成功的创建了。你会在D盘下找到刚刚创建的工程的目录。

PS C:\Users\admin> D:
PS D:\> django-admin startproject djangoProject
PS D:\>

你可以进入到工程的目录下执行Tree . /F命令，来查看这个目录的结构：

PS D:\> cd djangoProject
PS D:\djangoProject> Tree . /F
文件夹 PATH 列表
卷序列号为 00000029 EC57:1624
D:\DJANGOPROJECT
│  manage.py
│
└─djangoProject
        settings.py
        urls.py
        wsgi.py
        __init__.py

PS D:\djangoProject>

此时所创建的所有文件都是这个工程的配置文件，比如说，注册一个app，添加静态资源，配置数据库信息等等。

创建应用

那么，问题来了，我们在哪里写我们的代码啊？我告诉你，在每一个应用中。那应用又在哪里呢？我告诉你，自己创建去。那怎么创建呢？来吧，看代码：

执行以下的创建APP的代码时，我们一定要进入到我们创建的工程目录下。

PS D:\djangoProject> python manage.py startapp firstApp
PS D:\djangoProject>

shell就是这个特点，成功了，不会给你任何提示，就是这样偷偷的帅着。就这样，我们就帅帅的将名为firstApp的应用创建出来了。此时工程的目录结构是这样的：

PS D:\djangoProject> Tree . /F
文件夹 PATH 列表
卷序列号为 00000029 EC57:1624
D:\DJANGOPROJECT
│  manage.py
│
├─djangoProject
│  │  settings.py
│  │  urls.py
│  │  wsgi.py
│  │  __init__.py
│  │
│  └─__pycache__
│          settings.cpython-36.pyc
│          __init__.cpython-36.pyc
│
└─firstApp
    │  admin.py
    │  apps.py
    │  models.py
    │  tests.py
    │  views.py
    │  __init__.py
    │
    └─migrations
            __init__.py

此时，你还别高兴的太早，因为现在只是像应用的样子，还并不是一个真正的应用，我们需要在工程的配置文件（settings.py）中把这个应用注册进去。在INSTALLED_APPS配置中把我们的应用的名称添加进去，这样就完美了。

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

配置数据库

对于一个站点来说，后台数据库的支撑那是至关重要的，没有数据库的数据，我们拿什么去渲染前台的数据。所以，配置数据库是一个非常神圣的工作，django默认的数据库是sqlite3，但是在实际开发中几乎不会使用他，我们使用MySQL。既然要使用MySQL，那么就要先在你的机器上安装MySQL（本文不介绍MySQL的安装方式）。

配置MySQL我们需要三步：

第一步：安装MySQL驱动，Python3使用的MySQL驱动是pymysql

PS D:\djangoProject>pip install pymysql

第二步：配置settings.py文件

DATABASES = {
    'default': {
        # 'ENGINE': 'django.db.backends.sqlite3',
        # 'NAME': os.path.join(BASE_DIR, 'db.sqlite3'),
        'ENGINE': 'django.db.backends.mysql',
        'NAME': 'epoch',
        'USER': 'root',
        'PASSWORD': 'admin',
        'HOST': 'localhost',
        'PORT': '3306',
    }
}

各个参数的介绍：
ENGINE:数据库驱动，标志着使用的是什么数据库。
HOST:数据库所在主机的IP
PORT:数据库所监听的端口，MySQL默认监听3306
USER:数据库的操作用户
PASSWORD:数据库操作用户的密码
NAME:所使用的数据库实例名称。（此时一定要将NAME中配置的数据库创建出来）

第三步：在settings.py文件同级目录下的__init__.py文件中添加以下两行代码

import pymysql
pymysql.install_as_MySQLdb()

但是，为了一会看我们的数据库是否配置成功，我们添加以下几行代码，这样在我们启动服务器的时候，会在控制台中打印出数据库的版本信息。

# 打开数据库连接
db = pymysql.connect('localhost', 'root', 'admin', 'epoch')
# db = pymysql.connect(host="localhost", user="root", password="admin", db="epoch", port=3306)

# 使用cursor()方法获取操作游标
cursor = db.cursor()

# 使用 executor()方法执行SQL语句
cursor.execute("SELECT VERSION()")

# 使用fetchone()获取一条数据库
data = cursor.fetchone()

print("Database version : %s " % data)

# 关闭数据库连接
db.close()

配置模板目录

对于后台的一些配置我们都已经配置完毕了，那么问题又来了，我们的前台页面的代码写在哪里呢？别着急，这就说给你听。

在Django中，HTML页面这一部分内容统一称为模板，模板的作用就是将后台传递过来的数据渲染出来，展示给用户的。配置模板目录需要以下两步：

第一步：创建模板目录

在我们的工程目录下创建一个名为templates的目录，当然了，你可以使用别的名字，但是，约定俗成，都叫做这个名字了。

PS D:\djangopProject> mkdir templates

第二步：配置模板目录

将我们在上一步中创建的目录配置到settings.py文件中TEMPLATES配置项中的DIRS中，这个配置是一个list，我们可以再里边配置多个路径。代码结构如下：

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',
            ],
        },
    },
]

配置静态资源目录

我们使用的静态资源（js,css,图片,json文件,字体文件等等），又该放在哪里呢？接下来，我们来配置静态资源。配置静态资源目录两步走：

第一步：创建静态资源目录

在我们的工程目录下创建一个名为static的目录，当然了，你可以使用别的名字，但是，约定俗成，都叫做这个名字了。

PS D:\djangoProject> mkdir static

第二步：配置静态资源目录

打开settings.py文件，你会发现，在文件的最后一行中已经为我们配置好了STATIC_URL的目录为static了，但是为了以后在页面中使用动态链接（链接分为静态链接和动态链接，在后面的使用中我会做详细的介绍）时，我们在该配置的下边再添加一行配置：

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

这个配置也是一个list，我们可以配置多个。

细心的人会发现我在整个配置过程中，还没有启动过服务，你如何知道配置的对不对啊，确实，我也不知道对不对，实践是检验真理的唯一标准。那我们就启动一下服务器吧：

PS D:\djangoProject> python manage.py runserver

此时如果没有报错，在浏览器中通过访问http://127.0.0.1:8000可以访问到如下的页面内容，证明我们启动成功。

It worked!

Congratulations on your first Django-powered page.

Next, start your first app by running python manage.py startapp [app_label].

Youre seeing this message because you have DEBUG = True in your Django settings file and you havent configured any URLs. Get to work!

刚刚的启动顶多也就能看一看我们启动时没有报错，就证明我们写的还没有违背django的配置规范。如何证明可以访问数据库进行数据的处理呢，那就得写一些额外的代码，但是如果写过多的代码来验证，那么就影响了整个配置过程的清晰思路。

下面就让我们用实践来检验一下我们配置的正确与否。

从头到尾写套增删改查

因为绝大部分的系统都是有操作用户的，所以我们以用户表的增删改查来验证配置的正确与否！

我们在前面说到过，我们所写的业务代码都是在应用(APP)中写的，而且在前面我们也创建了一个名为firstApp的应用，我们接下来就在这里写我们的代码。

创建模板

我们之前简单的提过HTML页面就是就是模板，就是用数据渲染后，给人看的东西。因此我们首先要在模板目录下创建一个HTML文件，我们就叫做user.html

在该文件中简单的添加以下几行内容：

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <meta http-equiv="X-UA-Compatible" content="ie=edge">
    <title>操作用户表</title>
</head>
<body>
    <h2>操作用户表</h2>
    <form method="POST" action="#">
        用户名：<input type="text" name="username" />
        <br>
        密  码：<input type="password" name="passwd" />
        <br>
        <button>添加</button>
    </form>
</body>
</html>

但是此时你启动服务器还是原来的那个欢迎页面，我们如何能够在我访问站点的根路径时，自动跳转到我写的页面呢？我们就需要创建一个视图了。

创建视图

在我们的firstApp目录下有一个views.py文件，这个文件中就是写我们的视图的地方。我们在该文件中添加以下几行内容：

def user(request):
    return render(request, 'user.html')

创建完视图后，你仔细一想，还是不对啊，我怎么让我访问的某一个url找到指定的视图呢？这就需要配置url分发器了。

添加URL

在与settings.py文件的同级目录中有一个urls.py文件，这个文件就是url分发器。我们需要在里面的urlpatterns配置项中添加以下内容：

from firstApp import views

urlpatterns = [
    url(r'^$', views.user),
    url(r'^admin/', admin.site.urls),
]

此时我们启动服务器,就可以看到我们刚刚创建的HTML页面了。

添加模型

接下来，我们应该定义一个模型（model）,一个模型就是一个类，这个类就封装了一张数据库表而已，用于做数据库的初始化以及表的增删改查。
在我们创建的firstApp目录下有一个models.py文件，我们就在这个文件中定义模型，定义模型需要引入django.db中的models（应用中默认是已经引入的），模型类要继承models.Model类。我们以创建一个简单的用户模型为例，代码如下：

from django.db import models

# Create your models here.
class User(models.Model):
    username = models.CharField(max_length=20)
    passwd = models.CharField(max_length=16)

你先不需要关注这些代码是什么意思，只需要知道，这个模型有两个字段，与数据库中的某一张表是对应的关系就好，当你去访问数据库的时候，你会发现创建了好多张表，你根本就没有找到将User的这张表，为什么呢？因为默认情况下，django生成数据表的格式是appName_modelNmae.我们在后期的内容会做详细的介绍。

模型迁移

我们把模型定义完了还不够，我们需要将这个模型在数据库中生成一张表，那我们该如何做呢？分以下两步走：

第一步：生成迁移文件

我们的工程目录下执行以下命令：

PS D:\djangoProject> python manage.py makemigrations
Database version : 5.5.53
Migrations for 'firstApp':
  firstApp\migrations\0001_initial.py
    - Create model User
PS D:\djangoProject>

第二步：执行迁移

在执行完上一步后，只是生成了一个迁移文件，此时还没有在数据库中创建表，我们需要执行以下命令来生成数据表：

PS D:\djangoProject> python manage.py migrate
Database version : 5.5.53
Operations to perform:
  Apply all migrations: admin, auth, contenttypes, firstApp, sessions
Running migrations:
  Applying firstApp.0001_initial... OK
PS D:\djangoProject>

对用户表进行操作

前面的所有步骤都执行完成后，我们的整体框架算是完整了，接下来，我们进行一些数据的增删改查吧。

添加用户

我们在前文中已经添加了一个类似于登录页面的一个模板，我们就用这个页面中的两个字段进行添加操作。

首先我们在该模板中的form表单中的action属性中，添加一个url，但是这时候我们还没有url，所以，这就需要我们随心所欲的设计了，看我的代码吧：

user.html模板代码

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <meta http-equiv="X-UA-Compatible" content="ie=edge">
    <title>操作用户表</title>
</head>
<body>
    <h2>操作用户表</h2>
    <form method="POST" action="add/">
        {% csrf_token %}
        用户名：<input type="text" name="username" />
        <br>
        密  码：<input type="password" name="passwd" />
        <br>
        <button>添加</button>
    </form>
</body>
</html>

urls.py文件中的urlpatterns中添加url

urlpatterns = [
    url(r'^$', views.user),
    url(r'^add/$', views.add),
    url(r'^admin/', admin.site.urls),
]

此时views下的add方法还不存在，我们需要在firstApp/views.py文件中添加add方法。

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

# Create your views here.
def user(request):
    return render(request, 'user.html')

def add(request):
    username = request.POST.get('username')
    passwd = request.POST.get('passwd')
    print(username,passwd)
    return HttpResponse('添加成功！')
    

运行服务器，在表单中输入内容，点击添加，如果在页面中显示添加成功并在后台打印出你输入的内容，即表示该步骤是正确的。

PS D:\djangoProject> python manage.py runserver
Database version : 5.5.53
Database version : 5.5.53
Performing system checks...

System check identified no issues (0 silenced).
April 03, 2018 - 08:45:26
Django version 1.11.10, using settings 'djangoProject.settings'
Starting development server at http://127.0.0.1:8000/
Quit the server with CTRL-BREAK.
Database version : 5.5.53
Performing system checks...
admin ASDF
[03/Apr/2018 08:48:34] "POST /add/ HTTP/1.1" 200 15

最后一步，我们需要对模型进行操作了，这一步需要在views.py文件中引入当前目录下的models中的User类，将接收到的前台的数据添加到User对象中，然后执行save()添加操作。代码如下：

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

# Create your views here.
def user(request):
    return render(request, 'user.html')

def add(request):
    name = request.POST.get('username')
    password = request.POST.get('passwd')
    user = User()
    user.username = name
    user.passwd = password
    user.save()
    return HttpResponse('添加成功！')
    

启动服务器，重新执行添加操作，如果成功了，去查看数据库，你会发现表中多了一条你刚刚插入的数据。

查询所有用户

有了上一步添加操作的范本，我们就可以模仿着做一个查询的操作了。

首先是根据我们的功能来自己设计一个url，此时我们的urls.py中的urlpatterns的配置是这样的：

from django.conf.urls import url
from django.contrib import admin
from firstApp import views

urlpatterns = [
    url(r'^$', views.user),
    url(r'^add/$', views.add),
    url(r'^getAllUser/$', views.getAllUser),
    url(r'^admin/', admin.site.urls),
]

但是我们url所指向的views下的getAllUser视图方法还不存在，需要我们去创建该方法并在该视图方法中引入当前文件夹下的models类，再实现查询的业务逻辑。代码如下：

def getAllUser(request):
    userList = User.objects.all()
    return render(request, 'userList.html',{'users':userList})

你会发现我们的userList.html还没有创建，那就在模板目录下创建一个吧，并在文件中添加以下代码，我们将用户的id和用户名显示在前台。看代码吧：

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <meta http-equiv="X-UA-Compatible" content="ie=edge">
    <title>用户列表</title>
</head>
<body>
    <ul>
        {% for user in users %}
        <li>{{user.pk}}----{{user.username}}</li>
        {% endfor %}
    </ul>
</body>
</html>

此时，你又会有一个疑惑，我们的模型中没有pk这个字段啊，他是哪里出来的啊？这个是id，是模型在创建的时候自动生成的一个字段。在模型篇中，我们会做相应的讲解。

好了，我们启动服务器，访问一下http://127.0.0.1:8000/getAllUser这个url吧。如果你在页面中看到你在数据库中插入的所有的用户信息，证明你可以庆祝一下了。

细心的人可能会发现，我在做插入和查询的时候，我的操作顺序是不同的，我不是说查询就要这个顺序，插入就是这个顺序，这个还是要根据自己的思路来的。在现实的开发中，一般都是从前往后想，从后往前做。

声明一下：在接下来的修改和删除，为了简单我就不写模板页面了，但是在现实的工作中，这些操作一定是从前台来操作的。

修改用户

修改用户和插入用户的方法是相同的，都是从前台将数据传到后台，再到后台将数据库中的数据进行修改

定义url，在urls.py文件中的urlpatterns配置中添加以下的配置，想用什么url自己随心所欲喽。

url(r'^updateUser/$', views.updateUser),

定义视图并完成数据的处理

def updateUser(request):
    # 查询出用户表中的第一个用户
    upUser = User.objects.first()
    # 将该用户密码进行重新赋值
    upUser.passwd = '123456'
    # 将修改后的对象再重新save到数据库中
    upUser.save()
    # 如果没有错误返回添加成功的字样
    return HttpResponse('修改成功')

现在我们访问http://127.0.0.1:8000/updateUser的时候就可以将第一个用户的密码修改为123456了，如果我们创建了模板，只需要将表单中修改的数据传到后台处理一下就可以了。

删除用户

删除用户和修改用户的操作步骤是一样的。

定义url,在urls.py文件中的urlpatterns配置中添加以下的配置。

url(r'^deleteUser/$', views.deleteUser),

定义视图并完成数据的处理

def deleteUser(request):
    user = User.objects.get(id='2')
    user.delete()
    return HttpResponse('删除成功')

现在我们访问http://127.0.0.1:8000/deleteUser的时候就可以将id为2的用户删除掉了。

企业级改造

到这里，我们我Django框架就算搭建和验证完成了，同时也了解了基本的开发流程，但是企业开发过程中会在这个基础上还是会有很多扩展和改变的。下面我们就对他进行一下改造。

urls改造

我们现在是将所有的url都写在了工程的增提配置中的urls.py文件中了，这样做其实是不合理的，有以下几点原因：

• 实际的开发中可能会有几十甚至几百个url，如果都写在一个文件中对于维护来说，简直不堪设想；
• 实际的开发中是多个人同时进行的，很难保证你们的url没有冲突（虽然概率很小）；
• 对于团队开发的版本控制系统，如果都写在一个文件中，大家都来修改避免不了会有冲突。

因此，我们可以使用一下的方式进行改造：

1、在app目录下创建属于app自己的urls.py文件

进入到你所开发的app下，创建一个urls.py文件

我的工程名叫djangoProject,放在了D盘的根目录下

为了展示方便，我使用命令行操作的，你完全可以使用图形界面，我只是闲截图上传太麻烦了，而且这样看着也更加清晰。

PS C:\Users\admin> D:
PS D:\> cd djangoProject
PS D:\djangoProject> cd firstApp
PS D:\djangoProject\firstApp> new-item urls.py


    目录: D:\djangoProject\firstApp


Mode                LastWriteTime         Length Name
----                -------------         ------ ----
-a----        2018/4/13     10:53              0 urls.py


PS D:\djangoProject\firstApp>

2、将app的urls.py文件引入到工程的全局urls.py文件中

工程的全局配置文件都在工程目录下的与工程名同名的目录下

在该文件中引入from django.conf.urls import include ，并在urlpatterns配置中添加url(r'^', include('firstApp.urls', namespace='first_app'))配置，修改后的内容如下：

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

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

3、在firstApp的urls.py文件中引入相应的模块和添加该app中队医的所有url

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

urlpatterns = [
    url(r'^$', views.user),
    url(r'^add/$', views.add, name='addUser'),
    url(r'^getAllUser/$', views.getAllUser, name='getAllUser'),
    url(r'^updateUser/$', views.updateUser, name='updateUser'),
    url(r'^deleteUser/$', views.deleteUser, name='deleteUser'),
]

namespace和name的配置是用来配置动态url的。在以后的视图篇再做详细的分享。

此时你可以启动服务了，如果能够正常访问，证明的的改造已经成功了。

业务处理改造

在前文的内容中，我们做的增删改查都是在视图层进行对模型的直接操作，如果说业务比较复杂内容比较多的时候，这个文件会比较大，代码找起来也是很费劲。所以我们要对其进行改造。

1、我们在firstApp下新建一个service.py文件。

PS D:\djangoProject> cd firstApp
PS D:\djangoProject\firstApp> new-item service.py


    目录: D:\djangoProject\firstApp


Mode                LastWriteTime         Length Name
----                -------------         ------ ----
-a----        2018/4/13     11:21              0 service.py


PS D:\djangoProject\firstApp>

2、在该文件中引入当前目录下的models模块中的User模型，并添加处理代码。

我们以改造查询所有用户的方法来进行演示，其他的可以自行改造哦

代码如下：

from . models import User


class FirstAppService:

    def getAllUserService(self):
        return User.objects.all()

当然也可以不去创建类，直接定义方法，但是这样处理的话，我们容易出现和视图中的方法调用冲突。还有就是我们需要记住方法名，如果创建类的话，我们通过点方法提示就可以一目了然了。具体喜欢哪一种根据个人喜好了。

3、在视图中引入该service模块下的FirstAppService类，通过类来调用方法。

代码如下：

from . service import FirstAppService


def getAllUser(request):
    # userList = User.objects.all()
    userList = FirstAppService.getAllUserService()
    return render(request, 'userList.html',{'users':userList})

好了，业务处理也改造完了，可以启动访问一下试一试了。

小结

到这里，我们我Django框架就算搭建和验证完成了，同时也了解了基本的开发流程，但是开发过程中会在这个基础上还是会有很多扩展和改变的，这些内容我会在以后的分享中不断的完善。

好了，本期的内容就到这里。我会不断的去更新和修改我的文档。我们下一期的内容是“Django模板层的扩展“，如果您看到我的文章，希望您给出一些评价和指点，我会进行修改学习，更希望看到这篇文章的你在学习与工作的路上一天比一天优秀。