Let's dive into building a web application using Tornado, a Python web framework and asynchronous networking library. This guide will walk you through setting up a basic Tornado application, explaining its core components, and showing you how to handle requests and responses. Whether you're a seasoned developer or just starting out, this Tornado web application example will provide a solid foundation for building scalable and efficient web services.

Setting Up Your Environment

Before we begin, make sure you have Python installed on your system. Tornado requires Python 3.6 or higher. You can check your Python version by running python --version in your terminal. If you don't have Python installed, download it from the official Python website.

Next, you'll need to install Tornado. You can do this using pip, the Python package installer. Open your terminal and run the following command:

pip install tornado

This command will download and install Tornado and its dependencies. Once the installation is complete, you're ready to start building your first Tornado application.

Creating a Basic Tornado Application

A Tornado application consists of several key components: the Application class, request handlers, and a main loop. Let's create a simple "Hello, World!" application to illustrate these components. Create a new Python file named app.py and add the following code:

import tornado.ioloop
import tornado.web

class MainHandler(tornado.web.RequestHandler):
 def get(self):
 self.write("Hello, World!")

def make_app():
 return tornado.web.Application([
 (r"/", MainHandler),
 ])

if __name__ == "__main__":
 app = make_app()
 app.listen(8888)
 tornado.ioloop.IOLoop.current().start()

Let's break down this code:

