Django Web项目开发流程总结_djangoweb开发流程

1.创建项目
项目架构：
1）前端、后端部分（各五个分类）：
1: 用户user　2: 商品goods　3: 购物车cart　4: 订单order　5: 后台admin
2）关系数据库：mysql
3）缓存服务器（session）：redis内存型数据库
4）异步任务处理：celery
5）分布式文件存储系统：fastdfs

数据库设计：
（1）用户表：id，用户名，密码，邮箱，激活标识，权限标识
1
2

class User(AbstractUser, BaseModel):
    '''用户模型类'''

    class Meta:
        db_table = 'df_user'
        verbose_name = '用户'
        verbose_name_plural = verbose_name
1
2
3
4
5
6
7

        （2）地址表：id，收件人，收件地址，邮编，联系方式，是否默认，用户id

class Address(BaseModel):
    '''地址模型类'''
    user = models.ForeignKey('User', verbose_name='所属账户')
    receiver = models.CharField(max_length=20, verbose_name='收件人')
    addr = models.CharField(max_length=256, verbose_name='收件地址')
    zip_code = models.CharField(max_length=6, null=True, verbose_name='邮政编码')
    phone = models.CharField(max_length=11, verbose_name='联系电话')
    is_default = models.BooleanField(default=False, verbose_name='是否默认')

	# 自定义一个模型管理器对象，Django 会确保在模型类中至少有一个默认的Manager
	# 若没有添加自己的Manager，Django 将添加一个属性objects，它包含默认的Manager 实例
	# 若添加自己的Manager实例的属性，默认值则不会出现
    objects = AddressManager()

    class Meta:
        db_table = 'df_address'
        verbose_name = '地址'
        verbose_name_plural = verbose_name
        
class AddressManager(models.Manager):
    '''地址模型管理器类'''
    # 1.改变原有查询的结果集:all()
    # 2.封装方法:用户操作模型类对应的数据表(增删改查)
    def get_default_address(self, user):
        '''获取用户默认收货地址'''
        # self.model:获取self对象所在的模型类
        try:
            address = self.get(user=user, is_default=True)  # models.Manager
        except self.model.DoesNotExist:
            # 不存在默认收货地址
            address = None

        return address
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33

        （３）商品SKU表：id，名称，简介，价格，单位，库存，销量，图片，状态，种类ID，SPU ID

class GoodsSKU(BaseModel):
    '''商品SKU模型类'''
    status_choices = (
        (0, '下线'),
        (1, '上线'),
    )

    type = models.ForeignKey('GoodsType', verbose_name='商品种类')
    goods = models.ForeignKey('Goods', verbose_name='商品SPU')
    name = models.CharField(max_length=20, verbose_name='商品名称')
    desc = models.CharField(max_length=256, verbose_name='商品简介')
    price = models.DecimalField(max_digits=10, decimal_places=2, verbose_name='商品价格')
    unite = models.CharField(max_length=20, verbose_name='商品单位')
    image = models.ImageField(upload_to='goods', verbose_name='商品图片')
    stock = models.IntegerField(default=1, verbose_name='商品库存')
    sales = models.IntegerField(default=0, verbose_name='商品销量')
    status = models.SmallIntegerField(default=1, choices=status_choices, verbose_name='商品状态')

    class Meta:
        db_table = 'df_goods_sku'
        verbose_name = '商品'
        verbose_name_plural = verbose_name
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22

        （4）商品种类表：id，种类名称，logo，图片

class GoodsType(BaseModel):
    '''商品类型模型类'''
    name = models.CharField(max_length=20, verbose_name='种类名称')
    logo = models.CharField(max_length=20, verbose_name='标识')
    image = models.ImageField(upload_to='type', verbose_name='商品类型图片')

    class Meta:
        db_table = 'df_goods_type'
        verbose_name = '商品种类'
        verbose_name_plural = verbose_name

    def __str__(self):
        return self.name
