Tornado-操作演示-3

ｔｏｒｎａｄｏ演示转义


# ｔｏｒｎａｄｏ演示转义

import tornado
from tornado.httpserver import HTTPServer
from tornado.ioloop import IOLoop
from tornado.options import define, options, parse_config_file
from tornado.web import Application, RequestHandler

# 用来响应用户请求
class IndexHandler(RequestHandler):
    #响应以ｇｅｔ方式发起的请求
    def get(self, *args, **kwargs):
        #　服务器给浏览器的响应内容
        self.render('escape.html',result='')
    #响应以post方式发起的请求
    def post(self, *args, **kwargs):
        text = self.get_body_argument('text',None)

        self.render('escape.html',result = text)

#定义一个变量，用来代表端口号
define('port',type=int,default=8888,multiple=False)
#定义一个变量，用来代表数据库的连接信息(用户名，密码，端口号，数据库名称)
define('db',multiple=True,type=str,default=[])
#从指定的配置文件中，读取ｐｏｒｔ的内容
parse_config_file('config')

#创建Ａｐｐｌｉｃａｔｉｏｎ对象，进行若干个对服务器的设置
#例如：路由列表，模板路径，静态资源路径等
app = Application([('/',IndexHandler)],template_path='mytemplate')
#创建服务器程序
server = HTTPServer(app)
#服务器监听某个端口(建议使用１００００以上的端口)
server.listen(options.port)#10000
#打印获得的数据库参数
print('数据库参数：',options.db)
#启动服务器（在当前进程中启动服务器）
IOLoop.current().start()

ｔｏｒｎａｄｏ服务器模板使用的演示


# ｔｏｒｎａｄｏ服务器模板使用的演示
import random

import tornado
from os.path import join, dirname
from tornado.httpserver import HTTPServer
from tornado.ioloop import IOLoop
from tornado.options import define, options, parse_config_file
from tornado.web import Application, RequestHandler

# 用来响应用户请求
class IndexHandler(RequestHandler):
    def initialize(self):
        print('initialize方法执行')
    #响应以ｇｅｔ方式发起的请求
    def get(self, *args, **kwargs):
        print('get方法执行')
        msg = ''
        s = self.get_query_argument('msg',None)
        if s:
            msg = '用户名或密码错误'

        #　服务器给浏览器的响应内容
        self.render('login.html',result=msg)

    #响应以post方式发起的请求
    def post(self, *args, **kwargs):
        pass

    def on_finish(self):
        print('on_finish方法执行')

class LoginHandler(RequestHandler):
    def get(self, *args, **kwargs):
        pass
    def post(self, *args, **kwargs):
        name = self.get_body_argument('name',None)
        password = self.get_body_argument('password',None)

        if name=='abc' and password=='123':
            self.redirect('/blog')
        else:
            self.redirect('/?msg=fail')

class BlogHandler(RequestHandler):

    def my_rand(self,a,b):
        return random.randint(a,b)

    def get(self, *args, **kwargs):
        self.render('blog.html',myrand=self.my_rand,
                    blogs=[{'title':'第一篇博客',
                            'tag':['情感','男女','星座'],
                            'content':'好长好长好长的正文',
                            'author':'某某人',
                            'comment':45},
                           {'title':'第二篇博客',
                            'tag':['技术','达内'],
                            'content':'学好python找我就对了',
                            'author':'大旭旭',
                            'comment':0}])
    def post(self, *args, **kwargs):
        pass

#定义一个变量，用来代表端口号
define('port',type=int,default=8888,multiple=False)
#定义一个变量，用来代表数据库的连接信息(用户名，密码，端口号，数据库名称)
define('db',multiple=True,type=str,default=[])
#从指定的配置文件中，读取ｐｏｒｔ的内容
parse_config_file('config')

#创建Ａｐｐｌｉｃａｔｉｏｎ对象，进行若干个对服务器的设置
#例如：路由列表，模板路径，静态资源路径等
app = Application([('/',IndexHandler),
                   ('/login',LoginHandler),
                   ('/blog',BlogHandler)],
                  template_path=join(dirname(__file__),'mytemplate'))
#创建服务器程序
server = HTTPServer(app)
#服务器监听某个端口(建议使用１００００以上的端口)
server.listen(options.port)#10000
#打印获得的数据库参数
print('数据库参数：',options.db)
#启动服务器（在当前进程中启动服务器）
IOLoop.current().start()

ｔｏｒｎａｄｏ服务器在模板中使用静态资源的演示


# ｔｏｒｎａｄｏ服务器在模板中使用静态资源的演示
import random

import tornado
from os.path import join, dirname
from tornado.httpserver import HTTPServer
from tornado.ioloop import IOLoop
from tornado.options import define, options, parse_config_file
from tornado.web import Application, RequestHandler, UIModule

# 用来响应用户请求
class IndexHandler(RequestHandler):
    def initialize(self):
        print('initialize方法执行')
    #响应以ｇｅｔ方式发起的请求
    def get(self, *args, **kwargs):
        print('get方法执行')

        #　服务器给浏览器的响应内容
        self.render('login.html')

    #响应以post方式发起的请求
    def post(self, *args, **kwargs):
        pass

    def on_finish(self):
        print('on_finish方法执行')