• import tornado.ioloop and import tornado.web: These lines import the necessary Tornado modules. tornado.ioloop provides the core event loop, and tornado.web provides the classes and functions for building web applications.
• class MainHandler(tornado.web.RequestHandler): This defines a request handler class named MainHandler. Request handlers are responsible for handling incoming HTTP requests. The get method is called when the server receives a GET request for the associated path.
• self.write("Hello, World!"): This line writes the response body to the client. In this case, it sends the string "Hello, World!" as the response.
• def make_app(): This function creates a tornado.web.Application instance. The Application class takes a list of URL specifications as an argument. Each URL specification is a tuple containing a regular expression and a request handler class.
• (r"/", MainHandler): This tuple maps the root URL ("/") to the MainHandler class. When the server receives a request for the root URL, it will instantiate MainHandler and call its get method.
• if __name__ == "__main__": This block ensures that the application is only started when the script is run directly (not when it's imported as a module).
• app = make_app(): This creates an instance of the Tornado application.
• app.listen(8888): This starts the server and listens for incoming connections on port 8888. You can change this port to any available port on your system.
• tornado.ioloop.IOLoop.current().start(): This starts the Tornado I/O loop, which handles all incoming events and dispatches them to the appropriate handlers.

To run the application, save the app.py file and run the following command in your terminal:

python app.py

This will start the Tornado server. Open your web browser and navigate to http://localhost:8888. You should see the "Hello, World!" message displayed in your browser.

Handling Different HTTP Methods

In addition to the get method, request handlers can also define methods for handling other HTTP methods, such as post, put, delete, and head. For example, let's add a post method to our MainHandler class:

import tornado.ioloop
import tornado.web

class MainHandler(tornado.web.RequestHandler):
 def get(self):
 self.write("Hello, World!")

 def post(self):
 self.write("You posted to the server!")

def make_app():
 return tornado.web.Application([
 (r"/", MainHandler),
 ])

if __name__ == "__main__":
 app = make_app()
 app.listen(8888)
 tornado.ioloop.IOLoop.current().start()

Now, if you send a POST request to the root URL, the server will respond with "You posted to the server!". You can use tools like curl or Postman to send POST requests to your server. The use of appropriate HTTP methods is a cornerstone of RESTful API design, and Tornado makes it straightforward to implement.

Accessing Request Data

Tornado provides several ways to access data sent by the client in the request. You can access query parameters, form data, and request headers using the RequestHandler object.

Query Parameters

Query parameters are part of the URL and are typically used to pass data to the server in GET requests. You can access query parameters using the get_argument method. For example:

import tornado.ioloop
import tornado.web

class MainHandler(tornado.web.RequestHandler):
 def get(self):
 name = self.get_argument("name", "World")
 self.write(f"Hello, {name}!")

def make_app():
 return tornado.web.Application([
 (r"/", MainHandler),
 ])

if __name__ == "__main__":
 app = make_app()
 app.listen(8888)
 tornado.ioloop.IOLoop.current().start()

In this example, the get_argument method retrieves the value of the name query parameter. If the name parameter is not present in the URL, the method returns the default value "World". To test this, access http://localhost:8888?name=Tornado in your browser. It should display "Hello, Tornado!". Accessing http://localhost:8888 will display "Hello, World!".

Form Data

Form data is typically sent in POST requests and is used to submit data to the server. You can access form data using the get_argument method, just like query parameters. For example:

import tornado.ioloop
import tornado.web

class MainHandler(tornado.web.RequestHandler):
 def get(self):
 self.write("<form method='post'><input type='text' name='message'><input type='submit' value='Submit'></form>")

 def post(self):
 message = self.get_argument("message")
 self.write(f"You sent: {message}")

def make_app():
 return tornado.web.Application([
 (r"/", MainHandler),
 ])

if __name__ == "__main__":
 app = make_app()
 app.listen(8888)
 tornado.ioloop.IOLoop.current().start()

In this example, the get method renders an HTML form with a single text input field named message. When the form is submitted, the post method retrieves the value of the message field using the get_argument method and displays it in the response. This illustrates how Tornado can handle form submissions, a common task in web applications.

Request Headers

Request headers provide additional information about the request, such as the user agent, content type, and authorization tokens. You can access request headers using the request.headers attribute, which is a dictionary-like object. For example:

import tornado.ioloop
import tornado.web

class MainHandler(tornado.web.RequestHandler):
 def get(self):
 user_agent = self.request.headers.get("User-Agent")
 self.write(f"Your user agent is: {user_agent}")

def make_app():
 return tornado.web.Application([
 (r"/", MainHandler),
 ])

if __name__ == "__main__":
 app = make_app()
 app.listen(8888)
 tornado.ioloop.IOLoop.current().start()

In this example, the get method retrieves the value of the User-Agent header using the request.headers.get method and displays it in the response. Understanding request headers is crucial for tasks like content negotiation and user authentication.

Using Templates

Tornado provides a simple templating engine that allows you to generate dynamic HTML pages. Templates are plain text files that contain placeholders for data that will be inserted at runtime. Let's create a simple template to display a list of items.

First, create a directory named templates in the same directory as your app.py file. Then, create a file named index.html inside the templates directory and add the following code:

<!DOCTYPE html>
<html>
<head>
 <title>My List</title>
</head>
<body>
 <h1>My List</h1>
 <ul>
 {% for item in items %}
 <li>{{ item }}</li>
 {% end %}
 </ul>
</body>
</html>

This template defines an HTML page with a heading and an unordered list. The {% for item in items %} and {% end %} tags define a loop that iterates over the items variable. The {{ item }} tag displays the value of the current item.

Now, let's modify our app.py file to use the template:

import tornado.ioloop
import tornado.web

class MainHandler(tornado.web.RequestHandler):
 def get(self):
 items = ["Item 1", "Item 2", "Item 3"]
 self.render("index.html", items=items)

def make_app():
 return tornado.web.Application([
 (r"/", MainHandler),
 ], template_path="templates")

if __name__ == "__main__":
 app = make_app()
 app.listen(8888)
 tornado.ioloop.IOLoop.current().start()

In this example, we've added the template_path argument to the tornado.web.Application constructor, specifying the path to the templates directory. We've also modified the get method to call the render method, passing the name of the template and a dictionary of variables to be passed to the template. The render method automatically loads the template, substitutes the variables, and sends the resulting HTML to the client.

Now, when you access http://localhost:8888 in your browser, you should see the list of items displayed in the HTML page. Using templates allows for a clean separation of concerns between application logic and presentation.

Asynchronous Operations

One of the key features of Tornado is its support for asynchronous operations. Asynchronous operations allow you to perform long-running tasks without blocking the I/O loop, which can improve the performance and scalability of your application. This is particularly important for applications that need to handle a large number of concurrent connections.

To perform an asynchronous operation, you can use the tornado.gen.coroutine decorator and the yield keyword. For example:

import tornado.ioloop
import tornado.web
import tornado.gen
import time

class MainHandler(tornado.web.RequestHandler):
 @tornado.gen.coroutine
 def get(self):
 yield tornado.gen.sleep(5)
 self.write("Hello after 5 seconds!")

def make_app():
 return tornado.web.Application([
 (r"/", MainHandler),
 ])

if __name__ == "__main__":
 app = make_app()
 app.listen(8888)
 tornado.ioloop.IOLoop.current().start()

In this example, the get method is decorated with the @tornado.gen.coroutine decorator, which indicates that it's a coroutine. The yield tornado.gen.sleep(5) line pauses the execution of the coroutine for 5 seconds without blocking the I/O loop. After 5 seconds, the coroutine resumes execution and sends the "Hello after 5 seconds!" message to the client. This simple example demonstrates the power of asynchronous programming in Tornado.

Conclusion

This tornado web application example provided a comprehensive introduction to building web applications with Tornado. We covered setting up your environment, creating a basic application, handling different HTTP methods, accessing request data, using templates, and performing asynchronous operations. With this knowledge, you can start building your own scalable and efficient web services using Tornado. Remember to explore the official Tornado documentation for more advanced features and best practices. Happy coding, and may your Tornado applications always run smoothly!