淺析tornado 中demo的 blog模塊

​#!/usr/bin/env python

#

# Copyright 2009 Facebook

#

# Licensed under the Apache License, Version 2.0 (the "License"); you may

# not use this file except in compliance with the License. You may obtain

# a copy of the License at

#

#     http://www.apache.org/licenses/LICENSE-2.0

#

# Unless required by applicable law or agreed to in writing, software

# distributed under the License is distributed on an "AS IS" BASIS, WITHOUT

# WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the

# License for the specific language governing permissions and limitations

# under the License.

 

import markdown

import os.path

import re

import torndb

import tornado.auth

import tornado.httpserver

import tornado.ioloop

import tornado.options

import tornado.web

import unicodedata

 

from tornado.options import define, options

#定義一些通用的配置信息，好比數據庫的鏈接信息，端口信息

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

define("mysql_host", default="127.0.0.1:3306", help="blog database host")

define("mysql_database", default="blog", help="blog database name")

define("mysql_user", default="root", help="blog database user")

define("mysql_password", default="sa123", help="blog database password")

 

#定義Application信息，它是繼承tornado.web.Application 的

class Application(tornado.web.Application):

　　 # __init__ 函數自動調用

    def __init__(self):

　　    #這裏就是url對應的控制器，下面分別對應一個類，來處理裏面的邏輯

        handlers = [

            (r"/", HomeHandler),

            (r"/archive", ArchiveHandler),

            (r"/feed", FeedHandler),

            (r"/entry/([^/]+)", EntryHandler),

            (r"/compose", ComposeHandler),

            (r"/auth/login", AuthLoginHandler),

            (r"/auth/logout", AuthLogoutHandler),

        ]

　　    #設置，如博客標題，模板目錄，靜態文件目錄，xsrf，是否調試

        settings = dict(

            blog_title=u"Tornado Blog",

            template_path=os.path.join(os.path.dirname(__file__), "templates"),

            static_path=os.path.join(os.path.dirname(__file__), "static"),

            ui_modules={"Entry": EntryModule},

            xsrf_cookies=True,

            cookie_secret="__TODO:_GENERATE_YOUR_OWN_RANDOM_VALUE_HERE__",

            login_url="/auth/login",

            debug=True,

        )

　　     #而後調用tornado.web.Application類的__init__函數加載進來

        tornado.web.Application.__init__(self, handlers, **settings)

 

        # Have one global connection to the blog DB across all handlers

　　     #數據庫鏈接信息

        self.db = torndb.Connection(

            host=options.mysql_host, database=options.mysql_database,

            user=options.mysql_user, password=options.mysql_password)

 

#基類，繼承自tornado.web.RequestHandler 的，後面的類都是繼承這個類的

class BaseHandler(tornado.web.RequestHandler):

　　#屬性裝飾器，使db函數變成一個屬性，便於後面直接使用

    @property

    def db(self):

        return self.application.db

　　#得到當前的用戶

    def get_current_user(self):

        user_id = self.get_secure_cookie("blogdemo_user")

        if not user_id: return None

        return self.db.get("SELECT * FROM authors WHERE id = %s", int(user_id))

 

#首頁

class HomeHandler(BaseHandler):

    def get(self):

　　　　 #query 查詢不少列

        entries = self.db.query("SELECT * FROM entries ORDER BY published "

                                "DESC LIMIT 5")

        if not entries:

　　　　     #redirect 重定向到一個url

            self.redirect("/compose")

            return

　　　　 #render 渲染一個模板，後面是參數

        self.render("home.html", entries=entries)

 

 

class EntryHandler(BaseHandler):

    def get(self, slug):

　　　　#get 獲得一個值

        entry = self.db.get("SELECT * FROM entries WHERE slug = %s", slug)

　　　　#raise 觸發一個錯誤信息，後面必須接類型

        if not entry: raise tornado.web.HTTPError(404)

        self.render("entry.html", entry=entry)

 

 

class ArchiveHandler(BaseHandler):

    def get(self):

        entries = self.db.query("SELECT * FROM entries ORDER BY published "

                                "DESC")

        self.render("archive.html", entries=entries)

 

 

