tornado.web — RequestHandler and Application classes¶

tornado.web provides a simple web framework with asynchronousfeatures that allow it to scale to large numbers of open connections,making it ideal for long polling.

Here is a simple “Hello, world” example app:

  1. import tornado.ioloop
  2. import tornado.web
  3.  
  4. class MainHandler(tornado.web.RequestHandler):
  5.     def get(self):
  6.         self.write("Hello, world")
  7.  
  8. if __name__ == "__main__":
  9.     application = tornado.web.Application([
  10.         (r"/", MainHandler),
  11.     ])
  12.     application.listen(8888)
  13.     tornado.ioloop.IOLoop.current().start()

See the 用户手册 for additional information.

Thread-safety notes¶

In general, methods on RequestHandler and elsewhere in Tornado arenot thread-safe. In particular, methods such aswrite(), finish(), andflush() must only be called from the main thread. Ifyou use multiple threads it is important to use IOLoop.add_callbackto transfer control back to the main thread before finishing therequest.

Request handlers¶

class tornado.web.RequestHandler(application, request, **kwargs)[源代码]

Base class for HTTP request handlers.

Subclasses must define at least one of the methods defined in the“Entry points” section below.

Entry points¶

RequestHandler.initialize()[源代码]

Hook for subclass initialization. Called for each request.

A dictionary passed as the third argument of a url spec will besupplied as keyword arguments to initialize().

Example:



  1. class ProfileHandler(RequestHandler):
        def initialize(self, database):
            self.database = database

        def get(self, username):
            …

    app = Application([
        (r'/user/(.)', ProfileHandler, dict(database=database)),
        ])



RequestHandler.prepare()[源代码]

Called at the beginning of a request before get/post/etc.

Override this method to perform common initialization regardlessof the request method.

Asynchronous support: Decorate this method with gen.coroutineor return_future to make it asynchronous (theasynchronous decorator cannot be used on prepare).If this method returns a Future execution will not proceeduntil the Future is done.


3.1 新版功能: Asynchronous support.

RequestHandler.onfinish()[源代码]

Called after the end of a request.

Override this method to perform cleanup, logging, etc.This method is a counterpart to prepare. on_finish maynot produce any output, as it is called after the responsehas been sent to the client.

Implement any of the following methods (collectively known as theHTTP verb methods) to handle the corresponding HTTP method.These methods can be made asynchronous with one of the followingdecorators: gen.coroutine, return_future, or asynchronous.

To support a method not on this list, override the class variableSUPPORTED_METHODS:



  1. class WebDAVHandler(RequestHandler):
        SUPPORTED_METHODS = RequestHandler.SUPPORTED_METHODS + ('PROPFIND',)

        def propfind(self):
            pass



RequestHandler.get(args, kwargs)[源代码]
RequestHandler.head(*args, kwargs)[源代码]
RequestHandler.post(args, **kwargs)[源代码]
RequestHandler.delete(args, kwargs)[源代码]
RequestHandler.patch(*args, kwargs)[源代码]
RequestHandler.put(args, **kwargs)[源代码]
RequestHandler.options(args, **kwargs_)[源代码]

Input¶

RequestHandler.getargument(_name, default=<object object>, strip=True)[源代码]

Returns the value of the argument with the given name.

If default is not provided, the argument is considered to berequired, and we raise a MissingArgumentError if it is missing.

If the argument appears in the url more than once, we return thelast value.

The returned value is always unicode.
RequestHandler.getarguments(_name, strip=True)[源代码]

Returns a list of the arguments with the given name.

If the argument is not present, returns an empty list.

The returned values are always unicode.
RequestHandler.getquery_argument(_name, default=<object object>, strip=True)[源代码]

Returns the value of the argument with the given namefrom the request query string.

If default is not provided, the argument is considered to berequired, and we raise a MissingArgumentError if it is missing.

If the argument appears in the url more than once, we return thelast value.

The returned value is always unicode.


3.2 新版功能.

RequestHandler.getquery_arguments(_name, strip=True)[源代码]

Returns a list of the query arguments with the given name.

If the argument is not present, returns an empty list.

The returned values are always unicode.


3.2 新版功能.

RequestHandler.getbody_argument(_name, default=<object object>, strip=True)[源代码]

Returns the value of the argument with the given namefrom the request body.

If default is not provided, the argument is considered to berequired, and we raise a MissingArgumentError if it is missing.

If the argument appears in the url more than once, we return thelast value.

The returned value is always unicode.


3.2 新版功能.

RequestHandler.getbody_arguments(_name, strip=True)[源代码]

Returns a list of the body arguments with the given name.

If the argument is not present, returns an empty list.

The returned values are always unicode.


3.2 新版功能.

RequestHandler.decodeargument(_value, name=None)[源代码]

Decodes an argument from the request.

The argument has been percent-decoded and is now a byte string.By default, this method decodes the argument as utf-8 and returnsa unicode string, but this may be overridden in subclasses.

This method is used as a filter for both get_argument() and forvalues extracted from the url and passed to get()/post()/etc.