1
2
3
4
5
6
7
8
9
10
11
12
13

        （5）首页轮播商品表：id，sku_id，图片，index（代码略，同下模型类）
        （6）首页促销活动表：id，图片，活动url，index
        （7）首页SPU表：id，名称，详情
        （8）首页分类商品展示表：id，sku_id，种类id，展示标识，index
        （9）商品图片表：id，图片，sku_id
        （10）订单商品表：id，订单id，sku_id，商品数量，商品价格，评论
        （11）订单信息表：订单id，地址id，用户id，支付方式，总数目，总金额，运费，支付状态，创建时间

2.创建项目
项目开发环境：linux
安装好虚拟环境（virtualenvwrapper）以及相关第三方库
输入指令：
django-admin startproject 项目名称
cd 项目目录

进入项目目录当中进行开发

3.创建应用
一个项目中可包含很多应用，本项目应用进行了模块化处理。
输入命令创建四个主要应用：

python manage.py startapp users
python manage.py startapp goods
python manage.py startapp orders
python manage.py startapp cart
1
2
3
4

在settings中的INSTALLED_APPS中配置四个应用：
（１）users（２）goods（３）orders（４） cart

配置应用
由于之前User继承于AbstractUser和BaseModel，只在其模型类的元类中进行部分数据修正。AUTH_USER_MODEL配置参数要在第一次迁移数据库之前配置，否则django认证系统工作不正常。（配置如下图）在配置完AUTH_UESR_MODEL后，django会创建user表，并且之后进行

python manage.py createsuperuser
1

创建的超级管理员也会在df_user的表中。

配置django认证用户模型

3.配置数据库
Django支持多种数据库，这里演示使用 sqlite，具体数据库配置于项目下的settings.py中进行。

DATABASES = {
    'default': {
        'ENGINE': 'django.db.backends.mysql',
        'NAME': os.path.join(BASE_DIR, 'db.mysql'),
    }
}
1
2
3
4
5
6

5.编写models.py文件
MVT框架的M，表示model，负责与数据库交互。
进行各模型类代码编写（部分代码见项目数据库设计部分）
6.迁移模型至数据库
（1）激活模型：
　　 于settings的INSTALLED_APPS中注册应用（如上图）
（2）生成迁移文件
　　进行迁移这一过程，会根据定义的模型类来生成对应的sql语句：
　　终端执行如下指令：
　　python manage.py makemigrations
　　如此mysql数据库部分已搭建好了。
7. 编写模板文件
MVT框架的T，表示template，负责呈现内容到浏览器。 模板是Django项目中用来向用户展示网站具体信息的部分，为html文件，不过在其基础上添加了类python的可执行代码，具有python代码的html文件通过渲染后，可生成普通的html文件。
Django项目中模板的路径为项目根目录下的templates中。

带有python代码的html文件内容

8.编写视图文件
视图Django当中用来处理用户请求的部分，对应MVT中的V（view），是框架的核心，负责接收请求、获取数据和返回结果。
视图会根据用户所发出的请求向模型获取所需数据，并将数据发送给模板，并对模板进行渲染操作，将渲染好的html文件返回给浏览器进行展示。（鉴于篇幅，本文展示项目当中购物车cart模块的view文件内容）

from django.shortcuts import render
from django.views.generic import View
from django.http import JsonResponse

from goods.models import GoodsSKU
from django_redis import get_redis_connection
from utils.mixin import LoginRequiredMixin

# Create your views here.
# 添加商品到购物车:
# 1）请求方式，采用ajax post
# 如果涉及到数据的修改(新增，更新，删除), 采用post
# 如果只涉及到数据的获取，采用get
# 2) 传递参数: 商品id(sku_id) 商品数量(count)