class FeedHandler(BaseHandler):

    def get(self):

        entries = self.db.query("SELECT * FROM entries ORDER BY published "

                                "DESC LIMIT 10")

        self.set_header("Content-Type", "application/atom+xml")

        self.render("feed.xml", entries=entries)

 

 

class ComposeHandler(BaseHandler):

    #裝飾器

    @tornado.web.authenticated

    def get(self):

        id = self.get_argument("id", None)

        entry = None

        if id:

            entry = self.db.get("SELECT * FROM entries WHERE id = %s", int(id))

        self.render("compose.html", entry=entry)

 

    @tornado.web.authenticated

    def post(self):

        id = self.get_argument("id", None)

        title = self.get_argument("title")

        text = self.get_argument("markdown")

        html = markdown.markdown(text)

        if id:

            entry = self.db.get("SELECT * FROM entries WHERE id = %s", int(id))

            if not entry: raise tornado.web.HTTPError(404)

            slug = entry.slug

　　        #execute是執行的意思

            self.db.execute(

                "UPDATE entries SET title = %s, markdown = %s, html = %s "

                "WHERE id = %s", title, text, html, int(id))

        else:

            slug = unicodedata.normalize("NFKD", title).encode(

                "ascii", "ignore")

            slug = re.sub(r"[^\w]+", " ", slug)

            slug = "-".join(slug.lower().strip().split())

            if not slug: slug = "entry"

            while True:

                e = self.db.get("SELECT * FROM entries WHERE slug = %s", slug)

                if not e: break

                slug += "-2"

            self.db.execute(

                "INSERT INTO entries (author_id,title,slug,markdown,html,"

                "published) VALUES (%s,%s,%s,%s,%s,UTC_TIMESTAMP())",

                self.current_user.id, title, slug, text, html)

        self.redirect("/entry/" + slug)

 

 

class AuthLoginHandler(BaseHandler, tornado.auth.GoogleMixin):

    @tornado.web.asynchronous

    def get(self):

        if self.get_argument("openid.mode", None):

            self.get_authenticated_user(self.async_callback(self._on_auth))

            return

        self.authenticate_redirect()

　　#這裏定義一個函數，來供上面調用

    def _on_auth(self, user):

        if not user:

            raise tornado.web.HTTPError(500, "Google auth failed")

        author = self.db.get("SELECT * FROM authors WHERE email = %s",

                             user["email"])

        if not author:

            # Auto-create first author

            any_author = self.db.get("SELECT * FROM authors LIMIT 1")

            if not any_author:

                author_id = self.db.execute(

                    "INSERT INTO authors (email,name) VALUES (%s,%s)",

                    user["email"], user["name"])

            else:

                self.redirect("/")

                return

        else:

            author_id = author["id"]

        self.set_secure_cookie("blogdemo_user", str(author_id))

        self.redirect(self.get_argument("next", "/"))

 

 

class AuthLogoutHandler(BaseHandler):

    def get(self):

        self.clear_cookie("blogdemo_user")

　　    #get_argument爲得到next參數的值，默認爲"/"

        self.redirect(self.get_argument("next", "/"))

 

 

class EntryModule(tornado.web.UIModule):

    def render(self, entry):

        return self.render_string("modules/entry.html", entry=entry)

 

#入口函數

def main():

    tornado.options.parse_command_line()

　  #建立一個服務器

    http_server = tornado.httpserver.HTTPServer(Application())

　  #監聽端口

    http_server.listen(options.port)

　　#啓動服務

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

 

#調用的入口

if __name__ == "__main__":

    main()

 

 最後總結一下：

1）tornado框架中提供的幾個demo，都是以這種形式來建立一個應用的

2）對每個控制器函數，要麼是，只可能有2個對外的函數，一個是get，一個是post

3）數據庫有3中調用方式，query，get，exec

4）獲取參數的值使用 get_argument 函數

5）重定向用redirect 函數

6）全部的函數都是屬性這個類的，全部都用self調用

7）渲染模板用render函數