class LoginHandler(RequestHandler):
    def get(self, *args, **kwargs):
        pass
    def post(self, *args, **kwargs):
        name = self.get_body_argument('name',None)
        password = self.get_body_argument('password',None)

        if name=='abc' and password=='123':
            self.redirect('/blog')
        else:
            self.redirect('/?msg=fail')

class BlogHandler(RequestHandler):

    def my_rand(self,a,b):
        return random.randint(a,b)

    def get(self, *args, **kwargs):
        self.render('blog.html')
    def post(self, *args, **kwargs):
        pass

class RegistHandler(RequestHandler):

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

        self.render('regist.html')

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

class MyModule(UIModule):
    def render(self, *args, **kwargs):
        msg=''
        #uri = self.request.uri
        #print('uri:---->',uri)
        query = self.request.query
        print('query:--->',query)
        if query:
            msg='用户名或密码错误！'

        return self.render_string('module/module_login.html',result=msg)

class MyBlogModule(UIModule):
    def render(self, *args, **kwargs):
        return self.render_string('module/module_blog.html',blogs=[{'title':'第一篇博客',
                            'tag':['情感','男女','星座'],
                            'content':'好长好长好长的正文',
                            'author':'某某人',
                            'avatar':'a.jpg',
                            'comment':45},

                           {'title':'第二篇博客',
                            'tag':['技术','达内'],
                            'content':'学好python找我就对了',
                            'author':'大旭旭',
                            'avatar':None,
                            'comment':0}])

#定义一个变量，用来代表端口号
define('port',type=int,default=8888,multiple=False)
#定义一个变量，用来代表数据库的连接信息(用户名，密码，端口号，数据库名称)
define('db',multiple=True,type=str,default=[])
#从指定的配置文件中，读取ｐｏｒｔ的内容
parse_config_file('config')

#创建Ａｐｐｌｉｃａｔｉｏｎ对象，进行若干个对服务器的设置
#例如：路由列表，模板路径，静态资源路径等
app = Application([('/',IndexHandler),
                   ('/login',LoginHandler),
                   ('/blog',BlogHandler),
                   ('/regist',RegistHandler)],
                  template_path=join(dirname(__file__),'mytemplate'),
                  static_path=join(dirname(__file__),'mystatics'),
                  ui_modules={'mymodule':MyModule,
                              'myblogmodule':MyBlogModule})
#创建服务器程序
server = HTTPServer(app)
#服务器监听某个端口(建议使用１００００以上的端口)
server.listen(options.port)#10000
#打印获得的数据库参数
print('数据库参数：',options.db)
#启动服务器（在当前进程中启动服务器）
IOLoop.current().start()

regist.html

{%extends base.html%}
{%block title%}注册页面{%end%}
{%block body%}
    {%module mymodule()%}
{%end%}

base.html

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <title>{%block title%}{%end%}</title>
    {%block head%}{%end%}
</head>
<body>
    {%block body%}{%end%}
</body>
</html>

blog.html

{%extends base.html%}
{%block title%}博客{%end%}
{%block head%}
    <script src="{{static_url('js/jquery-3.2.1.js')}}"></script>

    <script>
        $(function () {
            alert('hello');
        });

    </script>
{%end%}

{%block body%}

    {%module myblogmodule()%}

{%end%}

escape.html

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <title>测试转义</title>
</head>
<body>

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

        <textarea cols="25" rows="5" name="text"></textarea>
        <input type="submit" value="提交">
    </form>
    {%raw result%}
    {{result}}

</body>
</html>

login.html

{%extends base.html%}
{%block title%}登录页面{%end%}
{%block body%}
    {%module mymodule()%}
{%end%}

ｔｏｒｎａｄｏ演示ｐｙｔｈｏｎ操作数据库


# ｔｏｒｎａｄｏ演示ｐｙｔｈｏｎ操作数据库
import random
import pymysql

import tornado
from os.path import join, dirname
from tornado.httpserver import HTTPServer
from tornado.ioloop import IOLoop
from tornado.options import define, options, parse_config_file
from tornado.web import Application, RequestHandler, UIModule

# 用来响应用户请求
class IndexHandler(RequestHandler):
    def initialize(self):
        print('initialize方法执行')
    #响应以ｇｅｔ方式发起的请求
    def get(self, *args, **kwargs):
        print('get方法执行')

        #　服务器给浏览器的响应内容
        self.render('login.html')

    #响应以post方式发起的请求
    def post(self, *args, **kwargs):
        pass

    def on_finish(self):
        print('on_finish方法执行')

class LoginHandler(RequestHandler):
    def get(self, *args, **kwargs):
        pass
    def post(self, *args, **kwargs):
        name = self.get_body_argument('name',None)
        password = self.get_body_argument('password',None)

        #利用用户输入的用户名和密码
        #通过ｐｙｍｙｓｑｌ到数据库的tb_user数据表中进行查询
        #1. 利用ｐｙｍｙｓｑｌ建立与数据库的连接
        connect = pymysql.connect(host='127.0.0.1',
                                  port=3306,
                                  user='root',
                                  password='123456',
                                  database='blogdb',
                                  charset='utf8')
        print('connect---->',connect)
        #2. 通过连接获取一个结果集
        cursor = connect.cursor()
        #3. 利用结果集发送ＳＱＬ语句操作数据库
        sql = 'select count(*) '               'from tb_user '               'where user_name=%s '               'and user_password=%s'

        param = (name,password)
        # where user_name="a\" or 1=1 or \("\1\"=\"1" and user_password="1\"\) or \"1\"=\"1"

        print ('sql:',sql)
        #cursor.execute(sql)
        cursor.execute(sql,param)
        #4. 利用结果集获取数据库返回的内容
        #result = cursor.fetchall()#((数据记录１),(数据记录２),...)
        result = cursor.fetchone()#(数据记录１)
        print('result----->',result)
        if result[0]:
            self.redirect('/blog')
        else:
            self.redirect('/?msg=fail')

