python tornado session

main.py ，此处使用的是内存方式redis和memecahe修改driver和后面的设置

import os
from tornado import ioloop
import tornado
import tornado.httpserver
import tornado.web

app_handlers = [
    (r'/test', TestHandler),
    (r'/', IndexHandler),
]

class Application(tornado.web.Application):
    def __init__(self):
        parent_path = os.path.dirname(__file__)
        handlers = app_handlers
        settings = dict(
            debug=True,
        )
        session_settings = dict(
            driver="memory",
            driver_settings=dict(
                host=self,
            ),
            sid_name='torndsession-mem',  # default is msid.
            session_lifetime=20* 60,  # default is 1200 seconds.
            force_persistence=True,
        )
        settings.update(session=session_settings)
        tornado.web.Application.__init__(self, handlers=handlers, template_path=os.path.join(parent_path, 'template'),
                                         static_path=os.path.join(parent_path, 'static'), **settings)


if __name__ == '__main__':
    try:
        # 初始化Server
        http_server = tornado.httpserver.HTTPServer(Application())
        http_server.listen(8800)
        tornado.ioloop.IOLoop.instance().start()

    except Exception as err:
        print("error:", err)

base_request.py

# -*- coding: utf-8 -*-
from sqlalchemy.orm import scoped_session, sessionmaker
from common.dbutils import engine
from torndsession.sessionhandler import SessionBaseHandler
from common.auth_utils import token_check
# 以下导入内容此处未用到，但在pyinstaller打包的时候会用，勿删
# import torndsession.memcachedsession

__author__ = 'Ennis'


class BaseHttpHandler(SessionBaseHandler):

    def __init__(self, application, request, **kwargs):
        super(BaseHttpHandler, self).__init__(application, request, **kwargs)
        self.db = scoped_session(sessionmaker(bind=engine))
        self._session = self.session.session

    def data_received(self, chunk):
        pass

    def write(self, chunk):
        super(BaseHttpHandler, self).write(chunk)

    def on_finish(self):
        self.db.rollback()
        self.db.close()

    def session_get(self, key, default=None):
        if key in self.session:
            return self._session[key]
        else:
            return default


@token_check
class ApiRequestHandler(BaseHttpHandler):
    def __init__(self, application, request, **kwargs):
        super(ApiRequestHandler, self).__init__(application, request, **kwargs)

        if 'token' in self.session:
            self.session['token'] = self.session['token']
            self.session.flush()

    def data_received(self, chunk):
        pass

 auth_utils.py

# -*- coding: utf-8 -*-
__author__ = 'Ennis'


def token_check(handler_class):
    def wrap_execute(handler_execute):
        def require_auth(handler, kwargs):
            """
            :param handler:
            :param kwargs:
            :return:

            # I've pulled this out just for clarity, but you could stick
            # it in _execute if you wanted.  It returns True iff
            # credentials were provided.  (The end of this function might
            # be a good place to see if you like their username and
            # password.)
            """
            if 'token' not in handler.session:
                handler.set_status(401)
                handler._transforms = []
                handler.write('session expired, please login again')
                handler.finish()
                return False

            return True

        def _execute(self, transforms, *args, **kwargs):
            """
            :param self:
            :param transforms:
            :param args:
            :param kwargs:
            :return:

            # Since we're going to attach this to a RequestHandler class,
            # the first argument will wind up being a reference to an
            # instance of that class.
            """
            if not require_auth(self, kwargs):
                return False
            return handler_execute(self, transforms, *args, **kwargs)

        return _execute

    handler_class._execute = wrap_execute(handler_class._execute)
    return handler_class

api使用，登录继承base不检查session，其他接口需要检查session继承apibase

class login(BaseHttpHandler):
    def post(self):
        msg_body = self.request.body.decode()
        msg = json.loads(msg_body)
        phone = msg["phone"]
        password = hashlib.md5(msg["password"].encode(encoding='UTF-8')).hexdigest()
       
        logging.info('user login success， user_id = %s', phone + password)
        self.session['token'] = phone + password
        self.session.flush()
        self.write(json.dumps({"result": 1}))



class getUserInfo(ApiRequestHandler):
    def post(self):
        msg_body = self.request.body.decode()
        msg = json.loads(msg_body)
        phone = msg["phone"]
   
        if user == None:
            self.write(json.dumps({"result": 0, "message": "该用户信息不存在"}))
            return

redis设置方式

session_settings = dict(
            driver="redis",
            driver_settings=dict(
                host='localhost',
                port=6379,
                db=0,
                max_connections=1024,
            )
            session_lifetime=10,
            force_persistence=True,
        )