实习手册八（Python基于Tornado框架的接口响应服务）最终章

目录

前言

Tornado_program

common

handler_base

mysql_base

sqlalchemy_base

redis_base

model

log

user

server

change_user

register_user

search_user

user_server

settings

config

结语

---

前言

手册目录：

软件下载及环境安装：

实习手册一（基于Tornado框架的接口响应服务）软件下载与环境配置

Tornado基本框架搭建：

实习手册二（基于Tornado框架的接口响应服务）Tornado基本框架的搭建

Tornado框架中日志的记录，路由的分发，接口的响应：

实习手册三（基于Tornado框架的接口响应服务）Tornado框架中日志的记录，路由的分发，接口的响应

通过PyMySQL，SQLAlchemy在PyCharm中实现对数据的增删改查：

实习手册四（基于Tornado框架的接口响应服务）通过PyMySQL，SQLAlchemy在PyCharm中实现对数据的增删改查

SqlAlchemy的再封装，PyMySQL和SqlAlchemy的结合使用：

实习手册五（基于Tornado框架的接口响应服务）SqlAlchemy的再封装，PyMySQL和SqlAlchemy的结合使用

在Tornado实现对数据库的操作功能：

实习手册六（基于Tornado框架的接口响应服务）在Tornado实现对数据库的操作功能

在Tornado中使用Redis来缓存数据

实习手册七（基于Tornado框架的接口响应服务）使用Redis来缓存数据

本章我们将前面几章的项目整合起来，形成一个大的项目。

项目目录如下：

其中，common用来存放公共类，logs用来存放日志，model用来存放数据模型，server用来存放服务，user用来存放和用户有关的服务，settings用来存放设置

Tornado_program

common

handler_base

# handler基类，用来重载get和post请求，以及log生成器，on_finish时的日志写入，还有报错
import datetime
import json
import logging
from tornado.web import RequestHandler
from model.log import Log


class HandlerBase(RequestHandler):
    data = None
    def get(self, *args, **kwargs):
        path = self.request.path.split('/')
        method = path[-1]
        if callable(getattr(self, method)):
            getattr(self, method)()
        else:
            self.write("404 not found")

    def post(self, *args, **kwargs):
        path = self.request.path.split('/')
        self.data = json.loads(self.request.body)
        method = path[-1]
        if callable(getattr(self, method)):
            getattr(self, method)()
        else:
            self.write("404 not found")

    def log(self, msg):
        logger = logging.getLogger('logger')
        logger.setLevel(level=logging.DEBUG)

        formatter = logging.Formatter('%(asctime)s - %(levelname)s: %(message)s')

        file_handler = logging.FileHandler('../logs/log.txt')
        file_handler.setLevel(level=logging.INFO)
        file_handler.setFormatter(formatter)

        stream_handler = logging.StreamHandler()
        stream_handler.setLevel(logging.DEBUG)
        stream_handler.setFormatter(formatter)

        logger.addHandler(file_handler)
        logger.addHandler(stream_handler)
        logger.info(msg)
    
    def on_finish(self):
        msg = str(self.request.path) + str(self.request.method) + str(self.request.headers)
        self.log(msg)
        new_log = Log(path=self.request.path, method=self.request.method, create_time=str(datetime.datetime.now()), msg=str(self.request.headers))
        Log.add(new_log)

mysql_base

# 数据库处理基类
# sqlalchemy增删改查等方法封装，以及测试数据库连接
from sqlalchemy import text
import pymysql
from common.sqlalchemy_base import SqlAchBase
from common.redis_base import RedisBase

class MysqlBase():
    session = SqlAchBase.get_session()
    conn = None
    @classmethod
    def TestConn(cls):
        if not cls.conn:
            cls.conn = pymysql.connect(user='root', host='localhost', password=你的密码, db=数据库名称, port=3306)
            print("trying to connect to '%s'" % cls.conn)

        else:
            print("already connected to '%s'" % cls.conn)

    @classmethod
    def add(cls, user):
        MysqlBase.TestConn()
        cls.session.add(user)
        cls.session.commit()

    @classmethod
    def delete(cls, filter):
        cls.TestConn()
        cls.session.query(cls).filter(text(filter)).delete(synchronize_session=False)
        cls.session.commit()

    @classmethod
    def update(cls, filter, value):
        cls.TestConn()
        cls.session.query(cls).filter(text(filter)).update(value, synchronize_session=False)
        cls.session.commit()

    @classmethod
    def query(cls, key, *columns):
        cls.TestConn()
        search_list = key.split("|")
        if RedisBase.get(key):
            print('successfully get data from redis')
            return RedisBase.get(key)
        else:
            item_list = cls.session.query(*columns or cls).filter(text(search_list[2]+' and '+search_list[3])).all()
            print(item_list)
            RedisBase.set(key, str(item_list), expire_time=10)
            return item_list