class BlogHandler(RequestHandler):

    def my_rand(self,a,b):
        return random.randint(a,b)

    def get(self, *args, **kwargs):
        self.render('blog.html')
    def post(self, *args, **kwargs):
        pass

class RegistHandler(RequestHandler):

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

        self.render('regist.html')

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

class MyModule(UIModule):
    def render(self, *args, **kwargs):
        msg=''
        #uri = self.request.uri
        #print('uri:---->',uri)
        query = self.request.query
        print('query:--->',query)
        if query:
            msg='用户名或密码错误！'

        return self.render_string('module/module_login.html',result=msg)

class MyRegistModule(UIModule):
    def render(self, *args, **kwargs):
        msg = ''
        return self.render_string('module/module_regist.html',result=msg)

class MyBlogModule(UIModule):
    def render(self, *args, **kwargs):
        return self.render_string('module/module_blog.html',blogs=[{'title':'第一篇博客',
                            'tag':['情感','男女','星座'],
                            'content':'好长好长好长的正文',
                            'author':'某某人',
                            'avatar':'a.jpg',
                            'comment':45},

                           {'title':'第二篇博客',
                            'tag':['技术','达内'],
                            'content':'学好python找我就对了',
                            'author':'大旭旭',
                            'avatar':None,
                            'comment':0}])

#定义一个变量，用来代表端口号
define('port',type=int,default=8888,multiple=False)
#定义一个变量，用来代表数据库的连接信息(用户名，密码，端口号，数据库名称)
define('db',multiple=True,type=str,default=[])
#从指定的配置文件中，读取ｐｏｒｔ的内容
parse_config_file('config')

#创建Ａｐｐｌｉｃａｔｉｏｎ对象，进行若干个对服务器的设置
#例如：路由列表，模板路径，静态资源路径等
app = Application([('/',IndexHandler),
                   ('/login',LoginHandler),
                   ('/blog',BlogHandler),
                   ('/regist',RegistHandler)],
                  template_path=join(dirname(__file__),'mytemplate'),
                  static_path=join(dirname(__file__),'mystatics'),
                  ui_modules={'mymodule':MyModule,
                              'myblogmodule':MyBlogModule,
                              'myregistmodule':MyRegistModule})
#创建服务器程序
server = HTTPServer(app)
#服务器监听某个端口(建议使用１００００以上的端口)
server.listen(options.port)#10000
#打印获得的数据库参数
print('数据库参数：',options.db)
#启动服务器（在当前进程中启动服务器）
IOLoop.current().start()

ｔｏｒｎａｄｏ演示通过继承Ａｐｐｌｉｃａｔｉｏｎ类添加自定义属性, 每次使用ｄｂｕｔｉｌ操作数据表时，不用反复构建对象


# ｔｏｒｎａｄｏ演示通过继承Ａｐｐｌｉｃａｔｉｏｎ类添加自定义属性
# 每次使用ｄｂｕｔｉｌ操作数据表时，不用反复构建对象
import hashlib
import random
import pymysql
import time

import tornado
from os.path import join, dirname
from tornado.httpserver import HTTPServer
from tornado.ioloop import IOLoop
from tornado.options import define, options, parse_config_file
from tornado.web import Application, RequestHandler, UIModule
#代码移动ALT+SHIFT＋方向
from day0201.myapp.myapplication import MyApplication
from day0201.myconfig import myconfig
from day0201.myhandlers.myhandlers import IndexHandler, LoginHandler, BlogHandler, RegistHandler, CheckHandler
from day0201.mymodulers.mymodulers import MyModule, MyBlogModule, MyRegistModule
from day0201.util.dbutil import DBUtil
from day0201.util.myutils import mymd5

#创建Ａｐｐｌｉｃａｔｉｏｎ对象，进行若干个对服务器的设置
#例如：路由列表，模板路径，静态资源路径等
app = MyApplication([('/',IndexHandler),
                   ('/login',LoginHandler),
                   ('/blog',BlogHandler),
                   ('/regist',RegistHandler),
                     ('/check',CheckHandler)],
                  tp=join(dirname(__file__),'mytemplate'),
                  sp=join(dirname(__file__),'mystatics'),
                  um={'mymodule':MyModule,
                              'myblogmodule':MyBlogModule,
                              'myregistmodule':MyRegistModule})
#创建服务器程序
server = HTTPServer(app)
#服务器监听某个端口(建议使用１００００以上的端口)
server.listen(myconfig.configs['port'])#10000
#启动服务器（在当前进程中启动服务器）
IOLoop.current().start()

ｔｏｒｎａｄｏ演示ｐｙｔｈｏｎ操作数据库


