面向对象基础

面向对象中通过索引的方式访问对象，需要内部实现 __getitem__ 、__delitem__、__setitem__方法

#!/usr/bin/env python# -*- coding:utf-8 -*-   class Foo(object):       def __getitem__(self, key):        print  ‘__getitem__‘,key       def __setitem__(self, key, value):        print ‘__setitem__‘,key,value       def __delitem__(self, key):        print ‘__delitem__‘,key         obj = Foo()result = obj[‘k1‘]#obj[‘k2‘] = ‘wupeiqi‘#del obj[‘k1‘]

Tornado扩展

在tornado的源码中,默认执行Handler的get/post等方法之前默认会执行 initialize方法，所以可以通过自定义的方式使得所有请求在处理前执行操作.

class BaseHandler(tornado.web.RequestHandler):       def initialize(self):        self.xxoo = "wupeiqi"      class MainHandler(BaseHandler):       def get(self):        print(self.xxoo)        self.write(‘index‘) class IndexHandler(BaseHandler):       def get(self):        print(self.xxoo)        self.write(‘index‘)

session

session其实就是定义在服务器端用于保存用户回话的容器，其必须依赖cookie才能实现。

自定义session_1

#!/usr/bin/env python# -*- coding:utf-8 -*-import configfrom hashlib import sha1import osimport time#生成一个随机的session_idcreate_session_id = lambda: sha1(bytes(‘%s%s‘ % (os.urandom(16), time.time()), encoding=‘utf-8‘)).hexdigest()#根据定义好的session存储方式,选择对应的处理方式class SessionFactory:    @staticmethod    def get_session_obj(handler):        obj = None        if config.SESSION_TYPE == "cache":            obj = CacheSession(handler)        elif config.SESSION_TYPE == "memcached":            obj = MemcachedSession(handler)        elif config.SESSION_TYPE == "redis":            obj = RedisSession(handler)        return objclass CacheSession:    session_container = {}    session_id = "__sessionId__"    def __init__(self, handler):        self.handler = handler        client_random_str = handler.get_cookie(CacheSession.session_id, None)        if client_random_str and client_random_str in CacheSession.session_container:            self.random_str = client_random_str        else:            self.random_str = create_session_id()            CacheSession.session_container[self.random_str] = {}        expires_time = time.time() + config.SESSION_EXPIRES        handler.set_cookie(CacheSession.session_id, self.random_str, expires=expires_time)    def __getitem__(self, key):        ret = CacheSession.session_container[self.random_str].get(key, None)        return ret    def __setitem__(self, key, value):        CacheSession.session_container[self.random_str][key] = value    def __delitem__(self, key):        if key in CacheSession.session_container[self.random_str]:            del CacheSession.session_container[self.random_str][key]class RedisSession:    def __init__(self, handler):        passclass MemcachedSession:    def __init__(self, handler):        pass

其中os.urandom(n): 返回n个随机byte值的string，作为加密使用

自定义session_2(定义存储方式)

session_app.py:

#!/usr/bin/env python# -*- coding:utf-8 -*-# pip3 install tornadoimport tornado.ioloopimport tornado.webfrom Session.session import SessionHandlerclass MainHandler(SessionHandler,tornado.web.RequestHandler):    def get(self):        self.render(‘login.html‘)    def post(self, *args, **kwargs):        user = self.get_argument(‘username‘)        pwd = self.get_argument(‘password‘)        if user == ‘alex‘ and pwd == ‘123‘:            self.session_obj[‘is_login‘] = True            self.session_obj[‘user‘] = user            self.redirect(‘/index‘)        else:            self.redirect(‘/main‘)class IndexHandler(SessionHandler,tornado.web.RequestHandler):    def get(self):        current_user = self.session_obj[‘user‘]        del self.session_obj[‘user‘]        if current_user:            self.write(current_user)        else:            self.write(‘滚‘)class MainHandler1(SessionHandler,tornado.web.RequestHandler):    def get(self):        self.write(‘ok‘)class MainHandler2(SessionHandler,tornado.web.RequestHandler):    def get(self):        print(‘ok‘)        self.write(‘ok‘)# obj = MainHandler() # 执行构造方法# obj.get()# func = getattr(obj, ‘get‘)# func()application = tornado.web.Application([    (r"/main", MainHandler),    (r"/index", IndexHandler),])if __name__ == "__main__":    application.listen(8888)    tornado.ioloop.IOLoop.instance().start()

Session/session.py:

import hashlibimport timefrom Session import confclass SessionHandler:    def initialize(self):        self.session_obj = SessionFacotory.get_session_obj(self)class SessionFacotory:    @staticmethod    def get_session_obj(handler):        if conf.session_type == ‘redis‘:            return RedisSession(handler)        elif conf.session_type == ‘memcache‘:            return RedisSession(handler)        else:            return MemorySession(handler)def md5():    m = hashlib.md5()    m.update(bytes(str(time.time()),encoding=‘utf-8‘))    return m.hexdigest()class MemorySession:    container = {    }    # self.r_str当前用户的随机字符串    def __init__(self,handler):        random_str = handler.get_cookie(‘___session_id___‘)        if random_str:            # 客户端有cookie            # 合法cookie            if random_str in MemorySession.container:                self.r_str = random_str            else:                # 非法cookie                random_str = md5()                MemorySession.container[random_str] = {}                self.r_str = random_str        else:            # 客户端无cookie，表示是新用户的到来            random_str = md5()            MemorySession.container[random_str] = {}            self.r_str = random_str        handler.set_cookie(‘___session_id___‘, random_str, expires=time.time() + 200)    def __setitem__(self, key, value):        MemorySession.container[self.r_str][key] = value    def __getitem__(self, item):        return MemorySession.container[self.r_str].get(item,None)    def __delitem__(self, key):        del MemorySession.container[self.r_str][key]class RedisSession:    def __init__(self):        pass    def __getitem__(self, item):        pass    def __setitem__(self, key, value):        pass    def __delitem__(self, key):        pass

