web框架

2018/07/13 day100

一、Web框架
　　- bottle
　　- flask
　　- tornado

　　基本的http请求周期：用户请求-》服务器的路由系统-》业务逻辑处理（操作数据库，原生或者orm）（模板渲染）。django还有中间件。

它们的特点：
# 三大组件
　　- 路由系统
　　- 控制器（含模版渲染）
　　- 数据库操作
# 微型框架
　　- 依赖第三方写的socket，都要遵循WSGI
　　- 本身功能少

# 安装

pip3 install bottle
pip3 install flask
pip3 install tornado

1. bottle

简单示例：

#!/usr/bin/env python
# -*- coding:utf-8 -*-
from bottle import template, Bottle
root = Bottle()

@root.route('/hello/')
def index():
return "Hello World"
# return template('<b>Hello {{name}}</b>!', name="Alex")	 
root.run(host='localhost', port=8080)	

a. 路由系统
　　- 静态：@root.route('/hello/')
　　- 动态：支持正则表达式、数字

@root.route('/wiki/<pagename>')	#pagename变量
@root.route('/object/<id:int>')	#int检测是否整数，然后传给id
@root.route('/show/<name:re:[a-z]+>')	#name参数，re后面是正则
@root.route('/static/<path:path>')	#静态资源配置路径，传给path参数，root是具体的路径

　　- 方法：@root.route('/hello/', method='POST') #允许什么方式访问
　　- 二级：路由分发

from framwork_bottle import app01
root.mount('app01', app01.app01)	#就指向了app01.py文件的路由
							
app01 = Bottle()
@app01.route('/hello/', method='GET')

b. 视图
　　- 获取用户内容 request

request.headers	#请求头信息
request.query	#get请求信息
request.forms	#post请求信息
request.files	#上传文件信息
request.params	#get和post请求信息
request.GET	#get请求信息
request.POST	#post和上传信息
request.cookies	#cookie信息
request.environ	#环境相关相关

 

　　- 数据库操作
　　- 文件操作
　　- ...
　　- 返回给用户内容return ""
　　- 模版引擎渲染

单值：			{{name}}
单行Python代码	% s1 = "hello"
Python代码块	<%	%>
Python、Html混合	% if True: % end
函数include：% include('header.tpl', title='Page Title')	#title参数
函数rebase：% rebase('base.tpl', title='Page Title')	#相当于dajngo的{% block css %}{% endblock %}
defined(name):		#检查当前变量是否已经被定义，已定义True，未定义False
get(name, default=None):	#获取某个变量的值，不存在时可设置默认值
setdefault(name, default):	#如果变量不存在时，为变量设置默认值
自定义函数：wupeiqi=custom	{{ wupeiqi() }}		#custom是定义的函数名，传给wupeiqi
xss安全：！相当于mark_safe

 

c. WSGI进行配置
　　socket基于wsui接口来实现，请求先到socket，再转交给web框架
　　root.run(host='localhost', port=8080, server='wsgiref')
　　默认server＝"wsgiref"，即：使用Python内置模块wsgiref，如果想要使用其他时，则需要首先安装相关类库，然后才能使用

2.flask

简单示例：

from flask import Flask
app = Flask(__name__)	
@app.route("/")
def hello():
return "Hello World!"	
if __name__ == "__main__":
app.run()

a.路由系统

@app.route('/user/<username>')	#正则
@app.route('/post/<int:post_id>')	#int传给post_id
@app.route('/post/<float:post_id>')
@app.route('/post/<path:path>')	#.*除换行符外所有
@app.route('/login', methods=['GET', 'POST'])	#方法

常用路由系统有以上五种，所有的路由系统都是基于一下对应关系来处理：

DEFAULT_CONVERTERS = {
　　'default': UnicodeConverter,
　　'string': UnicodeConverter,
　　'any': AnyConverter,	　　　　#('/<any(about, help, imprint, class, "foo,bar"):page_name>')
　　'path': PathConverter,
　　'int': IntegerConverter,
　　'float': FloatConverter,
　　'uuid': UUIDConverter,
}

b.模板
Flask使用的是Jinja2模板，所以其语法和Django无差别

return render_template()
自定义模板：{{k4()|safe}} k4=jinxi def jinxi():

c.请求数据

request.method
request.args
request.form
request.values
request.files
request.cookies
request.headers
request.path
request.full_path
request.script_root
request.url
request.base_url
request.url_root
request.host_url
request.host