# ｔｏｒｎａｄｏ演示ｐｙｔｈｏｎ操作数据库
import hashlib
import random
import pymysql
import time

import tornado
from os.path import join, dirname
from tornado.httpserver import HTTPServer
from tornado.ioloop import IOLoop
from tornado.options import define, options, parse_config_file
from tornado.web import Application, RequestHandler, UIModule
#代码移动ALT+SHIFT＋方向
from day0201.util.dbutil import DBUtil
from day0201.util.myutils import mymd5

# 用来响应用户请求

class IndexHandler(RequestHandler):
    def initialize(self):
        print('initialize方法执行')
    #响应以ｇｅｔ方式发起的请求
    def get(self, *args, **kwargs):
        print('get方法执行')

        #　服务器给浏览器的响应内容
        self.render('login.html')

    #响应以post方式发起的请求
    def post(self, *args, **kwargs):
        pass

    def on_finish(self):
        print('on_finish方法执行')

class LoginHandler(RequestHandler):
    def get(self, *args, **kwargs):
        pass
    def post(self, *args, **kwargs):
        name = self.get_body_argument('name',None)
        password = self.get_body_argument('password',None)
        #利用用户输入的用户名和密码
        #通过ｐｙｍｙｓｑｌ到数据库的tb_user数据表中进行查询
        #1. 利用ｐｙｍｙｓｑｌ建立与数据库的连接
        connect = pymysql.connect(host='127.0.0.1',
                                  port=3306,
                                  user='root',
                                  password='123456',
                                  database='blogdb',
                                  charset='utf8')
        print('connect---->',connect)
        #2. 通过连接获取一个结果集
        cursor = connect.cursor()
        #3. 利用结果集发送ＳＱＬ语句操作数据库
        sql = 'select count(*) '               'from tb_user '               'where user_name=%s '               'and user_password=%s'

        #对用户输入的登录密码进行md5转码
        # md = hashlib.md5()
        # md.update(password.encode('utf8'))
        # pwd = md.hexdigest()

        pwd = mymd5(password)

        param = (name,pwd)
        # where user_name="a\" or 1=1 or \("\1\"=\"1" and user_password="1\"\) or \"1\"=\"1"

        print ('sql:',sql)
        #cursor.execute(sql)
        cursor.execute(sql,param)
        #4. 利用结果集获取数据库返回的内容
        #result = cursor.fetchall()#((数据记录１),(数据记录２),...)
        result = cursor.fetchone()#(数据记录１)
        print('result----->',result)
        if result[0]:
            self.redirect('/blog')
        else:
            self.redirect('/?msg=fail')

class BlogHandler(RequestHandler):

    def my_rand(self,a,b):
        return random.randint(a,b)

    def get(self, *args, **kwargs):
        self.render('blog.html')
    def post(self, *args, **kwargs):
        pass

class RegistHandler(RequestHandler):

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

        self.render('regist.html')

    def post(self, *args, **kwargs):
        #收集用户提交的注册信息并写入数据库，完成新用户注册
        name = self.get_body_argument('name',None)
        password = self.get_body_argument('password',None)
        city = self.get_body_argument('city',None)
        #判断用户提交必要信息是否完整
        if name and password and city:
            #用户头像文件保存在服务器磁盘上对应文件的名称
            avatar_name = None
            #用户有没有上传头像
            files = self.request.files
            avatar = files.get('avatar',None)
            if avatar:
                #用户上传了头像文件
                #将用户上传的头像文件保存
                avatar_file = avatar[0]
                filename = avatar_file.get('filename')
                body = avatar_file.get('body')
                filename = str(time.time()) + filename
                writer = open('mystatics/images/%s'%filename,'wb')
                writer.write(body)
                writer.close()
                #将保存文件的名称赋值给avatar_name
                avatar_name = filename

            #将用户信息写入数据库tb_user数据表

            configs = {
                'host':'127.0.01',
                'port':3306,
                'user':'root',
                'password':'123456',
                'database':'blogdb',
                'charset':'utf8'
            }
            # **configs是将字典中的键值对自动拆分为关键字形式传参
            connect = pymysql.connect(**configs)
            cursor = connect.cursor()
            sql = 'insert into tb_user(user_name,user_password,user_city,user_avatar) values (%s,%s,%s,%s)'

            #对用户直接输入的密码进行md5的转码
            #123 ---> md5格式字符串
            #md = hashlib.md5()
            #md.update(password.encode('utf8'))
            #ｐｗｄ就是将ｐａｓｓｗｏｒｄ进行md5转码后的结果
            #pwd = md.hexdigest()

            pwd = mymd5(password)

            params = (name,pwd,city,avatar_name)
            try:
                #执行新增操作时，有可能出现用户名重复的情况
                #导致数据库扔出异常
                cursor.execute(sql,params)
                #进行提交，将内容真正写入数据表
                #connect.commit()
                cursor.connection.commit()

                self.redirect('/')

            except Exception as e:
                #打印异常信息
                print(e)
                #print(e.__str__())
                #print(type(e.__str__()))
                info = e.__str__()
                #(1062
                m = info.split(',')[0]
                #errmsg = m[1:]
                errmsg = m.split('(')[1]
                #/regist?msg=1062
                self.redirect('/regist?msg=%s' % errmsg)

        else:
            self.redirect('/regist?msg=fail')

