Django 创建项目的完整步骤

我就是我是好孩子啊

已于 2024-06-17 10:59:29 修改

阅读量688

点赞数

文章标签： python django 后端

于 2022-07-11 10:36:49 首次发布

from zhangxia

本文链接：https://blog.csdn.net/weixin_41442949/article/details/125716772

版权

创建Django步骤

安装Django pip3 install Django

django-admin startproject `projectname`

Projectname: 项目的容器。
manage.py: 一个实用的命令行工具，可让你以各种方式与该 Django 项目进行交互。
Projectname/init.py: 一个空文件，告诉 Python 该目录是一个 Python 包。
Projectname/asgi.py: 一个 ASGI 兼容的 Web 服务器的入口，以便运行你的项目。
Projectname/settings.py: 该 Django 项目的设置/配置。
Projectname/urls.py: 该 Django 项目的 URL 声明; 一份由 Django 驱动的网站"目录"。
Projectname/wsgi.py: 一个 WSGI 兼容的 Web 服务器的入口，以便运行你的项目。

2.进入项目目录，run 这条命令

python3 manage.py runserver

打开浏览器，访问http://127.0.0.1:8000/,看到Django的火箭欢迎界面，一切OK！
3.创建APP
在 Django 中，每一个应用（app）都是一个 Python 包，并且遵循着相同的约定。Django 自带一个工具，可以帮你生成应用的基础目录结构。
app应用与project项目的区别：

一个app实现某个具体功能，比如博客、公共档案数据库或者简单的投票系统；
一个project是配置文件和多个app的集合，这些app组合成整个站点；
一个project可以包含多个app；
一个app可以属于多个project！

app的存放位置可以是任何地点，但是通常都将它们放在与manage.py脚本同级的目录下，这样方便导入文件。

进入projectname项目根目录，确保与manage.py文件处于同一级，输入下述命令：

$ python3 manage.py startapp appname

Terminal终端中输入命令：python3 manage.py startapp appname这样也能创建appname应用。

创建应用成功后，需要将APP应用进行注册,在项目文档中找到settings.py文件-INSTALLED_APPS配置文件中将创建的应用名称加到文件中，注意：新添加应用后必须在设置文件中进行注册.

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

注册完成后在进行数据库表的设计（以MySQL数据库为例）在项目文档中找到settings.py文件-DATEBASES配置文件，修改自己的数据库配置.

创建mysql数据库

这篇博客有详细介绍安装和配置
（https://blog.csdn.net/qq_44370158/article/details/131400776?utm_medium=distribute.pc_relevant.none-task-blog-2_defaultbaidujs_baidulandingword~default-12-131400776-blog-137897845.235^v43pc_blog_bottom_relevance_base6&spm=1001.2101.3001.4242.7&utm_relevant_index=13）

import pymysql

pymysql.install_as_MySQLdb()

DATABASES = {
    'default': {
        'ENGINE': 'django.db.backends.mysql',
        'NAME': 'testwebDemo',
        'USER': 'root',
        'PASSWORD': 'zhangxia',
        'HOST': 'localhost',
        'OPTIONS': '3306'
    }
}

可根据你的数据库类型进行设置-- 例如：

'django.db.backends.sqlite3',
'django.db.backends.postgresql',
'django.db.backends.mysql',
'django.db.backends.oracle'

如果使用其他的数据库，请先安装相应的数据库操作模块，并将settings文件中DATABASES位置的’default’字典进行相应的修改，用于连接你的数据库。其中：

