Django 第三方

1. 富文本编辑器

2. 缓存

3. 全文检索

4. Celery

5. 部署

 

 

1. 富文本编辑器

借助富文本编辑器，管理员能够编辑出来一个包含 html 的页面，从而页面的显示效果可以由管理员定义，而不用完全依赖于前期开发人员。

以下以 tinymce 为例，使用编辑器的显示效果为：

下载安装

1）在网站 pypi 网站 搜索并下载“django-tinymce-版本号”。

2）解压：

tar zxvf django-tinymce-2.4.0.tar.gz

3）进入解压后的目录，工作在虚拟环境，安装：

python setup.py install

或在线安装：

pip install django-tinymce

应用到项目中

在 settings.py 中为 INSTALLED_APPS 添加编辑器应用：

INSTALLED_APPS = (
    ...
    'tinymce',
)

在 settings.py 中添加编辑配置项（此项效果用于站点管理里呈现）：

TINYMCE_DEFAULT_CONFIG = {
    'theme': 'advanced',
    'width': 600,
    'height': 400,
}

在根 urls.py 中配置：

urlpatterns = [
    ...
    url(r'^tinymce/', include('tinymce.urls')),
]

在应用中定义模型的属性：

from django.db import models
from tinymce.models import HTMLField


class HeroInfo(models.Model):
    ...
    hcontent = HTMLField()
  • 在后台管理界面中，就会显示为富文本编辑器，而不是多行文本框。

自定义使用

 定义视图 editor，用于显示编辑器并完成提交：

def editor(request):
    return render(request, 'other/editor.html')

应用 urls.py：

urlpatterns = [
    ...
    url(r'^editor/$', views.editor, name='editor'),
]

创建模板 editor.html：

 1 <!DOCTYPE html>
 2 <html>
 3 <head>
 4     <title></title>
 5     <script type="text/javascript" src='/static/tiny_mce/tiny_mce.js'></script>  <!- 安装了django-tinymce后会自动引入，无需真实存在 ->
 6     <script type="text/javascript">
 7         tinyMCE.init({  // 定义富文本编辑器的主题、高宽等
 8             'mode':'textareas',  // 将页面中的textarea换成富文本编辑器
 9             'theme':'advanced',
10             'width':400,
11             'height':100
12         });
13     </script>
14 </head>
15 <body>
16 <form method="post" action="/content/">
17     <input type="text" name="hname">
18     <br>
19     <textarea name='hcontent'>哈哈，这是啥呀</textarea>
20     <br>
21     <input type="submit" value="提交">
22 </form>
23 </body>
24 </html>

定义视图 content，接收请求，并更新 heroinfo 对象：

def content(request):

    hname = request.POST['hname']
    hcontent = request.POST['hcontent']

    heroinfo = HeroInfo.objects.get(pk=1)
    heroinfo.hname = hname
    heroinfo.hcontent = hcontent
    heroinfo.save()

    return render(request, 'other/content.html', {'hero': heroinfo})

添加 url 项：

urlpatterns = [
    ...
    url(r'^content/$', views.content, name='content'),
]

定义模板 content.html：

<!DOCTYPE html>
<html>
<head>
    <title></title>
</head>
<body>
姓名：{{hero.hname}}
<hr>
{%autoescape off%}
{{hero.hcontent}}
{%endautoescape%}
</body>
</html>

2. 缓存

对于中等流量的网站来说，尽可能地减少开销是必要的。缓存数据就是为了保存那些需要很多计算资源的结果，这样的话就不必在下次请求时重复消耗计算资源。

Django 自带了一个健壮的缓存系统来保存动态页面，避免对于每次请求都重新计算。

Django 提供了不同级别的缓存粒度：可以缓存特定视图的输出、模板的特定部分、特定数据、甚至可以缓存整个网站。

设置缓存

  • 通过设置决定把数据缓存在哪里：是数据库中、文件系统还是在内存中。
  • 通过 settings.py 文件的 CACHES 配置来实现。
  • 参数 TIMEOUT：缓存的默认过期时间，以秒为单位，这个参数默认是 300 秒，即 5 分钟；设置 TIMEOUT 为 None 表示永远不会过期，值设置成 0 造成缓存立即失效。
CACHES = {
    'default': {
        'BACKEND': 'django.core.cache.backends.locmem.LocMemCache',
        'TIMEOUT': 60,
    }
}

可以将 Cache 存到 Redis 中，默认采用 1 数据库，需要安装包并配置如下：

安装包：pip install django-redis-cache

CACHES = {
    "default": {
        "BACKEND": "redis_cache.cache.RedisCache",
        "LOCATION": "localhost:6379",
        'TIMEOUT': 60,
    },
}

