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

# 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()