class MyModule(UIModule):
    def render(self, *args, **kwargs):
        msg=''
        #uri = self.request.uri
        #print('uri:---->',uri)
        query = self.request.query
        print('query:--->',query)
        if query:
            msg='用户名或密码错误！'

        return self.render_string('module/module_login.html',result=msg)

class MyRegistModule(UIModule):
    def render(self, *args, **kwargs):
        msg = ''
        q = self.request.query
        if q:
            #有问题　msg = fail  msg=1062
            msg = '服务器繁忙，稍后重试'
            info = q.split('=')[1]
            if info=='fail':
                msg = '注册信息不完整'
            if info=='1062':
                msg = '用户名重复！'

        return self.render_string('module/module_regist.html',result=msg)

class MyBlogModule(UIModule):
    def render(self, *args, **kwargs):
        return self.render_string('module/module_blog.html',blogs=[{'title':'第一篇博客',
                            'tag':['情感','男女','星座'],
                            'content':'好长好长好长的正文',
                            'author':'某某人',
                            'avatar':'a.jpg',
                            'comment':45},

                           {'title':'第二篇博客',
                            'tag':['技术','达内'],
                            'content':'学好python找我就对了',
                            'author':'大旭旭',
                            'avatar':None,
                            'comment':0}])

#定义一个变量，用来代表端口号
define('port',type=int,default=8888,multiple=False)
#定义一个变量，用来代表数据库的连接信息(用户名，密码，端口号，数据库名称)
define('db',multiple=True,type=str,default=[])
#从指定的配置文件中，读取ｐｏｒｔ的内容
parse_config_file('config')

#创建Ａｐｐｌｉｃａｔｉｏｎ对象，进行若干个对服务器的设置
#例如：路由列表，模板路径，静态资源路径等
app = Application([('/',IndexHandler),
                   ('/login',LoginHandler),
                   ('/blog',BlogHandler),
                   ('/regist',RegistHandler)],
                  template_path=join(dirname(__file__),'mytemplate'),
                  static_path=join(dirname(__file__),'mystatics'),
                  ui_modules={'mymodule':MyModule,
                              'myblogmodule':MyBlogModule,
                              'myregistmodule':MyRegistModule})
#创建服务器程序
server = HTTPServer(app)
#服务器监听某个端口(建议使用１００００以上的端口)
server.listen(options.port)#10000
#打印获得的数据库参数
print('数据库参数：',options.db)
#启动服务器（在当前进程中启动服务器）
IOLoop.current().start()

ｔｏｒｎａｄｏ演示利用自己封装的ｄｂｕｔｉｌ工具类操作数据库


# ｔｏｒｎａｄｏ演示利用自己封装的ｄｂｕｔｉｌ工具类操作数据库
import hashlib
import random
import pymysql
import time

import tornado
from os.path import join, dirname
from tornado.httpserver import HTTPServer
from tornado.ioloop import IOLoop
from tornado.options import define, options, parse_config_file
from tornado.web import Application, RequestHandler, UIModule
#代码移动ALT+SHIFT＋方向
from day0201.util.dbutil import DBUtil
from day0201.util.myutils import mymd5

# 用来响应用户请求

class IndexHandler(RequestHandler):
    def initialize(self):
        print('initialize方法执行')
    #响应以ｇｅｔ方式发起的请求
    def get(self, *args, **kwargs):
        print('get方法执行')

        #　服务器给浏览器的响应内容
        self.render('login.html')

    #响应以post方式发起的请求
    def post(self, *args, **kwargs):
        pass

    def on_finish(self):
        print('on_finish方法执行')

class LoginHandler(RequestHandler):
    def get(self, *args, **kwargs):
        pass
    def post(self, *args, **kwargs):
        name = self.get_body_argument('name',None)
        password = self.get_body_argument('password',None)

        dbutil = DBUtil()

        if dbutil.isloginsuccess(name,password):
            self.redirect('/blog')
        else:
            self.redirect('/?msg=fail')

class BlogHandler(RequestHandler):

    def my_rand(self,a,b):
        return random.randint(a,b)

    def get(self, *args, **kwargs):
        self.render('blog.html')
    def post(self, *args, **kwargs):
        pass

class RegistHandler(RequestHandler):

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

        self.render('regist.html')

    def post(self, *args, **kwargs):
        #收集用户提交的注册信息并写入数据库，完成新用户注册
        name = self.get_body_argument('name',None)
        password = self.get_body_argument('password',None)
        city = self.get_body_argument('city',None)
        #判断用户提交必要信息是否完整
        if name and password and city:
            #用户头像文件保存在服务器磁盘上对应文件的名称
            avatar_name = None
            #用户有没有上传头像
            files = self.request.files
            avatar = files.get('avatar',None)
            if avatar:
                #用户上传了头像文件
                #将用户上传的头像文件保存
                avatar_file = avatar[0]
                filename = avatar_file.get('filename')
                body = avatar_file.get('body')
                filename = str(time.time()) + filename
                writer = open('mystatics/images/%s'%filename,'wb')
                writer.write(body)
                writer.close()
                #将保存文件的名称赋值给avatar_name
                avatar_name = filename

            #将用户信息写入数据库tb_user数据表

            dbutil = DBUtil()

            try:
                #执行新增操作时，有可能出现用户名重复的情况
                #导致数据库扔出异常
                params = dict(name=name,password=password,city=city,avatar_name=avatar_name)
                dbutil.registUser(**params)
                self.redirect('/')

            except Exception as e:
                #打印异常信息
                print(e)
                errmsg = e.__str__()
                self.redirect('/regist?msg=%s' % errmsg)

        else:
            self.redirect('/regist?msg=fail')

