session 原理及ORM 一对多 多对多的关系

一、SESSIN 原理

首先客户端访问服务器时生成一个COOKIE,服务器上有一个专门保存客户端访问服务器时COOKIE的SESSION 字典,  当客户端去访问服务器时,发送COOKIE 请求 去服务器SESSION字典认证,如果字典里没有,则生成SESSION 字符串保存到SESSION 字典中,然后返回给客户端,保存到COOKIE里,下次再访问服务器时 拿着此字符串去服务器端认证。

代码如下

#!/usr/bin/env python

# -*- coding:utf-8 -*-

import tornado.ioloop

import tornado.web

from hashlib import sha1

import os, time

session_container = {}#存session的字典

create_session_id = lambda: sha1(‘%s%s‘ % (os.urandom(16), time.time())).hexdigest()

class Session(object):

session_id = "session_cookie"#读取sessioncookie值

#如过存在session 就读取 如果不存在就创建

def __init__(self, request):

session_value = request.get_cookie(Session.session_id)

if not session_value:

# 创建随机字符串

self._id = create_session_id()  #创建的session 封装到session id 里

else:

# 如果有,直接将客户端的随机字符串设置为 _id

self._id = session_value

request.set_cookie(Session.session_id, self._id)#设置cookie

def __getitem__(self, key):

ret = None

try:

ret = session_container[self._id][key]

except Exception,e:

pass

return ret

def __setitem__(self, key, value):

# self._id

if session_container.has_key(self._id):

session_container[self._id][key] = value

else:

# key = is_login

# value = true

# {}

# {

#     随机字符串:{‘is_login‘: "true"}

# }

session_container[self._id] = {key: value}

def __delitem__(self, key):

del session_container[self._id][key]

class BaseHandler(tornado.web.RequestHandler):#继承RequestHandler   类

def initialize(self):#当请求过来是先执行此方法 获取用户COOkie

# my_session[‘k1‘]访问 __getitem__ 方法

self.my_session = Session(self) #self:LoginHandler 对象

class MainHandler(BaseHandler):

def get(self):

ret = self.my_session[‘is_login‘]

if ret:

self.write(‘index‘)

else:

self.redirect("/login")

class LoginHandler(BaseHandler):#继承BaseHandler的类

def get(self):#其次执行GET 方法

# self.set_cookie()

# self.get_cookie()

# 写 :session_cookie = "最忌字符串"

self.render(‘login.html‘)

def post(self, *args, **kwargs): #定义POST方法

username = self.get_argument(‘username‘)#用户名

password = self.get_argument(‘pwd‘)#密码

if username == ‘wupeiqi‘ and password == ‘123‘: #如果用户名密码匹配

self.my_session["is_login"] = "true"#SESSION 为真

# self.my_session[‘c_user‘]  # __getitem__

# self.my_session[‘c_user‘] = 123  # __setitem__

# del self.my_session[‘c_user‘]  # __delitem__

#

# self.my_session[‘c_user‘] = ‘wupeiqi‘

# self.my_session[‘c_card‘] = ‘12312312309823012‘

self.redirect(‘/index‘) #返回INDEX 页面

else:

self.render(‘login.html‘, **{‘status‘: ‘用户名或密码错误‘}) #否则报用户名密码错误

settings = {

‘template_path‘: ‘template‘,

‘static_path‘: ‘template‘,

‘static_url_prefix‘: ‘/template/‘,

‘cookie_secret‘: ‘aiuasdhflashjdfoiuashdfiuh‘,

‘login_url‘: ‘/login‘

}

#创建APPLICATION 及创建两个路径对应相对的函数

application = tornado.web.Application([

(r"/index", MainHandler),# 执行MainHandler 函数

(r"/login", LoginHandler),# 执行LoginHandler 函数

], **settings)

if __name__ == "__main__":

application.listen(8888)

tornado.ioloop.IOLoop.instance().start()

二、Django ORM  关系