ENGINE(引擎)：可以是django.db.backends.sqlite3、django.db.backends.postgresql、django.db.backends.mysql、django.db.backends.oracle.
NAME(数据库名称)：类似Mysql数据库管理系统中用于保存项目内容的数据库的名字。
注意：
在使用非SQLite3数据库时，请务必预先在数据库管理系统的提示符交互模式下创建数据库，你可以使用命令：CREATE DATABASE database_name;。
确保你在settings文件中提供的数据库用户具有创建数据库表的权限，因为在接下来的教程中，我们需要自动创建一个test数据表。（在实际项目中也需要确认这一条要求。）
如果你使用的是SQLite3直接使用就可以无需配置。
在修改settings文件时，请顺便将TIME_ZONE设置为国内所在的时区Asia/Shanghai，这样显示的就是我们北京时间。同时，请注意settings文件中顶部的INSTALLED_APPS设置项。它列出了所有的项目中被激活的Django应用(app)必须将你自己创建的app注册在这里。每个应用可以被多个项目使用，并且可以打包和分发给其他人在他们的项目中使用。默认情况，INSTALLED_APPS中会自动包含下列条目，它们都是Django自动生成的：

django.contrib.admin：admin管理后台站点
django.contrib.auth：身份认证系统
django.contrib.contenttypes：内容类型框架
django.contrib.sessions：会话框架
django.contrib.messages：消息框架
django.contrib.staticfiles：静态文件管理框架
上面的那些应用会默认被启动，并且也需要建立一些数据库表，所以在使用它们之前我们要在数据库中创建这些表。

在应用中的配置文件找到models.py 添加ORM框架的代码,输入命令进行数据库的表的初始化

Python3 manage.py migrate

然后找到App应用的models.py文件设计自己应用的数据库表.此方式就是根据django的ORM架构设计的数据表，它会帮我们在数据库创建好，举个小例子理解下:

class Station(models.Model):
    stationID = models.CharField(max_length=100,verbose_name=u'站位ID')
    stationName = models.CharField(max_length=100,verbose_name=u'站位名')
    displayName = models.CharField(max_length=100, verbose_name=u'站位显示名')
    script = models.CharField(max_length=100,null=True,blank=True,default='',verbose_name=u'代码文件名')
    innerScripts = models.CharField(max_length=520,verbose_name=u'代码内部文件名',null=True,blank=True,default='')
    description = models.TextField(verbose_name=u'描述',null=True,blank=True,default='')
    category = models.CharField(max_length=100,verbose_name=u'分类')
    isPOR = models.BooleanField(default=False, verbose_name=u'POR站位')
    isOffline = models.BooleanField(default=False, verbose_name=u'Offline站位')
    addTime = models.DateTimeField(verbose_name=u'添加时间',auto_now_add=True)
    tag = models.TextField(verbose_name=u'描述',null=True,blank=True, default='')
    overlayRadar = models.CharField(max_length=128,null=True,blank=True,default='',verbose_name=u'stationOverlayRadar')
    
    project = models.ForeignKey(Project, on_delete=models.CASCADE, null=True, blank=True, verbose_name=u'专案')

    class Meta:
        verbose_name = u'站位'
        verbose_name_plural = verbose_name

    def __str__(self):
        return self.stationName

django的ORM架构设计的数据表详解

Django 框架向我们提供了丰富的模块，避免程序员在开发的过程中重复“造轮子”，提高了开发者的工作效率。接下来的几节内容，将给大家介绍 Django 的主要功能模块，第一个模块是 Django 的 ORM 模块

一，什么是ORM？
ORM （Object Realtional Mapping）即对象关系映射，它是一种基于关系型数据库的程序技术。ORM 允许你使用类和对象对数据库进行操作，这大大提高了对数据库的控制，避免了直接使用 SQL 语句对数据库进行操作。这种程序技术的底层主要是通过映射机制实现的，有兴趣的可以自己研究一下！Web 开发中对数据库的操作是必不可少的，然而每种数据库的操作方式以及用法不尽相同。由于 Django 中 ORM 的存在，为我们操作不同种类的数据库提供了统一的方法，ORM 适配了多种常用的关系型数据库，例如 PostgreSQL、MySQL、Oracle、Sqlite3 等。

针对数据库中的字段类型，Django ORM 都有对应的 “xxxField” 来表述，见如下表格：

