一、项目总结三步骤

  1. 项目生命周期为基准线、分析要有层次感、不要想到什么说什么。
  2. 这条基准线上，负责的是哪一块，做了什么。
  3. 举例说明项目中遇到的问题及怎么解决的。

二、项目需求分析

  1. 管理员
  2.     1 注册
  3.     2 登录
  4.     3 上传视频
  5.     4 删除视频
  6.     5 发布公告
  7. 用户
  8.     1 注册
  9.     2 登录
  10.     3 冲会员
  11.     4 查看视频
  12.     5 下载免费视频
  13.     6 下载收费视频
  14.     7 查看观影记录
  15.     8 查看公告

三、搭建框架

  1. 层级结构：客户端   服务端  数据库
  3. 客户端：
  4.     基于tcp连接的套接字程序
  5.     管理员视图
  6.         注册、登录、上传视频、删除视频、发布公告
  7.     用户视图
  8.         注册、登录、购买vip、查看视频、下载免费视频、下载收费视频、查看下载记录、查看公告
  9. 服务端：
  10.     tcpserver：基于多线程实现并发的套接字通信  解决粘包问题
  11.     interface：admin_interface、user_interface、common_interface
  12.     models类和ORM框架：models类中的四张表继承ORM框架中的基类model
  13. 数据库：
  14.     创建四张表：user、movie、notice、download_record

四、ORM框架分析

  1. # 优点：让一个不懂数据库操作的小白也能够简单快速操作数据库实现相应功能
  2. # 缺点：sql封装固定,不利于sql查询优化
  4. # 对象关系映射
  5.     # 类 >>> 数据库的表
  6.     # 对象 >>> 表的一条条的记录
  7.     # 对象获取属性或方法 >>> 记录的字段对应的值
  9. # 一张表有字段,字段又有字段名,字段类型,字段是否是主键,字段的默认值
  11. class Field(object):
  12.     pass
  13. # 为了在定义的时候更加方便 通过继承Field定义具体的字段类型
  14. class StringField(Field):
  15.     pass
  16. class IntegerField(Field):
  17.     pass
  19. class Models(dict):
  20.     pass
  22.     def __getattr__(self,item):
  23.         return self.get(item)
  25.     def __setattr__(self,key,value)
  26.         self[key] = value
  28.     # 查询
  29.     def select(self,**kwargs):
  30.         # select * from userinfo
  31.         # select * from userinfo where id = 1
  33.     # 新增
  34.     def save(self):
  35.         # insert into userinfo(name,password) values('jason','123')
  37.     # 修改:是基于已经存在了的数据进行修改操作
  38.     def update(self):
  39.         # update userinfo set name='jason',password='234' where id = 1
  40. """
  41. (******)
  42. hasattr
  43. getattr
  44. setattr
  45. """
  46. # 元类拦截类的创建过程  使它具备表的特性
  47. class ModelsMetaClass(type):
  48.     def __new__(cls,class_name,class_bases,class_attrs):
  49.         # 只拦截模型表的创建表
  50.         if class_name == 'Models':
  51.             return type.__new__(cls,class_name,calss_bases,class_attrs)
  52.         table_name = class_attrs.get('table_name',class_name)
  53.         primary_key = None
  54.         mappings = {}
  55.         for k,v in class_attrs.items():
  56.             if isinstance(v,Field):
  57.                 mappings[k] = v
  58.                 if v.primary:
  59.                     if primary_key:
  60.                         raise TypeError('主键重复')
  61.                     primary_key = v.name
  62.         for k in mappings.keys():
  63.             class_attrs.pop(k)
  64.         if not primary_key:
  65.             raise TypeError('必须要有一个主键')
  66.         class_attrs['table_name'] = table_name
  67.         class_attrs['primary_key'] = primary_key
  68.         class_attrs['mappings'] = mappings
  69.         return type.__new__(cls,class_name,calss_bases,class_attrs)

五、数据库设计

  1. 表结构定义好以后，数据怎么操作，逻辑代码怎么实现就清晰了
  3. 用户表：包含管理员和普通用户信息 user--->id ,name ,password ,is_locked ,is_vip , user_type,register_time
  4. 电影表：movie---->id,name,, path,is_free, is_delete,user_id,create_time,file_md5
  5. 公告表：notice--->id,title,content,create_time,user_id
  6. 下载记录表：download_record---->id,user_id,movie_id,create_time
  8. create table user(
  9.     id int auto_increment primary key,
  10.     name varchar(255),
  11.     password varchar(255),
  12.     is_locked int not null default 0,
  13.     is_vip int not null default 0,
  14.     user_type varchar(255),
  15.     register_time varchar(255)
  16. )engine=Innodb charset='utf8';
  18. create table movie(
  19.     id int auto_increment primary key,
  20.     name varchar(64),
  21.     path varchar(255),
  22.     is_free int not null default 1,
  23.     is_delete int not null default 0,
  24.     create_time varchar(255),
  25.     file_md5 varchar(255),
  26.     user_id int
  27. )engine=Innodb charset='utf8';
  29. create table notice(
  30.     id int auto_increment primary key,
  31.     title varchar(255),
  32.     content varchar(255),
  33.     user_id int,
  34.     create_time varchar(255)
  35. )engine=Innodb charset='utf8';
  37. create table download_record(
  38.     id int auto_increment primary key,
  39.     user_id int,
  40.     movie_id int,
  41.     create_time varchar(255)
  42. )engine=Innodb charset='utf8';