The name of the argument is provided if known, but may be None(e.g. for unnamed groups in the url regex).
RequestHandler.request

The tornado.httputil.HTTPServerRequest object containing additionalrequest parameters including e.g. headers and body data.
RequestHandler.path_args
RequestHandler.path_kwargs

The path_args and path_kwargs attributes contain thepositional and keyword arguments that are passed to theHTTP verb methods. These attributes are setbefore those methods are called, so the values are availableduring prepare.

Output¶

RequestHandler.setstatus(_status_code, reason=None)[源代码]

Sets the status code for our response.

|参数:
|——-
|
- status_code (int) – Response status code. If reason is None,it must be present in httplib.responses.
- reason (string) – Human-readable reason phrase describing the statuscode. If None, it will be filled in fromhttplib.responses.

RequestHandler.setheader(_name, value)[源代码]

Sets the given response header name and value.

If a datetime is given, we automatically format it according to theHTTP specification. If the value is not a string, we convert it toa string. All header values are then encoded as UTF-8.
RequestHandler.addheader(_name, value)[源代码]

Adds the given response header and value.

Unlike set_header, add_header may be called multiple timesto return multiple values for the same header.
RequestHandler.clearheader(_name)[源代码]

Clears an outgoing header, undoing a previous set_header call.

Note that this method does not apply to multi-valued headersset by add_header.
RequestHandler.setdefault_headers()[源代码]

Override this to set HTTP headers at the beginning of the request.

For example, this is the place to set a custom Server header.Note that setting such headers in the normal flow of requestprocessing may not do what you want, since headers may be resetduring error handling.
RequestHandler.write(_chunk)[源代码]

Writes the given chunk to the output buffer.

To write the output to the network, use the flush() method below.

If the given chunk is a dictionary, we write it as JSON and setthe Content-Type of the response to be application/json.(if you want to send JSON as a different Content-Type, callsetheader _after calling write()).

Note that lists are not converted to JSON because of a potentialcross-site security vulnerability. All JSON output should bewrapped in a dictionary. More details athttp://haacked.com/archive/2009/06/25/json-hijacking.aspx/ andhttps://github.com/facebook/tornado/issues/1009
RequestHandler.flush(include_footers=False, callback=None)[源代码]

Flushes the current output buffer to the network.

The callback argument, if given, can be used for flow control:it will be run when all flushed data has been written to the socket.Note that only one flush callback can be outstanding at a time;if another flush occurs before the previous flush’s callbackhas been run, the previous callback will be discarded.


在 4.0 版更改: Now returns a Future if no callback is given.

RequestHandler.finish(chunk=None)[源代码]

Finishes this response, ending the HTTP request.
RequestHandler.render(template_name, **kwargs)[源代码]

Renders the template with the given arguments as the response.
RequestHandler.renderstring(_template_name, **kwargs)[源代码]

Generate the given template with the given arguments.

We return the generated byte string (in utf8). To generate andwrite a template as a response, use render() above.
RequestHandler.gettemplate_namespace()[源代码]

Returns a dictionary to be used as the default template namespace.

May be overridden by subclasses to add or modify values.

The results of this method will be combined with additionaldefaults in the tornado.template module and keyword argumentsto render or render_string.
RequestHandler.redirect(_url, permanent=False, status=None)[源代码]

Sends a redirect to the given (optionally relative) URL.

If the status argument is specified, that value is used as theHTTP status code; otherwise either 301 (permanent) or 302(temporary) is chosen based on the permanent argument.The default is 302 (temporary).
RequestHandler.senderror(_status_code=500, **kwargs)[源代码]

Sends the given HTTP error code to the browser.

If flush() has already been called, it is not possible to sendan error, so this method will simply terminate the response.If output has been written but not yet flushed, it will be discardedand replaced with the error page.

Override write_error() to customize the error page that is returned.Additional keyword arguments are passed through to write_error.
RequestHandler.writeerror(_status_code, **kwargs)[源代码]

Override to implement custom error pages.

writeerror may call write, render, set_header, etcto produce output as usual.

If this error was caused by an uncaught exception (includingHTTPError), an exc_info triple will be available askwargs["exc_info"]. Note that this exception may not bethe “current” exception for purposes of methods likesys.exc_info() or traceback.format_exc.
RequestHandler.clear()[源代码]

Resets all headers and content for this response.
RequestHandler.data_received(_chunk)[源代码]

Implement this method to handle streamed request data.

Requires the stream_request_body decorator.

Cookies¶

RequestHandler.cookies

An alias forself.request.cookies.

Gets the value of the cookie with the given name, else default.

Sets the given cookie name/value with the given options.

Additional keyword arguments are set on the Cookie.Morseldirectly.See http://docs.python.org/library/cookie.html#morsel-objectsfor available attributes.

Deletes the cookie with the given name.

Due to limitations of the cookie protocol, you must pass the samepath and domain to clear a cookie as were used when that cookiewas set (but there is no way to find out on the server sidewhich values were used for a given cookie).
RequestHandler.clearall_cookies(_path='/', domain=None)[源代码]

Deletes all the cookies the user sent with this request.

