面向对象基础
面向对象中通过索引的方式访问对象,需要内部实现 __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 == node: 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 = request.get_cookie(Session.session_id) 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)