d.数据库连接：
　　#python的ORM框架：SQLAchemy
　　#pymysql
e.响应：
　　字符串 return "index"
　　模板引擎 return render_template("index.html")
　　重定向 return redirect(url_for('login')) #login相当于url的name，flask中与函数同名
　　设置相应信息 response = make_response() response.set_cookie response.headers['X-Something'] = 'A value'
　　　　　　　　return response
f.Session:
　　加密放在cookie中，需要先设置app.secret_key = 'A0Zr98j/3yX R~XHH!jmN]LWX/,?RT'

　　设置：session['username'] ＝ 'xxx'

　　删除：session.pop('username', None)

g.基于wsgi自定制中间件

class Foo:
　　def __init__(self,w):
	self.w = w
　　def __call__(self, environ, start_response):
	obj = self.w(environ, start_response)       #前后即可定制操作
	return obj

if __name__ == "__main__":
# app.wsgi_app = my_wsgi_app
app.wsgi_app = Foo(app.wsgi_app)        #加括号执行Foo的call方法
app.run()

 

这样返回的wsgi_app还是内置的，但obj的前后可以自定制一些操作。django的中间件也是这样定制的

h.message
　　　　message是一个基于Session实现的用于保存数据的集合，其特点是：使用一次就删除

　　　　flash(v) #设置值
　　　　{% with messages = get_flashed_messages() %} #模板中取值，一次即删

i. flask程序目录

views
	-__init__.py	#import config，在这里创建app=Flask(__name__,template_folder = config.template_folder)，
								#	这样所有的py文件用的是同一个单例app
	-account.py		#from . import app，.表示本级目录，	
	-home.py
templates
	-index.html
	config.py			#写上template_folder = 'templates'
	manage.py			#import views即可，views.app.run()　

3. Tornado

- 异步非阻塞的框架 Node.js



模版语言：
Django: ORM，模板引擎
bottle: 模板引擎
SqlAchmey： ORM
JinJa2: 模板引擎，和django一样

2018/07/14 day101 Tornado


异步非阻塞的框架，遇到IO等待的时候可以处理其他，select

简单示例：

		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__":
			#创建socket对象
			#将对象添加到select或epoll中
			application.listen(8888)
			#将select或epoll开始死循环，while true
			tornado.ioloop.IOLoop.instance().start()

　　

1.路由系统

Tornado中每个url对应的是一个类。
class MainHandler(tornado.web.RequestHandler):
def get(self):
self.write("Hello, world")
2.模板
控制语句： {% %} {% end %}
表达语句： {{ }}
UIMethod：

		UIMethod：
			def tab(self):
				return 'UIMethod'	
			{{ tab() }}
			
		UIModule：
			class custom(UIModule):
				def render(self, *args, **kwargs):
					return escape.xhtml_escape('<h1>wupeiqi</h1>')	#不显示html格式
			{% module custom(123) %}

　

3.静态文件

		settings = {
			'template_path': 'template',
			'static_path': 'static',
			'static_url_prefix': '/static/',
		}
		application = tornado.web.Application([(r"/index", MainHandler),], **settings)

4.cookie

		self.set_cookie("mycookie", "myvalue")	
		self.get_cookie("mycookie")

　　

5.session


二、Web组件的定制

1. Session
请求到来

 　　　　　　请求到来
            - 用户浏览器设置cookie   {'session_id':随机字符串}
            - 
               session = {
                    随机字符串: {login:true}
                    随机字符串: {login:true}
               }

 

a.定义session.py文件，编写一个保存键值对的类和容器

　　　　　　　　　　　　　　import uuid
			class Session(object):
				container = {}
				def __init__(self,handler):
					# 获取用户cookie，有则不操作，没有就生成随机字符串，写给用户和保存在session
					nid = handler.get_cookie('session_id')
					if nid:
					   if nid in self.container:	#有nid在session中，每次访问时都更新超时时间
						   pass
					   else:
						   nid = str(uuid.uuid4())	#有nid不在session中，访问时创建sessionid，set_cookie
						   self.container[nid] = {}
					else:
						nid = str(uuid.uuid4())		#没有有nid，访问时创建sessionid,set_cookie
						self.container[nid]={}
					handler.set_cookie('session_id', nid, max_age=1000)		
					self.nid = nid          # 当前用户的随机字符串
					self.handler = handler  # 用户所有的请求信息
				def __setitem__(self, key, value):          # 设置session类的值时自动执行
					self.container[self.nid][key] = value
				def __getitem__(self,key):
					return self.container[self.nid].get(key) #如果没有返回none
				def __delitem__(self, key):
					del  self.container[self.nid][key]

 