六、项目中各个功能模块分析

  1. 管理员：
  2. 1、注册功能
  3.     客户端
  4.         1-1、选择每个功能之前都需要都需要需要连接上服务器，即需要一个socket对象，每个函数传一个client
  5.         1-2、密码在传递过程中不能是明文吧，需要加密，可选择hashlib中md5加密，定义一个公共方法咯
  6.         1-3、定义一个发送和接收的公共方法、这里要注意的是在这个方法有一个关键字形参、用于传输文件，默认为None
  7.         1-4、考虑一个问题，发送的字典中要包含哪些数据、对于注册这个问题，包含服务器端用于标识的type的功能类型、
  8.              用户名、密码（要加密）、还有用户类型"user_type"(admin或者user)这里是admin类型
  9.         1-5、接收得到的字典back_dic又包含那些数据，常见的就flag和msg，后续的功能中有返回列表类型的
  10.     服务端
  11.         1-6、首先就是基于多线程实现并发的套接字程序，子线程working函数中会先接收到客户端发来的字典（用到json、struct模块）
  12.         1-7、有个问题是有什么便利的方法将接收到的字典recv_dic 和与客户端建立连接的socket对象conn 交给接口层中相应的功能进
  13.              行操作数据库，那就定义一个分发函数dispatch（recv_dic,conn）,然后判断recv_dic["type]类型和全局func_dic字典中进行
  14.              比对，去执行与之对应的函数，如果传过来的类型不存在func_dic字典中，那就自定义一个字典back_dic(包含flag和msg数据)
  15.              调用服务端公共发送数据方法返回给客户端
  16.         1-8、咱们不知不觉就来到了服务端注册接口了，意味着可以操作数据库啦，就需要用到ORM框架和db目录中models模块中与表一一对应
  17.              的类、这四个类都是根据事先在数据库中定义好的字段进行创建的，不要写错了，字段和类型。这四个类都继承了ORM框架的基类
  18.              modle，所以可是直接点就可以调用ORM框架中基类中方法，select方法是类方法，得到的是一个列表套对象，还有save方法，用于保存
  19.              ，还有一个update方法用于更新，那咱们回过头来
  20.         1-9、注册功能拿到的recv_dic中可以拿到注册的用户名，得到用户名后使用user_data = models.User.select(name=name )进行判断要注册的
  21.              用户是否存在，若果存在老规矩back_dic(flag为False，msg为注册失败)返回去，不存在那咋整，还能咋整保存到数据库user表中呗，那
  22.              怎么保存呀，name，password，user_type,is_locked和is_vip都有默认值，register_time注册时间的话写个方法 time.strftime("%Y-%m-%d %X")
  23.              这样不就全搞定了，什么数据都拿到了，那就用models.User（）把这些数据搞进去创建得到一个对象，对象调用save方法进行方法就ojbk了，不急还有
  24.              要记得通知客户端，老规矩back_dic字典，调用公共发送方法，注册大功告成
  25. 登录
  26.     客户端
  27.         2-1、在注册功能该项目的总体框架都已经打通了任督二脉，我的乖乖，那登录功能需要考虑一个问题，客户端如果登陆成功，是不是需要标记一下登陆状态
  28.              ，老规矩在全局定义一个字典，把返回的字典中一个session存到全局字典cookie中，解决了ojbk，
  29.         2-2、发送字典send_dic中type类型修改为login，密码的话照样发送密文，然后over了
  30.     服务器
  31.         2-3、还记得tcpserver模块中的全局func_dic字典吗？强大的地方来了，刚刚只是写了一个注册的映射接口，现在来了一个login类型，那咋整，就往里加一个
  32.              login的映射方法，还可以直接拿到recv_dic和conn，任督二脉打通了就是强，哦还有注册和登录都是管理员和普通用户的公共方法，所以放到common_interface
  33.             中，其实放哪都一样只要能找到就行啦 哈哈
  34.         2-4、你要登陆，逻辑点在哪里，首先我要判断你这货存不存在呀，不存在登陆个屁呀，淡定淡定，哈哈，上面说过select方法得到的是列表，别给老子忘了，列表里面
  35.             放的是一个个对象，models中User类调用select方法根据name=recv_dic["name"]得到user_list,如果user_list存在，那就取零号位就拿到user_obj用户对象
  36.         2-5、拿到user_obj对象点表中的字段属性判断其类型和接收的recv_dic字典中类型和密码是否一致，一致的话便可以得到一个back_dic字典了，老规矩包含flag和msg
  37.         2-6、重点来了，这里可能有带你绕，请无关人员速速离开，要返回的back_dic字典中需要添加一个session添加到字典中，这个session是用户登陆成功之后生成的一个
  38.              随机字符串，咱这里也是用hashlib，这里要保证生成的字符串是唯一的，这里需要加盐，加一个当前cpu执行代码的时间 time.clock()
  39.         2-7、,服务端怎么校验用户的登陆问题，考虑两个问题，第一个问题服务端需要保存session，第二个问题当用户退出之后将该用户对应的键值删除？
  40.             那我们如何判断用户走了，运行到哪一段代码就标记用户走了呢，我们可不可以通过addr就可以定位哪一个用户断开了，找到当前用对应的数据删除，数据保存形式
  41.             {‘addr’:[session,user_id]}  将这个东西存在哪里呢，可以放在全局，但我们这里把他存到Tcpsever目录下user_data模块中live_user['addr’']=[session,user_id]
  42.             那问题又来，怎么拿到add，第一种思路给每一个函数都添加addr参数，但是这个addr参数只是login函数用到，其他函数都没用到，这样第一种思路很不合理，第二种思路
  43.             可以通过working中接收到的recv_dic字典添加recv_dic["addr"] = str(addr) 再传给每一个函数，在login函数中user_data.live_user[recv_dic["addr"]] = [session,user_obj.id]
  44.             有考虑一个问题，因为多线程要操作公共数据user_data中的live_user字典，就会出现数据错乱，所以要加锁，那这个锁在那里产生呢？我们要在tcpsever全局中产生mutex = Lock()
  45.             在这里产生，但是不能在这里用，因为会出现循环导入问题，tcpserver导入common_interface,在common_interface中又用到tcpserver中的锁，相互导入就出现循环导入，解决办法，
  46.             将锁保存到user_data中  user_data.mutex = mutex，在login中给user_data.live_user[recv_dic["addr"]] = [session,user_obj.id]加锁，直接导入user_data就可以使用到锁啦
  47.             还没完在tcpserver中 用户退出（try...except.(下面的执行的代码就表示其中一个线程断开)..）就要删除user_data.live_user.pop(str(addr))  ，这里也是公共方法需要
  48.             加锁user_data.mutex.acquire()和user_data.mutex.release()
  49.         2-8、下面的功能都需要先登录才能操作，这里来个装饰器功能：校验客户端发过来的随机字符串，如果有这个随机字符串那就正常执行函数，如果没有返回请先登录的提示，意味着客户端
  50.             发送的字典要带着session过来，装饰器inner（*args,**kwargs）中args=（recv_dic,conn） kwargs={}  拿到客户端发过来的随机字符串与服务器的数据进行比对  vlues=[session,user_id]
  51.             for vlues in user_data.live_user.vlues(): if args[0].get("session") == v[0]:将对应的user_id放入recv_dic中，以便后续使用args[0]["user_id"]=vlues[1] break
  52.             以上for循环不一定能找到，for循环只是单单的判断session，然后将user_id放到接收字典recv_dic中,那被装饰的函数到底执不执行，if args[0].get("user_id"): func(*args,**kwargs)
  53.             else: back_dic ={"flag"False,"msg":"请先登录"} 然后调用返回函数send_back(back_dic,args[1])
  54. 3、上传视频
  55.     客户端
  56.         3-1、查看有哪些影片需要上传的，即获取所有视频
  57.         3-2、判断影片是否存在才能上传，那应该怎么判断是个问题，我们能不能对上传的视频文件进行hashlib，自定义被hash的数据可以在文件开头，1/3，2/3，末尾-10然后得到md5值
  58.             发送字典类型"check_movie"，包含"session"，"file_md5"，得到字典back_dic，如果视频不存在那要输入is_free，是否免费，然后在发字典send_dic,该字典类型为"upload_movie"，还包含
  59.             "session"、"file_name"、 "file_size"、"file_md5"，这里调用公共收发方法是要给文件file传参了，把上传文件路径传过去
  60.      服务端
  61.         3-3、还记得tcpserver模块中的全局func_dic字典吗？加上"check_movie"和"upload_movie"映射，映射函数全都加上装饰器
  62.         3-4、"check_movie"比较简单，只是查看要上传视频的file_md5是否在数据库，注意数据库中存的只是文件地址而已，不是真实的视频文件
  63.         3-5、这里为了避免上传的视频名字是一样的但是内容不一样，所以文件名应该尽量取的唯一，所以给传来的file_name加上一个随机字符串，就直接调用之前定义的 get_session方法即可
  64.         3-6、这里要拼接文件的存放路径了，根据file_size循环写入文件
  65.         3-7、生成一个 movie_obj 电影对象，调用save方法保存，然后返回back_dic说明上传成功
  66. 4、删除视频
  67.     客户端
  68.         4-1、先查询出所有没有被删除的电影列表，即send_dic字典中"type"为'get_movie_list' 和'movie_type'为"all",返回的电影列表可以全部是收费，全部是免费，收费免费都有,这里需要注意的是获取所有视频列表考
  69.              虑的不周全，如果单从管理员角度要获得所有视频不考虑用户获取收费或者免费的视频，会出现一些代码冗余，所以在获取所有视频这个功能要判断传过来的的movie_type是all、free、charge
  70.         4-2、拿到所有视频列表movie_list，该列表的格式[电影名称，是否免费收费，电影id]发送字典send_dic中"type"为"delete_movie"和delete_movie_id'为movie_list[choice-1][2]
  71.     服务端
  72.         4-3、还记得tcpserver模块中的全局func_dic字典吗？加上'get_movie_list'和"delete_movie"映射，映射函数全都加上装饰器
  73.         4-4、删除电影不是真的删除，只是找到每一个电影对象，然后点is_delete属性改为1即可，所以get_movie_list方法会先获得所有对象列表，遍历列表得到每一个对象，对每一个对象的is_delete属性进行判断，注意还要判断
  74.             ecv_dic['movie_type']，这里是“all”类型，满足的全部添加到一个返回的列表中back_movie_list，然后返回给客户端
  75.         4-5、delete_movie方法的话 movie_list = models.Movie.select(id=recv_dic.get("delete_movie_id"))然后对列表去索引得到一个电影对象，然后修改movie_obj.is_delete，然后调用update()方法更新，然后返回back_cic
  76.   5、发布公告
  77.     客户端
  78.         5-1 公告包含title和content  发送的字典send_dic包含"type"为"release_notice"、"session"、"title"、"content"
  79.     服务端、
  80.         5-2、这里需要知道接受的字典recv_dic是包含user_id字段的，要写入表notice时用到
  81.         5-3、也是创建表notice对象，然后调用save方法保存
  82. 普通用户
  83. 1、注册
  84.     直接调用公共注册方法
  85. 2、登录
  86.     直接调用公共登录，在全局添加user_dic中保存session和is_vip
  87. 3、购买会员
  88.     客户端
  89.         3-1、判断全局user_dic['is_vip']可知道是否是会员
  90.         3-2、如果不是的话，让用户选择是否购买会员，购买的话最后要修改全局
  91.      服务端
  92.         3-3、根据recv_dic["user_id"]判断是哪一个用户要购买会员，得到的对象点is_vip属性修改为1，调用update(0方法保存
  93. 4、查看所有视频
  94.     客户端
  95.         4-1、发送字典send_dic里面的type为'get_movie_list'，'movie_type为'all'
  96.     服务器
  97.         4-2、直接调用之前写好的get_movie_list方法即可  这和管理员中删除视频就先获取所有视频
  98. 5、下载免费电影
  99.     客户端
  100.         5-1、先列出所有免费电影，和上个功能差不多，只是'movie_type'改为'free'
  101.         5-2、再发送字典send_dic中'type'为'download_movie' 'movie_id'为movie_list[choice-1][2]
  102.         5-3、接受得到的字典back_dic中有一个wait_time 打印可能是0或者30秒  拼接下载的路径，循环写入文件
  103.     服务端
  104.         5-4、id=recv_dic.get('movie_id')来得到电影列表movie_list，然后索引取值得到电影对象
  105.         5-5  id=recv_dic['user_id']来得到用户列表索引取得用户对象user_obj
  106.         5-6、下载电影的话先判断使用是否是vip，vip的话不需要等待30秒 不是的话需要等待30秒
  107.         5-7、更新下载记录到down_record表中
  108.         5-8、循环发送文件
  109.         5-9、发送字典back_dic
  110. 6、下载收费电影
  111.     客户端
  112.         6-1、针对普通用户和vip用户下载收费视频收费标准不一样（5元 10元）
  113.         6-2、发送字典send_dic 中还是'get_movie_list'但是电影类型为收费'movie_type':'charge'
  114.         6-3、剩下功能和下载免费电影差不多
  115.     服务器
  116.         同上
  117. 7、查看下载记录
  118.     客户端
  119.         7-1、发送字典send_dic 中的类型'check_download_record'
  120.         7-2、接受字典back_dic进行判断即可
  121.     服务端
  122.         7-3、还记得tcpserver模块中的全局func_dic字典吗？加上'check_download_record'的映射方法
  123.         7-4、要查看下载记录 先根据用户id得到一个记录列表，循环该列表得到的是每一个记录对象
  124.         7-5、根据每一个对象点movie_id 和电影id判断得到电影列表，索引取值得到各个对象
  125.         7-6、把每一个对象的名字添加到一个自定义的列表中，用于返回给客户端
  126. 8、查看公告
  127.     客户端
  128.         8-1、发送字典send_dic 中的类型'check_notice'
  129.         8-2、接受字典back_dic进行判断即可
  130.     服务端
  131.         8-3、还记得tcpserver模块中的全局func_dic字典吗？加上'check_notice'的映射方法
  132.         8-4、Notice类调用select方法得到公告列表
  133.         8-5、列表存在的话 遍历该列表得到每一个对象，返回字典中保存对象点title，点content进行返回

七、项目中遇到的问题及怎么解决的

  1. 校验登陆问题(服务端必须校验,客户端无所谓)
  2. 获取所有视频列表考虑的不周全，如果单从管理员角度要获得所有视频不考虑用户获取收费或者免费的视频，会出现一些代码冗余，所以在获取所有视频这个功能要判断传过来的的movie_type是all、free、charge
  3. 服务端怎样标识客户端问题：cookie保存到客户端、session保存到服务器user_data文件中
  4. 从客户端到数据库一顿操作打通以后遇到最多的问题有字段打错了

八、客户端代码框架

8.1 conf

8.1.1 setting

  1. import os
  2. BASE_DIR = os.path.dirname(os.path.dirname(__file__))
  3. UPDATE_MOVIE = os.path.join(BASE_DIR, 'update_movie')
  4. DOWNLOAD_MOVIE_DIR = os.path.join(BASE_DIR, 'download_movie')

8.2 core

8.2.1 src

  1. from core import admin, user
  3. func_dic = {"1": admin.admin_view, "2": user.user_view}
  5. def run():
  6.     while True:
  7.         print("""
  8.             1、管理员视图
  9.             2、普通用户视图
  10.             q、退出
  11.         """)
  12.         choice = input("please choice your number>>:").strip()
  13.         if choice == 'q': break
  14.         if choice not in func_dic:
  15.             print("choice err not in range")
  16.             continue
  17.         func_dic.get(choice)()

8.2.2 admin

  1. import os
  3. from Tcpclient import tcpclient
  4. from lib import common
  5. from conf import setting
  7. user_info = {
  8.     "session": None
  9. }
  11. def register(client):
  12.     while True:
  13.         name = input("please input your name>>:").strip()
  14.         password = input("please input your password>>:").strip()
  15.         re_password = input("please agan input your password>>:").strip()
  16.         if password != re_password:
  17.             print("两次密码不一致")
  18.             continue
  19.         send_dic = {"type": "register", "name": name, "password": common.get_md5(password), "user_type": "admin"}
  20.         back_dic = common.send_back(send_dic, client)
  21.         if back_dic["flag"]:
  22.             print(back_dic["msg"])
  23.             break
  24.         else:
  25.             print(back_dic["msg"])
  27. def login(client):
  28.     while True:
  29.         name = input("please input your name>>:").strip()
  30.         password = input("please input your password>>:").strip()
  31.         send_dic = {"type": "login", "name": name, "password": common.get_md5(password), "user_type": "admin"}
  32.         back_dic = common.send_back(send_dic, client)
  33.         if back_dic["flag"]:
  34.             print(back_dic["msg"])
  35.             user_info["session"] = back_dic["session"]
  36.             break
  37.         else:
  38.             print(back_dic["msg"])
  40. def update_movie(client):
  41.     """
  42.     思路：
  43.         1、是不是要先获取有哪些可以上传的视频
  44.         2、选择好要上传的视频后是不是还要判断服务器存不存在，存在了就不需要上传了
  45.         3、那就需要校验视频文件，可自定义校验规则
  46.         4、循环上传
  47.     :param client:
  48.     :return:
  49.     """
  50.     while True:
  51.         movie_list = common.get_movie()
  52.         if not movie_list:
  53.             print("暂无影片上传")
  54.             return
  55.         for i, m in enumerate(movie_list, start=1):
  56.             print("%s:%s" % (i, m))
  57.         choice = input("please input your choice>>: ").strip()
  58.         if choice == 'q': break
  59.         if choice.isdigit():
  60.             choice = int(choice)
  61.             if choice in range(1, len(movie_list) + 1):
  62.                 file_path = os.path.join(setting.UPDATE_MOVIE, movie_list[choice - 1])
  63.                 file_md5 = common.get_file_md5(file_path)
  64.                 send_dic = {"type": "check_movie", "session": user_info["session"], "file_md5": file_md5}
  65.                 back_dic = common.send_back(send_dic, client)
  66.                 if back_dic["flag"]:
  67.                     # 如果可以上传，那标识上传免费还是收费
  68.                     is_free = input("上传的影片是否免费（y/n）>>:").strip()
  69.                     is_free = 1 if is_free == 'y' else 0
  70.                     file_name = movie_list[choice - 1]
  71.                     send_dic = {"type": "update_movie", "session": user_info["session"], "is_free": is_free,
  72.                                 "file_name": file_name, "file_md5": file_md5, "file_size": os.path.getsize(file_path)}
  73.                     back_dic = common.send_back(send_dic, client, file_path)
  74.                     if back_dic["flag"]:
  75.                         print(back_dic["msg"])
  76.                         return
  77.                     else:
  78.                         print(back_dic["msg"])
  79.                 else:
  80.                     print(back_dic["msg"])
  81.             else:
  82.                 print("choice not in range")
  83.         else:
  84.             print("input choice must be a number ！")
  86. def delete_movie(client):
  87.     """
  88.     思路：
  89.         1、先从服务器获取所有视频
  90.         2、要删除的发给服务器
  91.     :param client:
  92.     :return:
  93.     """
  94.     send_dic = {"type": "get_movie_list", "session": user_info["session"], "movie_type": "all"}
  95.     back_dic = common.send_back(send_dic, client)
  96.     if back_dic["flag"]:
  97.         """
  98.         服务器的get_movie_list会返回一个电影列表,列表里面为[电影名，收费或免费，电影id]
  99.         """
  100.         movie_list = back_dic["movie_list"]
  101.         for i, m in enumerate(movie_list, start=1):
  102.             print("%s:%s-%s" % (i, m[0], m[1]))
  103.         choice = input("input your delete movie>>:").strip()
  104.         if choice.isdigit():
  105.             choice = int(choice)
  106.             if choice in range(1, len(movie_list) + 1):
  107.                 send_dic = {"type": "delete_movie", "session": user_info["session"],
  108.                             "movie_id": movie_list[choice - 1][2]}
  109.                 back_dic = common.send_back(send_dic, client)
  110.                 if back_dic['flag']:
  111.                     print(back_dic['msg'])
  112.                     return
  113.                 else:
  114.                     print(back_dic['msg'])
  115.             else:
  116.                 print('choice noe in range')
  117.     else:
  118.         print(back_dic['msg'])
  120. def release_notice(client):
  121.     while True:
  122.         title = input("please input title>>:").strip()
  123.         content = input("please input content>>:").strip()
  124.         send_dic = {"type": "release_notice", "session": user_info["session"], "title": title, "content": content}
  125.         back_dic = common.send_back(send_dic, client)
  126.         if back_dic["flag"]:
  127.             print(back_dic["msg"])
  128.             break
  129.         else:
  130.             print(back_dic['msg'])
  131.             break
  133. func_dic = {
  134.     "1": register,
  135.     "2": login,
  136.     "3": update_movie,
  137.     "4": delete_movie,
  138.     "5": release_notice
  139. }
  141. def admin_view():
  142.     client = tcpclient.get_client()
  143.     while True:
  144.         print("""
  145.                 1、注册
  146.                 2、登录
  147.                 3、上传电影
  148.                 4、删除电影
  149.                 5、发布公告
  150.             """)
  151.         choice = input("please choice your number>>:").strip()
  152.         if choice == 'q': break
  153.         if choice not in func_dic:
  154.             print("choice err not in range")
  155.             continue
  156.         func_dic.get(choice)(client)

8.2.3 user

  1. import os
  2. import time
  4. from Tcpclient import tcpclient
  5. from conf import setting
  6. from lib import common
  8. user_info = {
  9.     "session": None,
  10.     "is_vip": None
  11. }
  13. def register(client):
  14.     while True:
  15.         name = input("please input your name>>:").strip()
  16.         password = input("please input your password>>:").strip()
  17.         re_password = input("please agan input your password>>:").strip()
  18.         if password != re_password:
  19.             print("两次密码不一致")
  20.             continue
  21.         send_dic = {"type": "register", "name": name, "password": common.get_md5(password), "user_type": "user"}
  22.         back_dic = common.send_back(send_dic, client)
  23.         if back_dic["flag"]:
  24.             print(back_dic["msg"])
  25.             break
  26.         else:
  27.             print(back_dic["msg"])
  29. def login(client):
  30.     while True:
  31.         name = input("please input your name>>:").strip()
  32.         password = input("please input your password>>:").strip()
  33.         send_dic = {"type": "login", "name": name, "password": common.get_md5(password), "user_type": "user"}
  34.         back_dic = common.send_back(send_dic, client)
  35.         if back_dic["flag"]:
  36.             print(back_dic["msg"])
  37.             user_info["session"] = back_dic["session"]
  38.             user_info["is_vip"] = back_dic["is_vip"]
  39.             break
  40.         else:
  41.             print(back_dic["msg"])
  43. def buy_vip(client):
  44.     while True:
  45.         buy_vip = input("是否购买会员（y/n）>>:").strip()
  46.         if buy_vip == 'q': break
  47.         if buy_vip not in ['y', 'n']:
  48.             print("输入有误")
  49.             continue
  50.         if buy_vip == 'y':
  51.             send_dic = {"type": "buy_vip", "session": user_info["session"]}
  52.             back_dic = common.send_back(send_dic, client)
  53.             if back_dic["flag"]:
  54.                 print(back_dic["msg"])
  55.                 break
  56.             else:
  57.                 print(back_dic["msg"])
  58.         else:
  59.             print("欢迎下次购买")
  60.             break
  62. def check_movie(client):
  63.     send_dic = {"type": "get_movie_list", "session": user_info["session"], "movie_type": "all"}
  64.     back_dic = common.send_back(send_dic, client)
  65.     if back_dic["flag"]:
  66.         movie_list = back_dic["movie_list"]
  67.         for i, m in enumerate(movie_list, start=1):
  68.             print("%s:%s-%s" % (i, m[0], m[1]))
  69.     else:
  70.         print(back_dic["msg"])
  72. def download_free_movie(client):
  73.     send_dic = {"type": "get_movie_list", "session": user_info["session"], "movie_type": "free"}
  74.     back_dic = common.send_back(send_dic, client)
  75.     if back_dic["flag"]:
  76.         movie_list = back_dic["movie_list"]
  77.         for i, m in enumerate(movie_list, start=1):
  78.             print("%s:%s-%s" % (i, m[0], m[1]))
  79.         while True:
  80.             choice = input("请选择要下载的电影编号>>:").strip()
  81.             if choice == 'q': break
  82.             if choice.isdigit():
  83.                 choice = int(choice)
  84.                 if choice in range(1, len(movie_list) + 1):
  85.                     send_dic = {"type": "download_movie", "session": user_info["session"],
  86.                                 "movie_id": movie_list[choice - 1][2], "movie_type": "free"}
  87.                     back_dic = common.send_back(send_dic, client)
  88.                     if back_dic["flag"]:
  89.                         print("请等待》》》")
  90.                         time.sleep(back_dic["wait_time"])
  91.                         file_path = os.path.join(setting.DOWNLOAD_MOVIE_DIR, back_dic["file_name"])
  92.                         recv_size = 0
  93.                         with open(file_path, 'wb') as f:
  94.                             while recv_size < back_dic["file_size"]:
  95.                                 data = client.recv(1024)
  96.                                 f.write(data)
  97.                                 recv_size += len(data)
  98.                         print("下载成功")
  99.                         return
  100.                     else:
  101.                         print(back_dic["msg"])
  102.                 else:
  103.                     print("choice not in range")
  104.             else:
  105.                 print("choice must be number")
  106.     else:
  107.         print(back_dic["msg"])
  109. def download_charge_movie(client):
  110.     if user_info["is_vip"]:
  111.         charge = input("请支付10元(y/n)>>:").strip()
  112.     else:
  113.         charge = input('请支付20元(y/n)>>:').strip()
  114.     if charge != "y":
  115.         print("慢走 不送")
  116.         return
  117.     send_dic = {"type": "get_movie_list", "session": user_info["session"], "movie_type": "charge"}
  118.     back_dic = common.send_back(send_dic, client)
  119.     if back_dic["flag"]:
  120.         movie_list = back_dic["movie_list"]
  121.         for i, m in enumerate(movie_list, start=1):
  122.             print("%s:%s-%s" % (i, m[0], m[1]))
  123.         while True:
  124.             choice = input("请选择要下载的电影编号>>:").strip()
  125.             if choice == 'q': break
  126.             if choice.isdigit():
  127.                 choice = int(choice)
  128.                 if choice in range(1, len(movie_list) + 1):
  129.                     send_dic = {"type": "download_movie", "session": user_info["session"],
  130.                                 "movie_id": movie_list[choice - 1][2], "movie_type": "free"}
  131.                     back_dic = common.send_back(send_dic, client)
  132.                     if back_dic["flag"]:
  133.                         print("请等待》》》")
  134.                         time.sleep(back_dic["wait_time"])
  135.                         file_path = os.path.join(setting.DOWNLOAD_MOVIE_DIR, back_dic["file_name"])
  136.                         recv_size = 0
  137.                         with open(file_path, 'wb') as f:
  138.                             while recv_size < back_dic["file_size"]:
  139.                                 data = client.recv(1024)
  140.                                 f.write(data)
  141.                                 recv_size += len(data)
  142.                         print("下载成功")
  143.                         return
  144.                     else:
  145.                         print(back_dic["msg"])
  146.                 else:
  147.                     print("choice not in range")
  148.             else:
  149.                 print("choice must be number")
  150.     else:
  151.         print(back_dic["msg"])
  153. def download_movie_record(client):
  154.     """
  155.     思路：当前登录的用户需要查看自己的观影记录，需要得到电影名
  156.     :param client:
  157.     :return:
  158.     """
  159.     send_dic = {"type": "download_movie_record", "session": user_info["session"]}
  160.     back_dic = common.send_back(send_dic, client)
  161.     if back_dic["flag"]:
  162.         back_record_list = back_dic['back_record_list']
  163.         for m in back_record_list:
  164.             print(m)
  165.     else:
  166.         print(back_dic['msg'])
  168. def check_notice(client):
  169.     """
  170.     查看公告思路：
  171.     :param client:
  172.     :return:
  173.     """
  174.     send_dic = {"type": "check_notice", "session": user_info["session"]}
  175.     back_dic = common.send_back(send_dic, client)
  176.     if back_dic["flag"]:
  177.         back_record_list = back_dic['back_notice_list']
  178.         for m in back_record_list:
  179.             print(m)
  180.     else:
  181.         print(back_dic['msg'])
  183. func_dic = {
  184.     "1": register,
  185.     "2": login,
  186.     "3": buy_vip,
  187.     "4": check_movie,
  188.     "5": download_free_movie,
  189.     "6": download_charge_movie,
  190.     "7": download_movie_record,
  191.     "8": check_notice
  192. }
  194. def user_view():
  195.     client = tcpclient.get_client()
  196.     while True:
  197.         print("""
  198.                 1、注册
  199.                 2、登录
  200.                 3、购买会员
  201.                 4、查看所有电影
  202.                 5、下载免费电影
  203.                 6、下载收费电影
  204.                 7、查看观影记录
  205.                 8、查看公告
  206.             """)
  207.         choice = input("please choice your number>>:").strip()
  208.         if choice == 'q': break
  209.         if choice not in func_dic:
  210.             print("choice err not in range")
  211.             continue
  212.         func_dic.get(choice)(client)

8.3 lib

8.3.1 common

  1. import hashlib
  2. import json
  3. import os
  4. import struct
  5. from conf import setting
  7. def send_back(send_dic, client, file=None):
  8.     json_bytes = json.dumps(send_dic).encode("utf-8")
  9.     client.send(struct.pack('i', len(json_bytes)))
  10.     client.send(json_bytes)
  12.     if file:
  13.         with open(file, 'rb') as f:
  14.             for line in f:
  15.                 client.send(line)
  17.     recv_len = struct.unpack('i', client.recv(4))[0]
  18.     recv_dic = json.loads(client.recv(recv_len).decode("utf-8"))
  19.     return recv_dic
  21. def get_md5(password):
  22.     md = hashlib.md5()
  23.     md.update(password.encode("utf-8"))
  24.     return md.hexdigest()
  26. def get_movie():
  27.     movie_list = os.listdir(setting.UPDATE_MOVIE)
  28.     return movie_list
  30. def get_file_md5(path):
  31.     md = hashlib.md5()
  32.     file_size = os.path.getsize(path)
  33.     file_list = [0, file_size // 3, (file_size // 3) * 2, file_size - 10]
  34.     with open(path, "rb") as f:
  35.         for line in file_list:
  36.             f.seek(line)
  37.             md.update(f.read(10))
  38.     return md.hexdigest()

8.4 Tcpclient

8.4.1 tcpclient

  1. import socket
  3. def get_client():
  4.     client = socket.socket()
  5.     client.connect(("127.0.0.1", 1688))
  6.     return client

8.5 start

8.5.1 start

  1. import os, sys
  3. from core import src
  5. sys.path.append(os.path.dirname(__file__))
  6. if __name__ == '__main__':
  7.     src.run()

九、服务端框架

9.1 conf

9.1.1 setting

  1. import os
  2. BASE_DIR = os.path.dirname(os.path.dirname(__file__))
  3. MOVIE_DIR = os.path.join(BASE_DIR, 'movie_dir')

9.2 db

9.2.1 models

  1. from orm_pool.orm import Models, StringField, IntegerField
  3. class User(Models):
  4.     table_name = 'user'
  5.     id = IntegerField("id", primary_key=True)
  6.     name = StringField("name")
  7.     password = StringField("password")
  8.     is_locked = IntegerField("is_locked", default=0)
  9.     is_vip = IntegerField("is_vip", default=0)
  10.     user_type = StringField("user_type")
  11.     register_time = StringField("register_time")
  13. class Movie(Models):
  14.     table_name = "movie"
  15.     id = IntegerField("id", primary_key=True)
  16.     name = StringField("name", column_type="varchar(64)")
  17.     path = StringField("path")
  18.     is_free = IntegerField("is_free")
  19.     is_delete = IntegerField("is_delete", default=0)
  20.     create_time = StringField("create_time")
  21.     user_id = IntegerField("user_id")
  22.     file_md5 = StringField("file_md5")
  24. class Notice(Models):
  25.     table_name = "notice"
  26.     id = IntegerField("id", primary_key=True)
  27.     title = StringField("title")
  28.     content = StringField("content")
  29.     user_id = IntegerField("user_id")
  30.     create_time = StringField("create_time")
  32. class DownloadRecord(Models):
  33.     table_name = "download_record"
  34.     id = IntegerField("id", primary_key=True)
  35.     user_id = IntegerField("user_id")
  36.     movie_id = IntegerField("movie_id")
  37.     create_time = StringField("create_time")

9.3 interface

9.3.1 admin_interface

  1. import os
  3. from db import models
  4. from lib import common
  5. from conf import setting
  7. @common.login_auth
  8. def check_movie(recv_dic, conn):
  9.     movie_data = models.Movie.select(file_md5=recv_dic["file_md5"])
  10.     if movie_data:
  11.         back_dic = {"flag": False, "msg": "该电影已存在"}
  12.     else:
  13.         back_dic = {"flag": True, "msg": "可以上传"}
  14.     common.send_back(back_dic, conn)
  16. @common.login_auth
  17. def update_movie(recv_dic, conn):
  18.     file_name = common.get_session(recv_dic["file_name"]) + recv_dic["file_name"]
  19.     file_path = os.path.join(setting.MOVIE_DIR, file_name)
  20.     print(recv_dic)
  21.     recv_size = 0
  22.     with open(file_path, 'wb') as f:
  23.         while recv_size < recv_dic["file_size"]:
  24.             data = conn.recv(1024)
  25.             f.write(data)
  26.             recv_size += len(data)
  28.     movie_obj = models.Movie(name=file_name, path=file_path, is_free=recv_dic.get("is_free"), is_delete=0,
  29.                              create_time=common.get_time(), user_id=recv_dic.get("user_id"),
  30.                              file_md5=recv_dic.get("file_md5"))
  31.     movie_obj.save()
  32.     back_dic = {"flag": True, "msg": "上传成功"}
  33.     common.send_back(back_dic, conn)
  35. @common.login_auth
  36. def delete_movie(recv_dic, conn):
  37.     movie_obj = models.Movie.select(id=recv_dic.get('movie_id'))[0]
  38.     movie_obj.is_delete = 1
  39.     movie_obj.update()
  40.     back_dic = {"flag": True, "msg": "删除成功"}
  41.     common.send_back(back_dic, conn)
  43. @common.login_auth
  44. def release_notice(recv_dic, conn):
  45.     title = recv_dic["title"]
  46.     content = recv_dic["content"]
  47.     user_id = recv_dic["user_id"]
  48.     create_time = common.get_time()
  49.     notice_obj = models.Notice(title=title, content=content, user_id=user_id, create_time=create_time)
  50.     notice_obj.save()
  51.     back_dic = {"flag": True, "msg": "发布成功"}
  52.     common.send_back(back_dic, conn)

9.3.2 common_interface

  1. from db import models
  2. from lib import common
  3. from Tcpserver import user_data
  5. def register(recv_dic, conn):
  6.     user_list = models.User.select(name=recv_dic["name"])
  7.     if user_list:
  8.         back_dic = {"flag": False, "msg": "用户已存在"}
  9.         common.send_back(back_dic, conn)
  10.         return
  11.     user_obj = models.User(name=recv_dic["name"], password=recv_dic["password"], is_locked=0, is_vip=0,
  12.                            user_type=recv_dic["user_type"], register_time=common.get_time())
  13.     user_obj.save()
  14.     back_dic = {"flag": True, "msg": "注册成功"}
  15.     common.send_back(back_dic, conn)
  17. def login(recv_dic, conn):
  18.     user_list = models.User.select(name=recv_dic["name"])
  19.     if user_list:
  20.         user_obj = user_list[0]
  21.         if user_obj.user_type == recv_dic["user_type"]:
  22.             if user_obj.password == recv_dic["password"]:
  23.                 back_dic = {"flag": True, "msg": "登陆成功", "is_vip": user_obj.is_vip}
  24.                 # 获取每个用户的唯一随机字符串，用于标识每个用户
  25.                 session = common.get_session(user_obj.name)
  26.                 back_dic["session"] = session
  27.                 # 服务端要记录正在登录的客户端，将数据user_data文件live_user字典中，放在为了更好的标识
  28.                 # 每一个客户，字典的key为recv_dic["addr"]  -----他是一个元组包含ip和端口，值的话是一个列表
  29.                 # 保存每一个session和用户id
  30.                 # 因为时公共数据，且并发会造成数据错乱，咱们给他来个锁
  31.                 user_data.mutex.acquire()
  32.                 user_data.live_user[recv_dic["addr"]] = [session, user_obj.id]
  33.                 user_data.mutex.release()
  34.             else:
  35.                 back_dic = {"flag": False, "msg": "密码不正确"}
  36.         else:
  37.             back_dic = {"flag": False, "msg": "用户类型不对"}
  38.     else:
  39.         back_dic = {"flag": False, "msg": "用户不存在"}
  40.     common.send_back(back_dic, conn)
  42. @common.login_auth
  43. def get_movie_list(recv_dic, conn):
  44.     """
  45.     要给调用者返回相应的电影列表：all、free、charge
  46.     :param recv_dic:
  47.     :param conn:
  48.     :return:
  49.     """
  50.     movie_list = models.Movie.select()
  51.     if movie_list:
  52.         back_movie_list = []
  53.         for movie_obj in movie_list:
  54.             if not movie_obj.is_delete:
  55.                 if recv_dic["movie_type"] == "all":
  56.                     back_movie_list.append([movie_obj.name, '免费' if movie_obj.is_free else '收费', movie_obj.id])
  57.                 elif recv_dic["movie_type"] == "free":
  58.                     if movie_obj.is_free:
  59.                         back_movie_list.append([movie_obj.name, '免费', movie_obj.id])
  60.                 else:
  61.                     if not movie_obj.is_free:
  62.                         back_movie_list.append([movie_obj.name, '收费', movie_obj.id])
  63.         if back_movie_list:
  64.             back_dic = {"flag": True, "movie_list": back_movie_list}
  65.         else:
  66.             back_dic = {"flag": False, "msg": "暂无影片"}
  67.     else:
  68.         back_dic = {"flag": False, "msg": "暂无影片"}
  69.     common.send_back(back_dic, conn)

9.3.3 user_interface

  1. import os
  3. from conf import setting
  4. from db import models
  5. from lib import common
  7. @common.login_auth
  8. def buy_vip(recv_dic, conn):
  9.     user_obj = models.User.select(id=recv_dic['user_id'])[0]
  10.     if user_obj.is_vip:
  11.         back_dic = {"flag": False, "msg": "您已经是会员啦"}
  12.     else:
  13.         user_obj.is_vip = 1
  14.         user_obj.save()
  15.         back_dic = {"flag": True, "msg": "购买成功"}
  16.     common.send_back(back_dic, conn)
  18. @common.login_auth
  19. def download_movie(recv_dic, conn):
  20.     """
  21.     下载电影功能：普通用户下载需要等待30秒 VIP用下载不需要等待
  22.     :param recv_dic:
  23.     :param conn:
  24.     :return:
  25.     """
  26.     movie_list = models.Movie.select(id=recv_dic["movie_id"])
  27.     if movie_list:
  28.         movie_obj = movie_list[0]
  29.         file_path = movie_obj.path
  30.         user_obj = models.User.select(id=recv_dic["user_id"])[0]
  31.         wait_time = 0
  32.         if recv_dic["movie_type"] == "free":
  33.             if user_obj.is_vip:
  34.                 wait_time = 0
  35.             else:
  36.                 wait_time = 30
  37.         back_dic = {"flag": True, "file_name": movie_obj.name, "file_size": os.path.getsize(file_path),
  38.                     "wait_time": wait_time}
  40.         download_record = models.DownloadRecord(user_id=user_obj.id, movie_id=movie_obj.id,
  41.                                                 create_time=common.get_time())
  42.         download_record.save()
  43.         common.send_back(back_dic, conn)
  44.         with open(file_path, 'rb') as f:
  45.             for line in f:
  46.                 conn.send(line)
  48.     else:
  49.         back_dic = {"flag": False, "msg": "暂无影片"}
  50.         common.send_back(back_dic, conn)
  52. @common.login_auth
  53. def download_movie_record(recv_dic, conn):
  54.     record_list = models.DownloadRecord.select(user_id=recv_dic["user_id"])
  55.     back_record_list = []
  56.     if record_list:
  57.         for m in record_list:
  58.             movie_obj = models.Movie.select(id=m.movie_id)[0]
  59.             back_record_list.append(movie_obj.name)
  60.         back_dic = {"flag": True, "back_record_list": back_record_list}
  61.     else:
  62.         back_dic = {"flag": False, "msg": "暂无下载记录"}
  63.     common.send_back(back_dic, conn)
  65. @common.login_auth
  66. def check_notice(recv_dic, conn):
  67.     notice_list = models.Notice.select()
  68.     back_notice_list = []
  69.     if notice_list:
  70.         for notice_obj in notice_list:
  71.             back_notice_list.append([notice_obj.title, notice_obj.content])
  72.         back_dic = {"flag": True, "back_notice_list": back_notice_list}
  73.     else:
  74.         back_dic = {"flag": False, "msg": "暂无下载记录"}
  75.     common.send_back(back_dic, conn)

9.4 lib

9.4.1 common

  1. import hashlib
  2. import json
  3. import struct
  4. import time
  5. from functools import wraps
  7. from Tcpserver import user_data
  9. def send_back(back_dic, conn):
  10.     json_bytes = json.dumps(back_dic).encode("utf-8")
  11.     conn.send(struct.pack('i', len(json_bytes)))
  12.     conn.send(json_bytes)
  14. def get_time():
  15.     return time.strftime("%Y-%m-%d %X")
  17. def get_session(name):
  18.     # 为了保证每个用户的随机字符串是唯一的，不仅要对每一个用户名加密还要加上cpu执行时机----加盐
  19.     md = hashlib.md5()
  20.     md.update(str(time.clock()).encode("utf-8"))
  21.     md.update(name.encode("utf-8"))
  22.     return md.hexdigest()
  24. def login_auth(func):
  25.     @wraps(func)
  26.     def inner(*args, **kwargs):
  27.         # args=(recv_dic,conn)
  28.         # 登录了以后服务端user_data文件中live_user就有存在用户登陆的数据，如果没有登陆就没有数据，可以为此
  29.         # 来作为判断是否登录的依据
  30.         for values in user_data.live_user.values():
  31.             # values = [session,user_id]
  32.             if args[0]["session"] == values[0]:
  33.                 args[0]["user_id"] = values[1]
  34.                 break
  35.         if args[0].get("user_id"):
  36.             func(*args, **kwargs)
  37.         else:
  38.             back_dic = {"flag": False, "msg": "请先登录"}
  39.             send_back(back_dic, args[1])
  41.     return inner

9.5 orm_pool

9.5.1 db_pool

  1. from DBUtils.PooledDB import PooledDB
  2. import pymysql
  4. POOL = PooledDB(
  5.     creator=pymysql,  # 使用链接数据库的模块
  6.     maxconnections=6,  # 连接池允许的最大连接数，0和None表示不限制连接数
  7.     mincached=2,  # 初始化时，链接池中至少创建的空闲的链接，0表示不创建
  8.     maxcached=5,  # 链接池中最多闲置的链接，0和None不限制
  9.     maxshared=3,
  10.     # 链接池中最多共享的链接数量，0和None表示全部共享。PS: 无用，因为pymysql和MySQLdb等模块的 threadsafety都为1，所有值无论设置为多少，_maxcached永远为0，所以永远是所有链接都共享。
  11.     blocking=True,  # 连接池中如果没有可用连接后，是否阻塞等待。True，等待；False，不等待然后报错
  12.     maxusage=None,  # 一个链接最多被重复使用的次数，None表示无限制
  13.     setsession=
  14.     [],  # 开始会话前执行的命令列表。如：["set datestyle to ...", "set time zone ..."]
  15.     ping=0,
  16.     # ping MySQL服务端，检查是否服务可用。# 如：0 = None = never, 1 = default = whenever it is requested, 2 = when a cursor is created, 4 = when a query is executed, 7 = always
  17.     host='127.0.0.1',
  18.     port=3306,
  19.     user='root',
  20.     password='123',
  21.     database='youku',
  22.     charset='utf8',
  23.     autocommit='True')

9.5.2 mysql_singleton

  1. import pymysql
  2. from orm_pool import db_pool
  4. class Mysql(object):
  5.     def __init__(self):
  6.         self.conn = db_pool.POOL.connection()
  7.         self.cursor = self.conn.cursor(pymysql.cursors.DictCursor)
  9.     def close(self):
  10.         self.cursor.close()
  11.         self.conn.close()
  13.     def select(self, sql, args=None):
  14.         self.cursor.execute(sql, args)
  15.         res = self.cursor.fetchall()  # 列表套字典
  16.         return res
  18.     def execute(self, sql, args):
  19.         try:
  20.             self.cursor.execute(sql, args)
  21.         except BaseException as e:
  22.             print(e)

9.5.3 orm

  1. from orm_pool.mysql_singleton import Mysql
  3. # 定义字段类
  4. class Field(object):
  5.     def __init__(self, name, column_type, primary_key, default):
  6.         self.name = name
  7.         self.column_type = column_type
  8.         self.primary_key = primary_key
  9.         self.default = default
  11. # 定义具体的字段
  12. class StringField(Field):
  13.     def __init__(self,
  14.                  name,
  15.                  column_type='varchar(255)',
  16.                  primary_key=False,
  17.                  default=None):
  18.         super().__init__(name, column_type, primary_key, default)
  20. class IntegerField(Field):
  21.     def __init__(self,
  22.                  name,
  23.                  column_type='int',
  24.                  primary_key=False,
  25.                  default=None):
  26.         super().__init__(name, column_type, primary_key, default)
  28. class ModelMetaClass(type):
  29.     def __new__(cls, class_name, class_bases, class_attrs):
  30.         # 我仅仅只想拦截模型表的类的创建过程
  31.         if class_name == 'Models':
  32.             return type.__new__(cls, class_name, class_bases, class_attrs)
  33.         # 给类放表名,主键字段,所有字段
  34.         table_name = class_attrs.get('table_name', class_name)
  35.         # 定义一个存储主键的变量
  36.         primary_key = None
  37.         # 定义一个字典用来存储用户自定义的表示表的所有字段信息
  38.         mappings = {}
  39.         # for循环当前类的名称空间
  40.         for k, v in class_attrs.items():
  41.             if isinstance(v, Field):
  42.                 mappings[k] = v
  43.                 if v.primary_key:
  44.                     if primary_key:
  45.                         raise TypeError("主键只能有一个")
  46.                     primary_key = v.name
  47.         # 将重复的键值对删除
  48.         for k in mappings.keys():
  49.             class_attrs.pop(k)
  50.         if not primary_key:
  51.             raise TypeError('必须要有一个主键')
  52.         # 将处理好的数据放入class_attrs中
  53.         class_attrs['table_name'] = table_name
  54.         class_attrs['primary_key'] = primary_key
  55.         class_attrs['mappings'] = mappings
  56.         return type.__new__(cls, class_name, class_bases, class_attrs)
  58. class Models(dict, metaclass=ModelMetaClass):
  59.     def __init__(self, **kwargs):
  60.         super().__init__(**kwargs)
  62.     def __getattr__(self, item):
  63.         return self.get(item, '没有该键值对')
  65.     def __setattr__(self, key, value):
  66.         self[key] = value
  68.     # 查询方法
  69.     @classmethod
  70.     def select(cls, **kwargs):
  71.         ms = Mysql()
  72.         # select * from userinfo
  73.         if not kwargs:
  74.             sql = 'select * from %s' % cls.table_name
  75.             res = ms.select(sql)
  76.         else:
  77.             # select * from userinfo where id = 1
  78.             k = list(kwargs.keys())[0]
  79.             v = kwargs.get(k)
  80.             sql = 'select * from %s where %s=?' % (cls.table_name, k)
  81.             # select * from userinfo where id = ?
  82.             sql = sql.replace('?',
  83.                               '%s')  # select * from userinfo where id = %s
  84.             res = ms.select(sql, v)
  85.         if res:
  86.             return [cls(**r) for r in res]  # 将数据库的一条数据映射成类的对象
  88.     # 新增方法
  89.     def save(self):
  90.         ms = Mysql()
  91.         # insert into userinfo(name,password) values('jason','123')
  92.         # insert into %s(%s) values(?)
  93.         fields = []  # [name,password]
  94.         values = []
  95.         args = []
  96.         for k, v in self.mappings.items():
  97.             if not v.primary_key:  # 将id字段去除   因为新增一条数据 id是自动递增的不需要你传
  98.                 fields.append(v.name)
  99.                 args.append('?')
  100.                 values.append(getattr(self, v.name))
  101.         # insert into userinfo(name,password) values(?,?)
  102.         sql = "insert into %s(%s) values(%s)" % (
  103.             self.table_name, ','.join(fields), ','.join(args))
  104.         # insert into userinfo(name,password) values(?,?)
  105.         sql = sql.replace('?', '%s')
  106.         ms.execute(sql, values)
  108.     # 修改方法:基于已经存在了的数据进行一个修改操作
  109.     def update(self):
  110.         ms = Mysql()
  111.         # update userinfo set name='jason',password='123' where id = 1
  112.         fields = []  # [name,password]
  113.         values = []
  114.         pr = None
  115.         for k, v in self.mappings.items():
  116.             if v.primary_key:
  117.                 pr = getattr(self, v.name, v.default)
  118.             else:
  119.                 fields.append(v.name + '=?')
  120.                 values.append(getattr(self, v.name, v.default))
  121.         sql = 'update %s set %s where %s = %s' % (
  122.             self.table_name, ','.join(fields), self.primary_key, pr)
  123.         # update userinfo set name='?',password='?' where id = 1
  124.         sql = sql.replace('?', '%s')
  125.         ms.execute(sql, values)
  127. # if __name__ == '__main__':
  128. # class Teacher(Models):
  129. #     table_name = 'teacher'
  130. #     tid = IntegerField(name='tid',primary_key=True)
  131. #     tname = StringField(name='tname')
  132. # obj = Teacher(tname='jason老师')
  133. # obj.save()
  134. # res = Teacher.select()
  135. # for r in res:
  136. #     print(r.tname)
  137. # print(res)
  138. # res = Teacher.select(tid=1)
  139. # teacher_obj = res[0]
  140. # teacher_obj.tname = 'jason老师'
  141. # teacher_obj.update()
  142. # res1 = Teacher.select()
  143. # print(res1)
  144. # class User(Models):
  145. #     table_name = 'User'
  146. #     id = IntegerField(name='id', primary_key=True)
  147. #     name = StringField(name='name')
  148. #     password = StringField(name='password')
  149. # print(User.primary_key)
  150. # print(User.mappings)
  151. # obj = User(name='jason')
  152. # print(obj.table_name)
  153. # print(obj.primary_key)
  154. # print(obj.mappings)

9.6 Tcpserver

9.6.1 tcpserver

  1. import json
  2. import socket
  3. import struct
  4. import traceback
  5. from concurrent.futures import ThreadPoolExecutor
  6. from threading import Lock
  7. from Tcpserver import user_data
  9. from interface import common_interface, admin_interface, user_interface
  10. from lib import common
  12. pool = ThreadPoolExecutor(20)
  13. #全局产生锁，为了避免循环导入问题，将产生的锁放到user_data中
  14. mutex = Lock()
  15. user_data.mutex = mutex
  17. func_dic = {
  18.     "register": common_interface.register,
  19.     "login": common_interface.login,
  20.     "check_movie": admin_interface.check_movie,
  21.     "update_movie": admin_interface.update_movie,
  22.     "get_movie_list": common_interface.get_movie_list,
  23.     "delete_movie": admin_interface.delete_movie,
  24.     "release_notice": admin_interface.release_notice,
  25.     "buy_vip": user_interface.buy_vip,
  26.     "download_movie": user_interface.download_movie,
  27.     "download_movie_record": user_interface.download_movie_record,
  28.     "check_notice": user_interface.check_notice
  29. }
  31. def get_server():
  32.     server = socket.socket()
  33.     server.bind(("127.0.0.1", 1688))
  34.     server.listen(5)
  35.     while True:
  36.         conn, addr = server.accept()
  37.         pool.submit(working, conn, addr)
  39. def working(conn, addr):
  40.     while True:
  41.         try:
  42.             recv_header = conn.recv(4)
  43.             recv_bytes = conn.recv(struct.unpack('i', recv_header)[0])
  44.             recv_dic = json.loads(recv_bytes.decode("utf-8"))
  45.             recv_dic["addr"] = str(addr)
  46.             dispatch(recv_dic, conn)
  47.         except Exception as e:
  48.             traceback.print_exc()
  49.             conn.close()
  50.             # 当用户断开以后，服务器就无需保存表示他的数据
  51.             user_data.mutex.acquire()
  52.             user_data.live_user.pop(str(addr))
  53.             user_data.mutex.release()
  54.             break
  56. def dispatch(recv_dic, conn):
  57.     if recv_dic.get("type") in func_dic:
  58.         func_dic.get(recv_dic["type"])(recv_dic, conn)
  59.     else:
  60.         back_dic = {"flag": False, "msg": "类型不合法"}
  61.         common.send_back(back_dic, conn)

9.6.2 user_data

live_user={}

mutex=None

9.7 start

9.7.1 start

  1. import os, sys
  2. from Tcpserver import tcpserver
  3. sys.path.append(os.path.dirname(__file__))
  5. if __name__ == '__main__':
  6.     tcpserver.get_server()

MySQL数据库实战之优酷的更多相关文章

  1. mysql数据库实战之优酷项目

    管理员: 1.注册功能 客户端 1-1.选择每个功能之前都需要都需要需要连接上服务器,即需要一个socket对象,每个函数传一个client 1-2.密码在传递过程中不能是明文吧,需要加密,可选择ha ...

  2. mysql数据库性能调优总结积累

    mysql数据库的调优大概可以分为四大块 0 架构调优 ---根据业务 读写分库分表   ---主从 读写分离 1 配置的调优 ---开启缓存查询  设置缓存大小 ---最大连接数设置 ---数据库引 ...

  3. Python3连接MySQL数据库实战

    Python3连接MySQL数据库实战 第三方库 :pymysql 数据库连接 def connect(): try: #建立数据库连接,从左至右参数依次为 # ip地址 我用的是云端数据库 如果为本 ...

  4. MySQL 数据库性能调优

    MySQL 数据库性能调优 MySQL性能 最大数据量 最大并发数 优化的范围有哪些 存储.主机和操作系统方面: 应用程序方面: 数据库优化方面: 优化维度 数据库优化维度有四个: 优化选择: 数据库 ...

  5. mysql数据库索引调优

    一.mysql索引 1.磁盘文件结构 innodb引擎:frm格式文件存储表结构,ibd格式文件存储索引和数据. MyISAM引擎:frm格式文件存储表结构,MYI格式文件存储索引,MYD格式文件存储 ...

  6. MySQL 数据库规范--调优篇(终结篇)

    前言 这篇是MySQL 数据库规范的最后一篇--调优篇,旨在提供我们发现系统性能变弱.MySQL系统参数调优,SQL脚本出现问题的精准定位与调优方法. 目录 1.MySQL 调优金字塔理论 2.MyS ...

  7. mysql 数据库缓存调优之解决The total number of locks exceeds the lock table size错误

    环境: mysql5.6.2  主从同步(备注:需操作主库和从库) 一.InnoDB表执行大批量数据的更新,插入,删除操作时会出现这个问题,需要调整InnoDB全局的innodb_buffer_poo ...

  8. MYSQL数据库性能调优之八：mysql日志

    MySQL日志 主要包含:错误日志.查询日志.慢查询日志.事务日志.二进制日志.中继日志: 使用 SHOW GLOBAL VARIABLES LIKE '%log%';  查询所有日志配置详情: 一. ...

  9. MYSQL数据库性能调优之一：调优技术基础

    1.mysql数据库优化技术有哪些? 2.数据库三层结构? 3.数据库3NF

随机推荐

  1. 修改vscode的文件，对应的磁盘文件不改变

    两种解决办法: 首先:修改VSCode默认配置文件,点击左下角设置标志图 -> 设置,出来了设置相关的东西,搜索 files.autoSave 第一种:把"files.autoSave ...

  2. Flutter学习笔记（26）--返回拦截WillPopScope，实现1秒内点击两次返回按钮退出程序

    如需转载,请注明出处:Flutter学习笔记(26)--返回拦截WillPopScope,实现1秒内点击两次返回按钮退出程序 在实际开发中,为了防止用户误触返回按钮导致程序退出,通常会设置为在1秒内连 ...

  3. 编译原理之DFA最小化，语法分析初步

    1.将DFA最小化: 状态转换图: 识别语言:b*ac*(da)*bb* 2.构造以下文法相应的最小的DFA S→ 0A|1B A→ 1S|1 B→0S|0 (1)正规式: S -> 0(1S+ ...

  4. MongoDB 中聚合统计计算--$SUM表达式

    我们一般通过表达式$sum来计算总和.因为MongoDB的文档有数组字段,所以可以简单的将计算总和分成两种:1,统计符合条件的所有文档的某个字段的总和:2,统计每个文档的数组字段里面的各个数据值的和. ...

  5. log file switch (checkpoint incomplete) - 容易被误诊的event

    本文转自 https://blogs.oracle.com/database4cn/log-file-switch-checkpoint-incomplete-%e5%ae%b9%e6%98%93%e ...

  6. 08. Go 语言包（package）

    Go 语言包(package) Go 语言的源码复用建立在包(package)基础之上.Go 语言的入口 main() 函数所在的包(package)叫 main,main 包想要引用别的代码,必须同 ...

  7. enter键的使用

    vue全部的按键别名: .enter .tab .delete (捕获“删除”和“退格”键) .esc .space .up .down .left .right vue中 <input v-o ...

  8. idea 出现Can't load AMD 64-bit .dll on a IA 32-bit platform错误

    这个错误是在说无法在IA 32位平台上加载AMD 64位.dll,解决方法如下 下载安装64位的jdk(方法和安装32位的一致,可百度查阅相关资料) 按如下步骤配置

  9. mpvue快速入门

    主要特性 使用 mpvue 开发小程序,你将在小程序技术体系的基础上获取到这样一些能力: 彻底的组件化开发能力:提高代码复用性 完整的 Vue.js 开发体验 方便的 Vuex 数据管理方案:方便构建 ...

  10. ubuntu 中安装jenkins，基于docker运行jenkins

     本文是在ubuntu环境下安装jenkins,jenkins运行在docker容器中,至于docker如何安装,本文不再描述,大家可以上网查询下,如何安装docker,下面先放上一个使用jenkin ...