二，Django中定义数据表
那么在 Django 中如何使用 ORM 模块来定义一张数据表呢？在定义数据表之前，我们应该首先理解什么是模型类。

模型类
其实模型类本质上属于一个 Python 类，只不过在 Django 中称之为做模型类，它是由 django.db.models.Model 派生出的子类，在 Django 中模型类是数据交互的接口，一个模型类代表数据库中的一张数据表，模型类中每一个类属性都代表数据表中的一个字段。

通过上述介绍，我们可以这样理解：Django 中模型类就相当于 ORM 模块。

定义数据表
现在有一张用户信息表 UserInfo，它有两个字段 name 和 password，可以定义如下：

from django.db import models
class UserInfo（models.Model）:
      name = models.CharFiled(max_length=100)
      password = models.CharFiled(max_length=100)

通过以上代码，UserInfo 数据表就已经创建完成，我们对代码进行逐行解析：

第 1 行，使用 from django.db import models 导入 models 模块；
第 2 行，使用 class 关键字对 UserInfo 表进行类定义，并继承了models 模块中的 Model 类；
第3、4 行，数据表中的字段 name 和 password 是 UserInfo 类的属性，name 和 password 字段类型都是 CharFiled，字段长度均是100。
三，ORM 管理器对象
那么应该怎样对数据表进行操作呢？我们可以直接使用类名（即数据表名）来插入数据，下面是插入数据的一种方法

UserInfo.objects.create(name='jay',password='abc123')

上面代码插入一条名字是“jay”，密码是“abc123”的数据。读到这里，您可能会对"objects "产生疑问，所以在此处讲解一个重要的概念：每个继承自 models.Model 的模型类，都会有一个 objects 对象被同时继承下来，这个对象就叫做“管理器对象”，数据库的增删改查可以用 objects 管理器对象来实现。

利用 ORM 插入数据有两种方式，上面已经介绍了一种，下面介绍第二种方法，也就是创建 UserInfo 的实例对象，然后调用save()方法保存，代码如下：

Obj=UserInfo（name="jay",password="abc123"）
Obj.name="john"
Obj.save()

上述代码中 name 属性值会被赋值为“john”，最后调用 save() 方法保存。ORM 的增删改查称为 CURD 操作，下面列举几个常用语句：

UserInfo.objects.all()#查询表中的所有记录
UserInfo.objects.filter(name_contains='j')#查询表中name含有“j”的所有记录,被使用较多
UserInfo.objects.get(name="john")#有且只有一个查询结果，如果超出一个或者没有,则抛出异常
UserInfo.objects.get(name="john").delete()#删除名字为john的记录
UserInfo.objects.get(name="john").update(name='TOM')#更新数据表的name为TOM

设计好之后输入创建数据库迁移的命令.

python3 manage.py startapp student

此命令用于创建数据库迁移文件。当更改了Django项目中的模型定义时，需要使用此命令来生成新的数据库迁移文件将创建好的数据库迁移的文件更改应用到数据库中，输入命令

python3 manage.py migrate student

用于将数据库迁移应用到数据库中。当您对Django项目中的模型进行了更改后，需要使用此命令将这些更改应用到数据库中，以便在运行应用程序时能够正确地读取和写入数据。打开数据库查看一下(表和参数都已经创建成功了).

在APP应用中创建静态文件和模板文件

静态文件static中创建js、css、img、pluging文件便于我们创建前端文件直接调用

模板文件templates创建html文件

创建学生列表进行展示

首先，在urls.py 创建访问访问路径

from django.contrib import admin

from django.urls import path

from student import views

urlpatterns = [

    path("admin/", admin.site.urls),

    path("user/list/",views.info_add ),

]

访问user/list，去找到views.info_add函数

然后，在views.py中创建info_add函数，使返回学生列表的所有数据，并以info_list.html进行返回展示

from django.shortcuts import render

from student.models import UserInfo,Department

# Create your views here.

def info_list(request):

    data_list = Userinfo.object.all()

    return render(request,"info_list.html",{"data_list":data_list})

