目录

一、基本使用

二、路由系统

三、视图函数

四、模版语言

五、cookie

六、CSRF

七、文件上传

八、异步非阻塞

九、RESTFUL

十、自定义组件

一、基本使用

1、最简使用

import tornado.ioloop

import tornado.web

class MainHandler(tornado.web.RequestHandler):

    def get(self):

        self.write("Hello, world")

application = tornado.web.Application([

    (r"/index", MainHandler),

])

if __name__ == "__main__":

    application.listen(8888)

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

app.py示例

2、settings

settings = {

    'template_path': 'template',    #  html文件夹

    'static_path': 'static',    # 静态文件夹

    'static_url_prefix': '/static/',    # html里的静态文件夹路径前缀

    'ui_methods': mt,

    'ui_modules': md,

}

application = tornado.web.Application([

    (r"/index", MainHandler),

], **settings)    # 在这使用**settings

（1）html里静态文件使用方法

建议用这种

<link href="{{static_url("css/common.css")}}" rel="stylesheet" />

<script src="{{static_url("jquery-3.3.1.js")}}"></script>

或

<link href="/static/css/common.css" rel="stylesheet" />

<script src="/static/jquery-3.3.1.js"></script>

静态文件缓存的实现（这段不知道是什么，先记录下来）

def get_content_version(cls, abspath):

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

        This class method may be overridden by subclasses.  The

        default implementation is a hash of the file's contents.

        .. versionadded:: 3.1

        """

        data = cls.get_content(abspath)

        hasher = hashlib.md5()

        if isinstance(data, bytes):

            hasher.update(data)

        else:

            for chunk in data:

                hasher.update(chunk)

        return hasher.hexdigest()

静态文件缓存的实现

路由系统

1、基本使用

路由系统其实就是 url 和 类 的对应关系，这里不同于其他框架，其他很多框架均是 url 对应 函数，Tornado中每个url对应的是一个类

class MainHandler(tornado.web.RequestHandler):

    def get(self):

        self.write("Hello, world")

application = tornado.web.Application([

    (r"/index", MainHandler),

    (r"/story/([0-9]+)", StoryHandler),

])
import tornado.ioloop

import tornado.web

class MainHandler(tornado.web.RequestHandler):

    def get(self):

        self.write("Hello, world")

class StoryHandler(tornado.web.RequestHandler):

    def get(self, story_id):

        self.write("You requested the story " + story_id)

class BuyHandler(tornado.web.RequestHandler):

    def get(self):

        self.write("buy.wupeiqi.com/index")

application = tornado.web.Application([

    (r"/index", MainHandler),

    (r"/story/([0-9]+)", StoryHandler),

])

application.add_handlers('buy.wupeiqi.com$', [

    (r'/index',BuyHandler),

])

if __name__ == "__main__":

    application.listen(80)

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

示例

2、其他

reverse_url

#!/usr/bin/env python

# -*- coding:utf-8 -*-

import tornado.ioloop

import tornado.web

from tornado.web import RequestHandler

class MainHandler(RequestHandler):

    def get(self):

        url1 = self.application.reverse_url("n1")

        print(url1)

        url2 = self.application.reverse_url("n2",666)

        print(url2)

        self.write("Hello, world")

class HomeHandler(RequestHandler):

    def get(self,*args,**kwargs):

        print(args)

        print(kwargs)

        self.write("welcome home")

application = tornado.web.Application([

    (r"/index", MainHandler,{},"n1"),

    (r"/home/(?P<pk>\d+)", HomeHandler,{},"n2"),

])

if __name__ == "__main__":

    application.listen(8888)

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

'''

/index

/home/666

'''

app.py

视图函数

模版语言

1、基本使用

#!/usr/bin/env python

# -*- coding:utf-8 -*-

import tornado.ioloop

import tornado.web

class MainHandler(tornado.web.RequestHandler):

    def get(self):

        self.render("index.html", list_info = [11,22,33])

application = tornado.web.Application([

    (r"/index", MainHandler),

])

if __name__ == "__main__":

    application.listen(8888)

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

app.py

<!DOCTYPE html>

<html>

<head>

    <meta http-equiv="Content-Type" content="text/html; charset=UTF-8"/>

</head>

<body>

    <div>

        <ul>

            {% for item in list_info %}

                <li>{{item}}</li>

            {% end %}

        </ul>

    </div>

</body>

</html>

index.html

在模板中默认提供了一些函数、字段、类以供模板使用：

escape: tornado.escape.xhtml_escape 的別名

xhtml_escape: tornado.escape.xhtml_escape 的別名

url_escape: tornado.escape.url_escape 的別名

json_encode: tornado.escape.json_encode 的別名

squeeze: tornado.escape.squeeze 的別名

linkify: tornado.escape.linkify 的別名

datetime: Python 的 datetime 模组

handler: 当前的 RequestHandler 对象

request: handler.request 的別名

current_user: handler.current_user 的別名

locale: handler.locale 的別名

_: handler.locale.translate 的別名

static_url: for handler.static_url 的別名

xsrf_form_html: handler.xsrf_form_html 的別名

其他方法

2、for、if使用

{% for item in list_info %}

    <li>{{item}}</li>

{% end %} 
{% if item > 22 %}

    <h1>{{item}}</h1>

{% else %}

    <li>{{item}}</li>

{% end %}

3、母版、插件

（1）母版

用法与django基本一致

{% extends 'xxxxxxxx.html'%}

{% block xxx %}{% end %}
<!DOCTYPE html>

<html>

<head>

    <meta http-equiv="Content-Type" content="text/html; charset=UTF-8"/>

    <title>老男孩</title>

    {% block CSS %}{% end %}

</head>

<body>

    <div class="pg-header">

    </div>

    {% block RenderBody %}{% end %}

    {% block JavaScript %}{% end %}

</body>

</html>

layout.html

{% extends 'layout.html'%}

{% block CSS %}

{% end %}

{% block RenderBody %}

    <h1>Index</h1>

    <ul>

    {%  for item in list_info %}

        <li>{{item}}</li>

    {% end %}

    </ul>

{% end %}

{% block JavaScript %}

{% end %}

index.html

（2）插件

用法与django基本一致

{% include 'xxxxx.html' %}
<div>

    <ul>

        <li>1024</li>

        <li>42区</li>

    </ul>

</div>

header.html

<!DOCTYPE html>

<html>

<head>

    <meta http-equiv="Content-Type" content="text/html; charset=UTF-8"/>

</head>

<body>

    <div class="pg-header">

        {% include 'header.html' %}

    </div>

</body>

</html>

index.html

4、自定义UIMethod、UIModule

类似于django的simply_tag

（1）自定义uimethods.py与uimodules.py。注意：这里的uimethods和uimodules只是py的文件名

def tab(self):

    return 'UIMethod'

uimethods.py

#!/usr/bin/env python

# -*- coding:utf-8 -*-

from tornado.web import UIModule

from tornado import escape

class custom(UIModule):

    def render(self, *args, **kwargs):

        return escape.xhtml_escape('<h1>模版语言</h1>')

uimodules.py

（2）在主程序中注册settings

#!/usr/bin/env python

# -*- coding:utf-8 -*-

import tornado.ioloop

import tornado.web

from tornado.escape import linkify

import uimodules as md  # 导入自定义模块

import uimethods as mt  # 导入自定义模块

class MainHandler(tornado.web.RequestHandler):

    def get(self):

        self.render('index.html')

settings = {

    'template_path': 'template',  # html文件夹

    'static_path': 'static',  # 静态文件夹

    'static_url_prefix': '/static/',

    'ui_methods': mt,

    'ui_modules': md,

}

application = tornado.web.Application([

    (r"/index", MainHandler),

], **settings)

if __name__ == "__main__":

    application.listen(8888)

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

app.py

（3）在html上使用

<!DOCTYPE html>

<html>

<head lang="en">

    <meta charset="UTF-8">

    <title></title>

    <link href="{{static_url("commons.css")}}" rel="stylesheet" />

</head>

<body>

    <h1>hello</h1>

    {% module custom(123) %}

    {{ tab() }}

</body>

index.html

cookie

self.set_cookie("mycookie", "myvalue")

self.get_cookie("xxx")

self.set_secure_cookie("mycookie", "myvalue")

self.get_secure_cookie("xxx")

expires使用时间戳

import time

expire_time = time.time() + 300  # 时间戳

self.set_cookie("mycookie","myvalue",expires=expire_time)

1、基本使用

import tornado.ioloop

import tornado.web

class MainHandler(tornado.web.RequestHandler):

    def get(self):

        self.set_cookie('test_cookie',"helloworld")

        self.write("Hello, world")

application = tornado.web.Application([

    (r"/index", MainHandler),

])

if __name__ == "__main__":

    application.listen(8888)

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

app.py

2、加密cookie（签名）

Cookie 很容易被恶意的客户端伪造。加入你想在 cookie 中保存当前登陆用户的 id 之类的信息，你需要对 cookie 作签名以防止伪造。Tornado 通过 set_secure_cookie 和 get_secure_cookie 方法直接支持了这种功能。 要使用这些方法，你需要在创建应用时提供一个密钥，名字为 cookie_secret。 你可以把它作为一个关键词参数传入应用的设置中。

签名cookie的本质：

写cookie过程：

将值进行base64加密

对除值以外的内容进行签名，哈希算法（无法逆向解析）

拼接 签名 + 加密值

读cookie过程：

读取 签名 + 加密值

对签名进行验证

base64解密，获取值内容
import tornado.ioloop

import tornado.web

class MainHandler(tornado.web.RequestHandler):

    def get(self):

        if not self.get_secure_cookie("mycookie"):

            self.set_secure_cookie("mycookie", "myvalue")

            self.write("Your cookie was not set yet!")

        else:

            self.write("Your cookie was set!")

application = tornado.web.Application([

    (r"/index", MainHandler),

], cookie_secret="61oETzKXQAGaYdkL5gEmGeJJFuYh7EQnp2XdTP1o/Vo=")

if __name__ == "__main__":

    application.listen(8888)

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

app.py

def _create_signature_v1(secret, *parts):

    hash = hmac.new(utf8(secret), digestmod=hashlib.sha1)

    for part in parts:

        hash.update(utf8(part))

    return utf8(hash.hexdigest())

# 加密

def _create_signature_v2(secret, s):

    hash = hmac.new(utf8(secret), digestmod=hashlib.sha256)

    hash.update(utf8(s))

    return utf8(hash.hexdigest())

def create_signed_value(secret, name, value, version=None, clock=None,

                        key_version=None):

    if version is None:

        version = DEFAULT_SIGNED_VALUE_VERSION

    if clock is None:

        clock = time.time

    timestamp = utf8(str(int(clock())))

    value = base64.b64encode(utf8(value))

    if version == 1:

        signature = _create_signature_v1(secret, name, value, timestamp)

        value = b"|".join([value, timestamp, signature])

        return value

    elif version == 2:

        # The v2 format consists of a version number and a series of

        # length-prefixed fields "%d:%s", the last of which is a

        # signature, all separated by pipes.  All numbers are in

        # decimal format with no leading zeros.  The signature is an

        # HMAC-SHA256 of the whole string up to that point, including

        # the final pipe.

        #

        # The fields are:

        # - format version (i.e. 2; no length prefix)

        # - key version (integer, default is 0)

        # - timestamp (integer seconds since epoch)

        # - name (not encoded; assumed to be ~alphanumeric)

        # - value (base64-encoded)

        # - signature (hex-encoded; no length prefix)

        def format_field(s):

            return utf8("%d:" % len(s)) + utf8(s)

        to_sign = b"|".join([

            b"",

            format_field(str(key_version or 0)),

            format_field(timestamp),

            format_field(name),

            format_field(value),

            b''])

        if isinstance(secret, dict):

            assert key_version is not None, 'Key version must be set when sign key dict is used'

            assert version >= 2, 'Version must be at least 2 for key version support'

            secret = secret[key_version]

        signature = _create_signature_v2(secret, to_sign)

        return to_sign + signature

    else:

        raise ValueError("Unsupported version %d" % version)

# 解密

def _decode_signed_value_v1(secret, name, value, max_age_days, clock):

    parts = utf8(value).split(b"|")

    if len(parts) != 3:

        return None

    signature = _create_signature_v1(secret, name, parts[0], parts[1])

    if not _time_independent_equals(parts[2], signature):

        gen_log.warning("Invalid cookie signature %r", value)

        return None

    timestamp = int(parts[1])

    if timestamp < clock() - max_age_days * 86400:

        gen_log.warning("Expired cookie %r", value)

        return None

    if timestamp > clock() + 31 * 86400:

        # _cookie_signature does not hash a delimiter between the

        # parts of the cookie, so an attacker could transfer trailing

        # digits from the payload to the timestamp without altering the

        # signature.  For backwards compatibility, sanity-check timestamp

        # here instead of modifying _cookie_signature.

        gen_log.warning("Cookie timestamp in future; possible tampering %r",

                        value)

        return None

    if parts[1].startswith(b""):

        gen_log.warning("Tampered cookie %r", value)

        return None

    try:

        return base64.b64decode(parts[0])

    except Exception:

        return None

def _decode_fields_v2(value):

    def _consume_field(s):

        length, _, rest = s.partition(b':')

        n = int(length)

        field_value = rest[:n]

        # In python 3, indexing bytes returns small integers; we must

        # use a slice to get a byte string as in python 2.

        if rest[n:n + 1] != b'|':

            raise ValueError("malformed v2 signed value field")

        rest = rest[n + 1:]

        return field_value, rest

    rest = value[2:]  # remove version number

    key_version, rest = _consume_field(rest)

    timestamp, rest = _consume_field(rest)

    name_field, rest = _consume_field(rest)

    value_field, passed_sig = _consume_field(rest)

    return int(key_version), timestamp, name_field, value_field, passed_sig

def _decode_signed_value_v2(secret, name, value, max_age_days, clock):

    try:

        key_version, timestamp, name_field, value_field, passed_sig = _decode_fields_v2(value)

    except ValueError:

        return None

    signed_string = value[:-len(passed_sig)]

    if isinstance(secret, dict):

        try:

            secret = secret[key_version]

        except KeyError:

            return None

    expected_sig = _create_signature_v2(secret, signed_string)

    if not _time_independent_equals(passed_sig, expected_sig):

        return None

    if name_field != utf8(name):

        return None

    timestamp = int(timestamp)

    if timestamp < clock() - max_age_days * 86400:

        # The signature has expired.

        return None

    try:

        return base64.b64decode(value_field)

    except Exception:

        return None

def get_signature_key_version(value):

    value = utf8(value)

    version = _get_version(value)

    if version < 2:

        return None

    try:

        key_version, _, _, _, _ = _decode_fields_v2(value)

    except ValueError:

        return None

    return key_version

内部算法

内部算法

CSRF

Tornado中的跨站请求伪造和Django中的相似

（Ajax使用时，本质上就是去获取本地的cookie，携带cookie再来发送请求）

settings = {

    "xsrf_cookies": True,

}

application = tornado.web.Application([

    (r"/", MainHandler),

    (r"/login", LoginHandler),

], **settings)

app.py

<form action="/new_message" method="post">

  {{ xsrf_form_html() }}

  <input type="text" name="message"/>

  <input type="submit" value="Post"/>

</form>

html使用form表单post

function getCookie(name) {

    var r = document.cookie.match("\\b" + name + "=([^;]*)\\b");

    return r ? r[1] : undefined;

}

jQuery.postJSON = function(url, args, callback) {

    args._xsrf = getCookie("_xsrf");

    $.ajax({url: url, data: $.param(args), dataType: "text", type: "POST",

        success: function(response) {

        callback(eval("(" + response + ")"));

    }});

};

AJAX

文件上传

1、Form表单上传

<!DOCTYPE html>

<html>

<head>

    <meta http-equiv="Content-Type" content="text/html; charset=UTF-8"/>

    <title>上传文件</title>

</head>

<body>

    <form id="my_form" name="form" action="/index" method="POST"  enctype="multipart/form-data" >

        <input name="fff" id="my_file"  type="file" />

        <input type="submit" value="提交"  />

    </form>

</body>

</html>

html

#!/usr/bin/env python

# -*- coding:utf-8 -*-

import tornado.ioloop

import tornado.web

class MainHandler(tornado.web.RequestHandler):

    def get(self):

        self.render('index.html')

    def post(self, *args, **kwargs):

        file_metas = self.request.files["fff"]

        # print(file_metas)

        for meta in file_metas:

            file_name = meta['filename']

            with open(file_name,'wb') as up:

                up.write(meta['body'])

settings = {

    'template_path': 'template',

}

application = tornado.web.Application([

    (r"/index", MainHandler),

], **settings)

if __name__ == "__main__":

    application.listen(8000)

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

Python

app.py

2、AJAX上传

<!DOCTYPE html>

<html>

<head lang="en">

    <meta charset="UTF-8">

    <title></title>

</head>

<body>

    <input type="file" id="img" />

    <input type="button" onclick="UploadFile();" />

    <script>

        function UploadFile(){

            var fileObj = document.getElementById("img").files[0];

            var form = new FormData();

            form.append("k1", "v1");

            form.append("fff", fileObj);

            var xhr = new XMLHttpRequest();

            xhr.open("post", '/index', true);

            xhr.send(form);

        }

    </script>

</body>

</html>

HTML - XMLHttpRequest

<!DOCTYPE html>

<html>

<head lang="en">

    <meta charset="UTF-8">

    <title></title>

</head>

<body>

    <input type="file" id="img" />

    <input type="button" onclick="UploadFile();" />

    <script>

        function UploadFile(){

            var fileObj = $("#img")[0].files[0];

            var form = new FormData();

            form.append("k1", "v1");

            form.append("fff", fileObj);

            $.ajax({

                type:'POST',

                url: '/index',

                data: form,

                processData: false,  // tell jQuery not to process the data

                contentType: false,  // tell jQuery not to set contentType

                success: function(arg){

                    console.log(arg);

                }

            })

        }

    </script>

</body>

</html>

HTML - jQuery

<!DOCTYPE html>

<html>

<head lang="en">

    <meta charset="UTF-8">

    <title></title>

</head>

<body>

    <form id="my_form" name="form" action="/index" method="POST"  enctype="multipart/form-data" >

        <div id="main">

            <input name="fff" id="my_file"  type="file" />

            <input type="button" name="action" value="Upload" onclick="redirect()"/>

            <iframe id='my_iframe' name='my_iframe' src=""  class="hide"></iframe>

        </div>

    </form>

    <script>

        function redirect(){

            document.getElementById('my_iframe').onload = Testt;

            document.getElementById('my_form').target = 'my_iframe';

            document.getElementById('my_form').submit();

        }

        function Testt(ths){

            var t = $("#my_iframe").contents().find("body").text();

            console.log(t);

        }

    </script>

</body>

</html>

HTML - iframe

#!/usr/bin/env python

# -*- coding:utf-8 -*-

import tornado.ioloop

import tornado.web

class MainHandler(tornado.web.RequestHandler):

    def get(self):

        self.render('index.html')

    def post(self, *args, **kwargs):

        file_metas = self.request.files["fff"]

        # print(file_metas)

        for meta in file_metas:

            file_name = meta['filename']

            with open(file_name,'wb') as up:

                up.write(meta['body'])

settings = {

    'template_path': 'template',

}

application = tornado.web.Application([

    (r"/index", MainHandler),

], **settings)

if __name__ == "__main__":

    application.listen(8000)

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

app.py

验证成功，略。

<script type="text/javascript">

    $(document).ready(function () {

        $("#formsubmit").click(function () {

            var iframe = $('<iframe name="postiframe" id="postiframe" style="display: none"></iframe>');

            $("body").append(iframe);

            var form = $('#theuploadform');

            form.attr("action", "/upload.aspx");

            form.attr("method", "post");

            form.attr("encoding", "multipart/form-data");

            form.attr("enctype", "multipart/form-data");

            form.attr("target", "postiframe");

            form.attr("file", $('#userfile').val());

            form.submit();

            $("#postiframe").load(function () {

                iframeContents = this.contentWindow.document.body.innerHTML;

                $("#textarea").html(iframeContents);

            });

            return false;

        });

    });

</script>

<form id="theuploadform">

    <input id="userfile" name="userfile" size="" type="file" />

    <input id="formsubmit" type="submit" value="Send File" />

</form>

<div id="textarea">

</div>

扩展：基于iframe实现Ajax上传示例

$('#upload_iframe').load(function(){

                    var iframeContents = this.contentWindow.document.body.innerText;

                    iframeContents = JSON.parse(iframeContents);

                })
function bindChangeAvatar1() {

            $('#avatarImg').change(function () {

                var file_obj = $(this)[0].files[0];

                $('#prevViewImg')[0].src = window.URL.createObjectURL(file_obj)

            })

        }

        function bindChangeAvatar2() {

            $('#avatarImg').change(function () {

                var file_obj = $(this)[0].files[0];

                var reader = new FileReader();

                reader.readAsDataURL(file_obj);

                reader.onload = function (e) {

                    $('#previewImg')[0].src = this.result;

                };

            })

        }

        function bindChangeAvatar3() {

            $('#avatarImg').change(function () {

                var file_obj = $(this)[0].files[0];

                var form = new FormData();

                form.add('img_upload', file_obj);

                $.ajax({

                    url: '',

                    data: form,

                    processData: false,  // tell jQuery not to process the data

                    contentType: false,  // tell jQuery not to set contentType

                    success: function (arg) {

                    }

                })

            })

        }

        function bindChangeAvatar4() {

            $('#avatarImg').change(function () {

                $(this).parent().submit();

                $('#upload_iframe').load(function () {

                    var iframeContents = this.contentWindow.document.body.innerText;

                    iframeContents = JSON.parse(iframeContents);

                    if (iframeContents.status) {

                        $('#previewImg').attr('src', '/' + iframeContents.data);

                    }

                })

            })

        }

其他

异步非阻塞

1、同步阻塞和异步非阻塞对比

装饰器 + Future 从而实现Tornado的异步非阻塞

当发送GET请求时，由于方法被@gen.coroutine装饰且yield 一个 Future对象，那么Tornado会等待，等待用户向future对象中放置数据或者发送信号，如果获取到数据或信号之后，就开始执行doing方法。

#!/usr/bin/env python

# -*- coding:utf-8 -*-

import tornado.ioloop

import tornado.web

from tornado.web import RequestHandler

import time

class SyncHandler(RequestHandler):

    def get(self):

        self.doing()

        self.write('sync')

    def doing(self):

        time.sleep(10)

application = tornado.web.Application([

    (r"^/$", SyncHandler),

])

if __name__ == "__main__":

    application.listen(8888)

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

同步阻塞

#!/usr/bin/env python

# -*- coding:utf-8 -*-

import tornado.ioloop

import tornado.web

from tornado.web import RequestHandler

import time

from tornado.web import gen,Future

# class SyncHandler(RequestHandler):

#

#     def get(self):

#         self.doing()

#         self.write('sync')

#

#     def doing(self):

#         time.sleep(10)

class AsyncHandler(tornado.web.RequestHandler):

    @gen.coroutine

    def get(self):

        future = Future()

        tornado.ioloop.IOLoop.current().add_timeout(time.time() + 5, self.doing)

        yield future

    def doing(self, *args, **kwargs):

        self.write('async')

        self.finish()

application = tornado.web.Application([

    # (r"^/$", SyncHandler),

    (r"^/test/$", AsyncHandler),

])

if __name__ == "__main__":

    application.listen(8888)

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

异步非阻塞

2、httpclient类库

Tornado提供了httpclient类库用于发送Http请求，其配合Tornado的异步非阻塞使用。

import tornado.ioloop

import tornado.web

class MainHandler(tornado.web.RequestHandler):

    def get(self):

        import requests

        requests.get('http://www.google.com')

        self.write('xxxxx')

class IndexHandler(tornado.web.RequestHandler):

    def get(self):

        self.write("Index")

application = tornado.web.Application([

    (r"/main", MainHandler),

    (r"/index", IndexHandler),

])

if __name__ == "__main__":

    application.listen(8888)

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

同步阻塞

#!/usr/bin/env python

# -*- coding:utf-8 -*-

import tornado.web

from tornado import gen

from tornado import httpclient

# 方式一：

class AsyncHandler(tornado.web.RequestHandler):

    @gen.coroutine

    def get(self, *args, **kwargs):

        print('进入')

        http = httpclient.AsyncHTTPClient()

        data = yield http.fetch("http://www.google.com")

        print('完事',data)

        self.finish('')

# 方式二：

# class AsyncHandler(tornado.web.RequestHandler):

#     @gen.coroutine

#     def get(self):

#         print('进入')

#         http = httpclient.AsyncHTTPClient()

#         yield http.fetch("http://www.google.com", self.done)

#

#     def done(self, response):

#         print('完事')

#         self.finish('666')

application = tornado.web.Application([

    (r"/async", AsyncHandler),

])

if __name__ == "__main__":

    application.listen(8888)

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

httpclient的异步非阻塞

引入future.set_result 当有异步io阻塞的时候 使用future.set_result可以终止阻塞

import tornado.ioloop

import tornado.web

from tornado import gen

from tornado.concurrent import Future

future = None

class MainHandler(tornado.web.RequestHandler):

    @gen.coroutine

    def get(self):

        global future

        future = Future()

        future.add_done_callback(self.done)

        yield future

    def done(self, *args, **kwargs):

        self.write('Main')

        self.finish()

class IndexHandler(tornado.web.RequestHandler):

    def get(self):

        global future

        future.set_result(None)

        self.write("Index")

application = tornado.web.Application([

    (r"/main", MainHandler),

    (r"/index", IndexHandler),

])

if __name__ == "__main__":

    application.listen(8888)

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

set_result终止异步IO阻塞

3、自定义异步非阻塞web框架

http://www.cnblogs.com/wupeiqi/p/6536518.html#3957994

#!/usr/bin/env python

# -*- coding:utf-8 -*-

import re

import socket

import select

import time

class HttpResponse(object):

    """

    封装响应信息

    """

    def __init__(self, content=''):

        self.content = content

        self.headers = {}

        self.cookies = {}

    def response(self):

        return bytes(self.content, encoding='utf-8')

class HttpNotFound(HttpResponse):

    """

    404时的错误提示

    """

    def __init__(self):

        super(HttpNotFound, self).__init__('404 Not Found')

class HttpRequest(object):

    """

    用户封装用户请求信息

    """

    def __init__(self, conn):

        self.conn = conn

        self.header_bytes = bytes()

        self.header_dict = {}

        self.body_bytes = bytes()

        self.method = ""

        self.url = ""

        self.protocol = ""

        self.initialize()

        self.initialize_headers()

    def initialize(self):

        header_flag = False

        while True:

            try:

                received = self.conn.recv(8096)

            except Exception as e:

                received = None

            if not received:

                break

            if header_flag:

                self.body_bytes += received

                continue

            temp = received.split(b'\r\n\r\n', 1)

            if len(temp) == 1:

                self.header_bytes += temp

            else:

                h, b = temp

                self.header_bytes += h

                self.body_bytes += b

                header_flag = True

    @property

    def header_str(self):

        return str(self.header_bytes, encoding='utf-8')

    def initialize_headers(self):

        headers = self.header_str.split('\r\n')

        first_line = headers[0].split(' ')

        if len(first_line) == 3:

            self.method, self.url, self.protocol = headers[0].split(' ')

            for line in headers:

                kv = line.split(':')

                if len(kv) == 2:

                    k, v = kv

                    self.header_dict[k] = v

class Future(object):

    """

    异步非阻塞模式时封装回调函数以及是否准备就绪

    """

    def __init__(self, callback):

        self.callback = callback

        self._ready = False

        self.value = None

    def set_result(self, value=None):

        self.value = value

        self._ready = True

    @property

    def ready(self):

        return self._ready

class TimeoutFuture(Future):

    """

    异步非阻塞超时

    """

    def __init__(self, timeout):

        super(TimeoutFuture, self).__init__(callback=None)

        self.timeout = timeout

        self.start_time = time.time()

    @property

    def ready(self):

        current_time = time.time()

        if current_time > self.start_time + self.timeout:

            self._ready = True

        return self._ready

class Snow(object):

    """

    微型Web框架类

    """

    def __init__(self, routes):

        self.routes = routes

        self.inputs = set()

        self.request = None

        self.async_request_handler = {}

    def run(self, host='localhost', port=9999):

        """

        事件循环

        :param host:

        :param port:

        :return:

        """

        sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)

        sock.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)

        sock.bind((host, port,))

        sock.setblocking(False)

        sock.listen(128)

        sock.setblocking(0)

        self.inputs.add(sock)

        try:

            while True:

                readable_list, writeable_list, error_list = select.select(self.inputs, [], self.inputs,0.005)

                for conn in readable_list:

                    if sock == conn:

                        client, address = conn.accept()

                        client.setblocking(False)

                        self.inputs.add(client)

                    else:

                        gen = self.process(conn)

                        if isinstance(gen, HttpResponse):

                            conn.sendall(gen.response())

                            self.inputs.remove(conn)

                            conn.close()

                        else:

                            yielded = next(gen)

                            self.async_request_handler[conn] = yielded

                self.polling_callback()

        except Exception as e:

            pass

        finally:

            sock.close()

    def polling_callback(self):

        """

        遍历触发异步非阻塞的回调函数

        :return:

        """

        for conn in list(self.async_request_handler.keys()):

            yielded = self.async_request_handler[conn]

            if not yielded.ready:

                continue

            if yielded.callback:

                ret = yielded.callback(self.request, yielded)

                conn.sendall(ret.response())

            self.inputs.remove(conn)

            del self.async_request_handler[conn]

            conn.close()

    def process(self, conn):

        """

        处理路由系统以及执行函数

        :param conn:

        :return:

        """

        self.request = HttpRequest(conn)

        func = None

        for route in self.routes:

            if re.match(route[0], self.request.url):

                func = route[1]

                break

        if not func:

            return HttpNotFound()

        else:

            return func(self.request)

snow.py

自定义异步非阻塞web框架

from snow import Snow

from snow import HttpResponse

def index(request):

    return HttpResponse('OK')

routes = [

    (r'/index/', index),

]

app = Snow(routes)

app.run(port=8012)

基本使用

from snow import Snow

from snow import HttpResponse

from snow import TimeoutFuture

request_list = []

def async(request):

    obj = TimeoutFuture(5)

    yield obj

def home(request):

    return HttpResponse('home')

routes = [

    (r'/home/', home),

    (r'/async/', async),

]

app = Snow(routes)

app.run(port=8012)

异步非阻塞：超时

from snow import Snow

from snow import HttpResponse

from snow import Future

request_list = []

def callback(request, future):

    return HttpResponse(future.value)

def req(request):

    obj = Future(callback=callback)

    request_list.append(obj)

    yield obj

def stop(request):

    obj = request_list[0]

    del request_list[0]

    obj.set_result('done')

    return HttpResponse('stop')

routes = [

    (r'/req/', req),

    (r'/stop/', stop),

]

app = Snow(routes)

app.run(port=8012)

异步非阻塞：等待 基于等待模式可以完成自定制操作

RESTFUL

利用Tornado 的原生restfull，轻松的开发API

需求：Haproxy服务化，即：提供API可以对Ha配置文件进行获取，添加，删除

global

        log 127.0.0.1 local2

        daemon

        maxconn 256

        log 127.0.0.1 local2 info

defaults

        log global

        mode http

        timeout connect 5000ms

        timeout client 50000ms

        timeout server 50000ms

        option  dontlognull

listen stats :8888

        stats enable

        stats uri       /admin

        stats auth      admin:1234

frontend oldboy.org

        bind 0.0.0.0:80

        option httplog

        option httpclose

        option  forwardfor

        log global

        acl www hdr_reg(host) -i www.oldboy.org

        use_backend www.oldboy.net if www

backend www.oldboy.org

        server 10.1.70.9 10.1.70.9 weight 20 maxconn 3000

配置文件

配置文件

#!/usr/bin/env python

# -*- coding:utf-8 -*-

from __future__ import with_statement

import threading

import json

import os

import commands

from config import settings

class BaseResponse(object):

    """ 封装返回值"""

    def __init__(self):

        self.status = False

        self.message = ''

        self.data = ''

class BaseController(object):

    """ 操作基础类 """

    rLock = threading.RLock()

    def __init__(self, origin):

        self.config_path = settings['haproxy_config']

        self.config_path_bak = settings['haproxy_config_bak']

        self.origin = origin

    def get_request(self):

        try:

            post_data = self.origin

            if not post_data or not post_data.strip():

                raise Exception('parameters can not be empty')

            data = json.loads(post_data)

            return data

        except Exception, e:

            raise Exception('parameter is not valid')

    def check_post_data_format(self, post_dict):

        if not post_dict.has_key('rules') or not post_dict.has_key('backend'):

            raise Exception('parameter is not valid, not contain rules and backend')

        for item in post_dict['rules']:

            if not item.has_key('server') or not item.has_key('weight') or not item.has_key('maxconn') or not item.has_key('port'):

                raise Exception('parameter is not valid, not contain server or weight or maxconn or port')

    def check_post_data_format_part(self, post_dict):

        if not post_dict.has_key('rules') or not post_dict.has_key('backend'):

            raise Exception('parameter is not valid, not contain rules and backend')

        for item in post_dict['rules']:

            if not item.has_key('server') or not item.has_key('port'):

                raise Exception('parameter is not valid, not contain server or port')

    def file_block_list(self, frontend_title, backend_title):

        file_backend_list = []

        file_frontend_list = []

        file_backend_flag = False

        file_frontend_flag = False

        with open(self.config_path, 'r') as f:

            for line in f:

                if line.strip() == 'frontend %s' % (frontend_title,):

                    file_frontend_flag = True

                    file_frontend_list.append('frontend %s' % (frontend_title,))

                    continue

                elif line.strip() == 'backend %s' % (backend_title,):

                    file_backend_list.append('backend %s' % (backend_title,))

                    file_backend_flag = True

                    continue

                exec_line = line.expandtabs(8)

                if exec_line.startswith('%s' % (' '*8,)):

                    if file_frontend_flag:

                        file_frontend_list.append(exec_line.strip('\n'))

                        continue

                    if file_backend_flag:

                        file_backend_list.append(exec_line.strip('\n'))

                        continue

                else:

                    file_frontend_flag = False

                    file_backend_flag = False

        return [file_frontend_list, file_backend_list]

    def check(self, new_config_path):

        output = commands.getoutput('haproxy -f %s -c' % (new_config_path,))

        if output.strip() == 'Configuration file is valid':

            return True

        else:

            raise Exception('failed to check new config：%s' % (output.strip()))

    def reload(self):

        status, output = commands.getstatusoutput('/etc/init.d/haproxy reload')

        if status == 0:

            return 1

        else:

            return output

    def confirm(self, new_config):

        os.rename(self.config_path, self.config_path_bak)

        os.rename(new_config, self.config_path)

    def rollback(self):

        temp = self.config_path + '.error'

        os.rename(self.config_path, temp)

        os.rename(self.config_path_bak, self.config_path)

class GetController(BaseController):

    def execute(self, backend_title):

        response = BaseResponse()

        try:

            if not backend_title or not backend_title.strip():

                raise Exception('parameters can not be empty')

            #frontend_title = backend_title[backend_title.index('.')+1:]

            frontend_title = 'oldboy'

            file_frontend_list, file_backend_list = self.file_block_list(frontend_title, backend_title)

            response.data = {'frontend': file_frontend_list, 'backend': file_backend_list}

            response.status = True

        except Exception, e:

            response.message = str(e)

        return response

class AddController(BaseController):

    """ 新建配置功能类 """

    def process_frontend(self, backend_title, frontend_title, file_frontend_list):

        if not file_frontend_list:

            file_frontend_list.append('frontend %s' % (frontend_title,))

            file_frontend_list.append('%sbind 0.0.0.0:8000' % (" "*8,))

            file_frontend_list.append('%soption httplog' % (" "*8,))

            file_frontend_list.append('%soption httpclose' % (" "*8,))

            file_frontend_list.append('%soption  forwardfor' % (" "*8,))

            file_frontend_list.append('%slog global' % (" "*8,))

        #pre = backend_title[0:backend_title.index('.')]

        acl = "%sacl %s hdr_reg(host) -i %s" % (' '*8, backend_title, backend_title)

        if not file_frontend_list.__contains__(acl):

            file_frontend_list.append(acl)

        use_backend = "%suse_backend %s if %s" % (' '*8, backend_title, backend_title)

        if not file_frontend_list.__contains__(use_backend):

            file_frontend_list.append(use_backend)

    def process_backend(self, post_data, backend_title, file_backend_list):

        if not file_backend_list:

            file_backend_list.append('backend %s' % (backend_title,))

        for item in post_data['rules']:

            temp = "%sserver %s %s:%s weight %s maxconn %s" % (" "*8, item['server'], item['server'], item['port'], item['weight'], item['maxconn'], )

            if not file_backend_list.__contains__(temp):

                file_backend_list.append(temp)

    def write_config(self, file_frontend_list, file_backend_list, is_new_frontend, is_new_backend):

        in_file_path = self.config_path

        out_file_path = in_file_path + '.new'

        frontend_title = file_frontend_list[0]

        backend_title = file_backend_list[0]

        frontend_flag = False

        backend_flag = False

        temp_flag = True

        with open(in_file_path) as infile, open(out_file_path, 'w') as outfile:

            for line in infile:

                line = line.expandtabs(8)

                if frontend_flag:

                    if temp_flag:

                        for item in file_frontend_list:

                            outfile.write(item+'\n')

                        temp_flag = False

                    if line.startswith(' '*8):

                        continue

                    else:

                        frontend_flag = False

                        temp_flag = True

                if backend_flag:

                    if temp_flag:

                        for item in file_backend_list:

                            outfile.write(item+'\n')

                        temp_flag = False

                    if line.startswith(' '*8):

                        continue

                    else:

                        backend_flag = False

                        temp_flag = True

                if line.strip() == frontend_title.strip():

                    frontend_flag = True

                    continue

                if line.strip() == backend_title.strip():

                    backend_flag = True

                    continue

                outfile.write(line)

            if is_new_frontend:

                outfile.write('\n')

                for item in file_frontend_list:

                    outfile.write(item+'\n')

            if is_new_backend:

                outfile.write('\n')

                for item in file_backend_list:

                    outfile.write(item+'\n')

        return out_file_path

    def execute(self):

        response = BaseResponse()

        BaseController.rLock.acquire()

        try:

            post_data = self.get_request()

            self.check_post_data_format(post_data)

            backend_title = post_data['backend']

            #frontend_title = backend_title[backend_title.index('.')+1:]

            frontend_title = 'oldboy'

            file_frontend_list, file_backend_list = self.file_block_list(frontend_title, backend_title)

            is_new_frontend = False if file_frontend_list else True

            is_new_backend = False if file_backend_list else True

            self.process_frontend(backend_title, frontend_title, file_frontend_list)

            self.process_backend(post_data, backend_title, file_backend_list)

            new_config = self.write_config(file_frontend_list, file_backend_list, is_new_frontend, is_new_backend)

            if self.check(new_config):

                self.confirm(new_config)

                result = self.reload()

                if result == 1:

                    response.status = True

                    response.message = 'success'

                else:

                    self.rollback()

                    raise Exception(result)

        except Exception, e:

            response.message = str(e)

        finally:

            BaseController.rLock.release()

        return response

class DelController(BaseController):

    """ 删除配置功能类 """

    def process_backend(self, post_data, file_backend_list):

        for item in post_data['rules']:

            temp = "server %s %s:%s" % (item['server'], item['server'], item['port'],)

            '''

            if file_backend_list.__contains__(temp):

                del file_backend_list[file_backend_list.index(temp)]

            '''

            for rule in file_backend_list:

                if rule.strip().startswith(temp):

                    del file_backend_list[file_backend_list.index(rule)]

    def process_frontend(self, backend_title, file_frontend_list):

        #pre = backend_title[0:backend_title.index('.')]

        acl = "%sacl %s hdr_reg(host) -i %s" % (' '*8, backend_title, backend_title)

        if file_frontend_list.__contains__(acl):

            del file_frontend_list[file_frontend_list.index(acl)]

        use_backend = "%suse_backend %s if %s" % (' '*8, backend_title, backend_title)

        if file_frontend_list.__contains__(use_backend):

            del file_frontend_list[file_frontend_list.index(use_backend)]

    def del_config(self, file_frontend_list, file_backend_list, is_del_backend):

        in_file_path = self.config_path

        out_file_path = in_file_path + '.new'

        frontend_title = file_frontend_list[0]

        backend_title = file_backend_list[0]

        frontend_flag = False

        backend_flag = False

        temp_flag = True

        with open(in_file_path) as infile, open(out_file_path, 'w') as outfile:

            for line in infile:

                line = line.expandtabs(8)

                if frontend_flag:

                    if temp_flag:

                        for item in file_frontend_list:

                            outfile.write(item+'\n')

                        temp_flag = False

                    if line.startswith(' '*8):

                        continue

                    else:

                        frontend_flag = False

                        temp_flag = True

                if backend_flag:

                    if temp_flag:

                        if not is_del_backend:

                            for item in file_backend_list:

                                outfile.write(item+'\n')

                        temp_flag = False

                    if line.startswith(' '*8):

                        continue

                    else:

                        backend_flag = False

                        temp_flag = True

                if line.strip() == frontend_title.strip():

                    frontend_flag = True

                    continue

                if line.strip() == backend_title.strip():

                    backend_flag = True

                    continue

                outfile.write(line)

        return out_file_path

    def execute(self):

        response = BaseResponse()

        BaseController.rLock.acquire()

        try:

            post_data = self.get_request()

            self.check_post_data_format_part(post_data)

            backend_title = post_data['backend']

            #frontend_title = backend_title[backend_title.index('.')+1:]

            frontend_title = 'oldboy'

            file_frontend_list, file_backend_list = self.file_block_list(frontend_title, backend_title)

            if not file_frontend_list or not file_backend_list:

                raise Exception('config not exist')

            self.process_backend(post_data, file_backend_list)

            is_del_backend = False

            if len(file_backend_list) == 1:

                self.process_frontend(backend_title, file_frontend_list)

                is_del_backend = True

            new_config = self.del_config(file_frontend_list, file_backend_list, is_del_backend)

            if self.check(new_config):

                self.confirm(new_config)

                result = self.reload()

                if result == 1:

                    response.status = True

                    response.message = 'success'

                else:

                    self.rollback()

                    raise Exception(result)

        except Exception, e:

            response.message = e.message

        finally:

            BaseController.rLock.release()

        return response

lib/commons.py

lib/common.py

settings = {

    'haproxy_config': '/etc/haproxy/haproxy.cfg',

    'haproxy_config_bak': '/etc/haproxy/haproxy.cfg.bak',

}

settings.py

#!/usr/bin/env python

# -*- coding:utf-8 -*-

import tornado.ioloop

import tornado.web

from lib import commons

import json

class MainHandler(tornado.web.RequestHandler):

    def get(self):

        backend_title = self.get_argument('origin', None)

        obj = commons.GetController(backend_title)

        response = obj.execute(backend_title)

        self.write(json.dumps(response.__dict__))

    def post(self, *args, **kwargs):

        data = self.get_argument('origin', None)

        obj = commons.AddController(data)

        response = obj.execute()

        self.write(json.dumps(response.__dict__))

    def delete(self, *args, **kwargs):

        data = self.get_argument('origin', None)

        obj = commons.DelController(data)

        response = obj.execute()

        self.write(json.dumps(response.__dict__))

application = tornado.web.Application([

    (r"/haproxy/", MainHandler),

    (r"/haproxy", MainHandler),

])

if __name__ == "__main__":

    application.listen(port=9999, address='0.0.0.0')

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

app.py

自定义组件

1、验证码

http://www.cnblogs.com/fat39/p/8527489.html

2、自制session

自制session

3、自制form

（1）回忆Django的Form表单

回忆Django的Form

1、widget插件：input、textarea、choice、multiplychoice等

2、field字段：charfield、emailfield、floatfield等

3、单字段验证：clean_xxx

4、所有字段验证：clean

5、html字段：单字段输入框、错误信息、as_p等

（2）自己参考Tyrion实现一个最简单的form

# -*- coding:utf-8 -*-

import copy

import re

###### widget ######

class TextInput(object):

    def __init__(self,attrs={}):

        self.attrs = attrs

    def __str__(self):

        tmp = []

        for name,value in self.attrs.items():

            tmp.append("{0}='{1}'".format(name,value))

        return "<input type='text' {0} />".format(" ".join(tmp))

##### field #####

class Field(object):

    DEFAULT_WIDGET = TextInput

    def __init__(self,widget=None):

        self.widget = widget if widget else self.DEFAULT_WIDGET

    def __str__(self):

        return str(self.widget)

class CharField(Field):

    REGEX = "^\w+@\w+$"

    def field_valid(self,value):

        if re.match(self.REGEX,value):

            return True

        else:

            return False

##### form #####

class BaseForm(object):

    def __init__(self,data=None):

        self.data = data

        self.errors = {}

        self.initial()

    def initial(self):

        self.kv = {}

        for k,v in type(self).__dict__.items():

            print(k,v)

            if isinstance(v,Field):

                new_v = copy.deepcopy(v)

                setattr(self,k,new_v)

                self.kv[k] = new_v

    def is_valid(self):

        # print(self.data.get_argument)

        flag = True

        for k,v in self.kv.items():

            errors_dict = {}

            self.errors[k] = errors_dict

            field_value = self.data.get_argument(k)

            result = v.field_valid(field_value)

            if not field_value:

                errors_dict["require"] = "not empty"

                flag = False

            if not result:

                errors_dict["invalid"] = "invalid"

                flag = False

        return flag

form.py

#!/usr/bin/env python

# -*- coding:utf-8 -*-

import tornado.ioloop

import tornado.web

from tornado.web import RequestHandler

from form import BaseForm

from form import CharField

from form import TextInput

class MyForm(BaseForm):

    user = CharField(widget=TextInput(attrs={"name":"user"}))

    email = CharField(widget=TextInput(attrs={"name":"email"}))

class LoginHandler(RequestHandler):

    def get(self,*args,**kwargs):

        userinfo = MyForm(self)

        self.render("login.html",userinfo=userinfo)

    def post(self, *args, **kwargs):

        userinfo = MyForm(self)

        if userinfo.is_valid():

            self.write("haha")

        else:

            self.render("login.html", userinfo=userinfo)

application = tornado.web.Application([

    (r"/login.html", LoginHandler),

])

# application.reverse_url("n1")

if __name__ == "__main__":

    application.listen(8888)

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

app.py

<!DOCTYPE html>

<html lang="en">

<head>

    <meta charset="UTF-8">

    <title>Title</title>

</head>

<body>

    <h1>登录页面</h1>

    <form action="" method="POST">

        user:{% raw userinfo.user %} {{ userinfo.errors.get('user') }}

        email:{% raw userinfo.email %}{{ userinfo.errors.get('email') }}

        <input type="submit">

    </form>

</body>

</html>

html

（3）Tyrion学习（推荐使用）

原note：http://www.cnblogs.com/wupeiqi/p/5938916.html

github：https://github.com/WuPeiqi/Tyrion

参考或转发

http://www.cnblogs.com/wupeiqi/articles/5702910.html

最新文章

  1. 【原创】开源Math.NET基础数学类库使用(05)C#解析Delimited Formats数据格式
  2. HttpWebRequest出错 服务器提交了协议冲突. Section=ResponseHeader Detail=CR 后面必须是 LF
  3. asp.net TextBoxWatermark添加水印提示
  4. Java学习第一步: Win7配置JDK环境
  5. 刀哥多线程GCD核心概念gcd
  6. BZOJ 1296: [SCOI2009]粉刷匠 分组DP
  7. MySql排序性能对比
  8. [delphi技术]Delphi常见图象格式转换技术
  9. 《C语言程序设计现代方法》第4章 编程题
  10. rr
  11. Java报表开发组件DynamicReports
  12. android 图片尺寸 资料
  13. elasticsearch文档-analysis
  14. cocos2d中box2d讲解一
  15. 怎样查看Jdk是32位还是64位
  16. mysql中出现Unknown column &#39;qwe&#39; in &#39;field list&#39;的错误
  17. Linux中FTP的一点理解
  18. 安装和强行卸载fuse
  19. [LOJ6356]四色灯
  20. Elasticsearch 性能监控基础【转】

热门文章

  1. python3 mock
  2. $NOIp$前的日常
  3. 学习JavaWeb aop两种配置方式
  4. PostMan测试接口，绕过登录验证
  5. Go语言学习 总结一
  6. An Introduction to the Basics of Modern CSS Buttons
  7. 【commons】Bean工具类——commons-beanutils之BeanUtils
  8. JQuery第二天——JQuery的DOM操作
  9. intellIJ IDEA配置maven相关问题记录
  10. 对大表进行全表更新，导致 Replication 同步数据的过程十分缓慢