面向對象基礎
面向對象中通過索引的方式訪問對象，需要內部實現 __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 config
from hashlib import sha1
import os
import time
#生成一個隨機的session_id
create_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 obj
class 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):
pass
class 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 tornado
import tornado.ioloop
import tornado.web
from Session.session import SessionHandler
class 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 hashlib
import time
from Session import conf
class 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-8
import sys
import math
from bisect import bisect
if sys.version_info >= (2, 5):
import hashlib
md5_constructor = hashlib.md5
else:
import md5
md5_constructor = md5.new
class 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 sha1
import os, time
create_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)