Session/conf.py:

session_type = ‘redis‘

分布式session

一致性哈希:

#!/usr/bin/env python#coding:utf-8import sysimport mathfrom bisect import bisectif sys.version_info >= (2, 5):    import hashlib    md5_constructor = hashlib.md5else:    import md5    md5_constructor = md5.newclass HashRing(object):    """一致性哈希"""        def __init__(self,nodes):        ‘‘‘初始化        nodes : 初始化的节点，其中包含节点已经节点对应的权重                默认每一个节点有32个虚拟节点                对于权重，通过多创建虚拟节点来实现                如：nodes = [                        {‘host‘:‘127.0.0.1:8000‘,‘weight‘:1},                        {‘host‘:‘127.0.0.1:8001‘,‘weight‘:2},                        {‘host‘:‘127.0.0.1:8002‘,‘weight‘:1},                    ]        ‘‘‘                self.ring = dict()        self._sorted_keys = []        self.total_weight = 0                self.__generate_circle(nodes)                                    def __generate_circle(self,nodes):        for node_info in nodes:            self.total_weight += node_info.get(‘weight‘,1)                    for node_info in nodes:            weight = node_info.get(‘weight‘,1)            node = node_info.get(‘host‘,None)                            virtual_node_count = math.floor((32*len(nodes)*weight) / self.total_weight)            for i in xrange(0,int(virtual_node_count)):                key = self.gen_key_thirty_two( ‘%s-%s‘ % (node, i) )                if self._sorted_keys.__contains__(key):                    raise Exception(‘该节点已经存在.‘)                self.ring[key] = node                self._sorted_keys.append(key)                def add_node(self,node):        ‘‘‘ 新建节点        node : 要添加的节点，格式为：{‘host‘:‘127.0.0.1:8002‘,‘weight‘:1}，其中第一个元素表示节点，第二个元素表示该节点的权重。        ‘‘‘        node = node.get(‘host‘,None)        if not node:                raise Exception(‘节点的地址不能为空.‘)                        weight = node.get(‘weight‘,1)                self.total_weight += weight        nodes_count = len(self._sorted_keys) + 1                virtual_node_count = math.floor((32 * nodes_count * weight) / self.total_weight)        for i in xrange(0,int(virtual_node_count)):            key = self.gen_key_thirty_two( ‘%s-%s‘ % (node, i) )            if self._sorted_keys.__contains__(key):                raise Exception(‘该节点已经存在.‘)            self.ring[key] = node            self._sorted_keys.append(key)            def remove_node(self,node):        ‘‘‘ 移除节点        node : 要移除的节点 ‘127.0.0.1:8000‘        ‘‘‘        for key,value in self.ring.items():            if value =http://www.mamicode.com/= node:"hljs-keyword">del self.ring[key]                self._sorted_keys.remove(key)        def get_node(self,string_key):        ‘‘‘获取 string_key 所在的节点‘‘‘        pos = self.get_node_pos(string_key)        if pos is None:            return None        return self.ring[ self._sorted_keys[pos]].split(‘:‘)        def get_node_pos(self,string_key):        ‘‘‘获取 string_key 所在的节点的索引‘‘‘        if not self.ring:            return None                    key = self.gen_key_thirty_two(string_key)        nodes = self._sorted_keys        pos = bisect(nodes, key)        return pos        def gen_key_thirty_two(self, key):                m = md5_constructor()        m.update(key)        return long(m.hexdigest(), 16)            def gen_key_sixteen(self,key):                b_key = self.__hash_digest(key)        return self.__hash_val(b_key, lambda x: x)    def __hash_val(self, b_key, entry_fn):        return (( b_key[entry_fn(3)] << 24)|(b_key[entry_fn(2)] << 16)|(b_key[entry_fn(1)] << 8)| b_key[entry_fn(0)] )    def __hash_digest(self, key):        m = md5_constructor()        m.update(key)        return map(ord, m.digest())"""nodes = [    {‘host‘:‘127.0.0.1:8000‘,‘weight‘:1},    {‘host‘:‘127.0.0.1:8001‘,‘weight‘:2},    {‘host‘:‘127.0.0.1:8002‘,‘weight‘:1},]ring = HashRing(nodes)result = ring.get_node(‘98708798709870987098709879087‘)print result"""

分布式session:

from hashlib import sha1import os, timecreate_session_id = lambda: sha1(‘%s%s‘ % (os.urandom(16), time.time())).hexdigest()class Session(object):    session_id = "__sessionId__"    def __init__(self, request):        session_value = http://www.mamicode.com/request.get_cookie(Session.session_id)"hljs-keyword">if not session_value:            self._id = create_session_id()        else:            self._id = session_value        request.set_cookie(Session.session_id, self._id)    def __getitem__(self, key):        # 根据 self._id ，在一致性哈西中找到其对应的服务器IP        # 找到相对应的redis服务器，如： r = redis.StrictRedis(host=‘localhost‘, port=6379, db=0)        # 使用python redis api 链接        # 获取数据，即：        # return self._redis.hget(self._id, name)    def __setitem__(self, key, value):        # 根据 self._id ，在一致性哈西中找到其对应的服务器IP        # 使用python redis api 链接        # 设置session        # self._redis.hset(self._id, name, value)    def __delitem__(self, key):        # 根据 self._id 找到相对应的redis服务器        # 使用python redis api 链接        # 删除，即：        return self._redis.hdel(self._id, name)

Tornado之自定义session