2013-11-14
技术源代码阅读

web.py 项目之 skeleton

skeleton 是 web.py 官网上给出的一个最简单的项目结构示例。

目录树

.
└── src  
    ├── code.py  
    ├── config.py  
    ├── db.py  
    ├── sql
    │   └── tables.sql
    ├── templates
    │   ├── base.html
    │   ├── item.html
    │   └── listing.html
    └── view.py

3 directories, 9 files

结构分析

控制模块

#code.py

import web
import view, config
from view import render

urls = (
    '/', 'index'
)

class index:
    def GET(self):
        return render.base(view.listing())

if __name__ == "__main__":
    app = web.application(urls, globals())
    app.internalerror = web.debugerror
    app.run()

code 模块作为入口:

app 的创建与启动
url　与　处理类的映射与处理入口

但是，具体的处理并不在这里实现。而是放在了 view 模块中。

这一模块是MVC中的C吗？

显示模块

#view.py

import web
import db
import config

t_globals = dict(
  datestr=web.datestr,
)
render = web.template.render('templates/', cache=config.cache, 
    globals=t_globals)
render._keywords['globals']['render'] = render

def listing(\**k):
    l = db.listing(\**k)
    return render.listing(l)

从这里可以看出　view 模块

与模板关联
从数据库中取数据，然后发给模板

我们再来看看模板:

<!--
    templates/base.html
-->

$def with (page, title=None)
<html><head>
<title>my site\
$if title: : $title\
</title>
</head><body>
<h1><a href="/">my site</a></h1>
$:page   
</body></html>

base.html 是所有模块的公共部分，每个模块只需要提供它的 page ，即内容就可以了。

<!--
    templates/listing.html
-->

$def with (items)

$for item in items:
    $:render.item(item)

这一模块是MVC中的V吗

数据操作

数据库操作分三部分

sql/tables.sql 数据库表定义
config.py 数据库连接
db.py 数据库操作

/* tables.sql */
CREATE TABLE items (
    id serial primary key,
    author_id int references users,
    body text,
    created timestamp default current_timestamp 
);

#config.py

import web
DB = web.database(dbn='mysql', db='skeleton', user='root', pw='xx')
cache = False

# db.py
import config

def listing(\**k):
    return config.DB.select('items', **k)

这是MVC中的M吗

这是 web.py 中最基本的一个项目结构。应该是使用的MVC设计模式。但是因为程序本身不大，还体会不到 MVC 的好处。

分模块测试

application.py

对 application.py 的测试，调用命令：

python test/application.py

test_reloader(self)

def test_reloader(self):
    write('foo.py', data % dict(classname='a', output='a'))
    import foo
    app = foo.app
    
    self.assertEquals(app.request('/').data, 'a')
    
    # test class change
    time.sleep(1)
    write('foo.py', data % dict(classname='a', output='b'))
    self.assertEquals(app.request('/').data, 'b')

    # test urls change
    time.sleep(1)
    write('foo.py', data % dict(classname='c', output='c'))
    self.assertEquals(app.request('/').data, 'c')

总的来说，这个过程会生成一个 foo.py 文件

import web

urls = ("/", "a")
app = web.application(urls, globals(), autoreload=True)

class a:
    def GET(self):
        return "a"

这是一个典型的 web 服务端应用程序，表示对 / 发起 GET 请求时，会调用 class a 中的 GET 函数，测试就是看看 web.application 是否可以正常完成任务，即是否可以正确返回”a”

下面详细看代码。

首先使用 write 生成了一个 foo.py 程序:

        write('foo.py', data % dict(classname='a', output='a'))

write 源代码:

def write(filename, data):
    f = open(filename, 'w')
    f.write(data)
    f.close()

data 定义:

data = """
import web

urls = ("/", "%(classname)s")
app = web.application(urls, globals(), autoreload=True)

class %(classname)s:
    def GET(self):
        return "%(output)s"

"""

data 相当于一个小型 web 程序的模板，类名和返回值由一个 dict 指定，生成一个字符串，由 write 生成文件。

下面是类别和返回值为 a 时的 foo.py

import web

urls = ("/", "a")
app = web.application(urls, globals(), autoreload=True)

class a:
    def GET(self):
        return "a"

测试的方式采用 TestCase 中的 assertEquals 函数，比较实际值与预测值。

import foo
app = foo.app
self.assertEquals(app.request('/').data, 'a')

app.request('/') 会得到一个Storage类型的值：

<Storage {'status': '200 OK', 'headers': {}, 'header_items': [], 'data': 'a'}>

其中的 data 就是 foo.py 中 GET 返回的值。

我对这个 app.request('/') 是比较困惑的。以 foo.py 为例，之前写程序时，一般是有一个这样的程序：

import web

urls = ("/", "a")
app = web.application(urls, globals(), autoreload=True)

class a:
    def GET(self):
        return "a"

if __name__ == "__main__":
    app.run()

然后在浏览器中请求 0.0.0.0:8080/ 。而在 request 之前，也没看到 run 啊，怎么就能 request 回数据呢，而且通过上述代码运行后，程序会一直运行直到手动关闭，而 request 的方式则是测试完后，整个程序也结束了。

所以，下一部，想比较一下 application.run 和 application.request 的不同。

我们只看关键部分，即返回的值是如何被设值的。

在 web.application.request 中:

def request(self, localpart='/', method='GET', data=None,
            host="0.0.0.0:8080", headers=None, https=False, **kw):

    ...

response = web.storage()
def start_response(status, headers):
    response.status = status
    response.headers = dict(headers)
    response.header_items = headers
response.data = "".join(self.wsgifunc()(env, start_response))
return response

上述代码中 self.wsgifunc()(env, start_response) 比较另人困惑，我还以为是调用函数的新方式呢，然后看了一下 wsgifunc 的代码，它会返回一个函数wsgi，wsgi以 (env, start_response) 为参数。在 wsgi 内部，又会调用 handle_with_processors, handle_with_processors 会再调用 handle

    def handle(self):
        fn, args = self._match(self.mapping, web.ctx.path)
        return self._delegate(fn, self.fvars, args)

测试了一下，self._match() 会得到类名, self._delegate 会得到返回的字符串，即 GET的返回值。

进入 self._delegate, 会最终调用一个关键函数 handle_class:

def handle_class(cls):
    meth = web.ctx.method
    if meth == 'HEAD' and not hasattr(cls, meth):
        meth = 'GET'
    if not hasattr(cls, meth):
        raise web.nomethod(cls)
    tocall = getattr(cls(), meth)
    return tocall(\*args)

参数cls值为foo.a, meth 会得到方法名 GET, 然后 tocall 会得到函数 a.GET, 至此，我们终于得以调用， GET函数，得到了返回的字符串。

从整个过程可以看出，没有启动服务器的代码，只是不断地调用函数，最终来到 GET 函数。

*坤的

web.py 项目之 skeleton

目录树

结构分析

控制模块

显示模块

数据操作

分模块测试

application.py

test_reloader(self)

分模块测试

application.py

分模块测试

application.py

分模块测试

application.py

目录文件说明

README

alltest.py

webtest.py

web.test

Python包管理不同方式的区别

distutils

为什么我们需要数据结构

字符指针与字符数组真正的区别

问题缘起

示例1

示例2

为什么使用 Markdown