Python进阶：Tornado框架入门指南

需积分: 10 40 浏览量更新于2024-07-23 收藏 11.56MB PDF 举报

"Introduction to Tornado" 是一本关于Python Web框架Tornado的入门指南，由Michael Dory、Adam Parrish和Brendan Berg合著。这本书旨在帮助已经掌握Python的开发者进一步学习和理解Tornado框架。 Tornado是Python编程语言中的一个异步网络库，它最初由FriendFeed开发并开源，后来被Facebook收购。Tornado以其高并发处理能力而闻名，尤其适合实时Web服务，如长轮询、WebSockets和HTTP流。这个框架是用纯Python编写的，兼容Python 2和3，使得代码更易于理解和维护。在介绍Tornado时，首先会讲解Web开发的基础概念，包括HTTP协议和Web服务器的工作原理。然后，会详细介绍Tornado的核心组件，如HTTP服务器、请求处理器（Request Handler）、模板系统以及异步I/O模型。其中，异步I/O模型是Tornado区别于其他Web框架的关键特性，它允许开发者编写非阻塞的代码，从而提高服务器的性能和响应速度。书中可能会涵盖以下知识点： 1. **安装与设置**：如何安装Tornado库，以及如何配置基础的Web应用环境。 2. **路由系统**：Tornado的URL路由机制，如何将URL映射到对应的处理函数。 3. **请求处理器(Request Handlers)**：定义和实现Request Handler，处理HTTP请求和响应。 4. **模板系统**：学习如何使用Tornado的模板语言来动态生成HTML页面。 5. **异步编程**：理解Tornado的异步I/O模型，包括使用`@gen.coroutine`装饰器和`yield`关键字进行协程编程。 6. **WebSockets**：Tornado对WebSocket协议的支持，用于创建双向通信的实时应用。 7. **长轮询(Long Polling)**：在没有WebSocket的情况下，如何利用Tornado实现长轮询以实现类似实时的效果。 8. **Session管理**：如何在Tornado应用中处理用户会话和状态保持。 9. **错误处理**：处理HTTP错误和应用程序异常的方法。 10. **集成其他库和服务**：如何将Tornado与其他Python库（如数据库访问库）或外部服务（如OAuth认证）集成。 11. **性能优化**：讨论如何通过各种手段优化Tornado应用的性能，如使用异步操作、缓存策略等。 12. **部署与测试**：介绍如何将Tornado应用部署到生产环境，以及进行单元测试和集成测试的方法。通过学习这本书，读者将能够熟练地运用Tornado框架构建高性能、实时的Web应用，并且对Python的Web开发有更深入的理解。此外，作者团队的丰富经验将帮助读者避免常见的陷阱和误区，提升开发效率。

Simple Web Services

Now that we’ve covered what Tornado is, let’s look at what it can do. To start, we’ll

go over the basics of writing a simple web service with Tornado.

Hello Tornado

Tornado is a framework for writing responses to HTTP requests. Your job as a pro-

grammer is to write “handlers” that respond to HTTP requests that match particular

criteria. Here’s a basic example of a fully functional Tornado application:

Example 1-1. The basics: hello.py

import tornado.httpserver

import tornado.ioloop

import tornado.options

import tornado.web

from tornado.options import define, options

define("port", default=8000, help="run on the given port", type=int)

class IndexHandler(tornado.web.RequestHandler):

def get(self):

greeting = self.get_argument('greeting', 'Hello')

self.write(greeting + ', friendly user!')

if __name__ == "__main__":

tornado.options.parse_command_line()

app = tornado.web.Application(handlers=[(r"/", IndexHandler)])

http_server = tornado.httpserver.HTTPServer(app)

http_server.listen(options.port)

tornado.ioloop.IOLoop.instance().start()

Most of the work in making a Tornado application is to define classes that extend the

Tornado RequestHandler class. In this case, we’ve made a simple application that listens

for requests on a given port, and responds to requests to the root resource ("/").

Try running the program yourself on the command line to test it out:

$ python hello.py --port=8000

Now you can go to http://localhost:8000/ in a web browser, or open up a separate

terminal window to test out the application with curl:

$ curl http://localhost:8000/

Hello, friendly user!

$ curl http://localhost:8000/?greeting=Salutations

Salutations, friendly user!

Let’s break this example down into smaller chunks and analyze them one by one:

import tornado.httpserver

import tornado.ioloop

4 | Chapter 1: Introduction

import tornado.options

import tornado.web

At the top of the program, we import various Tornado libraries. There are other helpful

libraries included with Tornado, but you’ll need to import at least these four to get this

example running:

from tornado.options import define, options

define("port", default=8000, help="run on the given port", type=int)

Tornado includes a helpful library (tornado.options) for reading options from the

command line. We make use of that library here to let us specify which port our ap-

plication will listen on for HTTP requests. Here’s how it works: any option in a

define statement will become available as an attribute of the global options object, if

an option with the same name is given on the command line. If the user runs the pro-

gram with the --help parameter, the program will print out all of the options you’ve

defined, along with the text you specified with the help parameter in the call to

define. If the user fails to provide a value for an option we specified, the default value

for that option will be used instead. Tornado uses the type parameter to do basic type

checking on the parameter, throwing an error if a value of an inappropriate type is

given. Our line, therefore, allows the user to use an integer port argument, which we

can access in the body of the program as options.port. If the user doesn’t specify a

value, it defaults to 8000.

class IndexHandler(tornado.web.RequestHandler):