See clear_cookie for more information on the path and domainparameters.


在 3.2 版更改: Added the path and domain parameters.


Returns the given signed cookie if it validates, or None.

The decoded cookie value is returned as a byte string (unlikeget_cookie).


在 3.2.1 版更改: Added the minversion argument. Introduced cookie version 2;both versions 1 and 2 are accepted by default.


Returns the signing key version of the secure cookie.

The version is returned as int.

Signs and timestamps a cookie so it cannot be forged.

You must specify the cookiesecret setting in your Applicationto use this method. It should be a long, random sequence of bytesto be used as the HMAC secret for the signature.

To read a cookie set with this method, use get_secure_cookie().

Note that the expires_days parameter sets the lifetime of thecookie in the browser, but is independent of the max_age_daysparameter to get_secure_cookie.

Secure cookies may contain arbitrary byte values, not just unicodestrings (unlike regular cookies)


在 3.2.1 版更改: Added the version argument. Introduced cookie version 2and made it the default.

RequestHandler.create_signed_value(_name, value, version=None)[源代码]

Signs and timestamps a string so it cannot be forged.

Normally used via setsecure_cookie, but provided as a separatemethod for non-cookie uses. To decode a value not storedas a cookie use the optional value argument to get_secure_cookie.


在 3.2.1 版更改: Added the version argument. Introduced cookie version 2and made it the default.

tornado.web.MIN_SUPPORTED_SIGNED_VALUE_VERSION = 1

The oldest signed value version supported by this version of Tornado.

Signed values older than this version cannot be decoded.


3.2.1 新版功能.

tornado.web.MAX_SUPPORTED_SIGNED_VALUE_VERSION = 2

The newest signed value version supported by this version of Tornado.

Signed values newer than this version cannot be decoded.


3.2.1 新版功能.

tornado.web.DEFAULT_SIGNED_VALUE_VERSION = 2

The signed value version produced by RequestHandler.create_signed_value.

May be overridden by passing a version keyword argument.


3.2.1 新版功能.

tornado.web.DEFAULT_SIGNED_VALUE_MIN_VERSION = 1_

The oldest signed value accepted by RequestHandler.get_secure_cookie.

May be overridden by passing a min_version keyword argument.


3.2.1 新版功能.

Other¶

RequestHandler.application

The Application object serving this request
RequestHandler.checketag_header()[源代码]

Checks the Etag header against requests’s If-None-Match.

Returns True if the request’s Etag matches and a 304 should bereturned. For example:



  1. self.set_etag_header()
    if self.check_etag_header():
        self.set_status(304)
        return




This method is called automatically when the request is finished,but may be called earlier for applications that overridecompute_etag and want to do an early check for If-None-Matchbefore completing the request. The Etag header should be set(perhaps with set_etag_header) before calling this method.

Verifies that the _xsrf cookie matches the _xsrf argument.

To prevent cross-site request forgery, we set an _xsrfcookie and include the same value as a non-cookiefield with all POST requests. If the two do not match, wereject the form submission as a potential forgery.

The _xsrf value may be set as either a form field named _xsrfor in a custom HTTP header named X-XSRFToken or X-CSRFToken(the latter is accepted for compatibility with Django).

See http://en.wikipedia.org/wiki/Cross-site_request_forgery

Prior to release 1.1.1, this check was ignored if the HTTP headerX-Requested-With: XMLHTTPRequest was present. This exceptionhas been shown to be insecure and has been removed. For moreinformation please seehttp://www.djangoproject.com/weblog/2011/feb/08/security/http://weblog.rubyonrails.org/2011/2/8/csrf-protection-bypass-in-ruby-on-rails


在 3.2.2 版更改: Added support for cookie version 2. Both versions 1 and 2 aresupported.

RequestHandler.compute_etag()[源代码]

Computes the etag header to be used for this request.

By default uses a hash of the content written so far.

May be overridden to provide custom etag implementations,or may return None to disable tornado’s default etag support.
RequestHandler.create_template_loader(_template_path)[源代码]

Returns a new template loader for the given path.

May be overridden by subclasses. By default returns adirectory-based loader on the given path, using theautoescape and templatewhitespace applicationsettings. If a template_loader application setting issupplied, uses that instead.
RequestHandler.current_user

The authenticated user for this request.

This is set in one of two ways:

-
A subclass may override get_current_user(), which will be calledautomatically the first time self.current_user is accessed.get_current_user() will only be called once per request,and is cached for future access:



def get_current_user(self):
user_cookie = self.get_secure_cookie("user")
if user_cookie:
return json.loads(user_cookie)
return None




-
It may be set as a normal variable, typically from an overriddenprepare():



@gen.coroutine
def prepare(self):
user_id_cookie = self.get_secure_cookie("user_id")
if user_id_cookie:
self.current_user = yield load_user(user_id_cookie)




Note that prepare() may be a coroutine while get_current_user()may not, so the latter form is necessary if loading the user requiresasynchronous operations.

The user object may any type of the application’s choosing.
RequestHandler.get_browser_locale(_default='en_US')[源代码]