连接 Redis 查看存的数据：

连接：redis-cli
切换数据库：select 1
查看键：keys *
查看值：get 键

单个 view 缓存

django.views.decorators.cache 定义了 cache_page 装饰器，用于对视图的输出进行缓存。

示例代码如下：

from django.views.decorators.cache import cache_page

@cache_page(60 * 15)
def index(request):
    return HttpResponse('hello1')  # 第一次请求后会缓存"hello1"
    #return HttpResponse('hello2')  # 即使修改代码为输出"hello2"，仍会返回"hello1"给客户端，因为不再走此代码逻辑
  • cache_page 接受一个参数：timeout（秒为单位），上例中缓存了 15 分钟。
  • 如果多个 URL 指向同一视图，那么每个 URL 都会分别缓存。

模板片断缓存

使用 cache 模板标签可以缓存模板的一个片段/部分。

需要两个参数：

  • 缓存时间，以秒为单位
  • 给缓存片段起的名称

示例代码如下：

{% load cache %}
{% cache 500 hello %}
hello1
<!--hello2-->
{% endcache %}

底层的缓存 API

直接使用 API 缓存特定数据。

from django.core.cache import cache

设置：cache.set(键,值,有效时间)
获取：cache.get(键)
删除：cache.delete(键)
清空：cache.clear()

  

3. 全文检索

  • 全文检索不同于特定字段的模糊查询，使用全文检索的效率更高，并且能够对中文进行分词处理。
  • haystack：Django 的一个包，可以方便地对 model 里面的内容进行索引、搜索，此包设计为支持 Whoosh、Solr、Xapian、Elasticsearc 四种全文检索引擎后端，属于一种全文检索的框架。
  • whoosh：纯 Python 编写的全文搜索引擎，虽然性能比不上 Sphinx、Xapian、Elasticsearc 等，但是无二进制包，程序不会莫名其妙的崩溃，对于小型的站点，whoosh 已经足够使用。
  • jieba：一款免费的中文分词包，如果觉得不好用可以使用一些收费产品。

1）在虚拟环境中依次安装包

pip install django-haystack
pip install whoosh
pip install jieba

2）修改 settings.py 文件

添加应用：

INSTALLED_APPS = (
    ...
    'haystack',
)

添加搜索引擎：

HAYSTACK_CONNECTIONS = {
    'default': {
        'ENGINE': 'haystack.backends.whoosh_cn_backend.WhooshEngine',  # 配置所使用的全文搜索引擎
        'PATH': os.path.join(BASE_DIR, 'whoosh_index'),  # 配置索引数据的放置目录
    }
}

#自动生成索引（更新配置'PATH'的数据）
HAYSTACK_SIGNAL_PROCESSOR = 'haystack.signals.RealtimeSignalProcessor'

3）在项目的 urls.py 中添加 url

urlpatterns = [
    ...
    url(r'^search/', include('haystack.urls')),
]

4）在应用目录下建立 search_indexes.py 文件

from haystack import indexes
from models import GoodsInfo


class GoodsInfoIndex(indexes.SearchIndex, indexes.Indexable):
    text = indexes.CharField(document=True, use_template=True)

    def get_model(self):
        return GoodsInfo

    def index_queryset(self, using=None):
        return self.get_model().objects.all()

5）在目录“templates/search/indexes/应用名称/”下创建“模型类名称_text.txt”文件

# 如 goodsinfo_text.txt，文件中列出了要对哪些列的内容进行检索：object.字段名
{{ object.gName }}
{{ object.gSubName }}
{{ object.gDes }}

6）在目录“templates/search/”下建立 search.html

<!DOCTYPE html>
<html>
<head>
    <title></title>
</head>
<body>
{% if query %}
    <h3>搜索结果如下：</h3>
    {% for result in page.object_list %}
        <a href="/{{ result.object.id }}/">{{ result.object.gName }}</a><br/>
    {% empty %}
        <p>啥也没找到</p>
    {% endfor %}

    {% if page.has_previous or page.has_next %}
        <div>
            {% if page.has_previous %}<a href="?q={{ query }}&amp;page={{ page.previous_page_number }}">{% endif %}&laquo; 上一页{% if page.has_previous %}</a>{% endif %}
        |
            {% if page.has_next %}<a href="?q={{ query }}&amp;page={{ page.next_page_number }}">{% endif %}下一页 &raquo;{% if page.has_next %}</a>{% endif %}
        </div>
    {% endif %}
{% endif %}
</body>
</html>

7）建立 ChineseAnalyzer.py 文件

保存在 haystack 的安装文件夹下，路径如“/home/python/.virtualenvs/django_py2/lib/python2.7/site-packages/haystack/backends”。

import jieba
from whoosh.analysis import Tokenizer, Token


