自定义的tornado session，包含程序注释，直接可用

布满荆棘的人生 2022-05-26 13:56 59阅读 0赞

# coding:utf8
    import tornado.web
    import os
    import json
    
    import time
    import hashlib
    
    
    """
    程序初始化操作有些什么？自动执行了以下过程：
    在输入login的时候显示login界面，点击提交到了loginserviceHandler方法，接下来自动执行一些东西。说明如下：
    LoginserviceHandler继承了Foo类，Foo中有initialize方法，initialize方法会被自动执行。
    （原因：查看tornado.web.RequestHandler源码，_init_方法的时候就会调用initialize方法）
    
    更具体的流程如下：
    LoginserviceHandler一执行，调用_init_方法， _init_方法调用Foo类里面的initialize方法，这时实例化Session(),
    self.session = Session(self)，然后Session()在初始化的时候执行__init__方法，即（ #session初始化方法那里）。
    然后实例化CacheMethod()类，self.cacheclass = CacheMethod()
    然后获取浏览器的cookie，self.handler.get_cookie('my_session_id')，进行判断。
    
    
    """
    
    container = {}
    
    
    class Cache(object):
        def __init__(self):
            # self.container = {}
            pass
    
        def __contains__(self, item):
            return item in container
    
        def initial(self,random_str):
            container[random_str] = {}
    
        def get(self,random_str,key):
            return container[random_str].get(key)
    
        def set(self,random_str,key,value):
            # self.addtwodimdict(container,random_str,key,value)
            container[random_str][key] = value
    
        def showall(self):
            return container
    
        def delete(self,random_str,key):
            del container[random_str][key]
    
        def open(self):
            pass
    
        def close(self):
            pass
    
        def clear(self,random_str):
            print("cache里面的clear")
            del container[random_str]
    
        def addtwodimdict(self,thedict,key_a,key_b,val):#二维字典的赋值方式，但其实不用这么做，实际上程序也没有用这个函数
            if key_a in thedict:
                thedict[key_a].update({key_b: val})
            else:
                thedict.update({key_a: {key_b: val}})
    
    
    class Memcache(object):
        def __init__(self):
            pass
    
        def get(self,key):
            pass
    
        def set(self,key,value):
            pass
    
        def delete(self,key):
            pass
        
        def showall(self):
            pass
    
        def open(self):
            pass
    
        def close(self):
            pass
    
    
    class Filecache(object):
        def __init__(self):
            pass
    
        def get(self,key):
            pass
    
        def set(self,key,value):
            pass
    
        def delete(self,key):
            pass
    
        def showall(self):
            pass
        
        def open(self):
            pass
    
        def close(self):
            pass
    
    
    CacheMethod = Cache
    #这里根据需求改变存储的方式，自己写方法。cache是我写好的，file，redis，memcache等
    
    class Session(object):
        def __init__(self,handler):
            #session初始化方法
            print("sesson init")
            self.handler = handler
            self.random_str = None
            self.cacheclass = CacheMethod()
            #实例化存储的方法，这个方法可以自定义了。file，redis，memcache，自己写方法
            # 去用户请求信息中获取my_session_id，如果没有，新用户
            client_random_str = self.handler.get_cookie('my_session_id')
            if not client_random_str:
                "新用户"
                self.random_str = self.create_random_str()
                self.cacheclass.initial(self.random_str)
                print("新用户")
                # print(container)
                print(self.showall())#这个self.showall(）是Session()函数的，然后再在里面调用cache()的showall()
            else:
                if client_random_str in self.cacheclass:
                    #这里会调用cacheclass中的__contains__方法，其中item就是client_random_str，这是python魔术方法
                    #这样做的好处是，让这Session类只做参数传递，具体的参数操作和参数名是什么，可以由开发人员在存储方式中定义，即cache，redis
                    "老用户"
                    self.random_str = client_random_str
                    print("老用户")
                    # print(container)
                    print(self.showall())
    
                else:
                    "非法用户"
                    self.random_str = self.create_random_str()
                    self.cacheclass.initial(self.random_str)
                    print("非法用户")
                    # print(container)
                    print(self.showall())
    
            ctime = time.time()
            self.handler.set_cookie('my_session_id',self.random_str,expires=ctime+1800)
    
        def __setitem__(self, key, value):
            self.cacheclass.set(self.random_str,key,value)
            print("__setitem__")
    
        def __getitem__(self, key):
            print("__getitem__")
            v = self.cacheclass.get(self.random_str,key)
            return v
    
    
        def __delitem__(self, key):
            self.cacheclass.delete(self.random_str,key)
            print("__delitem__")
    
    
        def clear(self):
            print("Session里面的clear")
            self.cacheclass.clear(self.random_str)
    
        def showall(self):
            return self.cacheclass.showall()
    
        def create_random_str(self):
            v = str(time.time())
            m = hashlib.md5()
            m.update(bytes(v))
            return m.hexdigest()
    
    
    class Foo(object):
        def initialize(self):
            # self是MainHandler对象
            print("foo initialize")
            self.session = Session(self)
            #在其他类中调用session的方法提供的实例化对象为self.session
            super(Foo,self).initialize()
            #super不仅找父类，Foo继承的是object类，那么说明Foo这条线已经继承完，开始第二条线继承tornado.web.RequesHandler
    
    
    class HomeHandler(Foo,tornado.web.RequestHandler):
    
        def get(self):
            user = self.session['user']
            if not user:
                self.redirect("login")
            else:
                self.write(user)
                # print(container)
                print(self.session.showall())
    
    
    
    class LoginHandler(tornado.web.RequestHandler):
    
        def get(self, *args, **kwargs):
            self.render('views/login.html')
            print(container)
            # print(self.container)
    
    
    class LoginserviceHandler(Foo,tornado.web.RequestHandler):
        def get(self, *args, **kwargs):
            user = self.get_argument("user")
            pwd = self.get_argument("pwd")
            if(user == "user"):
                self.session['user'] = user
                self.session['pwd'] = pwd
                print("用户名正确")
                self.redirect('/home')
            else:
                print("用户名错误")
                self.redirect('/login')
    
    class ClearHandler(Foo,tornado.web.RequestHandler):
        def get(self,*args,**kwargs):
            del self.session['user']
            #首先调用Foo中initialize_然后实例化Session(),并调用__init__，其中del又会调用__delitem__操作
    
    class ClearallHandler(Foo,tornado.web.RequestHandler):
        def get(self):
            self.session.clear()
            #首先调用Foo中initialize方法_然后实例化Session()为self.session。再调用其中的clear()方法
            self.write("clearall")
    
    
    class ShowHandler(Foo,tornado.web.RequestHandler):
        def get(self):
            # self.write(container)
            self.write(self.session.showall())
            #首先调用Foo中initialize方法_然后实例化Session()为self.session。再调用其中的showall()方法
    
    
    class DemoHandler(tornado.web.RequestHandler):
        def get(self):
            self.write("demo")
            temp = self.create_random_str()
            self.write(temp)
    
        def create_random_str(self):
            v = str(time.time())
            m = hashlib.md5()
            m.update(bytes(v))
            return m.hexdigest()
    
    
    application = tornado.web.Application([
        (r"/login", LoginHandler),
        (r"/loginservice", LoginserviceHandler),
        (r"/home", HomeHandler),
        (r"/clear", ClearHandler),
        (r"/clearall", ClearallHandler),
        (r"/show", ShowHandler),
        (r"/", DemoHandler),
    ])
    
    if __name__ == "__main__":
        application.listen(9999)
        tornado.ioloop.IOLoop.instance().start()