Pembangunan Web dalam Python: Tornado in Action

Dengan peningkatan Internet, pembangunan Web telah menjadi semakin penting dalam bidang IT. Sebagai bahasa pengaturcaraan peringkat tinggi yang memfokuskan kepada kecekapan pembangunan, Python juga telah menjadi popular dalam bidang pembangunan web. Antaranya, Tornado, rangka kerja rangkaian ringan, mempunyai kedudukan unik dalam Python Ia menggunakan kaedah berasaskan IO tak segerak, yang menjadikannya memproses permintaan serentak lebih cepat daripada kaedah IO segerak tradisional. Artikel ini akan memperkenalkan kaedah dan teknik menggunakan Tornado untuk pembangunan web dalam Python melalui pertempuran praktikal.

1. Pemasangan dan penggunaan asas Tornado

Pertama, kita perlu memasang Tornado dalam persekitaran tempatan. Ia boleh dipasang melalui pip:

pip install tornado

Selepas pemasangan selesai, kita boleh menggunakan Tornado untuk membina pelayan web yang mudah.

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()

Dalam kod di atas, kami mentakrifkan kelas MainHandler yang diwarisi daripada tornado.web.RequestHandler, yang boleh mengendalikan permintaan GET daripada pelanggan. Dalam pembina, kami menggunakan kaedah self.write() untuk mengembalikan mesej kepada klien. Seterusnya, kami mentakrifkan fungsi make_app(), yang mencipta objek tornado.web.Application. Dalam pembina objek ini, kami memetakan laluan ke kelas MainHandler yang kami tentukan dan mengembalikannya. Akhir sekali, kami mencipta objek Aplikasi dalam blok kod if name == "__main__", dengar pada port 8888 tempatan dan mulakan gelung IOLoop. Lawati http://localhost:8888 dalam penyemak imbas tempatan anda dan anda akan melihat mesej "Hello, world".

2. IO Asynchronous dalam Tornado

Sebagai rangka kerja Web yang cekap, mekanisme berasaskan IO tak segerak Tornado membolehkannya bertindak balas dengan cepat kepada permintaan pelanggan. Dalam operasi IO segerak tradisional, setiap permintaan perlu menunggu penyiapan permintaan sebelumnya sebelum meneruskan ke permintaan seterusnya. Dalam operasi IO tak segerak, apabila operasi IO dimulakan, benang tidak akan disekat selama-lamanya, tetapi akan kembali serta-merta dan terus melaksanakan permintaan seterusnya. Mekanisme ini membolehkan pelayan web mengendalikan berbilang permintaan pada masa yang sama, dengan itu meningkatkan keupayaan pemprosesan serentak sistem.

Pertama, mari kita lihat contoh IO segerak.

import tornado.ioloop
import tornado.web
import time

class MainHandler(tornado.web.RequestHandler):
    def get(self):
        time.sleep(5)
        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()

Dalam kod di atas, kami mensimulasikan operasi yang mengambil masa 5 saat untuk diselesaikan. Jika kami mengakses pelayan dengan penyemak imbas, kami akan mendapati bahawa kami akan menunggu sehingga permintaan diproses.

Seterusnya, mari lihat contoh penggunaan operasi IO tak segerak.

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

class MainHandler(tornado.web.RequestHandler):
    @tornado.gen.coroutine
    def get(self):
        yield tornado.gen.sleep(5)
        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()

Dalam kod di atas, kami menggunakan pengubah suai tornado.gen.coroutine dan menggunakan pernyataan hasil untuk melaksanakan operasi IO tak segerak. Ini bermakna sebelum melaksanakan pernyataan hasil, pemproses akan segera kembali dan memproses permintaan seterusnya, dan hasilnya tidak akan dikembalikan kepada klien sehingga operasi tak segerak selesai.

3. Multi-threading dan multi-process dalam Tornado

Selain keupayaan IO asynchronous, Tornado juga boleh meningkatkan keupayaan pemprosesan serentak pelayan melalui multi-threading atau multi-process teknologi. Dalam Tornado, kita boleh menggunakan dua kaedah untuk melaksanakan pemprosesan berbilang benang atau berbilang proses:

1 Gunakan tornado.process.fork_processes() untuk mendayakan mod berbilang proses secara automatik. mod proses berdasarkan bilangan teras CPU Setiap proses diberikan port yang sepadan.

import tornado.ioloop
import tornado.web
import tornado.process

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.process.fork_processes()
    tornado.ioloop.IOLoop.current().start()

Dalam kod di atas, kami menggunakan kaedah tornado.process.fork_processes() untuk mendayakan mod berbilang proses, supaya kami boleh memanfaatkan sepenuhnya pemprosesan selari CPU.

2. Gunakan tornado.concurrent.futures.ThreadPoolExecutor() untuk mendayakan mod berbilang benang.

import tornado.ioloop
import tornado.web
import tornado.concurrent
import concurrent.futures

class MainHandler(tornado.web.RequestHandler):
    executor = concurrent.futures.ThreadPoolExecutor()

    @tornado.concurrent.run_on_executor
    def my_background_task(self):
        # 执行一些耗时的IO操作
        return result

    @tornado.gen.coroutine
    def get(self):
        result = yield self.my_background_task()
        self.write(result)

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

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

Dalam kod di atas, kami menggunakan tornado.concurrent.futures.ThreadPoolExecutor() untuk mendayakan mod multi-threading dan gunakan pengubah suai @tornado.concurrent.run_on_executor untuk menyerahkan kaedah my_background_task() kepada kolam benang untuk dilaksanakan. Dengan cara ini, kita boleh mengendalikan berbilang operasi IO secara serentak dalam satu utas.

4. Ringkasan

Artikel ini membolehkan pembaca memahami penggunaan Tornado untuk Web dalam Python dengan memperkenalkan penggunaan asas Tornado, operasi IO asynchronous, multi-threading dan teknologi berbilang proses, dan contoh penggunaan kaedah dan teknik. Kecekapan, kesederhanaan dan fleksibiliti Tornado menjadikannya salah satu alat penting untuk pembangunan web dalam Python. Walaupun Tornado tidak sesuai untuk semua senario Web, dalam sesetengah senario dengan prestasi tinggi dan keperluan selaras, Tornado akan menunjukkan prestasi unggulnya.

Atas ialah kandungan terperinci Pembangunan Web dalam Python: Tornado in Action. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!