b.创建session类的对象，传键和值进行设置和获取

			class BaseHandler(object):		#所有的视图函数执行前先执行这个函数：创建session对象给全局self
				def initialize(self):
					# 获取用户cookie，有则不操作，没有就生成随机字符串，写给用户和保存在session
					from session import Session
					self.session = Session(self)   #传给session方法，指IndexHandler等

					super(BaseHandler, self).initialize()   #不影响其他类的同名方法执行，先执行这个，再执行他们的

　　

c.视图函数中设置和获取session

			        if v == 'root':
						self.session['is_login']=True	#设置
		
					if self.session['is_login']:		#获取	
						self.write("Hello, world")		

 

d.不同储存类型的session选择
import session
cls = getattr(session,config.session_key) #config.py文件中session_key = 'Session'
self.session = cls(self) #传给session方法，指IndexHandler等

e.哈希算法选择服务器存储
将session的nid转数字，哈希算法分配服务器机台

2. Form组件
a. 表单验证
- 写Form类
- 定义Form类中的字段
- 用户发送
- obj = Form(请求数据)
obj.is_valid()
obj.cleaned_data

示例：

		示例：
			#!/usr/bin/env python
			# -*- coding:utf-8 -*-
			import tornado.ioloop
			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:	#Form组件
				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)
						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})		#调用字段的str方法，raw原生显示
				def post(self, *args, **kwargs):
					obj = LoginForm()
					valid,value_dict = obj.is_valid(self)
					if valid:
						print(value_dict)
					else:
						self.render('login.html', **{'obj': obj})

			settings = {'static_path':'static','static_url_prefix':'/css/','template_path':'templates'}
			application = tornado.web.Application([
				(r"/login", LoginHandler),
			],**settings)

			if __name__ == "__main__":
				application.listen(8888)
				tornado.ioloop.IOLoop.instance().start()　　

　　

三、tornado异步非阻塞原理：

 

2018/07/15 day102

1. 运算
v = 1 and 2 or 3 an 4
2. 基本数据类型
如字符串有几个方法
3. 列表生成式

4. 作用域
python与js类似
5. 函数的参数和返回值
可变类型当参数，一改整体改
6. 迭代器和生成器

7. 面向对象
- 继承
- metaclass


8. 异步IO模块

9. 异步非阻塞Web框架


=====================================================

支持异步非阻塞Web框架 - Tornado，Nodejs

异步IO模块：
我们作为客户端向服务端发起“并发”请求，select监听socket是否已经有变化

异步非阻塞框架：
服务器收到非计算型即IO请求挂起的同时，处理其他请求，当IO请求有结果，其他服务器返回时，再返回给IO请求，断掉连接。

future = Future()
1. 挂起当前请求，线程可以处理其他请求 *****
2. future设置值，当前挂起的请求返回

3种情况：
- 超时时间到，往future设置值，请求结束，等待同时可以处理其他请求
- 请求来了，再往远处发请求，远处有返回时结束当前请求
- 等待另一个请求设置future值终止

自定义Web框架：
- 同步
- 异步

一、Tornado异步非阻塞

1.设置超时时间

		from tornado import gen
		from tornado.concurrent import Future
		class MainHandler(tornado.web.RequestHandler):
			@gen.coroutine
			def get(self):
				future = Future()
				tornado.ioloop.IOLoop.current().add_timeout(time.time() + 5, self.doing)
				yield future

			def doing(self, *args, **kwargs):
				self.write('async')
				self.finish()

　　

2.往远处发请求

		class MainHandler(tornado.web.RequestHandler):
			@gen.coroutine
			def get(self):
				from tornado import httpclient
				http = httpclient.AsyncHTTPClient()
				yield http.fetch("http://www.google.com", self.done)

			def done(self, response):
				print('完事')
				self.finish('666')

　　

3.发请求设置future

		future = None
		class MainHandler(tornado.web.RequestHandler):
			@gen.coroutine
			def get(self):
				global future
				future = Future()
				future.add_done_callback(self.done)
				yield future

			def done(self, response):
				print('完事')
				self.finish('666')

		class IndexHandler(tornado.web.RequestHandler):
			def get(self):
				global future
				future.set_result(None)			#设置
				self.write("Hello, world")

　　