sqlalchemy_base

# sqlalchemy基类，用来获取session

from settings.config import URL
from sqlalchemy import create_engine
from sqlalchemy.ext.declarative import declarative_base
from sqlalchemy.orm import sessionmaker
from sqlalchemy import MetaData

class SqlAchBase():
    engine = create_engine(URL)
    base = declarative_base()
    session = sessionmaker(bind=engine)()
    metadata = MetaData()

    @classmethod
    def get_session(cls):
        return cls.session

redis_base

# redis基类，用来存放和redis相关的操作
import redis
from settings.config import redis_host, redis_port

class RedisBase():
    redis_tool = None
    @classmethod
    def TestConn(cls):
        if cls.redis_tool:
            print("already connect to redis_tool\n")
            pass
        else:
            pool = redis.ConnectionPool(host=redis_host, port=redis_port, db=0, decode_responses=True)
            cls.redis_tool = redis.Redis(connection_pool=pool)
            print("trying to connect to redis_tool\n")
        
    @classmethod
    def get(cls, key):
        cls.TestConn()
        return cls.redis_tool.get(key)

    @classmethod
    def set(cls, key, target, expire_time):
        cls.TestConn()
        cls.redis_tool.set(key, target, ex=expire_time)

    @classmethod
    def expire_seconds(cls, key):
        cls.TestConn()
        # 查询某个键的剩余时间
        return cls.redis_tool.ttl(key)

    @classmethod
    def keys(cls):
        cls.TestConn()
        return cls.redis_tool.keys()

    @classmethod
    def delete(cls, key):
        cls.TestConn()
        cls.redis_tool.delete(key)

    @classmethod
    def exists(cls, key):
        cls.TestConn()
        return cls.redis_tool.exists(key)

model

log

# 日志模型，用来映射

from common.sqlalchemy_base import SqlAchBase
from common.mysql_base import MysqlBase
from sqlalchemy import Column, String, Integer

class Log(SqlAchBase().base, MysqlBase):
    __tablename__ = 'log'
    id = Column(Integer, autoincrement=True, primary_key=True)
    path = Column(String(30))
    method = Column(String(30))
    create_time = Column(String(30))
    msg = Column(String(255))

user

# 用户模型，用来映射
from common.sqlalchemy_base import SqlAchBase
from common.mysql_base import MysqlBase
from sqlalchemy import Column, String, Integer

class User(SqlAchBase().base, MysqlBase):
    __tablename__ = 'user'
    userid = Column(Integer, autoincrement=True, primary_key=True)
    uname = Column(String(30))
    pwd = Column(String(30))
    create_time = Column(String(30))

server

change_user

from common.handler_base import HandlerBase
from model.user import User

# 用户更改的相关操作
class ChangeHandler(HandlerBase):
    # 删除用户
    def delete_user(self):
        User.delete(self.data['filter'])
    
    # 更改用户密码
    def update_pwd(self):
        filter = self.data['filter']
        value = eval(self.data['value'])
        User.update(filter, value)

register_user

# 用户注册处理器
import datetime
from common.handler_base import HandlerBase
from model.user import User


class RegisterHandler(HandlerBase):
    def register_user(self):
        user = User(uname=self.data['uname'], pwd=self.data['pwd'], create_time=datetime.datetime.now())
        User.add(user)

search_user

from model.user import User


class SearchHandler(HandlerBase):
    

    def search_user(self):
        # 获取表名
        table_name = User.__tablename__
        
        # 获取传递参数
        uname = self.get_argument('uname')
        userid = self.get_argument('userid')
        key = 'uname,userid,create_time' + '|' + table_name
        
        # 判断参数是否存在
        if uname:
            key += '|' + 'uname="{}"'.format(uname)
        if userid:
            key += '|' + 'userid={}'.format(userid)
        
        # 打印key
        print(key)

        # 获取返回值
        result = User.query(key, *[User.userid, User.uname, User.create_time])
    
        # 将返回的内容呈现到界面中
        self.write(str(result))

user_server

# 启动Tornado服务
from tornado.web import Application
from tornado.ioloop import IOLoop

from user.register_user import RegisterHandler
from user.change_user import ChangeHandler
from user.search_user import SearchHandler

app = Application([
    (r'/user/register/.*', RegisterHandler),
    (r'/user/search/.*', SearchHandler),
    (r'/user/change/.*', ChangeHandler)
])

if __name__ == '__main__':
    app.listen(8000)
    IOLoop.current().start()

settings

config

# 基本配置

URL = "mysql+pymysql://root:你的密码@localhost:3306/数据库名称"
redis_host = '127.0.0.1'
redis_port = 6379

结语

所有代码呈现完毕，有些部分如数据库名字，mysql密码，端口号这些需要你根据自身情况进行更改，代码写的比较差劲，各位多多包涵。