Determines the user’s locale from Accept-Language header.

See http://www.w3.org/Protocols/rfc2616/rfc2616-sec14.html#sec14.4
RequestHandler.getcurrent_user()[源代码]

Override to determine the current user from, e.g., a cookie.

This method may not be a coroutine.
RequestHandler.get_login_url()[源代码]

Override to customize the login URL based on the request.

By default, we use the login_url application setting.
RequestHandler.get_status()[源代码]

Returns the status code for our response.
RequestHandler.get_template_path()[源代码]

Override to customize template path for each handler.

By default, we use the template_path application setting.Return None to load templates relative to the calling file.
RequestHandler.get_user_locale()[源代码]

Override to determine the locale from the authenticated user.

If None is returned, we fall back to get_browser_locale().

This method should return a tornado.locale.Locale object,most likely obtained via a call like tornado.locale.get("en")
RequestHandler.locale

The locale for the current session.

Determined by either get_user_locale, which you can override toset the locale based on, e.g., a user preference stored in adatabase, or get_browser_locale, which uses the Accept-Languageheader.
RequestHandler.log_exception(_typ, value, tb)[源代码]

Override to customize logging of uncaught exceptions.

By default logs instances of HTTPError as warnings withoutstack traces (on the tornado.general logger), and allother exceptions as errors with stack traces (on thetornado.application logger).


3.1 新版功能.

RequestHandler.onconnection_close()[源代码]

Called in async handlers if the client closed the connection.

Override this to clean up resources associated withlong-lived connections. Note that this method is called only ifthe connection was closed during asynchronous processing; if youneed to do cleanup after every request override on_finishinstead.

Proxies may keep a connection open for a time (perhapsindefinitely) after the client has gone away, so this methodmay not be called promptly after the end user closes theirconnection.
RequestHandler.require_setting(_name, feature='this feature')[源代码]

Raises an exception if the given app setting is not defined.
RequestHandler.reverseurl(_name, *args)[源代码]

Alias for Application.reverse_url.
RequestHandler.setetag_header()[源代码]

Sets the response’s Etag header using self.compute_etag().

Note: no header will be set if compute_etag() returns None.

This method is called automatically when the request is finished.
RequestHandler.settings

An alias for self.application.settings.
RequestHandler.static_url(_path, include_host=None, **kwargs)[源代码]

Returns a static URL for the given relative static file path.

This method requires you set the static_path setting in yourapplication (which specifies the root directory of your staticfiles).

This method returns a versioned url (by default appending?v=<signature>), which allows the static files to becached indefinitely. This can be disabled by passinginclude_version=False (in the default implementation;other static file implementations are not required to supportthis, but they may support other options).

By default this method returns URLs relative to the currenthost, but if include_host is true the URL returned will beabsolute. If this handler has an include_host attribute,that value will be used as the default for all static_urlcalls that do not pass include_host as a keyword argument.
RequestHandler.xsrf_form_html()[源代码]

An HTML <input/> element to be included with all POST forms.

It defines the _xsrf input value, which we check on all POSTrequests to prevent cross-site request forgery. If you have setthe xsrf_cookies application setting, you must include thisHTML within all of your HTML forms.

In a template, this method should be called with {% module
xsrf_form_html() %}

See check_xsrf_cookie() above for more information.
RequestHandler.xsrf_token

The XSRF-prevention token for the current user/session.

To prevent cross-site request forgery, we set an ‘_xsrf’ cookieand include the same ‘_xsrf’ value as an argument with all POSTrequests. If the two do not match, we reject the form submissionas a potential forgery.

See http://en.wikipedia.org/wiki/Cross-site_request_forgery


在 3.2.2 版更改: The xsrf token will now be have a random mask applied in everyrequest, which makes it safe to include the token in pagesthat are compressed. See http://breachattack.com for moreinformation on the issue fixed by this change. Old (version 1)cookies will be converted to version 2 when this method is calledunless the xsrf_cookie_version Application setting isset to 1.



在 4.3 版更改: The xsrf_cookie_kwargs Application setting may beused to supply additional cookie options (which will bepassed directly to set_cookie). For example,xsrf_cookie_kwargs=dict(httponly=True, secure=True)will set the secure and httponly flags on the_xsrf cookie.

Application configuration¶

class tornado.web.Application(handlers=None, default_host='', transforms=None, **settings)[源代码]

A collection of request handlers that make up a web application.

Instances of this class are callable and can be passed directly toHTTPServer to serve the application:



  1. application = web.Application([
        (r"/", MainPageHandler),
    ])
    httpserver = httpserver.HTTPServer(application)
    http_server.listen(8080)
    ioloop.IOLoop.current().start()




The constructor for this class takes in a list of URLSpec objectsor (regexp, request_class) tuples. When we receive requests, weiterate over the list in order and instantiate an instance of thefirst request class whose regexp matches the request path.The request class can be specified as either a class object or a(fully-qualified) name.

Each tuple can contain additional elements, which correspond to thearguments to the URLSpec constructor. (Prior to Tornado 3.2,only tuples of two or three elements were allowed).