最后在templates中创建info_list.html的文件, 启动项目命令:

python3 manage.py runserver

4.编写第一个view.py

下面是一个例子

from copy import deepcopy
from django.http import JsonResponse
from django.db.models import Q
from django.conf import settings
from django.http import JsonResponse, QueryDict
from django.views.generic.base import View
import time
import os
import re
import json
import datetime
import calendar
import traceback
import requests
import urllib3

def mamabearData(request):
    if request.method == 'POST':
        response = {}
        try:
            user = request.POST.get('user', '')
            first = request.POST.get('first', '')
            second = request.POST.get('second', '')
            build = request.POST.get('build', '')
            payload = {
                'applet':'ATSWEB',
                'time':datetime.datetime.now().strftime("%Y-%m-%d %H:%M:%S"),
                'team':'ATS',
                'user':user,
                'first':first,
                'second':second,
                'location':'',
                'build':build
            }
            url="https://mamabear.sh.pegatroncorp.com/TestReceiverDataAPI/?"
            data=requests.post(url,json=payload,verify=False)
            result = json.loads(data.text)
            if result['status'] == 'success':
                response['msg'] = 'success'
                response['error_num'] = 0
            else:
                raise ValueError("mamabear request error!")
        except Exception as e:
            print(traceback.format_exc(limit=1))
            response['msg'] = str(e)
            response['error_num'] = 1

        return JsonResponse(response)

在url.py 中配置

    path('mamabear', CommonViews.mamabearData, name='mamabearData'),

创建模型
每个模型被表示为 django.db.models.Model 类的子类。每个模型有许多类变量，它们都表示模型里的一个数据库字段。
每个字段都是 Field 类的实例 - 比如，字符字段被表示为 CharField ，日期时间字段被表示为 DateTimeField 。这将告诉 Django 每个字段要处理的数据类型。
启用模型

要将应用添加到项目中，需要在INSTALLED_APPS设置中增加指向该应用的配置文件的链接.需要将创建的app在INSTALLED_APPS中,将该路径添加进去(string 格式)在run 下面这条命来迁移

在models.py中修改模型；
运行python manage.py makemigrations为改动创建迁移记录文件；
运行python manage.py migrate，将操作同步到数据库。

编写视图(View)和Template(模板)

打开views.py文件在这边编写要实现功能的function

urls.py文件中加入路由，将其映射到我们上面新增的视图

需要使用Django提供的模板系统，解耦视图和模板之间的硬连接。

首先，在polls目录下创建一个新的templates目录，Django会在它里面查找模板文件。

项目settings.py文件中的 TEMPLATES配置项描述了 Django 如何载入和渲染模板。默认的设置文件设置了 DjangoTemplates 后端作为模板引擎，并将 APP_DIRS设置成了 True。这一选项将会让 DjangoTemplates 在每个 INSTALLED_APPS 文件夹中寻找 “templates” 子目录。

在刚才创建的templates目录中，再创建一个新的子目录名叫polls，进入该子目录，创建一个新的HTML文件index.html。换句话说，模板文件应该是polls/templates/polls/index.html。因为 Django 会寻找到对应的app_directories ，所以只需要使用polls/index.html就可以引用到这一模板了。

快捷方式：render()
from django.shortcuts import render

render()函数的第一个位置参数是请求对象（就是view函数的第一个参数），这个参数是固定写法，不需要变动。第二个位置参数是模板文件。还可以有一个可选的第三参数，一个字典，包含需要传递给模板的数据。最后render函数返回一个经过字典数据渲染过的模板封装而成的HttpResponse对象。
** 单表操作**
实例化对象后要执行对象.save() 才能在数据库中新增成功。
filter() 方法用于查询符合条件的数据
exclude() 方法用于查询不符合条件的数据
get() 方法用于查询符合条件的返回模型类的对象符合条件的对象只能为一个，如果符合筛选条件的对象超过了一个或者没有一个都会抛出错误