二、自定义web框架

1.同步

		import socket
		import select

		class HttpRequest(object):
			"""
			用户封装用户请求信息
			"""
			def __init__(self, content):
				"""
				:param content: 请求头、请求体
				"""
				self.content = content

				self.header_bytes = bytes()
				self.header_dict = {}
				self.body_bytes = bytes()

				self.method = ""
				self.url = ""
				self.protocol = ""

				self.initialize()
				self.initialize_headers()

			def initialize(self):
				temp = self.content.split(b'\r\n\r\n', 1)   #分割请求体、头
				if len(temp) == 1:
					self.header_bytes += temp
				else:
					h, b = temp
					self.header_bytes += h
					self.body_bytes += b
					header_flag = True

			@property
			def header_str(self):
				return str(self.header_bytes, encoding='utf-8')

			def initialize_headers(self):
				headers = self.header_str.split('\r\n')
				first_line = headers[0].split(' ')
				if len(first_line) == 3:
					self.method, self.url, self.protocol = headers[0].split(' ')
					for line in headers:
						kv = line.split(':')
						if len(kv) == 2:
							k, v = kv
							self.header_dict[k] = v

		def index(request):
			return 'xxxx'

		def main(request):
			return 'main'

		routers = [
			('/index/',index),
			('/main/',main),
		]

		def run():
			sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
			sock.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
			sock.bind(('127.0.0.1', 9999,))
			sock.setblocking(False)
			sock.listen(128)

			inputs = []
			inputs.append(sock)
			while True:
				rlist,wlist,elist = select.select(inputs,[],[],0.05)
				for r in rlist:
					if r == sock:
						'''新请求到来'''
						conn,addr = sock.accept()
						conn.setblocking(False)     #设置客户端socket非阻塞
						inputs.append(conn)
					else:
						"""客户端发来数据"""
						data = b""      #包含请求头、请求体
						while True:
							try:
								chunks = r.recv(1024)       #接收字节类型
								data += chunks
							except Exception as e:
								chunks = None
							if not chunks:
								break
						request = HttpRequest(data)
						# print(request.url)
						# print(request.method)
						# print(request.header_dict)
						# print(request.body_bytes)
						# 1. 请求头获取url
						# 2. 路由匹配，获取指定函数
						import re
						flag = False
						func = None
						for route in routers:
							if re.match(route[0],request.url):
								flag = True
								func = route[1]
								break
						if flag:
							result = func(request)
							r.sendall(bytes(result,encoding='utf-8'))
						else:
							r.sendall(b'404')
						# 3. 执行函数，获取返回值
						# 4.r.sendall(b'asd')
						inputs.remove(r)
						r.close()

		if __name__ =='__main__':
			run()	

　　

总结：
select是IO多路复用，监听状态变化，本质还是同步

2.异步：Future

重点：return Future时pass，放到队列中，for循环监听Future的self.result值是否变化，变化了返回并close
变化可以是timeout作if判断，设置值；
请求的函数中设置（global一下Future）；
远处请求返回设置一下。

代码：

a.发送请求设置

			class Future(object):
				def __init__(self):
					self.result = None
			F = None			#全局变量
			def index(request):
				global F
				F = Future()
				return F

			def main(request):
				return 'main'

			def stop(request):
				global F
				F.result = b'sda'		#设置
				return 'stop'	

　　

循环监听：

			for conn in async_request_dict.keys():
				future = async_request_dict[conn]
				if future.result:					#监听值是否变化
					conn.sendall(future.result)
					conn.close()
					del async_request_dict[conn]
					inputs.remove(conn)
				else:
					pass

　　

b.超时

			class Future(object):
				def __init__(self,timeout):
					self.result = None
					self.timeout = timeout
					self.start_time = time.time()

			def index(request):
				f = Future(5)
				return f

　　

循环：

			for conn in async_request_dict.keys():
				future = async_request_dict[conn]
				start_time = future.start_time
				timeout = future.timeout
				ctime = time.time()
				if (start_time + timeout)<= ctime:
					future.result = b'timeout'
				if future.result:
					conn.sendall(future.result)
					conn.close()
					del async_request_dict[conn]
					inputs.remove(conn)
				else:
					pass