A dictionary may be passed as the third element of the tuple,which will be used as keyword arguments to the handler’sconstructor and initialize method. This patternis used for the StaticFileHandler in this example (note that aStaticFileHandler can be installed automatically with thestatic_path setting described below):



  1. application = web.Application([
        (r"/static/(.*)", web.StaticFileHandler, {"path": "/var/www"}),
    ])




We support virtual hosts with the add_handlers method, which takes ina host regular expression as the first argument:



  1. application.add_handlers(r"www.myhost.com", [
        (r"/article/([0-9]+)", ArticleHandler),
    ])




You can serve static files by sending the static_path settingas a keyword argument. We will serve those files from the/static/ URI (this is configurable with thestatic_url_prefix setting), and we will serve /favicon.icoand /robots.txt from the same directory. A custom subclass ofStaticFileHandler can be specified with thestatic_handler_class setting.
settings

Additional keyword arguments passed to the constructor aresaved in the settings dictionary, and are often referred toin documentation as “application settings”. Settings areused to customize various aspects of Tornado (although insome cases richer customization is possible by overridingmethods in a subclass of RequestHandler). Someapplications also like to use the settings dictionary as away to make application-specific settings available tohandlers without using global variables. Settings used inTornado are described below.

General settings:

- autoreload: If True, the server process will restartwhen any source files change, as described in Debug 模式 和 自动重新加载.This option is new in Tornado 3.2; previously this functionalitywas controlled by the debug setting.
- debug: Shorthand for several debug mode settings,described in Debug 模式 和 自动重新加载. Setting debug=True isequivalent to autoreload=True, compiled_template_cache=False,static_hash_cache=False, serve_traceback=True.
- default_handler_class and default_handler_args:This handler will be used if no other match is found;use this to implement custom 404 pages (new in Tornado 3.2).
- compress_response: If True, responses in textual formatswill be compressed automatically. New in Tornado 4.0.
- gzip: Deprecated alias for compress_response sinceTornado 4.0.
- log_function: This function will be called at the endof every request to log the result (with one argument, theRequestHandler object). The default implementationwrites to the logging module’s root logger. May also becustomized by overriding Application.log_request.
- serve_traceback: If true, the default error pagewill include the traceback of the error. This option is new inTornado 3.2; previously this functionality was controlled bythe debug setting.
- ui_modules and ui_methods: May be set to a mappingof UIModule or UI methods to be made available to templates.May be set to a module, dictionary, or a list of modulesand/or dicts. See UI 模版 for more details.
Authentication and security settings:

- cookie_secret: Used by RequestHandler.get_secure_cookieand set_secure_cookie to sign cookies.
- key_version: Used by requestHandler set_secure_cookieto sign cookies with a specific key when cookie_secretis a key dictionary.
- login_url: The authenticated decorator will redirectto this url if the user is not logged in. Can be furthercustomized by overriding RequestHandler.get_login_url
- xsrf_cookies: If true, 跨站请求伪造防护 will be enabled.
- xsrf_cookie_version: Controls the version of new XSRFcookies produced by this server. Should generally be leftat the default (which will always be the highest supportedversion), but may be set to a lower value temporarilyduring version transitions. New in Tornado 3.2.2, whichintroduced XSRF cookie version 2.
- xsrf_cookie_kwargs: May be set to a dictionary ofadditional arguments to be passed to RequestHandler.set_cookiefor the XSRF cookie.
- twitter_consumer_key, twitter_consumer_secret,friendfeed_consumer_key, friendfeed_consumer_secret,google_consumer_key, google_consumer_secret,facebook_api_key, facebook_secret: Used in thetornado.auth module to authenticate to various APIs.
Template settings:

- autoescape: Controls automatic escaping for templates.May be set to None to disable escaping, or to the _name_of a function that all output should be passed through.Defaults to "xhtml_escape". Can be changed on a per-templatebasis with the {% autoescape %} directive.
- compiled_template_cache: Default is True; if Falsetemplates will be recompiled on every request. This optionis new in Tornado 3.2; previously this functionality was controlledby the debug setting.
- template_path: Directory containing template files. Can befurther customized by overriding RequestHandler.get_template_path
- template_loader: Assign to an instance oftornado.template.BaseLoader to customize template loading.If this setting is used the template_path and autoescapesettings are ignored. Can be further customized by overridingRequestHandler.create_template_loader.
- template_whitespace: Controls handling of whitespace intemplates; see tornado.template.filter_whitespace for allowedvalues. New in Tornado 4.3.
Static file settings:

- static_hash_cache: Default is True; if Falsestatic urls will be recomputed on every request. This optionis new in Tornado 3.2; previously this functionality was controlledby the debug setting.
- static_path: Directory from which static files will beserved.
- static_url_prefix: Url prefix for static files,defaults to "/static/".
- static_handler_class, static_handler_args: May be set touse a different handler for static files instead of the defaulttornado.web.StaticFileHandler. static_handler_args, if set,should be a dictionary of keyword arguments to be passed to thehandler’s initialize method.
listen(_port, address='', **kwargs)[源代码]

Starts an HTTP server for this application on the given port.

