Flask 入门知识必备

Flask是一个使用 Python 编写的轻量级 Web 应用框架。其 WSGI（Python Web Server Gateway Interface）工具箱采用 Werkzeug ，模板引擎则使用 Jinja2 。Flask使用 BSD 授权。

Flask也被称为 “microframework” ，因为它使用简单的核心，用 extension 增加其他功能。Flask没有默认使用的数据库、窗体验证工具。

Flask 和其他python框架(Django，tornado等)相比，其特点就是简单可扩展和其特有的数据管理机制。它只实现web 框架最核心的功能，允许第三方插件来扩充功能。而且它的代码量少，核心代码之后2k+ 行。适合阅读源码去提高自己。

在读源码之前我们要先了解一些基础的知识，要不然会很有难度。
flask特有的数据管理方式就是上下文管理机制，这是它的特色之处同时也成了Flask框架复杂度比较集中的地方。要去理解Context的实现我们先要对栈操作和线程间的隔离技术有一定的了解。

下面我们来说一下具体需要了解的技术。

1.栈操作(先入后出)

class Stack():                                 #栈操作
    def __init__(self,size):                    #定义栈
        self.size=size
        self.stack=[]
        self.top=-1
    def push(self,x):                          #入栈
        if self.isfull():                      #判断栈满
            raise exception("stack is full")
        else:
            self.stack.append(x)
            self.top=self.top+1
    def pop(self):                             #出栈
        if self.isempty():                     #判断栈空
            raise exception("stack is empty")
        else:
            self.top=self.top-1
            self.stack.pop()
    def isfull(self):                         #栈满条件
        return self.top+1 == self.size
    def isempty(self):                       #栈空条件
        return self.top == '-1'
    def showStack(self):                      #显示栈
        print(self.stack)
s=Stack(10)                                  #实例化一个大小为10的栈
for i in range(6):                          #加入六个数
    s.push(i)
print(s.showStack())                        #显示栈
for i in range(3):                          #取出三个数
    s.pop()
print(s.showStack())                        #显示栈

提到栈我们可以和队列对比着看,不同于栈的先进后出,队列的操作是先进先出,下边是队列的实现因为和栈的实现差不多此处就不加注释了.

class Queue():                              #队列操作
    def __init__(self,size):
        self.size=size
        self.putnum =-1
        self.getnum =-1
        self.queue=[]
    def put(self,element):
        if self.isfull():
            raise exception("queue is full")
        else:
            self.queue.append(element)
            self.putnum=self.putnum+1
    def get(self):
        if self.isempty():
            raise exception("queue is empty")
        else:
            self.queue.pop(0)
            self.getnum=self.getnum+1
    def isfull(self):
        return self.putnum-self.getnum+1 == self.size
    def isempty(self):
        return self.putnum == self.getnum
    def showQueue(self):
        print(self.queue)

q=Queue(10)
for i in range(6):
    q.put(i)
q.showQueue()
for i in range(3):
    q.get()
q.showQueue()

2. threading.local

在多线程中，同一个进程中的多个线程是共享一个内存地址的，多个线程操作数据时，就会造成数据的不安全，所以我们就要线程私有化。自定义实现如下:

import threading
from threading import current_thread as getcurrent
class Local(object):
    def __init__(self):
        object.__setattr__(self,"_storage",{})
    def __setattr__(self, key, value):
        ident = getcurrent()   
        if ident in self._storage:
            self._storage[ident][key] = value
        else:
            self._storage[ident] = {key:value}
    def __getattr__(self, item):
        ident = getcurrent()
        return self._storage[ident][item]
local = Local()
def func(n):
    local.val = n
    print(n)
for i in range(10):
    t = threading.Thread(target=func,args=(i,))
    t.start()
    print(local._storage)

Werkzeug 没有直接使用 threading.local，而是自己实现了 werkzeug.local.Local 类。除 Local 外，Werkzeug 还实现了两种数据结构：LocalStack 和 LocalProxy。这些具体的实现我们会在下篇源码分析中说到,下面我们先看一下几个例子:

2.1:使用偏函数固定参数提取属性值

from functools import partial
class HttpRequest(object):                  #请求信息
    def __init__(self):
        self.method = "GET"
        self.body = b"name=abc@age=123"
    def __getitem__(self, item):
        return  self.__dict__[item]
class RequestContext(object):                          #添加session属性
    def __init__(self):
        self.request = HttpRequest()
        self.session = {"login":True,"is_super":False}
    def __getitem__(self, item):
        return self.__dict__[item]
reqcxt = RequestContext()                  #相当于Flask中从栈提取的上下文
def func(args):                            #提取属性值，此处用到__getattr__方法
    return getattr(reqcxt,args)
re_func = partial(func,'request')         #通过偏函数固定到提取的属性，此时 re_func==func(request)==HttpRequest()
se_func = partial(func,'session')         #同样 se_func()==func(session)=={"login":True,"is_super":False}
class LocalProxy(object):                  #本地代理本地化，提供栈隔离
    def __init__(self,local):
        self._local = local
    def _get_current_object(self):
        return self._local()
    def __getitem__(self, item):
        return getattr(self._get_current_object(),item)
request = LocalProxy(re_func)              #先进入__getitem__然后进入_get_current_object返回re_func的本地化调用，实现隔离
ret = request['method']
print(ret)
session = LocalProxy(se_func)              #local={"login":True,"is_super":False}
print(session._get_current_object())

2.2:用栈隔离技术来实现栈的存取

from threading import current_thread as getcurrent

class Local(object):
    def __init__(self):
        object.__setattr__(self,"_storage",{})
    def __setattr__(self, key, value):
        ident = getcurrent()   # 定制粒度更细的
        if ident in self._storage:
            self._storage[ident][key] = value
        else:
            self._storage[ident] = {key:value}
    def __getattr__(self, item):
        ident = getcurrent()
        return self._storage[ident][item]

class LocalStack(object):            #取栈顶元素
    def __init__(self):
        self.local = Local()
    def push(self,item):
        self.local.stack = []
        self.local.stack.append(item)
    def pop(self):
        return self.local.stack.pop()
    def top(self):
        return self.local.stack[-1]
_local_stack = LocalStack()
_local_stack.push(55)
print(_local_stack.top())

3.一个简易版的Flask框架为大家提供核心思想的参考

from wsgiref.simple_server import make_server
ViewFunctions = {}
def wapper(name):
    def _wapper(f):
        ViewFunctions[name] = f
        return f
    return _wapper
@wapper("/home")
def home():
    return [b'<h1>Hello, web!</h1>']
@wapper("/favicon.ico")
def pic():
    return [b'<h1>pic!</h1>']
print(ViewFunctions)
class Flask:
    def __init__(self):
        self.view_functions = {}
    def __call__(self,environ, start_response):
        key = environ['PATH_INFO']
        print(key)
        start_response('200 OK', [('Content-Type', 'text/html')])
        return ViewFunctions[key]()
application = Flask()
httpd = make_server('', 8000, application)
# 开始监听HTTP请求:
httpd.serve_forever()