# ajax发起的请求都在后台，在浏览器中看不到效果
# /cart/add
class CartAddView(View):
    '''购物车记录添加'''
    def post(self, request):
        '''购物车记录添加'''
        user = request.user
        if not user.is_authenticated():
            # 用户未登录
            return JsonResponse({'res':0, 'errmsg':'请先登录'})

        # 接收数据
        sku_id = request.POST.get('sku_id')
        count = request.POST.get('count')

        # 数据校验
        if not all([sku_id, count]):
            return JsonResponse({'res':1, 'errmsg':'数据不完整'})

        # 校验添加的商品数量
        try:
            count = int(count)
        except Exception as e:
            # 数目出错
            return JsonResponse({'res':2, 'errmsg':'商品数目出错'})

        # 校验商品是否存在
        try:
            sku = GoodsSKU.objects.get(id=sku_id)
        except GoodsSKU.DoesNotExist:
            # 商品不存在
            return JsonResponse({'res':3, 'errmsg':'商品不存在'})

        # 业务处理:添加购物车记录
        conn = get_redis_connection('default')
        cart_key = 'cart_%d'%user.id
        # 先尝试获取sku_id的值 -> hget cart_key 属性
        # 如果sku_id在hash中不存在，hget返回None
        cart_count = conn.hget(cart_key, sku_id)
        if cart_count:
            # 累加购物车中商品的数目
            count += int(cart_count)

        # 校验商品的库存
        if count > sku.stock:
            return JsonResponse({'res':4, 'errmsg':'商品库存不足'})

        # 设置hash中sku_id对应的值
        # hset->如果sku_id已经存在，更新数据， 如果sku_id不存在，添加数据
        conn.hset(cart_key, sku_id, count)

        # 计算用户购物车商品的条目数
        total_count = conn.hlen(cart_key)

        # 返回应答
        return JsonResponse({'res':5, 'total_count':total_count, 'message':'添加成功'})


# /cart/
class CartInfoView(LoginRequiredMixin, View):
    '''购物车页面显示'''
    def get(self, request):
        '''显示'''
        # 获取登录的用户
        user = request.user
        # 获取用户购物车中商品的信息
        conn = get_redis_connection('default')
        cart_key = 'cart_%d'%user.id
        # {'商品id':商品数量, ...}
        cart_dict = conn.hgetall(cart_key)

        skus = []
        # 保存用户购物车中商品的总数目和总价格
        total_count = 0
        total_price = 0
        # 遍历获取商品的信息
        for sku_id, count in cart_dict.items():
            # 根据商品的id获取商品的信息
            sku = GoodsSKU.objects.get(id=sku_id)
            # 计算商品的小计
            amount = sku.price*int(count)
            # 动态给sku对象增加一个属性amount, 保存商品的小计
            sku.amount = amount
            # 动态给sku对象增加一个属性count, 保存购物车中对应商品的数量
            sku.count = count
            # 添加
            skus.append(sku)

            # 累加计算商品的总数目和总价格
            total_count += int(count)
            total_price += amount

        # 组织上下文
        context = {'total_count':total_count,
                   'total_price':total_price,
                   'skus':skus}

        # 使用模板
        return render(request, 'cart.html', context)


# 更新购物车记录
# 采用ajax post请求
# 前端需要传递的参数:商品id(sku_id) 更新的商品数量(count)
# /cart/update
class CartUpdateView(View):
    '''购物车记录更新'''
    def post(self, request):
        '''购物车记录更新'''
        user = request.user
        if not user.is_authenticated():
            # 用户未登录
            return JsonResponse({'res': 0, 'errmsg': '请先登录'})

        # 接收数据
        sku_id = request.POST.get('sku_id')
        count = request.POST.get('count')

        # 数据校验
        if not all([sku_id, count]):
            return JsonResponse({'res': 1, 'errmsg': '数据不完整'})

        # 校验添加的商品数量
        try:
            count = int(count)
        except Exception as e:
            # 数目出错
            return JsonResponse({'res': 2, 'errmsg': '商品数目出错'})

        # 校验商品是否存在
        try:
            sku = GoodsSKU.objects.get(id=sku_id)
        except GoodsSKU.DoesNotExist:
            # 商品不存在
            return JsonResponse({'res': 3, 'errmsg': '商品不存在'})

        # 业务处理:更新购物车记录
        conn = get_redis_connection('default')
        cart_key = 'cart_%d'%user.id

        # 校验商品的库存
        if count > sku.stock:
            return JsonResponse({'res':4, 'errmsg':'商品库存不足'})

        # 更新
        conn.hset(cart_key, sku_id, count)

        # 计算用户购物车中商品的总件数 {'1':5, '2':3}
        total_count = 0
        vals = conn.hvals(cart_key)
        for val in vals:
            total_count += int(val)

        # 返回应答
        return JsonResponse({'res':5, 'total_count':total_count, 'message':'更新成功'})