This is a convenience alias for creating an HTTPServerobject and calling its listen method. Keyword arguments notsupported by HTTPServer.listen are passed to theHTTPServer constructor. For advanced uses(e.g. multi-process mode), do not use this method; create anHTTPServer and call itsTCPServer.bind/TCPServer.start methods directly.

Note that after calling this method you still need to callIOLoop.current().start() to start the server.

Returns the HTTPServer object.


在 4.3 版更改: Now returns the HTTPServer object.

addhandlers(_host_pattern, host_handlers)[源代码]

Appends the given handlers to our handler list.

Host patterns are processed sequentially in the order they wereadded. All matching patterns will be considered.
reverseurl(_name, *args)[源代码]

Returns a URL path for handler named name

The handler must be added to the application as a named URLSpec.

Args will be substituted for capturing groups in the URLSpec regex.They will be converted to strings if necessary, encoded as utf8,and url-escaped.
logrequest(_handler)[源代码]

Writes a completed HTTP request to the logs.

By default writes to the python root logger. To changethis behavior either subclass Application and override this method,or pass a function in the application settings dictionary aslogfunction.
_class tornado.web.URLSpec(pattern, handler, kwargs=None, name=None)[源代码]

Specifies mappings between URLs and handlers.

Parameters:

- pattern: Regular expression to be matched. Any capturinggroups in the regex will be passed in to the handler’sget/post/etc methods as arguments (by keyword if named, byposition if unnamed. Named and unnamed capturing groups maymay not be mixed in the same rule).
- handler: RequestHandler subclass to be invoked.
- kwargs (optional): A dictionary of additional argumentsto be passed to the handler’s constructor.
- name (optional): A name for this handler. Used byApplication.reverse_url.
The URLSpec class is also available under the name tornado.web.url.

Decorators¶

tornado.web.asynchronous(method)[源代码]

Wrap request handler methods with this if they are asynchronous.

This decorator is for callback-style asynchronous methods; forcoroutines, use the @gen.coroutine decorator without@asynchronous. (It is legal for legacy reasons to use the twodecorators together provided @asynchronous is first, but@asynchronous will be ignored in this case)

This decorator should only be applied to the HTTP verbmethods; its behavior is undefined for any other method.This decorator does not make a method asynchronous; it tellsthe framework that the method is asynchronous. For this decoratorto be useful the method must (at least sometimes) do somethingasynchronous.