class ChineseTokenizer(Tokenizer):
    def __call__(self, value, positions=False, chars=False,
                 keeporiginal=False, removestops=True,
                 start_pos=0, start_char=0, mode='', **kwargs):
        t = Token(positions, chars, removestops=removestops, mode=mode,
                  **kwargs)
        seglist = jieba.cut(value, cut_all=True)
        for w in seglist:
            t.original = t.text = w
            t.boost = 1.0
            if positions:
                t.pos = start_pos + value.find(w)
            if chars:
                t.startchar = start_char + value.find(w)
                t.endchar = start_char + value.find(w) + len(w)
            yield t


def ChineseAnalyzer():
    return ChineseTokenizer()

8）复制 whoosh_backend.py 文件，改名为 whoosh_cn_backend.py

 注意：复制出来的文件名，末尾会有一个空格，记得要删除这个空格。

from .ChineseAnalyzer import ChineseAnalyzer 
查找
analyzer=StemmingAnalyzer()
改为
analyzer=ChineseAnalyzer()

9）生成索引

初始化索引数据：

python manage.py rebuild_index

10）在模板中创建搜索栏

<form method='get' action="/search/" target="_blank">
    <input type="text" name="q">
    <input type="submit" value="查询">
</form>

 

4. Celery

Celery 简介

Celery 是一个简单、灵活且可靠的，处理大量消息的分布式系统，专注于实时处理的异步任务队列，同时也支持任务调度。

Celery 架构由三部分组成：

  • 消息中间件（Broker）：Celery 本身不提供消息服务，但是可以方便的和第三方提供的消息中间件集成，包括 RabbitMQ, Redis 等。
  • 任务执行单元（Worker）：Worker 是 Celery 提供的任务执行的单元，Worker 并发的运行在分布式的系统节点中。
  • 任务结果存储（Task Result Store）：Task Result Store 用来存储 Worker 执行的任务的结果。Celery 支持以不同方式存储任务的结果，包括 AMQP、Redis 等。

注意：项目服务和 Celery 服务是同时运行的，项目服务将需要异步处理的任务交给 Celery 服务，Celery 就会在需要时异步完成项目的需求。

官方网站

中文文档

应用场景：

  1. 用户发起 request，并等待 response 返回。在本些 views 中，可能需要执行一段耗时的程序，那么用户就会等待很长时间，造成不好的用户体验。
  2. 网站每小时需要同步一次天气预报信息，但是 http 是由请求触发的，难道要一小时请求一次吗？

使用 celery 后，情况就可以改善了：

  • 场景 1 的解决：将耗时的程序放到 celery 中执行。
  • 场景 2 的解决：使用 celery 定时执行。

名词

  • 任务 task：就是一个 Python 函数。
  • 队列 queue：将需要执行的任务加入到队列中。
  • 工人 worker：在一个新进程中，负责执行队列中的任务。
  • 代理人 agence：负责调度，在部署环境中使用 redis。

使用

安装包：

celery
celery-with-redis
django-celery

配置 settings：

INSTALLED_APPS = (
  ...
  'djcelery',
}

...

import djcelery
djcelery.setup_loader()
BROKER_URL = 'redis://127.0.0.1:6379/0'
CELERY_IMPORTS = ('应用名称.task')

在应用目录下创建 task.py 文件：

import time
from celery import task

@task
def sayhello():
    print('hello ...')
    time.sleep(10)
    print('world ...')

迁移，生成 celery 需要的数据表：

python manage.py migrate

启动 Redis：

sudo redis-server /etc/redis/redis.conf

启动 worker：

python manage.py celery worker --loglevel=info

调用语法：

function.delay(parameters)

原始的同步方案：

def sayhello(request):
    print('hello ...')
    import time
    time.sleep(10)
    print('world ...')
    # 按顺序处理完上述逻辑后才返回给客户端结果
    return HttpResponse("hello world")

使用 Celery 异步方案：

1 from task import *
2 
3 def celery_test(request):
4     sayhello.delay()  # 新起一个进程在后台处理耗时任务，并先直接返回结果"hello world"给客户端
5     return HttpResponse("hello world")

 

5. 部署

Django 项目部署一般从 uwsgi、nginx、静态文件三个方面处理。

1）uswgi

WSGI

python manage.py runserver 这是一款适合开发阶段使用的服务器，不适合运行在真实的生产环境中。而在生产环境中一般使用 WSGI。

WSGI 即 Web 服务器网关接口（Python Web Server Gateway Interface，缩写为 WSGI），是 Python 应用程序或框架和 Web 服务器之间的一种接口，被广泛接受。