# 删除购物车记录
# 采用ajax post请求
# 前端需要传递的参数:商品的id(sku_id)
# /cart/delete
class CartDeleteView(View):
    '''购物车记录删除'''
    def post(self, request):
        '''购物车记录删除'''
        user = request.user
        if not user.is_authenticated():
            # 用户未登录
            return JsonResponse({'res': 0, 'errmsg': '请先登录'})

        # 接收参数
        sku_id = request.POST.get('sku_id')

        # 数据的校验
        if not sku_id:
            return JsonResponse({'res':1, 'errmsg':'无效的商品id'})

        # 校验商品是否存在
        try:
            sku = GoodsSKU.objects.get(id=sku_id)
        except GoodsSKU.DoesNotExist:
            # 商品不存在
            return JsonResponse({'res':2, 'errmsg':'商品不存在'})

        # 业务处理:删除购物车记录
        conn = get_redis_connection('default')
        cart_key = 'cart_%d'%user.id

        # 删除 hdel
        conn.hdel(cart_key, sku_id)

        # 计算用户购物车中商品的总件数 {'1':5, '2':3}
        total_count = 0
        vals = conn.hvals(cart_key)
        for val in vals:
            total_count += int(val)

        # 返回应答
        return JsonResponse({'res':3, 'total_count':total_count, 'message':'删除成功'})
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215

9.配置url 在完成网站各个功能模块的model、templates、view创建后，接下来需要将这几个部分打通起来，使其组合起来协调工作。此时，需要进行url的配置。

当客户端浏览器一个request请求到服务器的时候，首先要对请求的url信息进行解析，获取当前请求需要的信息是什么，请求会对应一个具体的view视图，视图会将模板和模型组合起来。
10.项目配置
有关项目所需进行的配置：
（1）设置应用所在路径，以便于应用注册可找到相应应用

import os
import sys
BASE_DIR = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
sys.path.insert(0, os.path.join(BASE_DIR, 'apps'))
1
2
3
4

（2）uwsgi上线部署

DEBUG = False
# 为了让我们的项目可以被远程访问，在设置文件中指定项目运行的主机IP：
# 在uwsgi服务器中可设置为‘*’
ALLOWED_HOSTS = ['*']
1
2
3
4

（3）uwsgi应用路径设置

WSGI_APPLICATION = 'dailyfresh.wsgi.application'
1

（4）url全局配置

ROOT_URLCONF = 'dailyfresh.urls'
1

（5）url全局配置

ROOT_URLCONF = 'dailyfresh.urls'
1

（6）用户模型配置

# django认证系统使用的用户模型类（由于自行定制了用户模型类）
AUTH_USER_MODEL='user.User' 
1
2

（7）url全局配置

# 修改站点语言
# LANGUAGE_CODE = 'en-us'
LANGUAGE_CODE = 'zh-Hans'

# 修改站点时区
# TIME_ZONE = 'UTC'
TIME_ZONE = 'Asia/Shanghai'
1
2
3
4
5
6
7

（8）静态页面及文件的配置

STATIC_URL = '/static/'		# 静态文件的路径设置
STATICFILES_DIRS = [os.path.join(BASE_DIR, 'static')]
# 指定收集静态文件的路径
STATIC_ROOT='/var/www/dailyfresh/static'
1
2
3
4

（9）Tinymce富文本编辑器配置

# 富文本编辑器配置
TINYMCE_DEFAULT_CONFIG = {
    'theme': 'advance',
    'width': 600,
    'height': 400,
}
1
2
3
4
5
6

（10）邮件配置