order_by() 方法用于对查询结果进行排序
count() 方法用于查询数据的数量返回的数据是整数
first() 方法返回第一条数据返回的数据是模型类的对象也可以用索引下标 [0]
last() 方法返回最后一条数据返回的数据是模型类的对象不能用索引下标 [-1]，ORM 没有逆序索引
exists() 方法用于判断查询的结果 QuerySet 列表里是否有数据。
返回的数据类型是布尔，有为 true，没有为 false。
注意：判断的数据类型只能为 QuerySet 类型数据，不能为整型和模型类的对象
values() 方法用于查询部分字段的数据。
返回的是 QuerySet 类型数据，类似于 list，里面不是模型类的对象，而是一个可迭代的字典序列，字典里的键是字段，值是数据。
注意：

参数的字段名要加引号
想要字段名和数据用 values
values_list() 方法用于查询部分字段的数据。
返回的是 QuerySet 类型数据，类似于 list，里面不是模型类的对象，而是一个个元组，元组里放的是查询字段对应的数据。
注意：
参数的字段名要加引号
只想要数据用 values_list
distinct() 方法用于对数据进行去重。
返回的是 QuerySet 类型数据。
注意：
对模型类的对象去重没有意义，因为每个对象都是一个不一样的存在。
distinct() 一般是联合 values 或者 values_list 使用

filter() 方法基于双下划线的模糊查询（exclude 同理）。
注意：filter 中运算符号只能使用等于号 = ，不能使用大于号 > ，小于号 < ，等等其他符号。
__in 用于读取区间，= 号后面为列表 ,__gt 大于号，= 号后面为数字,__gte 大于等于，= 号后面为数字,__lt 小于，=号后面为数字,__lte 小于等于，= 号后面为数字,__range 在 … 之间，左闭右闭区间，= 号后面为两个元素的列表

删除
方式一：使用模型类的对象.delete()。
返回值：元组，第一个元素为受影响的行数。

Django 定时任务

1.使用Django-crontab 插件，只需下载一个Django-crontab就可以设置定时任务。
1.1,安装插件pip3 install django-crontab
1.2,注册app,在settings.py中INSTALLED_APPS引入app

INSTALLED_APPS = 
[    ...    
'django_crontab' 
]

（2）在settings.py中配置定时任务，在settings.py最后增加一下代码：

# 定时任务
'''
*    *    *    *    * ：分别表示 分(0-59)、时(0-23)、天(1 - 31)、月(1 - 12) 、周(星期中星期几 (0 - 7) (0 7 均为周天))
crontab范例：
每五分钟执行    */5 * * * *
每小时执行     0 * * * *
每天执行       0 0 * * *
每周一执行       0 0 * * 1
每月执行       0 0 1 * *
每天23点执行   0 23 * * *
'''
CRONJOBS = [
    ('*/1 * * * *', 'base.crontabs.confdict_handle', ' >> /tmp/logs/confdict_handle.log'), # 注意：/tmp/base_api 目录要手动创建
]
或者：
CRONJOBS = [
    ('*/5 * * * *', 'appname.cron.test','>>/home/test.log')
]

'''
‘/5 * * *’ 遵循的是crontab 语法。
‘appname.cron.test’，这个appname就是你开发时加入到settings中的那个。因为你的cron.py文件就在这个下面，否则找不到路径。cron 就是你自己起的任务文件的名字。test就是执行的函数中的内容。
‘>>/home/test.log’，通常会输出信息到一个文件中，就使用这个方法，注意的是‘>>’表示追加写入，’>’表示覆盖写入。
'''

