一、快速了解Tornado框架
1）tornado简介
Tornado 和现在的主流 Web 服务器框架（包括大多数 Python 的框架）有着明显的区别：它是非阻塞式服务器，而且速度相当快。得利于其 非阻塞的方式和对epoll的运用，Tornado 每秒可以处理数以千计的连接，因此 Tornado 是实时 Web 服务的一个 理想框架。我们开发这个 Web 服务器的主要目的就是为了处理 FriendFeed 的实时功能 ——在 FriendFeed 的应用里每一个活动用户都会保持着一个服务器连接
FriendFeed是一个聚合个人信息的网站，可集成网络社区媒体、社交网络服务、书签网站、博客、微博客的更新，及其他RSS/Atom信源
安装 pip install tornadoTornado和安装
2）tornado框架快速上手
import tornado.ioloop
import tornado.web
class MainHandler(tornado.web.RequestHandler):
def get(self):
self.write("Hello, world")
application = tornado.web.Application([
(r"/index", MainHandler),
])
if __name__ == "__main__":
application.listen(8888)
tornado.ioloop.IOLoop.instance().start()tornado的快速入门
执行过程
1：执行脚本，监听 8888 端口
2：浏览器客户端访问 /index --> http://127.0.0.1:8888/index
3：服务器接受请求，并交由对应的类处理该请求
4：类接受到请求之后，根据请求方式（post / get / delete ...）的不同调用并执行相应的方法
5：方法返回值的字符串内容发送浏览器
异
#!/usr/bin/env python
# -*- coding:utf-8 -*-
import tornado.ioloop
import tornado.web
from tornado import httpclient
from tornado.web import asynchronous
from tornado import gen
import uimodules as md
import uimethods as mt
class MainHandler(tornado.web.RequestHandler):
@asynchronous
@gen.coroutine
def get(self):
print 'start get '
http = httpclient.AsyncHTTPClient()
http.fetch("http://127.0.0.1:8008/post/", self.callback)
self.write('end')
def callback(self, response):
print response.body
settings = {
'template_path': 'template',
'static_path': 'static',
'static_url_prefix': '/static/',
'ui_methods': mt,
'ui_modules': md,
}
application = tornado.web.Application([
(r"/index", MainHandler),
], **settings)
if __name__ == "__main__":
application.listen(8009)
tornado.ioloop.IOLoop.instance().start()步非堵塞实例
二、tornado的模板语言
1）git请求，返回前端页面。render
import tornado.ioloop
import tornado.web
class LoginHandler(tornado.web.RequestHandler):
def get(self):
self.render('login.html')
def post(self):
self.write("Hello, world")
# 生成路由规则
application = tornado.web.Application([
(r"/login", LoginHandler),
])
if __name__ == "__main__":
# 创建socket对象8888
# 将socket对象添加到select或epoll
application.listen(8888)
# 将select或epoll开始死循环 while True
tornado.ioloop.IOLoop.instance().start()main.py
前端页面默认同级目录
2）前端模板显示内容
import tornado.ioloop
import tornado.web
class LoginHandler(tornado.web.RequestHandler):
def get(self):
# self.render('login.html')
# self.render('login.html',k1='v1')
# self.render('login.html',k1='v1',k2='v2')
# self.render('login.html',**{'k1':'v1'})
self.render('login.html',**{'k1':'v1',
'k2':[1,2,3,4],
'k3':{'name':'root','age':18}})
# 生成路由规则
application = tornado.web.Application([
(r"/login", LoginHandler),
])
if __name__ == "__main__":
# 创建socket对象8888
# 将socket对象添加到select或epoll
application.listen(8888)
# 将select或epoll开始死循环 while True
tornado.ioloop.IOLoop.instance().start()main.py
对于前端显示
<!DOCTYPE html>
<html lang="en">
<head>
<meta charset="UTF-8">
<title>Title</title>
</head>
<body>
<h1>Login</h1>
<h3>{{k1}}</h3>
<h2>{{k2}}</h2>
<h2>{{k2[0]}}</h2>
<ul>
{% for item in k2 %}
<li>{{item}}</li>
{%end%}
</ul>
<div>{{k3}}</div>
<div>{{k3['name']}}</div>
<div>{{k3.get('name')}}</div>
<ul>
{% for k,v in k3.items() %}
<li>{{k}}--{{v}}</li>
{%end%}
</ul>
</body>
</html>login.html
前端语法常用归纳
{% for item in k2 %}
<li>{{item}}</li>
{%end%}
<h2>{{k2}}</h2>
<h2>{{k2[0]}}</h2>
<div>{{k3['name']}}</div>
<div>{{k3.get('name')}}</div>3）获取用户相应信息
def get(self):
# 获取用户请求相关信息
self.get_cookie()
v = self.get_argument('p') # http://127.0.0.1:8888/login?p=123
print(v)
self.render('login.html',**{'k1':'v1',
'k2':[1,2,3,4],
'k3':{'name':'root','age':18}})View Code
有多个self，也返回给用户
4）self.set_cookies。设置额外的内容
def get(self):
# 设置额外的相应内容
self.set_cookie('k1','v1') # 设置cookies
self.set_header('h1','v1') # 设置相应头
self.render('login.html')设置额外的内容返回用户
5）跳转。self.redirect('/login/')
6）静态文件和模板文件的配置
settings = {
'static_path':'static',
'static_url_prefix':'/sss/',
'template_path':'templates',
}
application = tornado.web.Application([
(r"/login", LoginHandler),
],**settings)main.py
前端文件引入静态文件
<!DOCTYPE html>
<html lang="en">
<head>
<meta charset="UTF-8">
<title>Title</title>
<link rel="stylesheet" href="/sss/commons.css">
</head>
<body>
<h1>Login</h1>
</body>
</html>html引入css
7）后台获取form表单提交的数据
<form method="POST" action="/login">
<input type="text" name="user">
<input type="submit" value="提交">
</form>form.html
class LoginHandler(tornado.web.RequestHandler):
def get(self):
self.render('login.html')
def post(self):
v = self.get_argument('user')
print(v)
self.redirect('http://autohome.com.cn')main.py
8）自定义函数注册，前端执行函数
def tab(self):
return 'UIMethod'uimethods.py
settings字典注册
import uimethods as mt
settings = {
'static_path':'static',
'static_url_prefix':'/sss/',
'template_path':'templates',
'ui_methods':mt,
}
application = tornado.web.Application([
(r"/login", LoginHandler),
],**settings)View Code
前端调用函数
<body>
<h1>Login {{ tab() }}</h1>
<form method="POST" action="/login">
<input type="text" name="user">
<input type="submit" value="提交">
</form>
</body>html
9）自定义类方法注册。可返还一般数据，css样式，css文件，js文件
from tornado.web import UIModule
from tornado import escape
class Custom(UIModule):
def embedded_css(self):
return "body{color:blue;}"
def css_files(self):
return "a.sss"
def javascript_files(self):
return "a.js"
def render(self, *args, **kwargs):
return '<h1>user sb</h1>'
#return escape.xhtml_escape('<h1>user sb</h1>')uimodules.py
settings字典注册
import uimethods as mt
import uimodules as md
settings = {
'static_path':'static',
'static_url_prefix':'/sss/',
'template_path':'templates',
'ui_methods':mt,
'ui_modules':md,
}View Code
前端调用函数
<!DOCTYPE html>
<html lang="en">
<head>
<meta charset="UTF-8">
<title>Title</title>
<link rel="stylesheet" href="/sss/commons.css">
</head>
<body>
<h1>Login {{ tab() }}</h1>
<h2>{% module Custom(123) %}</h2>
<form method="POST" action="/login">
<input type="text" name="user">
<input type="submit" value="提交">
</form>
</body>
</html>html
三、tornado的session管理
1）基于内存的session
session文件方法
import uuid
class Session(object):
container = {}
def __init__(self,handler):
# 获取用户cookies，如果有，不操作，否则给用户生成随机字符串
# - 写给用户
# - 保存在session
nid = handler.get_cookie('session_id')
if nid:
if nid in Session.container:
pass
else:
nid = str(uuid.uuid4())
Session.container[nid] = {}
else:
nid = str(uuid.uuid4())
Session.container[nid] = {}
handler.set_cookie('session_id',nid,max_age=1000) # max_age=1000 超时时间
# nid 当前访问用户的随机字符串+
self.nid = nid
# 封装了所有用户请求信息
self.handler = handler
def __setitem__(self,key,value):
Session.container[self.nid][key] = value
def __getitem__(self,item):
return Session.container[self.nid].get(item)
def __delitem__(self, key):
del Session.container[self.nid][key]session.py
验证session的类
import tornado.ioloop
import tornado.web
class BaseHandler(object):
def initialize(self):
from session import Session
self.session = Session(self)
super(BaseHandler,self).initialize()
class IndexHandler(BaseHandler,tornado.web.RequestHandler):
def get(self):
if self.session['is_login']:
self.write('Hello World')
else:
self.redirect('/login')
class LoginHandler(BaseHandler,tornado.web.RequestHandler):
def get(self):
self.render('login.html')
def post(self):
v = self.get_argument('user')
if v == 'root':
self.session['is_login'] = True
self.redirect('/index')
else:
self.redirect('/login')main.py
总的运行文件
import tornado.ioloop
import tornado.web
class BaseHandler(object):
def initialize(self):
from session import Session
self.session = Session(self)
super(BaseHandler,self).initialize()
class IndexHandler(BaseHandler,tornado.web.RequestHandler):
def get(self):
if self.session['is_login']:
self.write('Hello World')
else:
self.redirect('/login')
class LoginHandler(BaseHandler,tornado.web.RequestHandler):
def get(self):
self.render('login.html')
def post(self):
v = self.get_argument('user')
if v == 'root':
self.session['is_login'] = True
self.redirect('/index')
else:
self.redirect('/login')
settings = {
'static_path':'static',
'static_url_prefix':'/sss/',
'template_path':'templates',
}
application = tornado.web.Application([
(r"/login", LoginHandler),
(r"/index", IndexHandler),
],**settings)
if __name__ == "__main__":
application.listen(8888)
tornado.ioloop.IOLoop.instance().start()main.py
2）基于redis的session
class RedisSession(object):
def __init__(self,handler):
# 获取用户cookies，如果有，不操作，否则给用户生成随机字符串
# - 写给用户
# - 保存在session
nid = handler.get_cookie('session_id')
if nid:
if nid in Session.container:
pass
else:
nid = str(uuid.uuid4())
# Session.container[nid] = {}
# 连接redis写值
else:
nid = str(uuid.uuid4())
# Session.container[nid] = {}
# 连接redis写值
handler.set_cookie('session_id',nid,max_age=1000) # max_age=1000 超时时间
# nid 当前访问用户的随机字符串+
self.nid = nid
# 封装了所有用户请求信息
self.handler = handler
def __setitem__(self,key,value):
# Session.container[self.nid][key] = value
pass
def __getitem__(self,item):
# return Session.container[self.nid].get(item)
pass
def __delitem__(self, key):
# del Session.container[self.nid][key]
passRedisSession
3）设置配置文件，选择使用哪种session
新建配置文件文件
session_key = "RedisSession"config.py
通过getattr方法找到config文件内容
import config
class BaseHandler(object):
def initialize(self):
import session
cls = getattr(session,config.session_key)
self.session = cls(self)
super(BaseHandler,self).initialize()BaseHandler
4）补充，根据算法，计算选择哪台机器，可设置机器的权重来分配机器的任务量
#__author: Administrator
#date: 2017/3/10
import sys
import math
from bisect import bisect
if sys.version_info >= (2, 5):
import hashlib
md5_constructor = hashlib.md5
else:
import md5
md5_constructor = md5.new
class HashRing(object):
"""一致性哈希"""
def __init__(self, nodes):
'''初始化
nodes : 初始化的节点，其中包含节点已经节点对应的权重
默认每一个节点有32个虚拟节点
对于权重，通过多创建虚拟节点来实现
如：nodes = [
{'host':'127.0.0.1:8000','weight':1},
{'host':'127.0.0.1:8001','weight':2},
{'host':'127.0.0.1:8002','weight':1},
]
'''
self.ring = dict()
self._sorted_keys = []
self.total_weight = 0
self.__generate_circle(nodes)
def __generate_circle(self, nodes):
for node_info in nodes:
self.total_weight += node_info.get('weight', 1)
for node_info in nodes:
weight = node_info.get('weight', 1)
node = node_info.get('host', None)
virtual_node_count = math.floor((32 * len(nodes) * weight) / self.total_weight)
for i in range(0, int(virtual_node_count)):
key = self.gen_key_thirty_two('%s-%s' % (node, i))
if self._sorted_keys.__contains__(key):
raise Exception('该节点已经存在.')
self.ring[key] = node
self._sorted_keys.append(key)
def add_node(self, node):
''' 新建节点
node : 要添加的节点，格式为：{'host':'127.0.0.1:8002','weight':1}，其中第一个元素表示节点，第二个元素表示该节点的权重。
'''
node = node.get('host', None)
if not node:
raise Exception('节点的地址不能为空.')
weight = node.get('weight', 1)
self.total_weight += weight
nodes_count = len(self._sorted_keys) + 1
virtual_node_count = math.floor((32 * nodes_count * weight) / self.total_weight)
for i in range(0, int(virtual_node_count)):
key = self.gen_key_thirty_two('%s-%s' % (node, i))
if self._sorted_keys.__contains__(key):
raise Exception('该节点已经存在.')
self.ring[key] = node
self._sorted_keys.append(key)
def remove_node(self, node):
''' 移除节点
node : 要移除的节点 '127.0.0.1:8000'
'''
for key, value in self.ring.items():
if value == node:
del self.ring[key]
self._sorted_keys.remove(key)
def get_node(self, string_key):
'''获取 string_key 所在的节点'''
pos = self.get_node_pos(string_key)
if pos is None:
return None
return self.ring[self._sorted_keys[pos]].split(':')
def get_node_pos(self, string_key):
'''获取 string_key 所在的节点的索引'''
if not self.ring:
return None
key = self.gen_key_thirty_two(string_key)
nodes = self._sorted_keys
pos = bisect(nodes, key)
return pos
def gen_key_thirty_two(self, key):
m = md5_constructor()
m.update(bytes(key,encoding='utf-8'))
return int(m.hexdigest(), 16)
def gen_key_sixteen(self, key):
b_key = self.__hash_digest(key)
return self.__hash_val(b_key, lambda x: x)
def __hash_val(self, b_key, entry_fn):
return (
(b_key[entry_fn(3)] << 24) | (b_key[entry_fn(2)] << 16) | (b_key[entry_fn(1)] << 8) | b_key[entry_fn(0)])
def __hash_digest(self, key):
m = md5_constructor()
m.update(bytes(key, encoding='utf-8'))
return map(ord, m.digest())
nodes = [
{'host':'127.0.0.1:8000','weight':5},
{'host':'127.0.0.1:8001','weight':1},
{'host':'127.0.0.1:8002','weight':5},
]
ring = HashRing(nodes)
result = ring.get_node('asdfasdfasdf')
print(result)View Code
四、form验证，生成html标签
1）自定义版本form验证
import tornado.web
import re
class StringField:
def __init__(self,name):
self.rex = "^\w+$"
self.name = name
self.value = ''
self.error = ""
def __str__(self):
return "<input type='text' name='%s' value='%s' />" %(self.name,self.value,)
class EmailField:
def __init__(self,name):
self.rex = "^\w+@.*$"
self.name = name
self.value = ''
self.error = ""
def __str__(self):
return "<input type='text' name='%s' value='%s' />" %(self.name,self.value,)
class LoginForm:
def __init__(self):
self.user = StringField(name='user')
self.email = EmailField(name='email')
def is_valid(self,handler):
value_dict = {}
flag = True
for k,v in self.__dict__.items():
inp = handler.get_argument(k)
# 1: k=user, inp='asdf' v ="\w+" => StringField(name='user')
# 1: k=email, inp='asdfasdf' v ="^\w+@.*$" => EmailField(name='email')
rex = re.match(v.rex,inp)
v.value = inp
if rex:
value_dict[k] = inp
else:
v.error = '%s 错误了..' %k
flag = False
return flag,value_dict
class LoginHandler(tornado.web.RequestHandler):
def get(self, *args, **kwargs):
obj = LoginForm()
self.render('login.html',**{'obj': obj})
def post(self, *args, **kwargs):
obj = LoginForm()
valid,value_dict = obj.is_valid(self)
print(valid,value_dict)
if valid:
print(value_dict)
else:
return self.render('login.html',**{'obj': obj})
settings = {
'static_path': 'static',
'static_url_prefix': '/sss/',
'template_path':'templates',
}
application = tornado.web.Application([
(r"/login", LoginHandler),
],**settings)
if __name__ == "__main__":
application.listen(8888)
tornado.ioloop.IOLoop.instance().start()View Code
五、pymysql连接数据库测试登录版本的tornado
#!/usr/bin/env python
#-*-coding: utf-8 -*-
import tornado.ioloop
import tornado.web
import pymysql
class MainHandler(tornado.web.RequestHandler):
def get(self): #get 和 post的区别，get，url中传输数据
self.render("login.html")
def post(self, *args, **kwargs): # 获取用户提交的数据a
username = self.get_argument('username', None) # 获取数据，通过，get_argument
pwd = self.get_argument('pwd', None)
# 创建数据库连接
conn = pymysql.connect(host='127.0.0.1', port=3306, user='root', passwd='', db='db1')
cursor = conn.cursor()
# temp = "select name from userinfo where name='%s' and password = '%s'" % (username, pwd) # 不安全
# print(temp)
effect_row = cursor.execute("select name from userinfo where name= %s and password = %s ", (username, pwd,)) #安全些
result = cursor.fetchone()
conn.commit()
cursor.close()
conn.close()
if result:
self.write('登录成功')
else:
self.write('登录失败')
settings = {
"template_path":"template", # 模板路径
'static_path': 'static', # 静态文件的处理，即对css文件的处理
'static_url_prefix': '/static/', # 静态文件的前缀
}
# 路由映射，路由系统
application = tornado.web.Application([
(r"/login", MainHandler), # ==》login.html
],**settings)
if __name__ == "__main__":
application.listen(8888)
tornado.ioloop.IOLoop.instance().start()View Code
2. login.html 文件
<!DOCTYPE html>
<html lang="en">
<head>
<meta charset="UTF-8">
<title>Title</title>
</head>
<body>
<form action="/login" method="post">
<input type="text" name="username" placeholder="用户" />
<input type="text" name="pwd" placeholder="密码" />
<input type="submit" />
</form>
</body>
</html>login.html
三、在tornado中定义模板路径
在模板中默认提供了一些函数、字段、类以供模板使用：
-
escape:tornado.escape.xhtml_escape的別名 -
xhtml_escape:tornado.escape.xhtml_escape的別名 -
url_escape:tornado.escape.url_escape的別名 -
json_encode:tornado.escape.json_encode的別名 -
squeeze:tornado.escape.squeeze的別名 -
linkify:tornado.escape.linkify的別名 -
datetime: Python 的datetime模组 -
handler: 当前的RequestHandler对象 -
request:handler.request的別名 -
current_user:handler.current_user的別名 -
locale:handler.locale的別名 -
_:handler.locale.translate的別名 -
static_url: forhandler.static_url的別名 -
xsrf_form_html:handler.xsrf_form_html的別名
Tornado默认提供的这些功能其实本质上就是 UIMethod 和 UIModule，我们也可以自定义从而实现类似于Django的simple_tag的功能：
1、定义
def tab(self):
return 'UIMethod'uimethods.py
#!/usr/bin/env python
# -*- coding:utf-8 -*-
from tornado.web import UIModule
from tornado import escape
class custom(UIModule):
def render(self, *args, **kwargs):
return escape.xhtml_escape('<h1>user</h1>')
#return escape.xhtml_escape('<h1>user</h1>')uimodules.py
2、注册
#!/usr/bin/env python
# -*- coding:utf-8 -*-
import tornado.ioloop
import tornado.web
from tornado.escape import linkify
import uimodules as md
import uimethods as mt
class MainHandler(tornado.web.RequestHandler):
def get(self):
self.render('index.html')
settings = {
'template_path': 'template',
'static_path': 'static',
'static_url_prefix': '/static/',
'ui_methods': mt,
'ui_modules': md,
}
application = tornado.web.Application([
(r"/index", MainHandler),
], **settings)
if __name__ == "__main__":
application.listen(8009)
tornado.ioloop.IOLoop.instance().start()main.py
3、使用
<!DOCTYPE html>
<html>
<head lang="en">
<meta charset="UTF-8">
<title></title>
<link href="{{static_url("commons.css")}}" rel="stylesheet" />
</head>
<body>
<h1>hello</h1>
</body>
</html>index.html
四、关于tornado的cookie的认识
cookie值即是用户登录系统后所有产生的cookie值，保留这种用户的客户端，再次登录只需要验证cookie值，就可登录成功
1、定义一个首页
<!DOCTYPE html>
<html lang="en">
<head>
<meta charset="UTF-8">
<title>Title</title>
</head>
<body>
<h1>首页</h1>
</body>
</html>index.html
2、定义登录页
<!DOCTYPE html>
<html lang="en">
<head>
<meta charset="UTF-8">
<title>Title</title>
</head>
<body>
<form action="/login" method="post">
<input type="text" name="username" />
<input type="password" name="password" />
<input type="submit" value="登录" />
<span style="color: red">{{status_text}}</span>
</form>
</body>
</html>login.html
3、定义登录后才见到的页面
<!DOCTYPE html>
<html lang="en">
<head>
<meta charset="UTF-8">
<title>Title</title>
</head>
<body>
<a href="/logout">退出</a>
<h1>银行卡余额1000</h1>
</body>
</html>manager.html
4、主程序。逻辑关系的呈现
#!/usr/bin/env python
#-*-coding: utf8-*-
# 项目一，关于cookis的认识
# viems文件夹
# index.html 主页
# login.html 登录页
# manager.html 登录能看的页
# __init__.py
# runmain.py
import tornado.ioloop
import tornado.web
# 定义首页
class IndexHandler(tornado.web.RequestHandler):
def get(self,*args,**kwargs):
self.render('index.html',)
# 定义需要登录才能看到的页面，即需要有cookie
class ManagerHandler(tornado.web.RequestHandler):
def get(self,*args,**kwargs):
co = self.get_cookie('auth')
if co == '1':
self.render('manager.html',)
else:
self.redirect("/login")
# 定义登录后出现的退出程序
class LogoutHandler(tornado.web.RequestHandler):
def get(self, *args, **kwargs):
self.get_cookie('auth','0')
self.render('/login' )
# 定义登录页，如果成功，则产生cookie
class LoginHandler(tornado.web.RequestHandler):
def get(self,*args,**kwargs):
self.render('login.html',status_text="")
def post(self, *args, **kwargs):
username = self.get_argument('username',None)
pwd = self.get_argument('password',None)
if username == 'user' and pwd == "sb":
self.set_cookie('auth','1')
self.redirect('/manager')
else:
self.render('login.html',status_text="登录失败")
settings = {
'template_path':'viems',
}
application = tornado.web.Application([
(r"/index", IndexHandler),
(r"/login", LoginHandler),
(r"/manager", ManagerHandler),
(r"/logout",LogoutHandler)
], **settings)
if __name__ == "__main__":
application.listen(8888)
tornado.ioloop.IOLoop.instance().start()runmain.py
运行程序，检验其逻辑关系，各个页面。127.0.0.1:8888/index ,127.0.0.1:8888/login，各个cookie值
5、补充cookie保存的时间，增加cookie值带的用户名
class LoginHandler(tornado.web.RequestHandler):
def get(self,*args,**kwargs):
self.render('login.html',status_text="")
def post(self, *args, **kwargs):
username = self.get_argument('username',None)
pwd = self.get_argument('password',None)
check = self.get_argument('auto',None)
if username == 'user' and pwd == "sb":
if check:
self.set_cookie('username',username,expires_days=7)
self.set_cookie('auth','1',expires_days=7)
else:
r = time.time() + 100
self.set_cookie('auth','1',expires=r)
self.set_cookie('username', username, expires=r)
self.redirect('/manager')
else:
self.render('login.html',status_text="登录失败")time()_cookies.py
<body>
<form action="/login" method="post">
<input type="text" name="username" />
<input type="password" name="password" />
<input type="checkbox" name="auto" value="1" />7天免登录
<input type="submit" value="登录" />
<span style="color: red">{{status_text}}</span>
</form>
</body>time()_cookie.html
本文章为转载内容，我们尊重原作者对文章享有的著作权。如有内容错误或侵权问题，欢迎原作者联系我们进行内容更正或删除文章。