# 发送邮件配置
EMAIL_BACKEND = 'django.core.mail.backends.smtp.EmailBackend'
# smpt服务地址
EMAIL_HOST = 'smtp.163.com'
EMAIL_PORT = 25
# 发送邮件的邮箱
EMAIL_HOST_USER = 'smartli_it@163.com'
# 在邮箱中设置的客户端授权密码
EMAIL_HOST_PASSWORD = 'smartli123'
# 收件人看到的发件人
EMAIL_FROM = '天天生鲜<smartli_it@163.com>'
1
2
3
4
5
6
7
8
9
10
11

（11）Django缓存配置

CACHES = {
    "default": {
        "BACKEND": "django_redis.cache.RedisCache",
        "LOCATION": "redis://172.16.179.142:6379/9",		# redis对应的服务器ip和端口
        "OPTIONS": {
            "CLIENT_CLASS": "django_redis.client.DefaultClient",
        }
    }
}
1
2
3
4
5
6
7
8
9

（12）配置session存储

SESSION_ENGINE = "django.contrib.sessions.backends.cache"
SESSION_CACHE_ALIAS = "default"
1
2

（13）配置登录url地址
登录地址因项目需要而定制url登录地址，故需于settings文件中自行配置

LOGIN_URL='/user/login' # /accounts/login?next=/user
1

（14）FDFS配置

# 设置Django的文件存储类
DEFAULT_FILE_STORAGE='utils.fdfs.storage.FDFSStorage'
# 设置fdfs使用的client.conf文件路径
FDFS_CLIENT_CONF='./utils/fdfs/client.conf'
# 设置fdfs存储服务器上nginx的IP和端口号
FDFS_URL='http://172.16.179.131:8888/'
1
2
3
4
5
6

（15）全文检索框架的配置

# 全文检索框架HAYSTACK的配置
HAYSTACK_CONNECTIONS = {
    'default': {
        # 使用whoosh引擎
        # 'ENGINE': 'haystack.backends.whoosh_backend.WhooshEngine',
        'ENGINE': 'haystack.backends.whoosh_cn_backend.WhooshEngine',
        # 索引文件路径
        'PATH': os.path.join(BASE_DIR, 'whoosh_index'),
    }
}

# 当添加、修改、删除数据时，自动生成索引
HAYSTACK_SIGNAL_PROCESSOR = 'haystack.signals.RealtimeSignalProcessor'

# 指定搜索结果每页显示的条数
HAYSTACK_SEARCH_RESULTS_PER_PAGE=1
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

11.启动服务

# 启用django正常指令
python manage.py runserver ip:port
# 配置uwsgi服务器
启动:uwsgi –-ini 配置文件路径 例如:uwsgi –-ini uwsgi.ini
停止:uwsgi --stop uwsgi.pid路径 例如:uwsgi –-stop uwsgi.pid
1
2
3
4
5

12.站点管理
Django自带一套完整可定制的后端站点管理系统，可实现对项目数据库的增删改查操作。
进入方式是在项目网址后面加 /admin
（1）创建超级用户
但在进入站点管理前必须创建一个超级用户，通过超级用户才能登陆到站点管理后台。

# 创建超级用户指令
python manage.py createsuperuser
1
2

（2）注册模型
进入网站管理界面主要是为了管理数据库中的内容，但之前的工作中只是定义了模型并完成模型带数据库的迁移操作，这些只是准备操作。
要想在站点中管理数据库对象必须要先在系统管理中进行注册。

注册方法：在所创建的应用目录下的admin.py文件，在该文件中导入对应的模型列，调用admin模块的register模块。

from django.contrib import admin
from django.core.cache import cache
from goods.models import GoodsType,IndexPromotionBanner,IndexGoodsBanner,IndexTypeGoodsBanner

admin.site.register(GoodsType)
admin.site.register(IndexGoodsBanner）
admin.site.register(IndexTypeGoodsBanner)
admin.site.register(IndexPromotionBanner)
1
2
3
4
5
6
7
8

对相应的模型类注册后，便可以登录到管理界面进行数据处理了。