If this decorator is given, the response is not finished when themethod returns. It is up to the request handler to callself.finish() to finish the HTTPrequest. Without this decorator, the request is automaticallyfinished when the get() or post() method returns. Example:



  1. class MyRequestHandler(RequestHandler):
        @asynchronous
        def get(self):
           http = httpclient.AsyncHTTPClient()
           http.fetch("http://friendfeed.com/&#34;, self.on_download)

        def _on_download(self, response):
           self.write("Downloaded!")
           self.finish()





在 3.1 版更改: The ability to use @gen.coroutine without @asynchronous.



在 4.3 版更改: Returning anything but None or ayieldable object from a method decorated with @asynchronousis an error. Such return values were previously ignored silently.

tornado.web.authenticated(_method)[源代码]

Decorate methods with this to require that the user be logged in.

If the user is not logged in, they will be redirected to the configuredlogin url.

If you configure a login url with a query parameter, Tornado willassume you know what you’re doing and use it as-is. If not, itwill add a next parameter so the login page knows where to sendyou once you’re logged in.
tornado.web.addslash(method)[源代码]

Use this decorator to add a missing trailing slash to the request path.

For example, a request to /foo would redirect to /foo/ with thisdecorator. Your request handler mapping should use a regular expressionlike r'/foo/?' in conjunction with using the decorator.
tornado.web.removeslash(method)[源代码]

Use this decorator to remove trailing slashes from the request path.

For example, a request to /foo/ would redirect to /foo with thisdecorator. Your request handler mapping should use a regular expressionlike r'/foo/*' in conjunction with using the decorator.
tornado.web.streamrequest_body(_cls)[源代码]

Apply to RequestHandler subclasses to enable streaming body support.

This decorator implies the following changes:

- HTTPServerRequest.body is undefined, and body arguments will notbe included in RequestHandler.get_argument.
- RequestHandler.prepare is called when the request headers have beenread instead of after the entire body has been read.
- The subclass must define a method datareceived(self, data):, whichwill be called zero or more times as data is available. Note thatif the request has an empty body, data_received may not be called.
- prepare and data_received may return Futures (such as via@gen.coroutine, in which case the next method will not be calleduntil those futures have completed.
- The regular HTTP method (post, put, etc) will be called afterthe entire body has been read.
There is a subtle interaction between data_received and asynchronousprepare: The first call to data_received may occur at any pointafter the call to prepare has returned _or yielded.

Everything else¶

exception tornado.web.HTTPError(status_code=500, log_message=None, *args, **kwargs)[源代码]

An exception that will turn into an HTTP error response.

Raising an HTTPError is a convenient alternative to callingRequestHandler.send_error since it automatically ends thecurrent function.

To customize the response sent with an HTTPError, overrideRequestHandler.write_error.

|参数:
|——-
|
- status_code (int) – HTTP status code. Must be listed inhttplib.responses unless the reasonkeyword argument is given.
- log_message (string) – Message to be written to the log for this error(will not be shown to the user unless the Application is in debugmode). May contain %s-style placeholders, which will be filledin with remaining positional parameters.
- reason (string) – Keyword-only argument. The HTTP “reason” phraseto pass in the status line along with statuscode. Normallydetermined automatically from status_code, but can be usedto use a non-standard numeric code.

_exception tornado.web.Finish[源代码]

An exception that ends the request without producing an error response.

When Finish is raised in a RequestHandler, the request willend (calling RequestHandler.finish if it hasn’t already beencalled), but the error-handling methods (includingRequestHandler.write_error) will not be called.

If Finish() was created with no arguments, the pending responsewill be sent as-is. If Finish() was given an argument, thatargument will be passed to RequestHandler.finish().

This can be a more convenient way to implement custom error pagesthan overriding writeerror (especially in library code):



  1. if self.current_user is None:
        self.set_status(401)
        self.set_header('WWW-Authenticate', 'Basic realm="something"')
        raise Finish()





在 4.3 版更改: Arguments passed to Finish() will be passed on toRequestHandler.finish.

_exception tornado.web.MissingArgumentError(arg_name)[源代码]

Exception raised by RequestHandler.get_argument.

This is a subclass of HTTPError, so if it is uncaught a 400 responsecode will be used instead of 500 (and a stack trace will not be logged).


3.1 新版功能.

class tornado.web.UIModule(handler)[源代码]

A re-usable, modular UI unit on a page.

UI modules often execute additional queries, and they can includeadditional CSS and JavaScript that will be included in the outputpage, which is automatically inserted on page render.

Subclasses of UIModule must override the render method.
render(*args, **kwargs)[源代码]

Override in subclasses to return this module’s output.
embeddedjavascript()[源代码]

Override to return a JavaScript stringto be embedded in the page.
javascript_files()[源代码]

Override to return a list of JavaScript files needed by this module.

If the return values are relative paths, they will be passed toRequestHandler.static_url; otherwise they will be used as-is.
embedded_css()[源代码]

Override to return a CSS stringthat will be embedded in the page.
css_files()[源代码]

Override to returns a list of CSS files required by this module.

If the return values are relative paths, they will be passed toRequestHandler.static_url; otherwise they will be used as-is.
html_head()[源代码]

Override to return an HTML string that will be put in the <head/>element.
html_body()[源代码]

Override to return an HTML string that will be put at the end ofthe <body/> element.
render_string(_path, **kwargs)[源代码]

Renders a template and returns it as a string.
class tornado.web.ErrorHandler(application, request, **kwargs)[源代码]

Generates an error response with statuscode for all requests.
_class tornado.web.FallbackHandler(application, request, **kwargs)[源代码]

A RequestHandler that wraps another HTTP server callback.

The fallback is a callable object that accepts anHTTPServerRequest, such as an Application ortornado.wsgi.WSGIContainer. This is most useful to use bothTornado RequestHandlers and WSGI in the same server. Typicalusage:



  1. wsgiapp = tornado.wsgi.WSGIContainer(
        django.core.handlers.wsgi.WSGIHandler())
    application = tornado.web.Application([
        (r"/foo", FooHandler),
        (r".*", FallbackHandler, dict(fallback=wsgi_app),
    ])



_class tornado.web.RedirectHandler(application, request, **kwargs)[源代码]

Redirects the client to the given URL for all GET requests.

You should provide the keyword argument url to the handler, e.g.:



  1. application = web.Application([
        (r"/oldpath", web.RedirectHandler, {"url": "/newpath"}),
    ])



class tornado.web.StaticFileHandler(application, request, **kwargs)[源代码]

A simple handler that can serve static content from a directory.

A StaticFileHandler is configured automatically if you pass thestaticpath keyword argument to Application. This handlercan be customized with the static_url_prefix, static_handler_class,and static_handler_args settings.

To map an additional path to this handler for a static data directoryyou would add a line to your application like:



  1. application = web.Application([
        (r"/content/(.)", web.StaticFileHandler, {"path": "/var/www"}),
    ])




The handler constructor requires a path argument, which specifies thelocal root directory of the content to be served.

Note that a capture group in the regex is required to parse the value forthe path argument to the get() method (different than the constructorargument above); see URLSpec for details.

To serve a file like index.html automatically when a directory isrequested, set static_handler_args=dict(default_filename="index.html")in your application settings, or add default_filename as an initializerargument for your StaticFileHandler.

To maximize the effectiveness of browser caching, this class supportsversioned urls (by default using the argument ?v=). If a versionis given, we instruct the browser to cache this file indefinitely.make_static_url (also available as RequestHandler.static_url) canbe used to construct a versioned url.

This handler is intended primarily for use in development and light-dutyfile serving; for heavy traffic it will be more efficient to usea dedicated static file server (such as nginx or Apache). We supportthe HTTP Accept-Ranges mechanism to return partial content (becausesome browsers require this functionality to be present to seek inHTML5 audio or video).

*Subclassing notes

This class is designed to be extensible by subclassing, but becauseof the way static urls are generated with class methods rather thaninstance methods, the inheritance patterns are somewhat unusual.Be sure to use the @classmethod decorator when overriding aclass method. Instance methods may use the attributes self.pathself.absolute_path, and self.modified.

Subclasses should only override methods discussed in this section;overriding other methods is error-prone. OverridingStaticFileHandler.get is particularly problematic due to thetight coupling with compute_etag and other methods.

To change the way static urls are generated (e.g. to match the behaviorof another server or CDN), override make_static_url, parse_url_path,get_cache_time, and/or get_version.

To replace all interaction with the filesystem (e.g. to servestatic content from a database), override get_content,get_content_size, get_modified_time, get_absolute_path, andvalidate_absolute_path.


在 3.1 版更改: Many of the methods for subclasses were added in Tornado 3.1.

compute_etag()[源代码]

Sets the Etag header based on static url version.

This allows efficient If-None-Match checks against cachedversions, and sends the correct Etag for a partial response(i.e. the same Etag as the full file).


3.1 新版功能.

set_headers()[源代码]

Sets the content and caching headers on the response.


3.1 新版功能.

should_return_304()[源代码]

Returns True if the headers indicate that we should return 304.


3.1 新版功能.

_classmethod getabsolute_path(_root, path)[源代码]

Returns the absolute location of path relative to root.

root is the path configured for this StaticFileHandler(in most cases the staticpath Application setting).

This class method may be overridden in subclasses. By defaultit returns a filesystem path, but other strings may be usedas long as they are unique and understood by the subclass’soverridden get_content.


3.1 新版功能.

validate_absolute_path(_root, absolute_path)[源代码]

Validate and return the absolute path.

root is the configured path for the StaticFileHandler,and path is the result of get_absolute_path

This is an instance method called during request processing,so it may raise HTTPError or use methods likeRequestHandler.redirect (return None after redirecting tohalt further processing). This is where 404 errors for missing filesare generated.

This method may modify the path before returning it, but note thatany such modifications will not be understood by make_static_url.

In instance methods, this method’s result is available asself.absolutepath.


3.1 新版功能.

_classmethod getcontent(_abspath, start=None, end=None)[源代码]

Retrieve the content of the requested resource which is locatedat the given absolute path.

This class method may be overridden by subclasses. Note that itssignature is different from other overridable class methods(no settings argument); this is deliberate to ensure thatabspath is able to stand on its own as a cache key.

This method should either return a byte string or an iteratorof byte strings. The latter is preferred for large filesas it helps reduce memory fragmentation.


3.1 新版功能.

classmethod getcontent_version(_abspath)[源代码]

Returns a version string for the resource at the given path.

This class method may be overridden by subclasses. Thedefault implementation is a hash of the file’s contents.


3.1 新版功能.

getcontent_size()[源代码]

Retrieve the total size of the resource at the given path.

This method may be overridden by subclasses.


3.1 新版功能.



在 4.0 版更改: This method is now always called, instead of only whenpartial results are requested.

get_modified_time()[源代码]

Returns the time that self.absolute_path was last modified.

May be overridden in subclasses. Should return a datetimeobject or None.


3.1 新版功能.

get_content_type()[源代码]

Returns the Content-Type header to be used for this request.


3.1 新版功能.

set_extra_headers(_path)[源代码]

For subclass to add extra headers to the response
getcache_time(_path, modified, mime_type)[源代码]

Override to customize cache control behavior.

Return a positive number of seconds to make the resultcacheable for that amount of time or 0 to mark resource ascacheable for an unspecified amount of time (subject tobrowser heuristics).

By default returns cache expiry of 10 years for resources requestedwith v argument.
classmethod makestatic_url(_settings, path, include_version=True)[源代码]

Constructs a versioned url for the given path.

This method may be overridden in subclasses (but note that itis a class method rather than an instance method). Subclassesare only required to implement the signaturemakestatic_url(cls, settings, path); other keywordarguments may be passed through static_urlbut are not standard.

settings is the Application.settings dictionary. pathis the static path being requested. The url returned should berelative to the current host.

include_version determines whether the generated URL shouldinclude the query string containing the version hash of thefile corresponding to the given path.
parse_url_path(_url_path)[源代码]

Converts a static URL path into a filesystem path.

urlpath is the path component of the URL withstatic_url_prefix removed. The return value should befilesystem path relative to static_path.

This is the inverse of make_static_url.
_classmethod getversion(_settings, path)[源代码]

Generate the version string to be used in static URLs.

settings is the Application.settings dictionary and pathis the relative location of the requested asset on the filesystem.The returned value should be a string, or None if no versioncould be determined.


在 3.1 版更改: This method was previously recommended for subclasses to override;get_content_version is now preferred as it allows the baseclass to handle caching of the result.

原文:

https://tornado-zh-cn.readthedocs.io/zh_CN/latest/web.html