class MyModule(UIModule):
    def render(self, *args, **kwargs):
        msg=''
        #uri = self.request.uri
        #print('uri:---->',uri)
        query = self.request.query
        print('query:--->',query)
        if query:
            msg='用户名或密码错误！'

        return self.render_string('module/module_login.html',result=msg)

class MyRegistModule(UIModule):
    def render(self, *args, **kwargs):
        msg = ''
        q = self.request.query
        if q:
            #有问题　msg = fail  msg=1062
            #msg = '服务器繁忙，稍后重试'
            info = q.split('=')[1]
            print('info---->',info)
            if info=='fail':
                msg = '注册信息不完整'
            else:
                msg = info
        return self.render_string('module/module_regist.html',result=msg)

class MyBlogModule(UIModule):
    def render(self, *args, **kwargs):
        return self.render_string('module/module_blog.html',blogs=[{'title':'第一篇博客',
                            'tag':['情感','男女','星座'],
                            'content':'好长好长好长的正文',
                            'author':'某某人',
                            'avatar':'a.jpg',
                            'comment':45},

                           {'title':'第二篇博客',
                            'tag':['技术','达内'],
                            'content':'学好python找我就对了',
                            'author':'大旭旭',
                            'avatar':None,
                            'comment':0}])

#定义一个变量，用来代表端口号
define('port',type=int,default=8888,multiple=False)
#定义一个变量，用来代表数据库的连接信息(用户名，密码，端口号，数据库名称)
define('db',multiple=True,type=str,default=[])
#从指定的配置文件中，读取ｐｏｒｔ的内容
parse_config_file('config')

#创建Ａｐｐｌｉｃａｔｉｏｎ对象，进行若干个对服务器的设置
#例如：路由列表，模板路径，静态资源路径等
app = Application([('/',IndexHandler),
                   ('/login',LoginHandler),
                   ('/blog',BlogHandler),
                   ('/regist',RegistHandler)],
                  template_path=join(dirname(__file__),'mytemplate'),
                  static_path=join(dirname(__file__),'mystatics'),
                  ui_modules={'mymodule':MyModule,
                              'myblogmodule':MyBlogModule,
                              'myregistmodule':MyRegistModule})
#创建服务器程序
server = HTTPServer(app)
#服务器监听某个端口(建议使用１００００以上的端口)
server.listen(options.port)#10000
#打印获得的数据库参数
print('数据库参数：',options.db)
#启动服务器（在当前进程中启动服务器）
IOLoop.current().start()

myapplication.py

from tornado.web import Application

from day0201.util.dbutil import DBUtil

class MyApplication(Application):
    def __init__(self,routers,tp,sp,um):
        super().__init__(routers,template_path=tp,static_path=sp,ui_modules=um)
        self.dbutil = DBUtil()

myconfig.py

configs={

    'port':9999,
    'db':{
        'host':'127.0.0.1',
        'port':3306,
        'user':'root',
        'password':'123456',
        'database':'blogdb',
        'charset':'utf8'
    }

}

myhandlers.py

import random

import time
from tornado.web import RequestHandler

class IndexHandler(RequestHandler):
    def initialize(self):
        print('initialize方法执行')
    #响应以ｇｅｔ方式发起的请求
    def get(self, *args, **kwargs):
        print('get方法执行')

        #　服务器给浏览器的响应内容
        self.render('login.html')

    #响应以post方式发起的请求
    def post(self, *args, **kwargs):
        pass

    def on_finish(self):
        print('on_finish方法执行')

class LoginHandler(RequestHandler):
    def get(self, *args, **kwargs):
        pass
    def post(self, *args, **kwargs):
        name = self.get_body_argument('name',None)
        password = self.get_body_argument('password',None)

        if self.application.dbutil.isloginsuccess(name,password):
            self.redirect('/blog')
        else:
            self.redirect('/?msg=fail')

class BlogHandler(RequestHandler):

    def my_rand(self,a,b):
        return random.randint(a,b)

    def get(self, *args, **kwargs):
        self.render('blog.html')
    def post(self, *args, **kwargs):
        pass

class RegistHandler(RequestHandler):

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

        self.render('regist.html')

    def post(self, *args, **kwargs):
        #收集用户提交的注册信息并写入数据库，完成新用户注册
        name = self.get_body_argument('name',None)
        password = self.get_body_argument('password',None)
        city = self.get_body_argument('city',None)
        #判断用户提交必要信息是否完整
        if name and password and city:
            #用户头像文件保存在服务器磁盘上对应文件的名称
            avatar_name = None
            #用户有没有上传头像
            files = self.request.files
            avatar = files.get('avatar',None)
            if avatar:
                #用户上传了头像文件
                #将用户上传的头像文件保存
                avatar_file = avatar[0]
                filename = avatar_file.get('filename')
                body = avatar_file.get('body')
                filename = str(time.time()) + filename
                writer = open('mystatics/images/%s'%filename,'wb')
                writer.write(body)
                writer.close()
                #将保存文件的名称赋值给avatar_name
                avatar_name = filename

            #将用户信息写入数据库tb_user数据表

            try:
                #执行新增操作时，有可能出现用户名重复的情况
                #导致数据库扔出异常
                params = dict(name=name,password=password,city=city,avatar_name=avatar_name)
                self.application.dbutil.registUser(**params)
                self.redirect('/')

            except Exception as e:
                #打印异常信息
                print(e)
                errmsg = e.__str__()
                self.redirect('/regist?msg=%s' % errmsg)

        else:
            self.redirect('/regist?msg=fail')

