bottle框架剖析
bottle框架剖析
-
使用
-
源码分析
一、使用
大致有以下几部分
-
quick start
-
request routing
-
generate contents
-
request Data
-
templates
quick start
下载： pip install bottle
from bottle import route, run @route('/hello') def hello(): return "Hello World!" run(host='localhost', port=8080, debug=True)
visit http://localhost:8080/hello 将会看到hello world
默认app
当第一次运行route() 会自动产生一个Bottle类的一个实例，bottle
request routing
route 装饰器将url path 与回调函数联系起来。并给默认的app 添加一个url.一个app可以添加好多个url.
like the following
@route('/') @route('/hello/<name>') def greet(name='Stranger'): return template('Hello {{name}}, how are you?', name=name)
多个url
from bottle import route, run, template @route('/') @route('/hello/<name>') def index(name='stranger'): return template('<b>hello</b>{{name}}',name=name) run(host='127.0.0.1', port=8080)
1可以将多个路由绑定到一个回调函数上。
2您可以添加通配符到URL并通过关键字参数访问它们。
动态路由
url里面有通配符的叫做动态路由，匹配一个或者多个url 在同样时间里。
A simple wildcard consists of a name enclosed in angle brackets (e.g. <name>) and accepts one or more characters up to the next slash (/).
For example, the route /hello/<name> accepts requests for /hello/alice as well as /hello/bob, but not for /hello, /hello/ or /hello/mr/smith.
每一个通配符都会将URL包含到那部分作为关键字参数传给请求的回调函数。
HTTP 请求方法
使用route()装饰器的method关键字参数或者是用5种装饰器 get() post() put() delete() or patch()
from bottle import route, run, template,get,post,request
@get('/login')
def login():
return '''
<form action="/login" method="post">
Username: <input name="username" type="text" />
Password: <input name="password" type="password" />
<input value="Login" type="submit" />
</form>
'''
@post('/login')
def do_login():
username = request.forms.get('username')
password = request.forms.get('password')
if username == 'yuyang' and password == '123':
return "<p>Your login information was correct.</p>"
else:
return "<p>Login failed.</p>"
run(host='127.0.0.1', port=8080)
reponse object
Response 的元数据比如状态吗，响应头，cookie 都存储在response 对象里。
Status Code
默认200 ok ,通常不需要手动设置
Response Header
Response headers such as Cache-Control or Location are defined via Response.set_header(). This method takes two parameters, a header name and a value. The name part is case-insensitive:
响应头。比如Cache-Control or Location 通过Response.set_header() 定义。这个方法需要两个参数，一个是头名字，一个是值，名称部分不区分大小写。
大部分的头是独一无二的。意味着只有一个标头会被发给客户端，有些特别的头允许在相应出现不止一次，为了添加额外的标头，使用Response.add_header() 去代替Response.set_header()
response.set_header('Set-Cookie', 'name=value') response.add_header('Set-Cookie', 'name2=value2')
这只是个例子，如果想使用cookie. 往下看。
Cookies
访问之前定义的cookie 可以通过 Request.get_cookie()，设置新的cookies 用Response.set_cookie()
@route('/hello') def hello_again(): if request.get_cookie("visited"): return "Welcome back! Nice to see you again" else: response.set_cookie("visited", "yes") return "Hello there! Nice to meet you"
Response.set_cookie()还接受一系列的关键字参数
- max_age: Maximum age in seconds. (default:
None) 存在时间 - expires: A datetime object or UNIX timestamp. (default:
None) 到期时间，datetime 对象或者unix timestamp - domain: The domain that is allowed to read the cookie. (default: current domain)
- path: Limit the cookie to a given path (default:
/) 限制cookie 取得路径 - secure: Limit the cookie to HTTPS connections (default: off).
- httponly: Prevent client-side javascript to read this cookie (default: off, requires Python 2.7 or newer).
- same_site: Disables third-party use for a cookie. Allowed attributes: lax and strict.
- In strict mode the cookie will never be sent. In lax mode the cookie is only sent with a top-level GET request.
使用cookie 注意的几点
- cookie 被限制在4KB以内。
- 有时候用户会选择将cookie 服务关掉，确保你的应用在没哟cookie情况下仍然能够使用
- cookie 被存储在客户端，并且没有被加密，用户能够读取它。更糟糕的是，攻击者可能偷掉用户的cookies,通过xss 攻击，
- 一些病i毒也知道读取浏览器的cookie,,因此永远不要吧机密信息放在cookie中。
- cookie很容易被篡改。不要信任cookie
signed cookie
cookies 可以轻易的被恶意的客户端篡改。Bottle能够通过加密技术签名你的cookie,来防止被篡改。
你所需要做的是提供一个key 用过secret 关键字参数传进去。无论什么时候去读或者设置cookie 保持这个key 是秘密的。如果cookie 没有签名或者不匹配，Resuqst.get_cookie将返回None
REQUEST DATA
request object 是 BaseRequest 的子类。有丰富的借口去访问数据。
FormDic
使用一种特别的字典类型去存储data 和cookies ,FormDict 的行为像是一个正常的字典，但是额外的特色让你生活更简单，轻松。
属性访问
多值一个key getall()
FormsDict is a subclass of MultiDict and can store more than one value per key.
The standard dictionary access methods will only return a single value, but the getall() method returns a (possibly empty) list of all values for a specific key:
cookies
所有被客户端发来的cookies 通过BaseRequest.cookies（a FormDcit）都是可用的
from bottle import route, request, response @route('/counter') def counter(): count = int( request.cookies.get('counter', '0') ) count += 1 response.set_cookie('counter', str(count)) return 'You visited this page %d times' % count
.get_cookie() 可以解密签名的cookies
HTTP HEADERS
所有从客户端发的HTTP headers 都被存放在 WSGIHeaderDcit 里，并能通过BaseRequest.headers 属性访问到，WSGIHeaderDcit 是基于key 大小写不敏感的字典。
from bottle import route, request @route('/is_ajax') def is_ajax(): if request.headers.get('X-Requested-With') == 'XMLHttpRequest': return 'This is an AJAX request' else: return 'This is a normal request'
Query Variables
通过BaseRequest.query属性(FormDict)
BaseRequest.query_string 是获得整个字符串。
POST FORM 表单
post data 存放在 BaseRequest.forms
JSON Content
BaseRequest.json 包含解析后的数据结构。
源码分析：
从request 入手
bootle 框架，只有一个bottle.py 文件，
若不指明，以下所有代码都是bottl.py 文件里的
bottle.py
request = LocalRequest()
class LocalRequest(BaseRequest): ''' A thread-local subclass of :class:`BaseRequest` with a different set of attributes for each thread. There is usually only one global instance of this class (:data:`request`). If accessed during a request/response cycle, this instance always refers to the *current* request (even on a multithreaded server). ''' bind = BaseRequest.__init__ environ = local_property()
def local_property(name=None): if name: depr('local_property() is deprecated and will be removed.') #0.12 ls = threading.local() def fget(self): try: return ls.var except AttributeError: raise RuntimeError("Request context not initialized.") def fset(self, value): ls.var = value def fdel(self): del ls.var return property(fget, fset, fdel, 'Thread-local property')
在local_prperty() 函数中，定义了三个子函数，并用到了property修饰，使得ls 可以获取值，设置值。删除值，
比如request.environ #获取
request.environ= 'asdasds' #设置
del request.environ #删除
自己测试
dic={} 没用
' >>> class Foo(): dic={} def __init__(self,na): self._name = na def fget(self): return self._name def fset(self,value): self._name = value return value def fdel(self): del self._name name = property(fget,fset,fdel) >>> f1=Foo() Traceback (most recent call last): File "<pyshell#15>", line 1, in <module> f1=Foo() TypeError: __init__() missing 1 required positional argument: 'na' >>> f1=Foo('yuyang') >>> f1.name 'yuyang' >>> f1.name = 'alex' >>> f1.name 'alex' >>> del f1.name >>> f1.name Traceback (most recent call last): File "<pyshell#21>", line 1, in <module> f1.name File "<pyshell#14>", line 6, in fget return self._name AttributeError: 'Foo' object has no attribute '_name' >>> class Foo(): dic={} def __init__(self,na): self._name = na def fget(self): return self._name def fset(self,value): self._name = value return value name = property(fget,fset) >>> f1=Foo('yuyang') >>> f1.name 'yuyang' >>> f1.name ='da SyntaxError: EOL while scanning string literal >>> f1.name ='da' >>> del f1.name Traceback (most recent call last): File "<pyshell#28>", line 1, in <module> del f1.name AttributeError: can't delete attribute >>>
property([fget[, fset[, fdel[, doc]]]])
Return a property attribute for new-style classes (classes that derive from object).
fget is a function for getting an attribute value, likewise fset is a function for setting, and fdel a function for del’ing, an attribute. Typical use is to define a managed attribute x:
https://docs.python.org/release/2.6/library/functions.html#property
environ = property(fget, fset, fdel, 'Thread-local property') #用到了闭包函数。
ls = threading.local()
Thread-local data is data whose values are thread specific. To manage thread-local data, just create an instance of local (or a subclass) and store attributes on it:
mydata = threading.local()
mydata.x = 1
The instance’s values will be different for separate threads.
- class
threading.local -
A class that represents thread-local data.
For more details and extensive examples, see the documentation string of the
_threading_localmodule.
View Codeimport time import threading from threading import Thread def func(i): mydata.x=i print('xiancheng %s mydata.x is %s' %(i,mydata.x)) mydata = threading.local() mydata.x = 'zhuxiancheng' ls = [] for i in range(2): t = Thread(target=func,args=(i,)) ls.append(t) t.start() for i in ls: i.join() print(mydata.x) print('end')
从上面的代码可以看出threading.local() 在不同的线程的值是不一样的。
总的来说 bottle框架只有一个py文件 当import bottle 时
做了以下几件事
request = LocalRequest() #: A thread-safe instance of :class:`LocalResponse`. It is used to change the #: HTTP response for the *current* request. response = LocalResponse() #: A thread-safe namespace. Not used by Bottle. local = threading.local() # Initialize app stack (create first empty Bottle app) # BC: 0.6.4 and needed for run() app = default_app = AppStack() app.push()
实例化一个request对象，response对象，执行，app = default_app = AppStack() 返回app=AppStack 实例对象 app.push() 会在列表里添加一个bottle 实例对象。
class AppStack(list): """ A stack-like list. Calling it returns the head of the stack. """ def __call__(self): """ Return the current default application. """ return self[-1] def push(self, value=None): """ Add a new :class:`Bottle` instance to the stack """ if not isinstance(value, Bottle): value = Bottle() self.append(value) return value
AppStack 类继承Python列表
local = threading.local()
这是一个线程安全的名称空间
第二部分 route
first_bottle.py
@route('/hello') def hello(): if request.get_cookie('account'): return 'welcome back! nice to see you again!' else: return 'you are not logged in ,access denied!'
源码：
route = make_default_app_wrapper('route') def make_default_app_wrapper(name): ''' Return a callable that relays calls to the current default app. ''' @functools.wraps(getattr(Bottle, name)) def wrapper(*a, **ka): return getattr(app(), name)(*a, **ka) return wrapper
@route('/hello') 是一个有参装饰器。
关于有参装饰器
@route('/hello')
def login():
pass
实际会执行以下的代码：
tmp = route('/hello') #第一步 def login(): #第二步 pass login = tmp(login) #第三步
当然在import bottle.py 时，就执行了这句代码：
route = make_default_app_wrapper('route')
所以这时候route 实际是 wrapper 函数。
执行步骤应该是：
tmp = wrapper('/hello')
tmp = getattr(app(), name)(*a, **ka)
app 之前分析是由AppStack类实例出的对象，app() 会调用__call__() 方法，返回self[-1] 实际就是bottle 实例对象。
我们知道name= 'route'
从bottle对象去反射，找route方法，并调用
让我们看下Bottle 类下的route 方法做了什么
def route(self, path=None, method='GET', callback=None, name=None, apply=None, skip=None, **config): """ A decorator to bind a function to a request URL. Example:: @app.route('/hello/:name') def hello(name): return 'Hello %s' % name The ``:name`` part is a wildcard. See :class:`Router` for syntax details. :param path: Request path or a list of paths to listen to. If no path is specified, it is automatically generated from the signature of the function. :param method: HTTP method (`GET`, `POST`, `PUT`, ...) or a list of methods to listen to. (default: `GET`) :param callback: An optional shortcut to avoid the decorator syntax. ``route(..., callback=func)`` equals ``route(...)(func)`` :param name: The name for this route. (default: None) :param apply: A decorator or plugin or a list of plugins. These are applied to the route callback in addition to installed plugins. :param skip: A list of plugins, plugin classes or names. Matching plugins are not installed to this route. ``True`` skips all. Any additional keyword arguments are stored as route-specific configuration and passed to plugins (see :meth:`Plugin.apply`). """ if callable(path): path, callback = None, path plugins = makelist(apply) skiplist = makelist(skip) def decorator(callback): # TODO: Documentation and tests if isinstance(callback, basestring): callback = load(callback) for rule in makelist(path) or yieldroutes(callback): for verb in makelist(method): verb = verb.upper() route = Route(self, rule, verb, callback, name=name, plugins=plugins, skiplist=skiplist, **config) self.add_route(route) return callback return decorator(callback) if callback else decorator
分析这段代码，不难得知，我们将'/hello'传进去，path = '/hello'
先判断path 是不是可调用对象，比如函数，实例等，如果是的话，callback 和path 的值互换。
makelist() 是吧一个对象放在列表中
def makelist(data): # This is just to handy if isinstance(data, (tuple, list, set, dict)): return list(data) elif data: return [data] else: return []
这个方法其实也是一个装饰器。
所以回到最初
getattr(app(), name)(*a, **ka) 这段代码执行结果会得到decorator(callback) if callback else decorator
这次我们并没有传递callback 进去，所以会得到decorator
所以tmp = decorator
至此有参装饰器执行完第一步，
第二步是定义login 函数
第三步
login = decorator(login)
def decorator(callback): # TODO: Documentation and tests if isinstance(callback, basestring): callback = load(callback) for rule in makelist(path) or yieldroutes(callback): for verb in makelist(method): verb = verb.upper() route = Route(self, rule, verb, callback, name=name, plugins=plugins, skiplist=skiplist, **config) self.add_route(route) return callback
callback参数对应是login 函数
basestring = str #bottle.py 提前定义的
所以这段代码执行完，会实例化一个route 对象，并吧route 对象添加到bottle 对象里。返回callback 函数，所以得出被route装饰后的login 实际还是原来的login 函数。
def add_route(self, route): ''' Add a route object, but do not change the :data:`Route.app` attribute.''' self.routes.append(route) self.router.add(route.rule, route.method, route, name=route.name)
class Bottle
self.routes = [] # List of installed :class:`Route` instances. self.router = Router() # Maps requests to :class:`Route` instances.
有点复杂，先略过
执行路由大致分析完了
现在让我们分析最后让服务器启动的代码
first_bottle.py
run(host='127.0.0.1', port=8080,reloader=True)
def run(app=None, server='wsgiref', host='127.0.0.1', port=8080, interval=1, reloader=False, quiet=False, plugins=None, debug=None, **kargs): """ Start a server instance. This method blocks until the server terminates. :param app: WSGI application or target string supported by :func:`load_app`. (default: :func:`default_app`) :param server: Server adapter to use. See :data:`server_names` keys for valid names or pass a :class:`ServerAdapter` subclass. (default: `wsgiref`) :param host: Server address to bind to. Pass ``0.0.0.0`` to listens on all interfaces including the external one. (default: 127.0.0.1) :param port: Server port to bind to. Values below 1024 require root privileges. (default: 8080) :param reloader: Start auto-reloading server? (default: False) :param interval: Auto-reloader interval in seconds (default: 1) :param quiet: Suppress output to stdout and stderr? (default: False) :param options: Options passed to the server adapter.
reloader 参数表示是不是重新加载，默认是false ,interval 表示隔多长时间加载一次，默认是一秒。
quiet 表示是不是废止输出错误信息等。默认是输出错误信息等。如果是True.不会再终端打印某些错误信息等。
if reloader and not os.environ.get('BOTTLE_CHILD'): try: lockfile = None fd, lockfile = tempfile.mkstemp(prefix='bottle.', suffix='.lock') os.close(fd) # We only need this file to exist. We never write to it while os.path.exists(lockfile): args = [sys.executable] + sys.argv environ = os.environ.copy() environ['BOTTLE_CHILD'] = 'true' environ['BOTTLE_LOCKFILE'] = lockfile p = subprocess.Popen(args, env=environ) while p.poll() is None: # Busy wait... os.utime(lockfile, None) # I am alive! time.sleep(interval) if p.poll() != 3: if os.path.exists(lockfile): os.unlink(lockfile) sys.exit(p.poll()) except KeyboardInterrupt: pass finally: if os.path.exists(lockfile): os.unlink(lockfile) return
上面这段是当你设置参数重新加载为True 执行的代码，暂不分析这段代码，
以下应该是run 函数的核心代码。
try: if debug is not None: _debug(debug) app = app or default_app() if isinstance(app, basestring): app = load_app(app) if not callable(app): raise ValueError("Application is not callable: %r" % app) for plugin in plugins or []: app.install(plugin) if server in server_names: server = server_names.get(server) if isinstance(server, basestring): server = load(server) if isinstance(server, type): server = server(host=host, port=port, **kargs) if not isinstance(server, ServerAdapter): raise ValueError("Unknown or unsupported server: %r" % server) server.quiet = server.quiet or quiet if not server.quiet: _stderr("Bottle v%s server starting up (using %s)...\n" % (__version__, repr(server))) _stderr("Listening on http://%s:%d/\n" % (server.host, server.port)) _stderr("Hit Ctrl-C to quit.\n\n") if reloader: lockfile = os.environ.get('BOTTLE_LOCKFILE') bgcheck = FileCheckerThread(lockfile, interval) with bgcheck: server.run(app) if bgcheck.status == 'reload': sys.exit(3) else: server.run(app) except KeyboardInterrupt: pass except (SystemExit, MemoryError): raise except: if not reloader: raise if not getattr(server, 'quiet', quiet): print_exc() time.sleep(interval) sys.exit(3)
debug 默认是None, 下面这句并不执行。当debug is None
if debug is not None: _debug(debug)
app = app or default_app() if isinstance(app, basestring): app = load_app(app) if not callable(app): raise ValueError("Application is not callable: %r" % app)
app 由之前分析，是个AppStack 实例对象，app 有__call__方法，所以是可调用对象
测试：
>>> class Foo: pass >>> isinstance(Foo,type) True >>> callable(Foo) True >>> f1 = Foo() >>> callable(f1) False >>> class Foo: def __call__(self): pass >>> f1 = Foo() >>> callable(f1) True
只要一个对象有__call__ 属性就是可调用对象
if server in server_names: server = server_names.get(server) if isinstance(server, basestring): server = load(server) if isinstance(server, type): server = server(host=host, port=port, **kargs) if not isinstance(server, ServerAdapter): raise ValueError("Unknown or unsupported server: %r" % server)
server = 'wsgiref'
server_names = { 'cgi': CGIServer, 'flup': FlupFCGIServer, 'wsgiref': WSGIRefServer, 'waitress': WaitressServer, 'cherrypy': CherryPyServer, 'paste': PasteServer, 'fapws3': FapwsServer, 'tornado': TornadoServer, 'gae': AppEngineServer, 'twisted': TwistedServer, 'diesel': DieselServer, 'meinheld': MeinheldServer, 'gunicorn': GunicornServer, 'eventlet': EventletServer, 'gevent': GeventServer, 'geventSocketIO':GeventSocketIOServer, 'rocket': RocketServer, 'bjoern' : BjoernServer, 'auto': AutoServer, }
server_names 是个字典，key 是server 字符串，value 是对应的类。
至此，server = WSGIRefServer
执行下面代码：
if isinstance(server, type):
server = server(host=host, port=port, **kargs)
server 是一个WSGIRefServer 实例化的对象。
ServerAdapter 类是一个抽象类，所有服务器的类都继承这个类。
到了关键的服务器启动的一步
server.run(app)
server.run(app)
server.run(app)
来看WSGIRefServe 类
class WSGIRefServer(ServerAdapter): def run(self, app): # pragma: no cover from wsgiref.simple_server import WSGIRequestHandler, WSGIServer from wsgiref.simple_server import make_server import socket class FixedHandler(WSGIRequestHandler): def address_string(self): # Prevent reverse DNS lookups please. return self.client_address[0] def log_request(*args, **kw): if not self.quiet: return WSGIRequestHandler.log_request(*args, **kw) handler_cls = self.options.get('handler_class', FixedHandler) server_cls = self.options.get('server_class', WSGIServer) if ':' in self.host: # Fix wsgiref for IPv6 addresses. if getattr(server_cls, 'address_family') == socket.AF_INET: class server_cls(server_cls): address_family = socket.AF_INET6 srv = make_server(self.host, self.port, app, server_cls, handler_cls) srv.serve_forever()
ServerAdapter类，初始化，run方法又子类重写。
class ServerAdapter(object): quiet = False def __init__(self, host='127.0.0.1', port=8080, **options): self.options = options self.host = host self.port = int(port) def run(self, handler): # pragma: no cover pass
看到这里，我想我要去研究WSGIREF 模块的源码去了。。。。。。。
server.run(app)主要看红色部分的代码，调用了wsgiref 模块
调用wsgiref的make_server 实例了一个srv对象,srv调用serve_forever() 方法
simple_server.py
def make_server( host, port, app, server_class=WSGIServer, handler_class=WSGIRequestHandler ): """Create a new WSGI server listening on `host` and `port` for `app`""" server = server_class((host, port), handler_class) server.set_app(app) return server
实例了WSGIServer对象
WSGIServer 继承自HTTPServer ，
class WSGIServer(HTTPServer): """BaseHTTPServer that implements the Python WSGI protocol""" application = None def server_bind(self):
HTTPServer ，继承自socketserver.TCPServer
class HTTPServer(socketserver.TCPServer): allow_reuse_address = 1 # Seems to make sense in testing environment def server_bind(self): """Override server_bind to store the server name.""" socketserver.TCPServer.server_bind(self) host, port = self.server_address[:2] self.server_name = socket.getfqdn(host) self.server_port = port
TCPServer继承自BaseServer、
创建一个socket对象
然后执行server_bind()方法和server_active()方法
server_bind()绑定ip端口，设置基本环境变量
class TCPServer(BaseServer): address_family = socket.AF_INET socket_type = socket.SOCK_STREAM request_queue_size = 5 allow_reuse_address = False def __init__(self, server_address, RequestHandlerClass, bind_and_activate=True): """Constructor. May be extended, do not override.""" BaseServer.__init__(self, server_address, RequestHandlerClass) self.socket = socket.socket(self.address_family, self.socket_type) if bind_and_activate: try: self.server_bind() self.server_activate() except: self.server_close() raise
cket.getsockname()
TCPServer
绑定
TCPServer 类下的
def server_bind(self): """Called by constructor to bind the socket. May be overridden. """ if self.allow_reuse_address: self.socket.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1) self.socket.bind(self.server_address) self.server_address = self.socket.getsockname()
监听
def server_activate(self): """Called by constructor to activate the server. May be overridden. """ self.socket.listen(self.request_queue_size)
至此实例化结束，执行srv.serve_forever() 这个函数是处理请求，直到关机。使用轮询，用到了selector 模块，
def serve_forever(self, poll_interval=0.5): """Handle one request at a time until shutdown. Polls for shutdown every poll_interval seconds. Ignores self.timeout. If you need to do periodic tasks, do them in another thread. """ self.__is_shut_down.clear() try: # XXX: Consider using another file descriptor or connecting to the # socket to wake this up instead of polling. Polling reduces our # responsiveness to a shutdown request and wastes cpu at all other # times. with _ServerSelector() as selector: selector.register(self, selectors.EVENT_READ) while not self.__shutdown_request: ready = selector.select(poll_interval) if ready: self._handle_request_noblock() self.service_actions() finally: self.__shutdown_request = False self.__is_shut_down.set()
note :这里的self.__is_shut_down 是一个event 对象，
self.__is_shut_down = threading.Event()
self.__shutdown_request = False
srv.serve_foreverT放到 适当放松的()
