class Application(tornado.web.Application): 
  def __init__(self): 
    settings = dict( 
      # 設(shè)定 cookie_secret, 用于 secure_cookie 
      cookie_secret = "e446976943b4e8442f099fed1f3fea28462d5832f483a0ed9a3d5d3859f==78d", 
      # 設(shè)定 session_secret 用于生成 session_id 
      session_secret = "3cdcb1f00803b6e78ab50b466a40b9977db396840c28307f428b25e2277f1bcc", 
      # memcached 地址 
      memcached_address = ["127.0.0.1:11211"], 
      # session 過期時(shí)間 
      session_timeout = 60, 
      template_path = os.path.join(os.path.dirname(__file__), "templates"), 
      static_path = os.path.join(os.path.dirname(__file__), "static"), 
      xsrf_cookies = True, 
      login_url = "/login", 
    ) 
 
    handlers = [ 
      (r"/", MainHandler), 
      (r"/login", LoginHandler) 
    ] 
 
    # 初始化父類 tornado.web.Application 
    tornado.web.Application.__init__(self, handlers, **settings) 
    # 初始化該類的 session_manager 
    self.session_manager = session.SessionManager(settings["session_secret"], settings["memcached_address"], settings["session_timeout"]) 

class LoginHandler(BaseHandler): 
  def get(self): 
    self.render("login.html") 
 
  def post(self): 
    # 以字典的鍵值對(duì)形式存取 
    self.session["user_name"] = self.get_argument("name") 
    # 修改完要調(diào)用 session 的 save, 否則等于沒有修改哦... 
    self.session.save() 
    self.redirect("/") 

class BaseHandler(tornado.web.RequestHandler): 
  def __init__(self, *argc, **argkw): 
    super(BaseHandler, self).__init__(*argc, **argkw) 
    # 定義 handler 的 session, 注意，根據(jù) HTTP 特點(diǎn)，每次訪問都會(huì)初始化一個(gè) Session 實(shí)例哦，這對(duì)于你后面的理解很重要 
    self.session = session.Session(self.application.session_manager, self) 
 
  # 這是干嘛的？用于驗(yàn)證登錄...請(qǐng) google 關(guān)于 tornado.web.authenticated, 其實(shí)就是 tornado 提供的用戶驗(yàn)證 
  def get_current_user(self): 
    return self.session.get("user_name") 

# 繼承字典，因?yàn)?session 的存取類似于字典 
class SessionData(dict): 
  # 初始化時(shí)提供 session id 和 hmac_key 
  def __init__(self, session_id, hmac_key): 
    self.session_id = session_id 
    self.hmac_key = hmac_key 

# 繼承 SessionData 類 
class Session(SessionData): 
  # 初始化，綁定 session_manager 和 tornado 的對(duì)應(yīng) handler 
  def __init__(self, session_manager, request_handler): 
    self.session_manager = session_manager 
    self.request_handler = request_handler 
 
    try: 
      # 正常是獲取該 session 的所有數(shù)據(jù)，以 SessionData 的形式保存 
      current_session = session_manager.get(request_handler) 
    except InvalidSessionException: 
      # 如果是第一次訪問會(huì)拋出異常，異常的時(shí)候是獲取了一個(gè)空的 SessionData 對(duì)象,里面沒有數(shù)據(jù)，但包含新生成的 
      # session_id 和 hmac_key 
      current_session = session_manager.get() 
 
    # 取出 current_session 中的數(shù)據(jù)，以鍵值對(duì)的形式迭代存下 
    for key, data in current_session.iteritems(): 
      self[key] = data 
 
    # 保存下 session_id 
    self.session_id = current_session.session_id 
    # 以及對(duì)應(yīng)的 hmac_key 
    self.hmac_key = current_session.hmac_key 
 
  # 定義 save 方法，用于 session 修改后的保存，實(shí)際調(diào)用 session_manager 的 set 方法 
  def save(self): 
    self.session_manager.set(self.request_handler, self) 

# 初始化需要一個(gè)用于 session 加密的 secret, memcache 地址, session 的過期時(shí)間 
def __init__(self, secret, memcached_address, session_timeout): 
  self.secret = secret 
  self.memcached_address = memcached_address 
  self.session_timeout = session_timeout 

# 該方法用 session_id 從 memcache 中取出數(shù)據(jù) 
def _fetch(self, session_id): 
  try: 
    # 連接 memcache 服務(wù)器 
    mc = memcache.Client(self.memcached_address, debug=0) 
    # 獲取數(shù)據(jù) 
    session_data = raw_data = mc.get(session_id) 
    if raw_data != None: 
      # 為了重新刷新 timeout 
      mc.replace(session_id, raw_data, self.session_timeout, 0) 
      # 反序列化 
      session_data = pickle.loads(raw_data) 
    # 如果拿到的數(shù)據(jù)是字典形式，才進(jìn)行返回 
    if type(session_data) == type({}): 
      return session_data 
    else: 
      return {} 
  except IOError: 
    return {} 

def get(self, request_handler = None): 
 
  # 獲取對(duì)應(yīng)的 session_id 和 hmac_key 
  if (request_handler == None): 
    session_id = None 
    hmac_key = None 
  else: 
    # session 的基礎(chǔ)還是靠 cookie 
    session_id = request_handler.get_secure_cookie("session_id") 
    hmac_key = request_handler.get_secure_cookie("verification") 
 
  # session_id 不存在的時(shí)候則生成一個(gè)新的 session_id 和 hmac_key 
  if session_id == None: 
    session_exists = False 
    session_id = self._generate_id() 
    hmac_key = self._generate_hmac(session_id) 
  else: 
    session_exists = True 
 
  # 檢查 hmac_key 
  check_hmac = self._generate_hmac(session_id) 
  # 不通過則拋出異常 
  if hmac_key != check_hmac: 
    raise InvalidSessionException() 
 
  # 新建 SessionData 對(duì)象 
  session = SessionData(session_id, hmac_key) 
 
  if session_exists: 
    # 通過 _fetch 方法獲取 memcache 中該 session 的所有數(shù)據(jù) 
    session_data = self._fetch(session_id) 
    for key, data in session_data.iteritems(): 
      session[key] = data 
 
  return session 

# 設(shè)置新的 session,需要設(shè)置 handler 的 cookie 和 memcache 客戶端 
def set(self, request_handler, session): 
  # 設(shè)置瀏覽器的 cookie 
  request_handler.set_secure_cookie("session_id", session.session_id) 
  request_handler.set_secure_cookie("verification", session.hmac_key) 
  # 用 pickle 進(jìn)行序列化 
  session_data = pickle.dumps(dict(session.items()), pickle.HIGHEST_PROTOCOL) 
  # 連接 memcache 服務(wù)器 
  mc = memcache.Client(self.memcached_address, debug=0) 
  # 寫入 memcache 
  mc.set(session.session_id, session_data, self.session_timeout, 0) 

# 生成 session_id 
def _generate_id(self): 
  new_id = hashlib.sha256(self.secret + str(uuid.uuid4())) 
  return new_id.hexdigest() 
 
# 生成 hmac_key 
def _generate_hmac(self, session_id): 
  return hmac.new(session_id, self.secret, hashlib.sha256).hexdigest()