写在前面
初次阅读此书是三年前,当时没经历过完整的项目 觉得这书就是扯淡 后来经历过项目加班与毒打 今天再翻开此书 觉得实乃不可多得之物 花些时间啃下来吧
django版本 3.2
本博客开源项目地址 kimsmith/django企业实战 (gitee.com)
有的代码因为版本混乱报错 自己调调
需求
需求文档
写文档,列举需要实现的功能,详细列举,不考虑技术实现细节
需求评审与分析
主要是将需求文档落实到技术细节,评审需求需要的技术栈,然后评审需求是否可实现,预估每个子需求的工作量等
此处可以考虑后续的衍生需求,考虑技术实现是否可行是否困难,技术需要的工作量等
功能分析
技术人员对需求评审的结果进行技术实现分析,模块划分等
模块划分可以基于数据实体制作ER图,或者建立UML图
模块划分
作用是将一个大项目分成几个小模块,让手下的人去按模块开发
框架基础和技术选型
需要选择 语言 框架 数据库 然后考虑团队开发与实现能力等
wsgi
wsgi,全称Web Server Gateway Interface,Web服务器网关接口,是用来规定web server应如何和程序交互的网关协议。可以理解为一个web应用的容器,适配了程序和操作系统之间功能,将操作系统一些功能抽象为接口提供给程序使用
可以使用wsgi,目的是使用实现统一协议的web server,不然换着乱
简单的web server
一个基本的socket监听程序
# coding:utf-8
import socket
EOL1 = b'\n\n'
EOL2 = b'\n\r\n'
body = 'hello, world<h1> from tjh </h1>'
resp_params = [
'HTTP/1.0 200 OK',
'Date: Sun, 31 jul 2024 09:35:33 GMT',
'Content-Type: text/html; charset=utf-8',
'Content-Length: ()\r\n'.format(len(body.encode())),
body
]
resp = '\r\n'.join(resp_params)
def handle_connection(conn, addr):
req = b''
while EOL1 not in req and EOL2 not in req:
req += conn.recv(1024)
print(req)
conn.send(resp.encode())
conn.close()
def main():
ss = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
ss.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
ss.bind(('127.0.0.1', 8000))
ss.listen(5) # conn max queue number
print('http://127.0.0.1:8000')
try:
while True:
conn, addr = ss.accept()
handle_connection(conn, addr)
finally:
ss.close()
if __name__ == '__main__':
main()
效果
注意 Content-Type为text/plain 还是text/html
多线程版web server
还是阻塞模式,非阻塞会报错 还没处理
# coding:utf-8
import socket
import errno
import threading
import time
EOL1 = b'\n\n'
EOL2 = b'\n\r\n'
body = 'hello, world<h1> from tjh </h1>-from {thread_name}'
resp_params = [
'HTTP/1.0 200 OK',
'Date: Sun, 31 jul 2024 09:35:33 GMT',
'Content-Type: text/html; charset=utf-8',
'Content-Length: {length}\r\n',
body
]
resp = '\r\n'.join(resp_params)
def handle_connection(conn, addr):
req = b''
while EOL1 not in req and EOL2 not in req:
req += conn.recv(1024)
print(req)
current_thread = threading.currentThread()
content_length = len(body.format(thread_name=current_thread.name).encode())
print(current_thread.name)
conn.send(resp.format(thread_name=current_thread.name, length=content_length).encode())
conn.close()
def main():
ss = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
# ss.setblocking(0) # set socket mode as non block
# ss.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
ss.bind(('127.0.0.1', 8000))
ss.listen(10) # conn max queue number
print('http://127.0.0.1:8000')
# ss.setblocking(0) # set socket mode as non block
try:
i = 0
while True:
try:
conn, addr = ss.accept()
except socket.error as e:
if e.args[0] != errno.EAGAIN:
raise
continue
i += 1
print(i)
t = threading.Thread(target=handle_connection, args=(conn, addr), name='thread-%s' % i)
t.start()
finally:
ss.close()
if __name__ == '__main__':
main()
效果
简单wsgi application
wsgi协议分为两部分,一个是web server,一个是web application。接受请求时,会通过wsgi协议将数据发给web application,application处理完后,设置对应状体和header,之后返回body给web server,web server拿到数据后,进行http协议封装,返回完整http response
# coding: utf-8
import os
import sys
from app import simple_app
def wsgi_to_bytes(s):
return s.encode()
def run_with_cgi(app):
environ = dict(os.environ.items())
environ['wsgi.input'] = sys.stdin.buffer
environ['wsgi.errors'] = sys.stderr
environ['wsgi.version'] = (1, 0)
environ['wsgi.multithread'] = False
environ['wsgi.multiprocess'] = True
environ['wsgi.run_once'] = True
if environ.get('HTTPS', 'off') in ('on', '1'):
environ['wsgi.url_scheme'] = 'https'
else:
environ['wsgi.url_scheme'] = 'http'
headers_set = []
headers_sent = []
def write(data):
out = sys.stdout.buffer
if not headers_set:
raise AssertionError('write() before start_response()')
elif not headers_sent:
status, resp_headers = headers_sent[:] = headers_set
out.write(wsgi_to_bytes('Status: %s\r\n' % status))
for header in resp_headers:
out.write(wsgi_to_bytes('%s: %s\r\n' % header))
out.write(wsgi_to_bytes('\r\n'))
out.write(data)
out.flush()
def start_response(status, resp_headers, exc_info=None):
if exc_info:
try:
if headers_sent:
raise (exc_info[0], exc_info[1], exc_info[2])
finally:
exc_info = None
elif headers_set:
raise AssertionError('headers already set')
headers_set[:] = [status, resp_headers]
return write
result = app(environ, start_response)
try:
for data in result:
if data:
write(data)
if not headers_sent:
write('')
finally:
if hasattr(result, 'close'):
result.close()
if __name__ == '__main__':
run_with_cgi(simple_app)
理解wsgi
wsgi规定,application必须是一个可调用对象,则这个可调用对象可以是函数或实现了__call__方法的实例
wsgi中间件和werkzeug
flask
截至目前 有了两种方法提供web服务:直接通过socket处理请求,或者通过实现wsgi application部分协议
入门推荐
py微型框架有比如web.py, bottle,flask等 flask是一个不错的微型框架
tornado
高性能。tornado不是基于wsgi协议的框架,但提供了wsgi的支持,特性是异步和非阻塞。可以使用自带的http server进行部署而不是wsgi,因为wsgi是一个同步接口
和flask相比,tornado更侧重性能,整体并不比flask丰富,flask更多的支持对业务的满足
django
和微型框架不同,django框架不是仅需要两三个py文件就能跑起来的web框架,django功能更全也更大
django起步
管理系统后台开发
先安装django,再django-admin startproject project_name创建初始项目
cd到project下,创建一个app
models.py
from django.db import models
# Create your models here.
class Student(models.Model):
SEX_ITEMS = [(1, '男'), (2, '女'), (0, '未知')]
STATUS_ITEMS = [(0, '申请'), (1, '通过'), (2, '拒绝')]
name = models.CharField(max_length=128, verbose_name='姓名')
sex = models.IntegerField(choices=SEX_ITEMS, verbose_name='性别')
profession = models.CharField(max_length=128, verbose_name='职业')
email = models.EmailField(verbose_name='Email')
qq = models.CharField(max_length=128, verbose_name='QQ')
phone = models.CharField(max_length=128, verbose_name='电话')
status = models.IntegerField(choices=STATUS_ITEMS, default=0, verbose_name='审核状态')
created_time = models.DateTimeField(auto_now_add=True, editable=False, verbose_name='创建时间')
def __str__(self):
return '<Student: {}>'.format(self.name)
class Meta:
verbose_name = verbose_name_plural = '学员信息'
admin.py
from django.contrib import admin
# Register your models here.
from .models import Student
admin.site.register(Student)
将创建的app在setting中加到installed_apps下
创建数据库迁移文件 python manage.py makemigrations
创建表 python manage.py migrate
创建超级用户 python manage.py createsuperuser
运行测试服务器,访问127.0.0.1:8000 发现是默认页面
访问127.0.0.1:8000/admin会跳转到刚开发的管理员页面,然后用刚创的管理员用户名和密码登录
管理员页面语言是英文,时区也是UTC,可在setting进行配置
重新启动测试服务器,再次登入管理员页面,发现语言变成中文
管理系统前台开发
创一个默认视图函数index
from django.shortcuts import render
# Create your views here.
def index(request):
words = 'hello, world!'
return render(request, 'index.html', context={'words': words})
视图函数使用了模板文件index.html,在app的templates目录下创建index.html,render渲染时会自动去寻找模板文件。django渲染时会去每个app下查找模板,寻找的目标app是在setting中注册的app,并且是按顺序寻找(从上到下)。如果两个不同app下有同名模板,则第一个app的模板会覆盖第二个app的模板
先在app下创建目录templates再在templates中创建index.html
<!DOCTYPE html>
<html>
<head>
<title>学员管理系统</title>
</head>
<body>
{{ words }}
</body>
</html>
模板用到了django模板语法 {{ words }},这个变量是从视图函数的context传过来的上下文
在urls.py中配置url
from django.contrib import admin
from django.urls import path, re_path
from admin_backend.views import index
urlpatterns = [
re_path(r'^$', index, name='index'),
path('admin/', admin.site.urls),
]
重新运行测试服务器,访问127.0.0.1:8000查看效果
在admin后台站点尝试手动创建几个学生数据用于练手,需要修改views.py
def index(request):
students = Student.objects.all()
return render(request, 'index.html', context={'students': students})
<body>
<ul>
{% for student in students %}
<li>{{ student.name }} - {{student.get_status_display }}</li>
{% endfor %}
</ul>
</body>
注意到student的方法get_status_display,实际模型只有status字段没有这个方法,方法是django自己拼出来的,方法作用是展示这个字段实际打算展示的值。
还有一个,模板里的方法可以不用写括号,django会自己帮忙调用
开发提交数据的功能,使用模型表单
from django import forms
from .models import Student
class StudentForm(forms.Form):
# name = forms.CharField(label='姓名', max_length=128)
# sex = forms.ChoiceField(label='性别', choices=Student.SEX_ITEMS)
# profession = forms.CharField(label='职业', max_length=128)
# email = forms.EmailField(label='邮箱', max_length=128)
# qq = forms.CharField(label='QQ', max_length=128)
# phone = forms.CharField(label='手机', max_length=128)
class Meta:
model = Student
fields = ('name', 'sex', 'profession', 'email', 'qq', 'phone')
模型表单可以每一条字段一行,也可以直接复用models.py中对应的模型字段
当需要form和model不完全一致时,可以在模型表单里单独修改,比如增加qq号必须是纯数字校验
class StudentForm(forms.Form):
def clean_qq(self):
cleaned_data = self.cleaned_data['qq']
if not cleaned_data.isdigit():
raise forms.ValidationError('必须是数字')
class Meta:
model = Student
fields = ('name', 'sex', 'profession', 'email', 'qq', 'phone')
clean_qq是模型表单会自动调用处理每个字段的方法
有了表单,修改views.py逻辑,开始使用模型表单
from django.shortcuts import render
from django.http import HttpResponseRedirect
from django.urls import reverse
from .models import Student
from .forms import StudentForm
# Create your views here.
def index(request):
students = Student.objects.all()a
if request.method == 'POST':
form = StudentForm(request.POST)
if form.is_valid():
cleaned_data = form.cleaned_data
student = Student()
student.name = cleaned_data['name']
student.sex = cleaned_data['sex']
student.email = cleaned_data['email']
student.profession = cleaned_data['profession']
student.qq = cleaned_data['qq']
student.phone = cleaned_data['phone']
student.save()
return HttpResponseRedirect(reverse('index'))
else:
form = StudentForm()
context = {
'students': students,
'form': form,
}
return render(request, 'index.html', context=context)
form.cleaned_data是用户在页面输入完数据提交后,django根据字段类型转换后的字段
reverse方法避免了将url地址硬编码到视图函数中,如果要修改url地址,仅需在urls.py中改即可,无需修改views.py
表单模型提供了表单验证能力,减少了前端进行表单验证代码量
上述代码中,手动将字段值从form实例更新到模型实例可以省略,直接保存表单模型实例就可以
# Create your views here.
def index(request):
students = Student.objects.all()
if request.method == 'POST':
form = StudentForm(request.POST)
if form.is_valid():
form.save()
return HttpResponseRedirect(reverse('index'))
else:
form = StudentForm()
context = {
'students': students,
'form': form,
}
return render(request, 'index.html', context=context)
当用户get的时候,页面是填写表单,提交时,保存表单
index.html
<!DOCTYPE html>
<html>
<head>
<title>学员管理系统</title>
</head>
<body>
<h3><a href="/admin/">Admin</a></h3>
<ul>
{% for student in students %}
<li>{{ student.name }} - {{ student.get_status_display }}</li>
{% endfor %}
</ul>
<hr />
<form action="/" method="post">
{% csrf_token %}
{{ form }}
<input type="submit" value="Submit"/>
</form>
</body>
</html>
csrf_token如果没有这个,提交的数据是无效的,这可以用来防止跨站伪造请求攻击
访问127.0.0.1:8000看下效果
发现提交后没有报错 也没有显示新提交的信息,原因是字段非法,视图函数也没报错
注意到视图函数中包含了查询数据的操作,当需要过滤查询条件,或者需要缓存数据,都需要修改视图函数代码,此时可将数据获取逻辑封装到model中
模型层代码
class Student(models.Model):
@classmethod
def get_all(cls):
return cls.objects.all()
# 省略其他代码
视图函数代码
def index(request):
students = Student.all()
管理系统进阶开发
class-based view
当有多个类似的view函数,可以考虑使用class-based抽象
# urls.py
urlpatterns = [
re_path(r'^$', index, name='index'),
# re_path(r'^$', IndexView.as_view(), name='index'),
path('admin/', admin.site.urls),
]
# views.py
class IndexView(View):
template_name = 'index.html'
def get_context(self):
students = Student.get_all()
context = {'students': students}
return context
def get(self, request):
context = self.get_context()
form = StudentForm()
context.update({'form': form})
return render(request, self.template_name, context=context)
def post(self, request):
form = StudentForm(request.POST)
if form.is_valid():
form.save()
return HttpResponseRedirect(reverse('index'))
context = self.get_context()
context.update({'form': form})
return render(request, self.template_name, context=context)
创建一个middleware练手,用来统计django接受请求到返回请求的时间
先创建文件middlewares.py,与views.py同级别
# middlewares.py
import time
from django.urls import reverse
from django.utils.deprecation import MiddlewareMixin
class TimeItMiddleware(MiddlewareMixin):
def process_request(self, request):
self.start_time = time.time()
return
def process_view(self, request, func, *args, **kwargs):
if request.path != reverse('index'):
return None
start = time.time()
response = func(request)
costed = time.time() - start
print('process view: {:.2f}s'.format(costed))
return response
def process_exception(self, request, exception):
pass
def process_tempmlate_response(self, request, response):
return response
def process_response(self, request, response):
costed = time.time() - self.start_time
print('request to response cost: {:.2f}s'.format(costed))
return response
请求来和返回相应一般会按顺序调用这些函数:process_request, process_view, process_exception, process_template_response, process_response
process_request是请求来第一个处理函数,此函数可放些请求头校验等任务
process_view是process_request之后执行,用来执行view函数,func参数就是视图函数。可以在此处进行视图函数执行耗时统计
process_template_response 当拿到视图函数的返回函数,且返回函数为模板渲染的函数,则会执行该函数
process_response 当处理完模板渲染的视图函数后,会执行该方法
process_exception 当在视图函数处理过程或返回模板渲染时发生异常,才会执行proces_exception函数。但如果在process_view中手动调用func,就不会触发process_exception
middleware写完后,在settings中的MIDDLEWARE加上middleware
运行web,查看控制台打印访问耗时
写单元测试
运行单元测试时,django会创建一个基于内存的测试数据库,也就是说,这对生产部署的环境没有影响
但对于mysql数据库,django会直接用配置的数据库用户名和密码创建一个名为test_modelname_db的数据库用于测试,此时需要保证有见表和建数据库的权限
也可以在settings指定测试创建的数据库名
对于测试用例,django提供了一个名为TestCase的基类,可以继承这个类实现自己的测试用例。基类的方法和python的单元测试方法差不多
# models.py
@property
def sex_show(self):
return dict(self.SEX_ITEMS)[self.sex]
# tests.py
from django.test import TestCase, client
from .models import Student
# Create your tests here.
class StudentTestCase(TestCase):
def setUp(self):
Student.objects.create(
name='tjh',
sex=1,
email='test@qq.com',
profession='coder',
qq='2222',
phone='3333',
)
def test_create_and_sex_show(self):
student = Student.objects.creat(
name='tjh',
sex=1,
email='aaa@dd.com',
profession='coder',
qq='4444',
phone='5555'
)
self.assertEqual(student.sex_show, '男', "性别字段内容和展示不一致")
def test_filter(self):
student = Student.objects.creat(
name='tjh',
sex=1,
email='aaa@dd.com',
profession='coder',
qq='4444',
phone='5555'
)
name = 'tjhaa'
students = Student.objects.filter(name=name)
self.assertEqual(students.count(), 1, 'student count should be 1')
view层测试
# tests.py
def test_get_index(self):
client = Client()
resp = client.get('/')
self.assertEqual(resp.status_code, 200, 'status code should be 200')
def test_post_student(self):
client = Client()
data = dict(
name='test_for_post',
sex=1,
email='123@qq.com',
profession='coder',
qq='1111',
phone='9999'
)
resp = client.post('/', data)
self.assertEqual(resp.status_code, 302, 'status code should be 302')
resp = client.get('/')
self.assertTrue(b'test_for_post' in resp.context, 'resp content should include test_for_post')