WSGI 没有官方的实现，因为 WSGI 更像一个协议，只要遵照这些协议，WSGI 应用（Application）都可以在任何服务器（Server）上运行。

  • 执行 django-admin startproject 命令后会在项目目录下生成一个简单的 wsgi.py 文件，文件中确定了 settings、application 对象。
    • application 对象：在 Python 模块中使用 application 对象与应用服务器交互。
    • settings 模块：Django 需要导入 settings 模块，这里是应用定义的地方。

此处的服务器是一个软件，可以监听网卡端口、遵从网络层传输协议，收发 http 协议级别的数据。

uWSGI

  • uWSGI 实现了 WSGI 的所有接口，是一个快速、自我修复、开发人员和系统管理员友好的服务器。
  • uWSGI 代码完全用 C 编写，因此运行速度较快。

安装 uWSGI：

pip install uwsgi

服务器环境配置

在本地环境的项目根目录下，执行命令收集所有包：

pip freeze > plist.txt  # pip freeze 不会列出python自带的包

通过 ftp 软件将开发好的项目工程上传到此服务器的某个目录，并在服务器主机上安装所需要的包：

pip install -r plist.txt

更改 settings.py 文件：

DEBUG = False
ALLOW_HOSTS=['*',]  # 表示可以访问服务器的ip

使用 python manage.py runserver 启动服务器，运行正常，但是静态文件无法加载。

配置 uWSGI，在项目中新建文件 uwsgi.ini，编写如下配置：

[uwsgi]
socket=外网ip:端口（使用nginx连接时，使用socket）
http=外网ip:端口（直接做web服务器，使用http）
chdir=项目根目录
wsgi-file=项目中wsgi.py文件的目录，相对于项目根目录
processes=4（服务器开启的进程数，根据主机性能来配置）
threads=2（服务器开启的线程数，根据主机性能来配置）
master=True（是否为主服务器）
pidfile=uwsgi.pid（记录父进程的pid）
daemonize=uswgi.log（守护模式并打印日志）

uWSGI 使用命令：

  • 启动：uwsgi --ini uwsgi.ini
  • 停止：uwsgi --stop uwsgi.pid
  • 重启：uwsgi --reload uwsgi.pid
  • 使用 http 协议查看网站运行情况，运行正常，但是静态文件无法加载

2）nginx

nginx 的作用：

  • 负载均衡：多台服务器轮流处理请求。
  • 反向代理：隐藏真实服务器。

实现构架：

  • 客户端请求 nginx，再由 nginx 请求 uwsgi，运行 django 框架下的 python 代码。
  • nginx+uwsgi 也可以用于其它框架的 python web 代码，不限于 django。

安装配置

到官网下载 nginx 压缩文件或通过命令安装。以下以 Ubuntu 为例：

sudo apt-get nginx
解压缩：
tar zxvf nginx-1.6.3.tar.gz

进入nginx-1.6.3目录依次执行如下命令进行安装：
./configure
make
sudo make install

运行

默认安装到 /usr/local/nginx 目录，进入此目录执行命令。

  • 查看版本：sudo sbin/nginx -v
  • 启动：sudo sbin/nginx
  • 停止：sudo sbin/nginx -s stop
  • 重启：sudo sbin/nginx -s reload

通过浏览器查看 nginx 运行结果

指向 uwsgi 项目：编辑 conf/nginx.conf 文件

sudo conf/nginx.conf

在server下添加新的location项，指向uwsgi的ip与端口
location / {
    include uwsgi_params;将所有的参数转到uwsgi下
    uwsgi_pass uwsgi的ip与端口;
}
  1. 修改 uwsgi.ini 文件，启动 socket，禁用 http。
  2. 重启 nginx、uwsgi。
  3. 在浏览器中查看项目，发现静态文件加载不正常，接下来解决静态文件的问题。

3）静态文件

静态文件一直都找不到，现在终于可以解决了。

所有的静态文件都会由 nginx 处理，不会将请求转到 uwsgi。

1）配置 nginx 的静态项，打开 conf/nginx.conf 文件，找到 server，添加新 location。

location /static {
    alias /var/www/test5/static/;
}

2）在服务器上创建目录结构 “/var/www/test5/”，并修改目录权限：

sudo chmod 777 /var/www/test5

3）创建 static 目录，注意顺序是先分配权限，再创建目录：

mkdir static

最终目录结构如下图：

4）修改 settings.py 文件：

STATIC_ROOT='/var/www/test5/static/'
STATIC_URL='/static/'

5）执行命令 python manage.py collectstatic：收集所有静态文件到 static_root 指定目录。

6）重启 nginx、uwsgi，再次访问静态文件，正常显示。

 

posted @ 2021-04-27 12:05  Juno3550  阅读(164)  评论(0)  编辑  收藏  举报