核心语法：
CRONJOBS = [('*/5 * * * ‘, ‘任务路径.任务函数名’,’>>/home/book.log’)]
参数说明：
‘/5 * * *’ 表示五分钟一次,而django-crontab是调用Linux的crontab.
第一个参数：代表执行时间或者周期时间的顺序为[分->时->天->月->周]
第二个参数：代表需要定时执行的函数（路径+函数名）
第三个参数：输出log信息的路径+log文件

python websocket Django 实时消息推送

WebSocket 是什么？
WebSocket 是 HTML5 提供的一种浏览器与服务器间进行全双工通讯的协议。依靠这种协议可以实现客户端和服务器端，一次握手，双向实时通信。
安装dwebsocket: python setup.py install
2.HelloWorld项目代码：
urls.py代码：

from django.conf.urls import url
from django.contrib import admin
import views
 
 
urlpatterns = [
    url(r'^admin/', admin.site.urls),
    url(r'^index/(?P<username>\w+)', views.gotoIndex),
    url(r'websocketLink/(?P<username>\w+)', views.websocketLink)# webSocket 链接
]

views.py

# coding=utf8
from django.shortcuts import render
import threading
from models import Ad
from dwebsocket.decorators import accept_websocket
import json
# from model_admin.models import MessageLog
# 跳转到主页
 
def gotoIndex(request, username):
    return render(request, 'index.html', {'username': username})
 
 
 
# 存储连接websocket的用户
clients = {}
# 记录连接人数   其实没什么卵用  = =
count = 0
 
 
# 连接websocket  ws://localhost：8000/websocketLink/22
# 因为 websocket 是协议  所以不能用 http或https
@accept_websocket
def websocketLink(request, username):
    '连接websocket'
    global count
    # 获取连接
    if request.is_websocket:
        lock = threading.RLock()#rlock线程锁
        try:
            lock.acquire()#抢占资源
            s = {}
            #  因为同一个账号打开多个页面连接信息是不同的
            if clients.get(username) != None:
                # 连接信息  键 连接名  值：连接保存
                s[str(request.websocket)] = request.websocket
                # 已存在的连接信息继续增加
                clients[username].update(s)
            else:
                # 人数加1
                count = count + 1
                #  连接信息  键 连接名  值：连接保存
                s[str(request.websocket)] = request.websocket
                # 新增 用户  连接信息
                clients[username] = s
            print("用户人数" + str(count))
 
            # 监听接收客户端发送的消息 或者 客户端断开连接
                       sql = ("select id,code,name "
                   "from "
                   "prov_ad  order by create_date desc limit 1"
                   )
 
            data_list = Ad.objects.raw(sql)
            datas = []
            for item in data_list:
                datas.append({
                    'id': item.id,
                    'name': item.name,  # 区域名称
                    'code': item.code,  # 区域编码
                    'long': item.long,  # 经度
                    'lat': item.lat  # 纬度
                })
            send(username,datas)
        except Exception as e:
            print e
        finally:
                # 通过用户名找到 连接信息 再通过 连接信息 k 找到 v (k就是连接信息)
                clients.get(username).pop(str(request.websocket))
                #释放锁
                lock.release()
 
 
 # 发送消息
def websocketMsg(client, msg):
    import json
    # 因为一个账号会有多个页面打开 所以连接信息需要遍历
    for cli in client:
        'client客户端 ，msg消息'
        b1 = json.dumps(msg).encode('utf-8')
        client[cli].send(b1)
 
 
# 服务端发送消息
def send(username, title, data, url):
    'username:用户名 title：消息标题 data：消息内容，消息内容:ulr'
    try:
       if clients[username]:
 
        websocketMsg(clients[username], { 'data': data})
except BaseException:
        pass
finally:
        pass

index.html代码：

<!DOCTYPE html>
<html>
<head>
    {% load static %}
 
    <link rel="stylesheet" type="text/css" href="{% static 'iziToast/css/iziToast.min.css' %}">
    <script type="text/javascript" src="{% static 'iziToast/js/iziToast.min.js' %}"></script>
     <script type="text/javascript" src="{% static 'iziToast/js/websocket.js' %}"></script>
    <title>django-websocket</title>
    <script src="http://code.jquery.com/jquery-1.11.1.min.js"></script>
    <script type="text/javascript">
     var websocket;
     var userId=$("#userId").val();
    var name= '{{username}}';
var lockReconnect = false;  //避免ws重复连接
var ws = null;          // 判断当前浏览器是否支持WebSocket
var wsUrl = "ws://localhost:9000/websocketLink/"+name;
createWebSocket(wsUrl);   //连接ws
 
function createWebSocket(url) {
    try{
        if('WebSocket' in window){
            ws = new WebSocket(url);
        }else if('MozWebSocket' in window){
            ws = new MozWebSocket(url);
        }else{
              alert("您的浏览器不支持websocket协议,建议使用新版谷歌、火狐等浏览器，请勿使用IE10以下浏览器，360浏览器请使用极速模式，不要使用兼容模式！");
        }
        initEventHandle();
    }catch(e){
        reconnect(url);
        console.log(e);
    }
}
  
function initEventHandle() {
 
    ws.onclose = function () {
        reconnect(wsUrl);
        console.log("llws连接关闭!" + new Date().toUTCString());
    };
    ws.onerror = function () {
        reconnect(wsUrl);
        console.log("llws连接错误!");
    };
    ws.onopen = function () {
        console.log("llws连接成功!" + new Date().toUTCString());
        heartCheck.reset().start();      //心跳检测重置
    };
    ws.onmessage = function (event) {    //如果获取到消息，心跳检测重置
        console.log("llws收到消息啦:" + event.data);
        if (event.data != 'pong') {
            var obj = eval("(" + event.data + ")");
            var data =JSON.parse(event.data)
        }
         heartCheck.reset().start();      //心跳检测重置
    }
}
// 监听窗口关闭事件，当窗口关闭时，主动去关闭websocket连接，防止连接还没断开就关闭窗口，server端会抛异常。
window.onbeforeunload = function() {
    ws.close();
}
 
function reconnect(url) {
    if(lockReconnect) return;
    lockReconnect = true;
    setTimeout(function () {     //没连接上会一直重连，设置延迟避免请求过多
        createWebSocket(url);
        lockReconnect = false;
    }, 544000);
}
 
//心跳检测
var heartCheck = {
    timeout: 5403000,        //9分钟发一次心跳
    timeoutObj: null,
    serverTimeoutObj: null,
    reset: function(){
        clearTimeout(this.timeoutObj);
        clearTimeout(this.serverTimeoutObj);
        return this;
    },
    start: function(){
        var self = this;
        this.timeoutObj = setTimeout(function(){
            //这里发送一个心跳，后端收到后，返回一个心跳消息，
            //onmessage拿到返回的心跳就说明连接正常
            ws.send("ping");
            console.log("ping!")
            self.serverTimeoutObj = setTimeout(function(){//如果超过一定时间还没重置，说明后端主动断开了
                ws.close();     //如果onclose会执行reconnect，我们执行ws.close()就行了.如果直接执行reconnect 会触发onclose导致重连两次
            }, self.timeout)
        }, this.timeout)
    }
}
 </script>
</head>
<body>
<br>
<input type="text" id="message" value="Hello, World!" />
<button type="button" id="send_message">发送消息</button>
<button type="button" id="close_websocket">关闭websocket</button>
 
</body>
</html>

Nginx部署dwebsocket服务

如果项目部署到nginx服务上，你的项目要用到dwebsocket服务
我使用的是nginx+uwsgi
一.首要需要启一个主服务：
配置nginx.conf、uwsgi.ini，正常启动服务就可以了。
二.还需要启动websocket服务，才能让ws://服务器ip进行通信
1.在项目对应的settings.py里添加下面配置，不然会提示报错：handshake的返回400，也就是客户端不合法
WEBSOCKET_FACTORY_CLASS=“dwebsocket.backends.uwsgi.factory.uWsgiWebSocketFactory”
2.在新的uwsgi.ini文件里添加下面配置:
DJANGO_SETTINGS_MODULE=项目路径.settings
启动websocket服务
3.项目里添加的dwebsocket服务就开启了