这一阵正在学习廖雪峰老师的实战课程，这里对其中web.py框架进行一些分析，总结一下学到的东西。
这一部分的课程网站：http://www.liaoxuefeng.com/wiki/001374738125095c955c1e6d8bb493182103fac9270762a000/0014023080708565bc89d6ab886481fb25a16cdc3b773f0000
近期学习了廖雪峰老师Python教程实战课程中WebApp博客的编写，这个项目最核心的部分就是web框架的编写。在这里总结一下学到的东西。
其实简化来说这就是一个WSGI的实现填充，所以需要对wsgi有一定的了解。
首先要对整体的流程和结构有一个掌握：
1.用Request接受并分析客户端发出请求；
2.通过Route将请求的地址和要返回的模板关联起来；
3.再通过Response将结果返回客户端。
以上就是整个框架中主要的三块，这三部分通过wsgi协议来组装，从而构成一个完整的框架。
在对这三个部分进行分析前，还有一些启动程序前要做的准备工作：
a.注册函数
1.先用@get, @post来装饰函数，从而设定func.__web_method__和func.__web_route__;
def get(path):
def _decorator(func):
func.__web_route__ = path
func.__web_method__ = 'GET'
return func
return _decorator
def post(path):
def _decorator(func):
func.__web_route__ = path
func.__web_method__ = 'POST'
return func
return _decorator
2.再用@view将函数与模板联系起来；
def view(path):
def _decorator(func):
@functools.wraps(func)
def _wrapper(*args, **kw):
r = func(*args, **kw) #这时函数原本应该返回的值，应当为字典类型。
if isinstance(r, dict):
logging.info('return Template')
return Template(path, **r) #得到self.template_name 和 self.model。
raise ValueError('Expect return a dict when using @view() decorator.')
return _wrapper
return _decorator
3.最后用wsgi.add_module(urls)来将这些函数注册到WSGIApplication中（这个函数存在于WSGIApplication中）。
b.添加拦截器
wsgi.add_interceptor(urls.user_interceptor)
1.用@interceptor()装饰拦截函数；
def interceptor(pattern='/'):
def _decorator(func):
#简单来说就是：给func添加了一个__interceptor__属性，这一属性并非一个单纯的值，
# 而是一个可调用的函数，这个函数使用时：
# func.__interceptor__(ctx.request.path_info)
# 根据ctx.request.path_info判断返回True或者False,从而决定拦截函数是否运行-->看2.
func.__interceptor__ = _build_pattern_fn(pattern)
return func
return _decorator
2.
根据ctx.request.path_info判断返回True或者False,从而决定拦截函数是否运行；def _build_interceptor_fn(func, next):
def _wrapper():
if func.__interceptor__(ctx.request.path_info):
#如果上面为True，那么启动拦截函数
return func(next)
else:
#否则直接运行原函数
return next()
return _wrapper
下面看主要的三个部分：
1. class Route(object):
这个模块的目的是将函数包裹Route()中，从而存储func对应的请求路径和请求方法，这个函数是在add_url（）中调用的：route = Route(func)。
这个类的作用主要是：
a.将函数路径和对应的方法放到实例中；
b.并给实例添加属性来判断对应的请求路径是静态还是动态（就是在函数用@get, @post来装饰时的path中是否含有变量如：'/:id'等）
c.添加match方法，当路径是动态时，用来将其中的变量提出，作为函数的参数使用：具体看WSGIApplication中get_wsgi_application下的函数fn_route()。
class Route(object):
'''
A Route object is a callable object.
'''
def __init__(self, func):
self.path = func.__web_route__
self.method = func.__web_method__
self.is_static = _re_route.search(self.path) is None
if not self.is_static:
self.route = re.compile(_build_regex(self.path))
self.func = func
def match(self, url):
m = self.route.match(url)
if m:
return m.groups()
return None
def __call__(self, *args):
return self.func(*args)
def __str__(self):
if self.is_static:
return 'Route(static,%s,path=%s)' % (self.method, self.path)
return 'Route(dynamic,%s,path=%s)' % (self.method, self.path)
__repr__ = __str__
2. Request(object)
这一部分主要是解析客户端发送的请求，我们只将其主要的部分进行分析，其他的方法都是类似的。
最主要的就是 _parse_input()方法，它主要是将请求中表单的部分转换成为字典类型，以供后面的函数调用；
_get_raw_input()和input()都是在这个基础上的装饰复制，从而方便下面的使用；
后面很多用 @property装饰的函数都是通过self._environ来获得想要的信息；
还有一些设置cookie和header的函数。
class Request(object):
'''
Request object for obtaining all http request information.
'''
def __init__(self, environ):
self._environ = environ
def _parse_input(self):
def _convert(item):
if isinstance(item, list):
return [_to_unicode(i.value) for i in item]
if item.filename:
return MultipartFile(item)
return _to_unicode(item.value)
#将self._environ['wsgi.input']转换成字典类型
fs = cgi.FieldStorage(fp=self._environ['wsgi.input'], environ=self._environ, keep_blank_values=True)
inputs = dict()
for key in fs:
inputs[key] = _convert(fs[key])
return inputs
def _get_raw_input(self):
'''
Get raw input as dict containing values as unicode, list or MultipartFile.
'''
if not hasattr(self, '_raw_input'):
#将上面的结果放到_raw_input属性中
self._raw_input = self._parse_input()
return self._raw_input
def input(self, **kw):
#复制上边得到的表单字典
copy = Dict(**kw)
raw = self._get_raw_input()
for k, v in raw.iteritems():
copy[k] = v[0] if isinstance(v, list) else v
return copy
def get_body(self):
#得到environ['wsgi.input']原始的数据
fp = self._environ['wsgi.input']
return fp.read()
@property
def remote_addr(self):
return self._environ.get('REMOTE_ADDR', '0.0.0.0')
def _get_cookies(self):
if not hasattr(self, '_cookies'):
cookies = {}
cookie_str = self._environ.get('HTTP_COOKIE')
if cookie_str:
for c in cookie_str.split(';'):
pos = c.find('=')
if pos>0:
cookies[c[:pos].strip()] = _unquote(c[pos+1:])
self._cookies = cookies
return self._cookies
@property
def cookies(self): return Dict(**self._get_cookies())
def cookie(self, name, default=None): return self._get_cookies().get(name, default)
3.Response(object)
这部分主要的作用就是设置status 和 headers ，后边各种方法都是围绕这一主题进行的。具体可以看源码的注释。
class Response(object):
def __init__(self):
self._status = '200 OK'
self._headers = {'CONTENT-TYPE': 'text/html; charset=utf-8'}
接下来就是这个模块最关键的部分了，WSGI的实现，这个类将上面三部分有机结合到一起，从而完成整个服务器的过程（可以看注释）：
class WSGIApplication(object):
#初始化时创建后面要用到的属性
def __init__(self, document_root=None, **kw):
'''
Init a WSGIApplication.
Args:
document_root: document root path.
''' self._running = False
self._document_root = document_root
self._interceptors = []
self._template_engine = None
self._get_static = {}
self._post_static = {}
self._get_dynamic = []
self._post_dynamic = [] #用来查看服务器是否正在运行
def _check_not_running(self):
if self._running:
raise RuntimeError('Cannot modify WSGIApplication when running.')
#添加模板
@property
def template_engine(self):
return self._template_engine
@template_engine.setter
def template_engine(self, engine):
self._check_not_running()
self._template_engine = engine #add_module()和add_url()用来将urls.py中的函数注册到服务器中
def add_module(self, mod):
self._check_not_running()
m = mod if type(mod)==types.ModuleType else _load_module(mod)
logging.info('Add module: %s' % m.__name__)
for name in dir(m):
fn = getattr(m, name)
if callable(fn) and hasattr(fn, '__web_route__') and hasattr(fn, '__web_method__'):
self.add_url(fn)
def add_url(self, func):
self._check_not_running()
route = Route(func)
if route.is_static:
if route.method=='GET':
self._get_static[route.path] = route
if route.method=='POST':
self._post_static[route.path] = route
else:
if route.method=='GET':
self._get_dynamic.append(route)
if route.method=='POST':
self._post_dynamic.append(route)
logging.info('Add route: %s' % str(route)) #添加拦截函数
def add_interceptor(self, func):
self._check_not_running()
self._interceptors.append(func)
logging.info('Add interceptor: %s' % str(func)) #运行服务器
def run(self, port=9000, host='127.0.0.1'):
from wsgiref.simple_server import make_server
logging.info('application (%s) will start at %s:%s...' % (self._document_root, host, port))
#httpd = make_server('', 8000, hello_world_app) 其中self.get_wsgi_application(debug=True)便是代替hello_world_app，
#这个是一个函数对象wsgi, 可以被调用
server = make_server(host, port, self.get_wsgi_application(debug=True))
server.serve_forever()
#这时这个应用中的核心
#返回值wsgi是一个函数对象，而不是一个确定值，主要是为了上面的调用
def get_wsgi_application(self, debug=False):
self._check_not_running()
if debug:
self._get_dynamic.append(StaticFileRoute())
self._running = True
_application = Dict(document_root=self._document_root) #这个函数的作用就是将注册的函数和请求的路径联系起来
def fn_route():
request_method = ctx.request.request_method
path_info = ctx.request.path_info
if request_method=='GET':
fn = self._get_static.get(path_info, None)
if fn:
#静态路径的话就可以直接调用函数：
return fn()
for fn in self._get_dynamic:
#如果是动态的路径，那么将其中的动态部分提取出来作为函数的参数：
args = fn.match(path_info)
if args:
return fn(*args)
raise notfound()
if request_method=='POST':
fn = self._post_static.get(path_info, None)
if fn:
return fn()
for fn in self._post_dynamic:
args = fn.match(path_info)
if args:
return fn(*args)
raise notfound()
raise badrequest() #添加拦截函数
fn_exec = _build_interceptor_chain(fn_route, *self._interceptors) #wsgi就是应用程序了，其中的两个参数在wsgiref中会提供的：
def wsgi(env, start_response): #将Request和Response实例化成为ctx的属性
ctx.application = _application
ctx.request = Request(env)
response = ctx.response = Response() try: r = fn_exec()
#正常情况下r是被包裹的函数返回的填入返回值的模板
if isinstance(r, Template):
r = self._template_engine(r.template_name, r.model)
if isinstance(r, unicode):
r = r.encode('utf-8')
if r is None:
r = []
start_response(response.status, response.headers)
return r
#处理各种错误
except RedirectError, e:
response.set_header('Location', e.location)
start_response(e.status, response.headers)
return []
except HttpError, e:
start_response(e.status, response.headers)
return ['<html><body><h1>', e.status, '</h1></body></html>']
except Exception, e:
logging.exception(e)
if not debug:
start_response('500 Internal Server Error', [])
return ['<html><body><h1>500 Internal Server Error</h1></body></html>']
exc_type, exc_value, exc_traceback = sys.exc_info()
fp = StringIO()
traceback.print_exception(exc_type, exc_value, exc_traceback, file=fp)
stacks = fp.getvalue()
fp.close()
start_response('500 Internal Server Error', [])
return [
r'''<html><body><h1>500 Internal Server Error</h1><div style="font-family:Monaco, Menlo, Consolas, 'Courier New', monospace;"><pre>''',
stacks.replace('<', '<').replace('>', '>'),
'</pre></div></body></html>']
#请求结束后将线程的各个属性删除
finally:
del ctx.application
del ctx.request
del ctx.response
return wsgi
这就是整个web.py框架的结构了，其中具体的细节就需要参看代码了。