Django 的ORM 有多总关系: 一对一,多对一,多对多。

各自定义的方式为:

一对一: OneToOneField 即一个对应一个

一对多: ForeignKey 即多个对应一个

多对多: ManyToManyField即 多个对应多个

一对多

1.创建的时候有两种方式

时间: 2024-10-10 13:56:34

session 原理及ORM 一对多 多对多的关系的相关文章

数据库表与表之间的一对多多对多的关系

一对一要约束 unique 多对多和一对一事通过一对多的基础上模拟的 原文地址:https://www.cnblogs.com/jintian/p/11161225.html

beego orm 一对多、多对多 关联查询

一对多 model ype User struct {Id int64 json:"id"Name string json:"name,omitempty" orm:"size(50)"Passwords string json:"passwords" orm:"size(32)"Baby []Baby json:"baby" orm:"reverse(many)"}

框架 day32 Hibernate,一级缓存,关联关系映射(一对多,多对多)

一级缓存 概念 *在 Session 接口的实现中包含一系列的 Java 集合, 这些 Java集合构成了Session缓存. 只要 Session 实例没有结束生命周期, 存放在它缓存中的对象也不会结束生命周期 *当session的save()方法持久化一个对象时,该对象被载入缓存, 以后即使程序中不再引用该对象,只要缓存不清空,该对象仍然处于生命周期中. 当试图get(). load()对象时,会判断缓存中是否存在该对象,有则返回,此时不查询数据库.没有再查询数据库 *Session 能够在

一对多(多对一)关系中的inverse和cascade属性

首先说一下inverse: "inverse" 直译过来就是"反转,使颠倒"的意思,书面化的解释为"是否将关系维护的权力交给对方" 1. 在hibernate中inverse默认是false,也就是己方拥有维护关系的权利, 当然为true的话,就是把维护关系的权利交给了对方 2. 在一对多的关系(多对一)中,通常将一端的inverse设置为false(一端设为true的话会多出更新语句,有性能问题,下面会讲到),而多对多的关系中,inverse的

SQLAlchemy_定义(一对一/一对多/多对多)关系

目录 Basic Relationship Patterns One To Many One To One Many To Many Basic Relationship Patterns 基本关系模式 The imports used for each of the following sections is as follows: 下列的 import 语句,应用到接下来所有的代章节中: from sqlalchemy import Table, Column, Integer, Forei

Hibernate 集合映射 一对多多对一 inverse属性 + cascade级联属性 多对多 一对一 关系映射

1 . 集合映射 需求:购物商城,用户有多个地址. // javabean设计 // javabean设计 public class User { private int userId; private String userName; // 一个用户,对应的多个地址 private Set<String> address; private List<String> addressList = new ArrayList<String>(); //private Str

hibernate 一对多|多对一

一对多:(一个客户对应多个联系人) 客户实体:Customer.java package cn.future.domain; import java.util.HashSet; import java.util.Set; public class Customer { /* * CREATE TABLE `cst_customer` ( `cust_id` BIGINT(32) NOT NULL AUTO_INCREMENT COMMENT '客户编号(主键)', `cust_name` VAR

Django进阶(二) &nbsp; 数据库的ORM操作之多对多

多对多的关系简单来说就是两张表里的数据,每一行都可以对应另外一张表里的多行数据.采用我们在一对多时使用的例子.加入我们放开限制,主机表Host表的数据都有可以有多个管理员.同时反过来HostAdmin表里的每个管理员也同时管理多个主机.代码如下: # coding:utf-8 from __future__ import unicode_literals from django.db import models # Create your models here. class Host(mode

DjangoORM一对多&多对多操作

简要说明 通过操作对象的方式操作数据库 详细步骤 models.py的结构是: 如果models.py中外键定义没有写 related_name='student_teacher', 可以直接用 studentList = teacher.student_teacher.all() 可以改写成: teacher = Teacher.objects.get(id = 1) studentList = teacher.student_set.all() =======================