class CheckHandler(RequestHandler):
    def get(self, *args, **kwargs):
        pass

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

        username = self.get_body_argument('username',None)
        print('获取到的username:----->',username)

        #利用ｄｂｕｔｉｌ去根据ｕｓｅｒｎａｍｅ查询
        #tb_user表中是否已有该用户名
        if self.application.dbutil.hasUser(username):
            result = dict(msg='ok')
        else:
            result = dict(msg='no_ok')

        self.write(result)

mymodulers.py

from tornado.web import UIModule

class MyModule(UIModule):
    def render(self, *args, **kwargs):
        msg=''
        #uri = self.request.uri
        #print('uri:---->',uri)
        query = self.request.query
        print('query:--->',query)
        if query:
            msg='用户名或密码错误！'

        return self.render_string('module/module_login.html',result=msg)

class MyRegistModule(UIModule):
    def render(self, *args, **kwargs):
        msg = ''
        q = self.request.query
        if q:
            #有问题　msg = fail  msg=1062
            #msg = '服务器繁忙，稍后重试'
            info = q.split('=')[1]
            print('info---->',info)
            if info=='fail':
                msg = '注册信息不完整'
            else:
                msg = info
        return self.render_string('module/module_regist.html',result=msg)

class MyBlogModule(UIModule):
    def render(self, *args, **kwargs):
        return self.render_string('module/module_blog.html',blogs=[{'title':'第一篇博客',
                            'tag':['情感','男女','星座'],
                            'content':'好长好长好长的正文',
                            'author':'某某人',
                            'avatar':'a.jpg',
                            'comment':45},

                           {'title':'第二篇博客',
                            'tag':['技术','达内'],
                            'content':'学好python找我就对了',
                            'author':'大旭旭',
                            'avatar':None,
                            'comment':0}])

dbuntil.py

import pymysql

from day0201.util.myutils import mymd5

class DBUtil:

    def __init__(self,**kwargs):
        #获取到与数据库的连接

        #直接使用用户传递的内容不太好
        #应该简单的提取
        host = kwargs.get('host','127.0.0.1')
        port =kwargs.get('port',3306)
        user = kwargs.get('user','root')
        password= kwargs.get('password','123456')
        database=kwargs.get('database','blogdb')
        charset = kwargs.get('charset','utf8')
        #把经过提取的内容作为参数传递给ｃｏｎｎｅｃｔ方法
        configs = dict(host=host,port=port,user=user,password=password,database=database,charset=charset)
        conn = pymysql.connect(**configs)

        #进而获取到结果集
        if conn:
            self.cursor = conn.cursor()
        else:
            raise Exception('数据库连接参数错误！')

    #注册用户
    def registUser(self,**kwargs):
        name = kwargs.get('name')
        password = kwargs.get('password')
        pwd = mymd5(password)
        city = kwargs.get('city')
        avatar_name = kwargs.get('avatar_name')

        sql='insert into tb_user(user_name,user_password,user_city,user_avatar) values(%s,%s,%s,%s)'
        params=(name,pwd,city,avatar_name)
        try:
            self.cursor.execute(sql,params)
            self.cursor.connection.commit()
        except Exception as e:
            #(1062,"Duplicat......")
            #raise Exception(e.__str__())
            info = e.__str__()
            # (1062
            m = info.split(',')[0]
            # errmsg = m[1:]
            errmsg = m.split('(')[1]
            err='数据库未知错误！'
            if errmsg == '1062':
                err = '用户名重复'
            raise Exception(err)

    #登录
    #　根据参数中提供的用户和密码
    #  去数据库tb_user表中查询是否有匹配的数据记录
    #  如果有，就返回Ｔｒｕｅ，否则Ｆａｌｓｅ
    def isloginsuccess(self,name,password):

        sql = 'select count(*) from tb_user where user_name=%s and user_password=%s'

        pwd = mymd5(password)

        params = (name,pwd)

        self.cursor.execute(sql,params)

        result = self.cursor.fetchone()

        if result[0]:
            return True
        else:
            return False

    #判定某个用户是否存在
    def hasUser(self,username):
        #利用ｕｓｅｒｎａｍｅ去tb_user表查询
        # return True / False
        Pass

myutils.py

import hashlib

def mymd5(orginal):

    md = hashlib.md5()
    md.update(orginal.encode('utf8'))
    m = md.hexdigest()
return m

原文地址：https://www.cnblogs.com/-hjj/p/9946527.html

时间： 2024-11-08 22:48:56

Tornado-操作演示-3的相关文章

Selenium2学习-040-JavaScript弹出框（alert、confirm、prompt）操作演示实例