def get(self):

greeting = self.get_argument('greeting', 'Hello')

self.write(greeting + ', friendly user!')

This is a Tornado request handler class. When handling a request, Tornado instantiates

this class and calls the method corresponding to the HTTP method of the request. In

this example, we’ve defined only a get method, meaning that this handler will respond

only to HTTP GET requests. We’ll look at handlers that implement more than one HTTP

method later.

greeting = self.get_argument('greeting', 'Hello')

Tornado’s RequestHandler class has a number of useful built-in methods, including

get_argument, which we use here to get an argument greeting from the query string.

(If no such argument is present in the query string, Tornado will use the second argu-

ment provided to get_argument, if any, as a default.)

self.write(greeting + ', friendly user!')

Another method of the RequestHandler class is write, which takes a string as a parameter

and writes that string into the HTTP response. Here, we take the string supplied in the

request’s greeting parameter, interpolate it into a greeting, and write it back in the

response.

if __name__ == "__main__":

tornado.options.parse_command_line()

app = tornado.web.Application(handlers=[(r"/", IndexHandler)])

Simple Web Services | 5

These are the lines that actually make the Tornado application run. First, we use

Tornado’s options library to parse the command line. Then we create an instance of

Tornado’s Application class. The most important argument to pass to the __init__

method of the Application class is handlers. This tells Tornado which classes to use to

handle which requests. More on this in a moment.

http_server = tornado.httpserver.HTTPServer(app)

http_server.listen(options.port)

tornado.ioloop.IOLoop.instance().start()

From here on out, this code is boilerplate: once it has been created, we can pass the

Application object to Tornado’s HTTPServer object, which then listens to the port we

specified on the command line (retrieved through the options object). Finally, we create

an instance of Tornado’s IOLoop, after which point the program is ready to accept HTTP

requests.

The handlers Parameter

Let’s take a look at one line from the hello.py example again:

app = tornado.web.Application(handlers=[(r"/", IndexHandler)])

The handlers parameter here is important, and worth looking at in further detail. It

should be a list of tuples, with each tuple containing a regular expression to match as

its first member and a RequestHandler class as its second member. In hello.py, we

specified only one regular expression RequestHandler pair, but you can put as many of

these pairs into the list as needed.

Specifying paths with regular expressions

Tornado uses the regular expression in the tuples to match the path of the HTTP re-

quest. (The path is the portion of the URL that follows the hostname, excluding the

query string and fragment.) Tornado treats these regular expressions as though they

contain beginning-of-line and end-of-line anchors (i.e., the string "/" is assumed to

mean "^/$").

When a regular expression has a capture group in it (i.e., a portion of the regular ex-

pression is enclosed in parentheses), the matching contents of that group will be passed

to the RequestHandler object as parameters to the method corresponding to the HTTP

request. We’ll see how this works in the next example.

6 | Chapter 1: Introduction

Second, POST requests to the /wrap resource will take text specified in an argument

text and return that text, wrapped to the width specified in an argument named

width. The following request specifies a string but no width, so the output is wrapped

to the default width specified in the program’s get_argument call, 40 characters:

$ curl http://localhost:8000/wrap »

-d text=Lorem+ipsum+dolor+sit+amet,+consectetuer+adipiscing+elit.

Lorem ipsum dolor sit amet, consectetuer

adipiscing elit.

The cURL command just shown was broken onto two lines for format-

ting reasons, but should be typed as a single line. As a convention, we

will use the right double quote character (») to indicate a line

continuation.

The string service example shares most of its code with the example presented in the

previous section. Let’s zero in on some parts of the code that are new. First, let’s look

at the value passed in the handlers parameter to the Application constructor:

app = tornado.web.Application(handlers=[

(r"/reverse/(\w+)", ReverseHandler),

(r"/wrap", WrapHandler)

])

In the previous code, the Application class is instantiated with two RequestHandlers in

the “handlers” parameter. The first directs Tornado to send requests whose path

matches the following regular expression:

/reverse/(\w+)

This regular expression tells Tornado to match any path beginning with the

string /reverse/ followed by one or more alphanumeric characters. The parentheses

tell Tornado to save the string that matched inside the parentheses, and pass that string

to the RequestHandler’s request method as a parameter. Check out the definition of

ReverseHandler to see how it works:

class ReverseHandler(tornado.web.RequestHandler):

def get(self, input):

self.write(input[::-1])

You can see here that the get method takes an additional parameter input. This pa-

rameter will contain whatever string was matched inside the first set of parentheses in

the regular expression that matched the handler. (If there are additional sets of paren-

theses in the regular expression, the matched strings will be passed in as additional

parameters, in the same order as they occurred in the regular expression.)

Now, let’s take a look at the definition of WrapHandler:

class WrapHandler(tornado.web.RequestHandler):

def post(self):

text = self.get_argument('text')

8 | Chapter 1: Introduction

剩余135页未读，继续阅读

xtrachen

粉丝: 26
资源: 10

Python进阶：Tornado框架入门指南

Introduction to tornado中文教程.epub

Introduction to Tornado 中文版pdf tornado介绍

Introduction to tornado中文教程.mobi kindle版

[Introduction.to.Tornado(2012.3)].Michael.Dory.文字版.pdf

Tornado Train Workshop

Pastebin:使用Tornado粘贴代码Web系统

A Guide to Porting C C++ to Rust 等53本

Tornado入门指南

深入学习Tornado Web框架

Python网络框架Tornado深度解析

最新资源