弹出框是网页自动化测试常见得操作页面元素之一,常见的JavaScript弹出框有如下三种: 1.alert(message):方法用于显示带有一条指定消息和一个 OK 按钮的警告框.DemoAlert.html 示例代码如下所示: <!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd"> <html&g

全站仪经纬仪水准仪操作演示视频教程建筑工程测量放线7日通

全站仪经纬仪水准仪操作演示视频教程建筑工程测量放线7日通您遇到的下面的所有问题都将在这里找到答案全站仪怎么定向,全站仪怎修改观测气象参数,全站仪怎么不用尺子测出仪器镜子高,全站仪怎么放线,全站仪的精度怎么算,全站仪的电子气泡和激光对中怎么调出,全站仪的盘左与盘右怎么区分,全站仪的归零角怎么设置水准仪怎么放样,二等水准测量规范下载经纬仪怎么放线,经纬仪怎么测角度更新日志: 2014年 1月11日---新增院校版全套视频教程(详见视频详解栏) 2013年10月20日----新增<中

java 线程原子类相关操作演示样例 thinking in java4 文件夹21.3.4

java 线程原子类相关操作演示样例 package org.rui.thread.volatiles; import java.util.Timer; import java.util.TimerTask; import java.util.concurrent.ExecutorService; import java.util.concurrent.Executors; import java.util.concurrent.atomic.AtomicInteger; /** * 原子类

阿里云ECS操作演示

12.ECS操作演示查看ECS实例适用场景:实例的日常维护实例运行状态和详细信息查看启动ECS实例适用场景:实例停止运行之后的再次启动停止.重启实例适用场景:实例运行的服务暂停时使用停止实例实例运行的服务需要重启服务器时使用重启实例ECS实例操作设置/取消自动释放时间适用场景:创建临时实例解决业务高峰,高峰结束后自动释放当业务高峰没有停止时,可以取消自动释放管理控制台演示13.ECS磁盘操作挂载数据盘适用场景:当ECS实例运行的服务需要的数据存储不够时挂载数据盘有两种入口1. 从实例操作入口2

C#线程池操作演示源码

把开发过程中经常用到的一些代码段做个备份,下面代码内容是关于C#线程池操作演示的代码. static void Main(string[] args){ThreadPool.SetMaxThreads(1000, 1000);for (int i = 0; i < 10;i ){ThreadPool.QueueUserWorkItem(new WaitCallback(ShowMessage), string.Format("当前编号{0}",i));}Console.ReadL

基于吉日嘎底层架构的Web端权限管理操作演示-日志管理

权限管理要实现的效果是对“ 谁”可以访问“什么内容”,可以进行“哪些操作” 一系列权限的精细化控制.衡量一个软件好坏的重要标准是:它的权限体系是否足够细致.是否可以立体勾勒出信息对象的访问控制.前面4篇我们依次介绍了<用户管理>.<角色管理>.<菜单模块管理>和<组织机构管理>,这篇我们演示一下日志管理: 异常日志访问日志上传日志修改日志在线视频优酷视频地址,手机无法播放的点击这里:http://v.youku.com/v_show/id_XMTc

基于吉日嘎底层架构的Web端权限管理操作演示-菜单模块管理

按照顺序,这一篇介绍菜单模块管理,主要演示如下操作: 新增.修改.锁定.解锁.删除.撤销删除排序角色成员管理用户成员管理导出菜单模块数据也许你会问,你在这自吹自擂,你这个BS的权限管理有啥缺点不?其中一个美中不足之处:没有批量增加权限Action(或者叫Operation)的地方,下一个版本会加上. 演示视频如下: 优酷视频地址,手机无法播放的点击这里:http://v.youku.com/v_show/id_XMTc0MzMxODk1Mg==.html 下一篇会继续讲解组织机构管理

java -io字符流FileWrite操作演示

FileWriter字符输出流演示: /* * FiileWriter 字符流的操作 * FileWriter 的构造方法可传递 File类型还可以传递String类型 * * 方法 : * write(int c) 传递一个字节 * write(char[] a ) 传递一个字符数组 * write(char[]a , 开始索引 , 传递几个) * write(String s) 传递一个字符串 * * 注意:写完之后一定要刷新缓冲区不然数据写入不进 * 对象.flush() * */

django的操作演示

第一步首先是django的所有命令演示 1.下载: pip install django ==1.11.18 pip install django ==1.11.18 -i 源在pycharm中打开 2.创建一个项目 django-adminstartproject项目名称 3.启动项目如果没有pycharm 直接到cmd窗口操作可以这样开始操作 python manage.py runserver #127.0.0.1:8000 启动项 python manage

Linux 系统文本编辑器vi常用命令详解（操作演示）

引言: 在Linux中我们常用的文本编辑器有vi.vim(vi的增强版本).而且vi编辑器不仅仅是适用于Linux,它是所有Unix以及Linux系统下的标准编辑器,几乎适用于Unix.Linux系统的所有版本.vi或vim虽然没有图形界面编辑器那样点鼠标的简单操作,但vi编辑器在系统管理.服务器管理字符界面中,永远不是图形界面的编辑器能比的.它能轻易地创建和修改文本文件,维护Linux系统中的配置文件.学会它,你就拥有了打开Linux大门的钥匙. 主要内容: vi编辑器的三种工作模式命令模式的