一、项目总结三步骤

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

二、项目需求分析

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

三、搭建框架

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

四、ORM框架分析

# 优点：让一个不懂数据库操作的小白也能够简单快速操作数据库实现相应功能
# 缺点：sql封装固定,不利于sql查询优化# 对象关系映射# 类 >>> 数据库的表# 对象 >>> 表的一条条的记录# 对象获取属性或方法 >>> 记录的字段对应的值# 一张表有字段,字段又有字段名,字段类型,字段是否是主键,字段的默认值class Field(object):pass
# 为了在定义的时候更加方便 通过继承Field定义具体的字段类型
class StringField(Field):pass
class IntegerField(Field):passclass Models(dict):passdef __getattr__(self,item):return self.get(item)def __setattr__(self,key,value)self[key] = value# 查询def select(self,**kwargs):# select * from userinfo# select * from userinfo where id = 1# 新增def save(self):# insert into userinfo(name,password) values('jason','123')# 修改:是基于已经存在了的数据进行修改操作def update(self):# update userinfo set name='jason',password='234' where id = 1
"""
(******)
hasattr
getattr
setattr
"""
# 元类拦截类的创建过程  使它具备表的特性
class ModelsMetaClass(type):def __new__(cls,class_name,class_bases,class_attrs):# 只拦截模型表的创建表if class_name == 'Models':return type.__new__(cls,class_name,calss_bases,class_attrs)table_name = class_attrs.get('table_name',class_name)primary_key = Nonemappings = {}for k,v in class_attrs.items():if isinstance(v,Field):mappings[k] = vif v.primary:if primary_key:raise TypeError('主键重复')primary_key = v.namefor k in mappings.keys():class_attrs.pop(k)if not primary_key:raise TypeError('必须要有一个主键')class_attrs['table_name'] = table_nameclass_attrs['primary_key'] = primary_keyclass_attrs['mappings'] = mappingsreturn type.__new__(cls,class_name,calss_bases,class_attrs)

五、数据库设计

表结构定义好以后，数据怎么操作，逻辑代码怎么实现就清晰了用户表：包含管理员和普通用户信息 user--->id ,name ,password ,is_locked ,is_vip , user_type,register_time
电影表：movie---->id,name,, path,is_free, is_delete,user_id,create_time,file_md5
公告表：notice--->id,title,content,create_time,user_id
下载记录表：download_record---->id,user_id,movie_id,create_timecreate table user(id int auto_increment primary key,name varchar(255),password varchar(255),is_locked int not null default 0,is_vip int not null default 0,user_type varchar(255),register_time varchar(255)
)engine=Innodb charset='utf8';create table movie(id int auto_increment primary key,name varchar(64),path varchar(255),is_free int not null default 1,is_delete int not null default 0,create_time varchar(255),file_md5 varchar(255),user_id int
)engine=Innodb charset='utf8';create table notice(id int auto_increment primary key,title varchar(255),content varchar(255),user_id int,create_time varchar(255)
)engine=Innodb charset='utf8';create table download_record(id int auto_increment primary key,user_id int,movie_id int,create_time varchar(255)
)engine=Innodb charset='utf8';

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

管理员：
1、注册功能客户端1-1、选择每个功能之前都需要都需要需要连接上服务器，即需要一个socket对象，每个函数传一个client1-2、密码在传递过程中不能是明文吧，需要加密，可选择hashlib中md5加密，定义一个公共方法咯1-3、定义一个发送和接收的公共方法、这里要注意的是在这个方法有一个关键字形参、用于传输文件，默认为None1-4、考虑一个问题，发送的字典中要包含哪些数据、对于注册这个问题，包含服务器端用于标识的type的功能类型、用户名、密码（要加密）、还有用户类型"user_type"(admin或者user)这里是admin类型1-5、接收得到的字典back_dic又包含那些数据，常见的就flag和msg，后续的功能中有返回列表类型的服务端1-6、首先就是基于多线程实现并发的套接字程序，子线程working函数中会先接收到客户端发来的字典（用到json、struct模块）1-7、有个问题是有什么便利的方法将接收到的字典recv_dic 和与客户端建立连接的socket对象conn 交给接口层中相应的功能进行操作数据库，那就定义一个分发函数dispatch（recv_dic,conn）,然后判断recv_dic["type]类型和全局func_dic字典中进行比对，去执行与之对应的函数，如果传过来的类型不存在func_dic字典中，那就自定义一个字典back_dic(包含flag和msg数据)调用服务端公共发送数据方法返回给客户端1-8、咱们不知不觉就来到了服务端注册接口了，意味着可以操作数据库啦，就需要用到ORM框架和db目录中models模块中与表一一对应的类、这四个类都是根据事先在数据库中定义好的字段进行创建的，不要写错了，字段和类型。这四个类都继承了ORM框架的基类modle，所以可是直接点就可以调用ORM框架中基类中方法，select方法是类方法，得到的是一个列表套对象，还有save方法，用于保存，还有一个update方法用于更新，那咱们回过头来1-9、注册功能拿到的recv_dic中可以拿到注册的用户名，得到用户名后使用user_data = models.User.select(name=name )进行判断要注册的用户是否存在，若果存在老规矩back_dic(flag为False，msg为注册失败)返回去，不存在那咋整，还能咋整保存到数据库user表中呗，那怎么保存呀，name，password，user_type,is_locked和is_vip都有默认值，register_time注册时间的话写个方法 time.strftime("%Y-%m-%d %X")这样不就全搞定了，什么数据都拿到了，那就用models.User（）把这些数据搞进去创建得到一个对象，对象调用save方法进行方法就ojbk了，不急还有要记得通知客户端，老规矩back_dic字典，调用公共发送方法，注册大功告成
登录客户端2-1、在注册功能该项目的总体框架都已经打通了任督二脉，我的乖乖，那登录功能需要考虑一个问题，客户端如果登陆成功，是不是需要标记一下登陆状态，老规矩在全局定义一个字典，把返回的字典中一个session存到全局字典cookie中，解决了ojbk，2-2、发送字典send_dic中type类型修改为login，密码的话照样发送密文，然后over了服务器2-3、还记得tcpserver模块中的全局func_dic字典吗？强大的地方来了，刚刚只是写了一个注册的映射接口，现在来了一个login类型，那咋整，就往里加一个login的映射方法，还可以直接拿到recv_dic和conn，任督二脉打通了就是强，哦还有注册和登录都是管理员和普通用户的公共方法，所以放到common_interface中，其实放哪都一样只要能找到就行啦 哈哈2-4、你要登陆，逻辑点在哪里，首先我要判断你这货存不存在呀，不存在登陆个屁呀，淡定淡定，哈哈，上面说过select方法得到的是列表，别给老子忘了，列表里面放的是一个个对象，models中User类调用select方法根据name=recv_dic["name"]得到user_list,如果user_list存在，那就取零号位就拿到user_obj用户对象2-5、拿到user_obj对象点表中的字段属性判断其类型和接收的recv_dic字典中类型和密码是否一致，一致的话便可以得到一个back_dic字典了，老规矩包含flag和msg2-6、重点来了，这里可能有带你绕，请无关人员速速离开，要返回的back_dic字典中需要添加一个session添加到字典中，这个session是用户登陆成功之后生成的一个随机字符串，咱这里也是用hashlib，这里要保证生成的字符串是唯一的，这里需要加盐，加一个当前cpu执行代码的时间 time.clock()2-7、,服务端怎么校验用户的登陆问题，考虑两个问题，第一个问题服务端需要保存session，第二个问题当用户退出之后将该用户对应的键值删除？那我们如何判断用户走了，运行到哪一段代码就标记用户走了呢，我们可不可以通过addr就可以定位哪一个用户断开了，找到当前用对应的数据删除，数据保存形式{‘addr’:[session,user_id]}  将这个东西存在哪里呢，可以放在全局，但我们这里把他存到Tcpsever目录下user_data模块中live_user['addr’']=[session,user_id]那问题又来，怎么拿到add，第一种思路给每一个函数都添加addr参数，但是这个addr参数只是login函数用到，其他函数都没用到，这样第一种思路很不合理，第二种思路可以通过working中接收到的recv_dic字典添加recv_dic["addr"] = str(addr) 再传给每一个函数，在login函数中user_data.live_user[recv_dic["addr"]] = [session,user_obj.id]有考虑一个问题，因为多线程要操作公共数据user_data中的live_user字典，就会出现数据错乱，所以要加锁，那这个锁在那里产生呢？我们要在tcpsever全局中产生mutex = Lock()在这里产生，但是不能在这里用，因为会出现循环导入问题，tcpserver导入common_interface,在common_interface中又用到tcpserver中的锁，相互导入就出现循环导入，解决办法，将锁保存到user_data中  user_data.mutex = mutex，在login中给user_data.live_user[recv_dic["addr"]] = [session,user_obj.id]加锁，直接导入user_data就可以使用到锁啦还没完在tcpserver中 用户退出（try...except.(下面的执行的代码就表示其中一个线程断开)..）就要删除user_data.live_user.pop(str(addr))  ，这里也是公共方法需要加锁user_data.mutex.acquire()和user_data.mutex.release()2-8、下面的功能都需要先登录才能操作，这里来个装饰器功能：校验客户端发过来的随机字符串，如果有这个随机字符串那就正常执行函数，如果没有返回请先登录的提示，意味着客户端发送的字典要带着session过来，装饰器inner（*args,**kwargs）中args=（recv_dic,conn） kwargs={}  拿到客户端发过来的随机字符串与服务器的数据进行比对  vlues=[session,user_id]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以上for循环不一定能找到，for循环只是单单的判断session，然后将user_id放到接收字典recv_dic中,那被装饰的函数到底执不执行，if args[0].get("user_id"): func(*args,**kwargs)else: back_dic ={"flag"False,"msg":"请先登录"} 然后调用返回函数send_back(back_dic,args[1])
3、上传视频客户端3-1、查看有哪些影片需要上传的，即获取所有视频3-2、判断影片是否存在才能上传，那应该怎么判断是个问题，我们能不能对上传的视频文件进行hashlib，自定义被hash的数据可以在文件开头，1/3，2/3，末尾-10然后得到md5值发送字典类型"check_movie"，包含"session"，"file_md5"，得到字典back_dic，如果视频不存在那要输入is_free，是否免费，然后在发字典send_dic,该字典类型为"upload_movie"，还包含"session"、"file_name"、 "file_size"、"file_md5"，这里调用公共收发方法是要给文件file传参了，把上传文件路径传过去服务端3-3、还记得tcpserver模块中的全局func_dic字典吗？加上"check_movie"和"upload_movie"映射，映射函数全都加上装饰器3-4、"check_movie"比较简单，只是查看要上传视频的file_md5是否在数据库，注意数据库中存的只是文件地址而已，不是真实的视频文件3-5、这里为了避免上传的视频名字是一样的但是内容不一样，所以文件名应该尽量取的唯一，所以给传来的file_name加上一个随机字符串，就直接调用之前定义的 get_session方法即可3-6、这里要拼接文件的存放路径了，根据file_size循环写入文件3-7、生成一个 movie_obj 电影对象，调用save方法保存，然后返回back_dic说明上传成功
4、删除视频客户端4-1、先查询出所有没有被删除的电影列表，即send_dic字典中"type"为'get_movie_list' 和'movie_type'为"all",返回的电影列表可以全部是收费，全部是免费，收费免费都有,这里需要注意的是获取所有视频列表考虑的不周全，如果单从管理员角度要获得所有视频不考虑用户获取收费或者免费的视频，会出现一些代码冗余，所以在获取所有视频这个功能要判断传过来的的movie_type是all、free、charge4-2、拿到所有视频列表movie_list，该列表的格式[电影名称，是否免费收费，电影id]发送字典send_dic中"type"为"delete_movie"和delete_movie_id'为movie_list[choice-1][2]服务端4-3、还记得tcpserver模块中的全局func_dic字典吗？加上'get_movie_list'和"delete_movie"映射，映射函数全都加上装饰器4-4、删除电影不是真的删除，只是找到每一个电影对象，然后点is_delete属性改为1即可，所以get_movie_list方法会先获得所有对象列表，遍历列表得到每一个对象，对每一个对象的is_delete属性进行判断，注意还要判断ecv_dic['movie_type']，这里是“all”类型，满足的全部添加到一个返回的列表中back_movie_list，然后返回给客户端4-5、delete_movie方法的话 movie_list = models.Movie.select(id=recv_dic.get("delete_movie_id"))然后对列表去索引得到一个电影对象，然后修改movie_obj.is_delete，然后调用update()方法更新，然后返回back_cic5、发布公告客户端5-1 公告包含title和content  发送的字典send_dic包含"type"为"release_notice"、"session"、"title"、"content"服务端、5-2、这里需要知道接受的字典recv_dic是包含user_id字段的，要写入表notice时用到5-3、也是创建表notice对象，然后调用save方法保存
普通用户
1、注册直接调用公共注册方法
2、登录直接调用公共登录，在全局添加user_dic中保存session和is_vip
3、购买会员客户端3-1、判断全局user_dic['is_vip']可知道是否是会员3-2、如果不是的话，让用户选择是否购买会员，购买的话最后要修改全局服务端3-3、根据recv_dic["user_id"]判断是哪一个用户要购买会员，得到的对象点is_vip属性修改为1，调用update(0方法保存
4、查看所有视频客户端4-1、发送字典send_dic里面的type为'get_movie_list'，'movie_type为'all'服务器4-2、直接调用之前写好的get_movie_list方法即可  这和管理员中删除视频就先获取所有视频
5、下载免费电影客户端5-1、先列出所有免费电影，和上个功能差不多，只是'movie_type'改为'free'5-2、再发送字典send_dic中'type'为'download_movie' 'movie_id'为movie_list[choice-1][2]5-3、接受得到的字典back_dic中有一个wait_time 打印可能是0或者30秒  拼接下载的路径，循环写入文件服务端5-4、id=recv_dic.get('movie_id')来得到电影列表movie_list，然后索引取值得到电影对象5-5  id=recv_dic['user_id']来得到用户列表索引取得用户对象user_obj5-6、下载电影的话先判断使用是否是vip，vip的话不需要等待30秒 不是的话需要等待30秒5-7、更新下载记录到down_record表中5-8、循环发送文件5-9、发送字典back_dic
6、下载收费电影客户端6-1、针对普通用户和vip用户下载收费视频收费标准不一样（5元 10元）6-2、发送字典send_dic 中还是'get_movie_list'但是电影类型为收费'movie_type':'charge'6-3、剩下功能和下载免费电影差不多服务器同上
7、查看下载记录客户端7-1、发送字典send_dic 中的类型'check_download_record'7-2、接受字典back_dic进行判断即可服务端7-3、还记得tcpserver模块中的全局func_dic字典吗？加上'check_download_record'的映射方法7-4、要查看下载记录 先根据用户id得到一个记录列表，循环该列表得到的是每一个记录对象7-5、根据每一个对象点movie_id 和电影id判断得到电影列表，索引取值得到各个对象7-6、把每一个对象的名字添加到一个自定义的列表中，用于返回给客户端
8、查看公告客户端8-1、发送字典send_dic 中的类型'check_notice'8-2、接受字典back_dic进行判断即可服务端8-3、还记得tcpserver模块中的全局func_dic字典吗？加上'check_notice'的映射方法8-4、Notice类调用select方法得到公告列表8-5、列表存在的话 遍历该列表得到每一个对象，返回字典中保存对象点title，点content进行返回

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

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

八、客户端代码框架

8.1 conf

8.1.1 setting

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

8.2 core

8.2.1 src

from core import admin, userfunc_dic = {"1": admin.admin_view, "2": user.user_view}def run():while True:print("""1、管理员视图2、普通用户视图q、退出""")choice = input("please choice your number>>:").strip()if choice == 'q': breakif choice not in func_dic:print("choice err not in range")continuefunc_dic.get(choice)()

8.2.2 admin

import osfrom Tcpclient import tcpclient
from lib import common
from conf import settinguser_info = {"session": None
}def register(client):while True:name = input("please input your name>>:").strip()password = input("please input your password>>:").strip()re_password = input("please agan input your password>>:").strip()if password != re_password:print("两次密码不一致")continuesend_dic = {"type": "register", "name": name, "password": common.get_md5(password), "user_type": "admin"}back_dic = common.send_back(send_dic, client)if back_dic["flag"]:print(back_dic["msg"])breakelse:print(back_dic["msg"])def login(client):while True:name = input("please input your name>>:").strip()password = input("please input your password>>:").strip()send_dic = {"type": "login", "name": name, "password": common.get_md5(password), "user_type": "admin"}back_dic = common.send_back(send_dic, client)if back_dic["flag"]:print(back_dic["msg"])user_info["session"] = back_dic["session"]breakelse:print(back_dic["msg"])def update_movie(client):"""思路：1、是不是要先获取有哪些可以上传的视频2、选择好要上传的视频后是不是还要判断服务器存不存在，存在了就不需要上传了3、那就需要校验视频文件，可自定义校验规则4、循环上传:param client::return:"""while True:movie_list = common.get_movie()if not movie_list:print("暂无影片上传")returnfor i, m in enumerate(movie_list, start=1):print("%s:%s" % (i, m))choice = input("please input your choice>>: ").strip()if choice == 'q': breakif choice.isdigit():choice = int(choice)if choice in range(1, len(movie_list) + 1):file_path = os.path.join(setting.UPDATE_MOVIE, movie_list[choice - 1])file_md5 = common.get_file_md5(file_path)send_dic = {"type": "check_movie", "session": user_info["session"], "file_md5": file_md5}back_dic = common.send_back(send_dic, client)if back_dic["flag"]:# 如果可以上传，那标识上传免费还是收费is_free = input("上传的影片是否免费（y/n）>>:").strip()is_free = 1 if is_free == 'y' else 0file_name = movie_list[choice - 1]send_dic = {"type": "update_movie", "session": user_info["session"], "is_free": is_free,"file_name": file_name, "file_md5": file_md5, "file_size": os.path.getsize(file_path)}back_dic = common.send_back(send_dic, client, file_path)if back_dic["flag"]:print(back_dic["msg"])returnelse:print(back_dic["msg"])else:print(back_dic["msg"])else:print("choice not in range")else:print("input choice must be a number ！")def delete_movie(client):"""思路：1、先从服务器获取所有视频2、要删除的发给服务器:param client::return:"""send_dic = {"type": "get_movie_list", "session": user_info["session"], "movie_type": "all"}back_dic = common.send_back(send_dic, client)if back_dic["flag"]:"""服务器的get_movie_list会返回一个电影列表,列表里面为[电影名，收费或免费，电影id]"""movie_list = back_dic["movie_list"]for i, m in enumerate(movie_list, start=1):print("%s:%s-%s" % (i, m[0], m[1]))choice = input("input your delete movie>>:").strip()if choice.isdigit():choice = int(choice)if choice in range(1, len(movie_list) + 1):send_dic = {"type": "delete_movie", "session": user_info["session"],"movie_id": movie_list[choice - 1][2]}back_dic = common.send_back(send_dic, client)if back_dic['flag']:print(back_dic['msg'])returnelse:print(back_dic['msg'])else:print('choice noe in range')else:print(back_dic['msg'])def release_notice(client):while True:title = input("please input title>>:").strip()content = input("please input content>>:").strip()send_dic = {"type": "release_notice", "session": user_info["session"], "title": title, "content": content}back_dic = common.send_back(send_dic, client)if back_dic["flag"]:print(back_dic["msg"])breakelse:print(back_dic['msg'])breakfunc_dic = {"1": register,"2": login,"3": update_movie,"4": delete_movie,"5": release_notice
}def admin_view():client = tcpclient.get_client()while True:print("""1、注册2、登录3、上传电影4、删除电影5、发布公告""")choice = input("please choice your number>>:").strip()if choice == 'q': breakif choice not in func_dic:print("choice err not in range")continuefunc_dic.get(choice)(client)

8.2.3 user

import os
import timefrom Tcpclient import tcpclient
from conf import setting
from lib import commonuser_info = {"session": None,"is_vip": None
}def register(client):while True:name = input("please input your name>>:").strip()password = input("please input your password>>:").strip()re_password = input("please agan input your password>>:").strip()if password != re_password:print("两次密码不一致")continuesend_dic = {"type": "register", "name": name, "password": common.get_md5(password), "user_type": "user"}back_dic = common.send_back(send_dic, client)if back_dic["flag"]:print(back_dic["msg"])breakelse:print(back_dic["msg"])def login(client):while True:name = input("please input your name>>:").strip()password = input("please input your password>>:").strip()send_dic = {"type": "login", "name": name, "password": common.get_md5(password), "user_type": "user"}back_dic = common.send_back(send_dic, client)if back_dic["flag"]:print(back_dic["msg"])user_info["session"] = back_dic["session"]user_info["is_vip"] = back_dic["is_vip"]breakelse:print(back_dic["msg"])def buy_vip(client):while True:buy_vip = input("是否购买会员（y/n）>>:").strip()if buy_vip == 'q': breakif buy_vip not in ['y', 'n']:print("输入有误")continueif buy_vip == 'y':send_dic = {"type": "buy_vip", "session": user_info["session"]}back_dic = common.send_back(send_dic, client)if back_dic["flag"]:print(back_dic["msg"])breakelse:print(back_dic["msg"])else:print("欢迎下次购买")breakdef check_movie(client):send_dic = {"type": "get_movie_list", "session": user_info["session"], "movie_type": "all"}back_dic = common.send_back(send_dic, client)if back_dic["flag"]:movie_list = back_dic["movie_list"]for i, m in enumerate(movie_list, start=1):print("%s:%s-%s" % (i, m[0], m[1]))else:print(back_dic["msg"])def download_free_movie(client):send_dic = {"type": "get_movie_list", "session": user_info["session"], "movie_type": "free"}back_dic = common.send_back(send_dic, client)if back_dic["flag"]:movie_list = back_dic["movie_list"]for i, m in enumerate(movie_list, start=1):print("%s:%s-%s" % (i, m[0], m[1]))while True:choice = input("请选择要下载的电影编号>>:").strip()if choice == 'q': breakif choice.isdigit():choice = int(choice)if choice in range(1, len(movie_list) + 1):send_dic = {"type": "download_movie", "session": user_info["session"],"movie_id": movie_list[choice - 1][2], "movie_type": "free"}back_dic = common.send_back(send_dic, client)if back_dic["flag"]:print("请等待》》》")time.sleep(back_dic["wait_time"])file_path = os.path.join(setting.DOWNLOAD_MOVIE_DIR, back_dic["file_name"])recv_size = 0with open(file_path, 'wb') as f:while recv_size < back_dic["file_size"]:data = client.recv(1024)f.write(data)recv_size += len(data)print("下载成功")returnelse:print(back_dic["msg"])else:print("choice not in range")else:print("choice must be number")else:print(back_dic["msg"])def download_charge_movie(client):if user_info["is_vip"]:charge = input("请支付10元(y/n)>>:").strip()else:charge = input('请支付20元(y/n)>>:').strip()if charge != "y":print("慢走 不送")returnsend_dic = {"type": "get_movie_list", "session": user_info["session"], "movie_type": "charge"}back_dic = common.send_back(send_dic, client)if back_dic["flag"]:movie_list = back_dic["movie_list"]for i, m in enumerate(movie_list, start=1):print("%s:%s-%s" % (i, m[0], m[1]))while True:choice = input("请选择要下载的电影编号>>:").strip()if choice == 'q': breakif choice.isdigit():choice = int(choice)if choice in range(1, len(movie_list) + 1):send_dic = {"type": "download_movie", "session": user_info["session"],"movie_id": movie_list[choice - 1][2], "movie_type": "free"}back_dic = common.send_back(send_dic, client)if back_dic["flag"]:print("请等待》》》")time.sleep(back_dic["wait_time"])file_path = os.path.join(setting.DOWNLOAD_MOVIE_DIR, back_dic["file_name"])recv_size = 0with open(file_path, 'wb') as f:while recv_size < back_dic["file_size"]:data = client.recv(1024)f.write(data)recv_size += len(data)print("下载成功")returnelse:print(back_dic["msg"])else:print("choice not in range")else:print("choice must be number")else:print(back_dic["msg"])def download_movie_record(client):"""思路：当前登录的用户需要查看自己的观影记录，需要得到电影名:param client::return:"""send_dic = {"type": "download_movie_record", "session": user_info["session"]}back_dic = common.send_back(send_dic, client)if back_dic["flag"]:back_record_list = back_dic['back_record_list']for m in back_record_list:print(m)else:print(back_dic['msg'])def check_notice(client):"""查看公告思路：:param client::return:"""send_dic = {"type": "check_notice", "session": user_info["session"]}back_dic = common.send_back(send_dic, client)if back_dic["flag"]:back_record_list = back_dic['back_notice_list']for m in back_record_list:print(m)else:print(back_dic['msg'])func_dic = {"1": register,"2": login,"3": buy_vip,"4": check_movie,"5": download_free_movie,"6": download_charge_movie,"7": download_movie_record,"8": check_notice
}def user_view():client = tcpclient.get_client()while True:print("""1、注册2、登录3、购买会员4、查看所有电影5、下载免费电影6、下载收费电影7、查看观影记录8、查看公告""")choice = input("please choice your number>>:").strip()if choice == 'q': breakif choice not in func_dic:print("choice err not in range")continuefunc_dic.get(choice)(client)

8.3 lib

8.3.1 common

import hashlib
import json
import os
import struct
from conf import settingdef send_back(send_dic, client, file=None):json_bytes = json.dumps(send_dic).encode("utf-8")client.send(struct.pack('i', len(json_bytes)))client.send(json_bytes)if file:with open(file, 'rb') as f:for line in f:client.send(line)recv_len = struct.unpack('i', client.recv(4))[0]recv_dic = json.loads(client.recv(recv_len).decode("utf-8"))return recv_dicdef get_md5(password):md = hashlib.md5()md.update(password.encode("utf-8"))return md.hexdigest()def get_movie():movie_list = os.listdir(setting.UPDATE_MOVIE)return movie_listdef get_file_md5(path):md = hashlib.md5()file_size = os.path.getsize(path)file_list = [0, file_size // 3, (file_size // 3) * 2, file_size - 10]with open(path, "rb") as f:for line in file_list:f.seek(line)md.update(f.read(10))return md.hexdigest()

8.4 Tcpclient

8.4.1 tcpclient

import socketdef get_client():client = socket.socket()client.connect(("127.0.0.1", 1688))return client

8.5 start

8.5.1 start

import os, sysfrom core import srcsys.path.append(os.path.dirname(__file__))
if __name__ == '__main__':src.run()

九、服务端框架

9.1 conf

9.1.1 setting

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

9.2 db

9.2.1 models

from orm_pool.orm import Models, StringField, IntegerFieldclass User(Models):table_name = 'user'id = IntegerField("id", primary_key=True)name = StringField("name")password = StringField("password")is_locked = IntegerField("is_locked", default=0)is_vip = IntegerField("is_vip", default=0)user_type = StringField("user_type")register_time = StringField("register_time")class Movie(Models):table_name = "movie"id = IntegerField("id", primary_key=True)name = StringField("name", column_type="varchar(64)")path = StringField("path")is_free = IntegerField("is_free")is_delete = IntegerField("is_delete", default=0)create_time = StringField("create_time")user_id = IntegerField("user_id")file_md5 = StringField("file_md5")class Notice(Models):table_name = "notice"id = IntegerField("id", primary_key=True)title = StringField("title")content = StringField("content")user_id = IntegerField("user_id")create_time = StringField("create_time")class DownloadRecord(Models):table_name = "download_record"id = IntegerField("id", primary_key=True)user_id = IntegerField("user_id")movie_id = IntegerField("movie_id")create_time = StringField("create_time")

9.3 interface

9.3.1 admin_interface

import osfrom db import models
from lib import common
from conf import setting@common.login_auth
def check_movie(recv_dic, conn):movie_data = models.Movie.select(file_md5=recv_dic["file_md5"])if movie_data:back_dic = {"flag": False, "msg": "该电影已存在"}else:back_dic = {"flag": True, "msg": "可以上传"}common.send_back(back_dic, conn)@common.login_auth
def update_movie(recv_dic, conn):file_name = common.get_session(recv_dic["file_name"]) + recv_dic["file_name"]file_path = os.path.join(setting.MOVIE_DIR, file_name)print(recv_dic)recv_size = 0with open(file_path, 'wb') as f:while recv_size < recv_dic["file_size"]:data = conn.recv(1024)f.write(data)recv_size += len(data)movie_obj = models.Movie(name=file_name, path=file_path, is_free=recv_dic.get("is_free"), is_delete=0,create_time=common.get_time(), user_id=recv_dic.get("user_id"),file_md5=recv_dic.get("file_md5"))movie_obj.save()back_dic = {"flag": True, "msg": "上传成功"}common.send_back(back_dic, conn)@common.login_auth
def delete_movie(recv_dic, conn):movie_obj = models.Movie.select(id=recv_dic.get('movie_id'))[0]movie_obj.is_delete = 1movie_obj.update()back_dic = {"flag": True, "msg": "删除成功"}common.send_back(back_dic, conn)@common.login_auth
def release_notice(recv_dic, conn):title = recv_dic["title"]content = recv_dic["content"]user_id = recv_dic["user_id"]create_time = common.get_time()notice_obj = models.Notice(title=title, content=content, user_id=user_id, create_time=create_time)notice_obj.save()back_dic = {"flag": True, "msg": "发布成功"}common.send_back(back_dic, conn)

9.3.2 common_interface

from db import models
from lib import common
from Tcpserver import user_datadef register(recv_dic, conn):user_list = models.User.select(name=recv_dic["name"])if user_list:back_dic = {"flag": False, "msg": "用户已存在"}common.send_back(back_dic, conn)returnuser_obj = models.User(name=recv_dic["name"], password=recv_dic["password"], is_locked=0, is_vip=0,user_type=recv_dic["user_type"], register_time=common.get_time())user_obj.save()back_dic = {"flag": True, "msg": "注册成功"}common.send_back(back_dic, conn)def login(recv_dic, conn):user_list = models.User.select(name=recv_dic["name"])if user_list:user_obj = user_list[0]if user_obj.user_type == recv_dic["user_type"]:if user_obj.password == recv_dic["password"]:back_dic = {"flag": True, "msg": "登陆成功", "is_vip": user_obj.is_vip}# 获取每个用户的唯一随机字符串，用于标识每个用户session = common.get_session(user_obj.name)back_dic["session"] = session# 服务端要记录正在登录的客户端，将数据user_data文件live_user字典中，放在为了更好的标识# 每一个客户，字典的key为recv_dic["addr"]  -----他是一个元组包含ip和端口，值的话是一个列表# 保存每一个session和用户id# 因为时公共数据，且并发会造成数据错乱，咱们给他来个锁user_data.mutex.acquire()user_data.live_user[recv_dic["addr"]] = [session, user_obj.id]user_data.mutex.release()else:back_dic = {"flag": False, "msg": "密码不正确"}else:back_dic = {"flag": False, "msg": "用户类型不对"}else:back_dic = {"flag": False, "msg": "用户不存在"}common.send_back(back_dic, conn)@common.login_auth
def get_movie_list(recv_dic, conn):"""要给调用者返回相应的电影列表：all、free、charge:param recv_dic::param conn::return:"""movie_list = models.Movie.select()if movie_list:back_movie_list = []for movie_obj in movie_list:if not movie_obj.is_delete:if recv_dic["movie_type"] == "all":back_movie_list.append([movie_obj.name, '免费' if movie_obj.is_free else '收费', movie_obj.id])elif recv_dic["movie_type"] == "free":if movie_obj.is_free:back_movie_list.append([movie_obj.name, '免费', movie_obj.id])else:if not movie_obj.is_free:back_movie_list.append([movie_obj.name, '收费', movie_obj.id])if back_movie_list:back_dic = {"flag": True, "movie_list": back_movie_list}else:back_dic = {"flag": False, "msg": "暂无影片"}else:back_dic = {"flag": False, "msg": "暂无影片"}common.send_back(back_dic, conn)

9.3.3 user_interface

import osfrom conf import setting
from db import models
from lib import common@common.login_auth
def buy_vip(recv_dic, conn):user_obj = models.User.select(id=recv_dic['user_id'])[0]if user_obj.is_vip:back_dic = {"flag": False, "msg": "您已经是会员啦"}else:user_obj.is_vip = 1user_obj.save()back_dic = {"flag": True, "msg": "购买成功"}common.send_back(back_dic, conn)@common.login_auth
def download_movie(recv_dic, conn):"""下载电影功能：普通用户下载需要等待30秒 VIP用下载不需要等待:param recv_dic::param conn::return:"""movie_list = models.Movie.select(id=recv_dic["movie_id"])if movie_list:movie_obj = movie_list[0]file_path = movie_obj.pathuser_obj = models.User.select(id=recv_dic["user_id"])[0]wait_time = 0if recv_dic["movie_type"] == "free":if user_obj.is_vip:wait_time = 0else:wait_time = 30back_dic = {"flag": True, "file_name": movie_obj.name, "file_size": os.path.getsize(file_path),"wait_time": wait_time}download_record = models.DownloadRecord(user_id=user_obj.id, movie_id=movie_obj.id,create_time=common.get_time())download_record.save()common.send_back(back_dic, conn)with open(file_path, 'rb') as f:for line in f:conn.send(line)else:back_dic = {"flag": False, "msg": "暂无影片"}common.send_back(back_dic, conn)@common.login_auth
def download_movie_record(recv_dic, conn):record_list = models.DownloadRecord.select(user_id=recv_dic["user_id"])back_record_list = []if record_list:for m in record_list:movie_obj = models.Movie.select(id=m.movie_id)[0]back_record_list.append(movie_obj.name)back_dic = {"flag": True, "back_record_list": back_record_list}else:back_dic = {"flag": False, "msg": "暂无下载记录"}common.send_back(back_dic, conn)@common.login_auth
def check_notice(recv_dic, conn):notice_list = models.Notice.select()back_notice_list = []if notice_list:for notice_obj in notice_list:back_notice_list.append([notice_obj.title, notice_obj.content])back_dic = {"flag": True, "back_notice_list": back_notice_list}else:back_dic = {"flag": False, "msg": "暂无下载记录"}common.send_back(back_dic, conn)

9.4 lib

9.4.1 common

import hashlib
import json
import struct
import time
from functools import wrapsfrom Tcpserver import user_datadef send_back(back_dic, conn):json_bytes = json.dumps(back_dic).encode("utf-8")conn.send(struct.pack('i', len(json_bytes)))conn.send(json_bytes)def get_time():return time.strftime("%Y-%m-%d %X")def get_session(name):# 为了保证每个用户的随机字符串是唯一的，不仅要对每一个用户名加密还要加上cpu执行时机----加盐md = hashlib.md5()md.update(str(time.clock()).encode("utf-8"))md.update(name.encode("utf-8"))return md.hexdigest()def login_auth(func):@wraps(func)def inner(*args, **kwargs):# args=(recv_dic,conn)# 登录了以后服务端user_data文件中live_user就有存在用户登陆的数据，如果没有登陆就没有数据，可以为此# 来作为判断是否登录的依据for values in user_data.live_user.values():# values = [session,user_id]if args[0]["session"] == values[0]:args[0]["user_id"] = values[1]breakif args[0].get("user_id"):func(*args, **kwargs)else:back_dic = {"flag": False, "msg": "请先登录"}send_back(back_dic, args[1])return inner

9.5 orm_pool

9.5.1 db_pool

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

9.5.2 mysql_singleton

import pymysql
from orm_pool import db_poolclass Mysql(object):def __init__(self):self.conn = db_pool.POOL.connection()self.cursor = self.conn.cursor(pymysql.cursors.DictCursor)def close(self):self.cursor.close()self.conn.close()def select(self, sql, args=None):self.cursor.execute(sql, args)res = self.cursor.fetchall()  # 列表套字典return resdef execute(self, sql, args):try:self.cursor.execute(sql, args)except BaseException as e:print(e)

9.5.3 orm

from orm_pool.mysql_singleton import Mysql# 定义字段类
class Field(object):def __init__(self, name, column_type, primary_key, default):self.name = nameself.column_type = column_typeself.primary_key = primary_keyself.default = default# 定义具体的字段
class StringField(Field):def __init__(self,name,column_type='varchar(255)',primary_key=False,default=None):super().__init__(name, column_type, primary_key, default)class IntegerField(Field):def __init__(self,name,column_type='int',primary_key=False,default=None):super().__init__(name, column_type, primary_key, default)class ModelMetaClass(type):def __new__(cls, class_name, class_bases, class_attrs):# 我仅仅只想拦截模型表的类的创建过程if class_name == 'Models':return type.__new__(cls, class_name, class_bases, class_attrs)# 给类放表名,主键字段,所有字段table_name = class_attrs.get('table_name', class_name)# 定义一个存储主键的变量primary_key = None# 定义一个字典用来存储用户自定义的表示表的所有字段信息mappings = {}# for循环当前类的名称空间for k, v in class_attrs.items():if isinstance(v, Field):mappings[k] = vif v.primary_key:if primary_key:raise TypeError("主键只能有一个")primary_key = v.name# 将重复的键值对删除for k in mappings.keys():class_attrs.pop(k)if not primary_key:raise TypeError('必须要有一个主键')# 将处理好的数据放入class_attrs中class_attrs['table_name'] = table_nameclass_attrs['primary_key'] = primary_keyclass_attrs['mappings'] = mappingsreturn type.__new__(cls, class_name, class_bases, class_attrs)class Models(dict, metaclass=ModelMetaClass):def __init__(self, **kwargs):super().__init__(**kwargs)def __getattr__(self, item):return self.get(item, '没有该键值对')def __setattr__(self, key, value):self[key] = value# 查询方法@classmethoddef select(cls, **kwargs):ms = Mysql()# select * from userinfoif not kwargs:sql = 'select * from %s' % cls.table_nameres = ms.select(sql)else:# select * from userinfo where id = 1k = list(kwargs.keys())[0]v = kwargs.get(k)sql = 'select * from %s where %s=?' % (cls.table_name, k)# select * from userinfo where id = ?sql = sql.replace('?','%s')  # select * from userinfo where id = %sres = ms.select(sql, v)if res:return [cls(**r) for r in res]  # 将数据库的一条数据映射成类的对象# 新增方法def save(self):ms = Mysql()# insert into userinfo(name,password) values('jason','123')# insert into %s(%s) values(?)fields = []  # [name,password]values = []args = []for k, v in self.mappings.items():if not v.primary_key:  # 将id字段去除   因为新增一条数据 id是自动递增的不需要你传fields.append(v.name)args.append('?')values.append(getattr(self, v.name))# insert into userinfo(name,password) values(?,?)sql = "insert into %s(%s) values(%s)" % (self.table_name, ','.join(fields), ','.join(args))# insert into userinfo(name,password) values(?,?)sql = sql.replace('?', '%s')ms.execute(sql, values)# 修改方法:基于已经存在了的数据进行一个修改操作def update(self):ms = Mysql()# update userinfo set name='jason',password='123' where id = 1fields = []  # [name,password]values = []pr = Nonefor k, v in self.mappings.items():if v.primary_key:pr = getattr(self, v.name, v.default)else:fields.append(v.name + '=?')values.append(getattr(self, v.name, v.default))sql = 'update %s set %s where %s = %s' % (self.table_name, ','.join(fields), self.primary_key, pr)# update userinfo set name='?',password='?' where id = 1sql = sql.replace('?', '%s')ms.execute(sql, values)# if __name__ == '__main__':
# class Teacher(Models):
#     table_name = 'teacher'
#     tid = IntegerField(name='tid',primary_key=True)
#     tname = StringField(name='tname')
# obj = Teacher(tname='jason老师')
# obj.save()
# res = Teacher.select()
# for r in res:
#     print(r.tname)
# print(res)
# res = Teacher.select(tid=1)
# teacher_obj = res[0]
# teacher_obj.tname = 'jason老师'
# teacher_obj.update()
# res1 = Teacher.select()
# print(res1)
# class User(Models):
#     table_name = 'User'
#     id = IntegerField(name='id', primary_key=True)
#     name = StringField(name='name')
#     password = StringField(name='password')
# print(User.primary_key)
# print(User.mappings)
# obj = User(name='jason')
# print(obj.table_name)
# print(obj.primary_key)
# print(obj.mappings)

9.6 Tcpserver

9.6.1 tcpserver

import json
import socket
import struct
import traceback
from concurrent.futures import ThreadPoolExecutor
from threading import Lock
from Tcpserver import user_datafrom interface import common_interface, admin_interface, user_interface
from lib import commonpool = ThreadPoolExecutor(20)
#全局产生锁，为了避免循环导入问题，将产生的锁放到user_data中
mutex = Lock()
user_data.mutex = mutexfunc_dic = {"register": common_interface.register,"login": common_interface.login,"check_movie": admin_interface.check_movie,"update_movie": admin_interface.update_movie,"get_movie_list": common_interface.get_movie_list,"delete_movie": admin_interface.delete_movie,"release_notice": admin_interface.release_notice,"buy_vip": user_interface.buy_vip,"download_movie": user_interface.download_movie,"download_movie_record": user_interface.download_movie_record,"check_notice": user_interface.check_notice
}def get_server():server = socket.socket()server.bind(("127.0.0.1", 1688))server.listen(5)while True:conn, addr = server.accept()pool.submit(working, conn, addr)def working(conn, addr):while True:try:recv_header = conn.recv(4)recv_bytes = conn.recv(struct.unpack('i', recv_header)[0])recv_dic = json.loads(recv_bytes.decode("utf-8"))recv_dic["addr"] = str(addr)dispatch(recv_dic, conn)except Exception as e:traceback.print_exc()conn.close()# 当用户断开以后，服务器就无需保存表示他的数据user_data.mutex.acquire()user_data.live_user.pop(str(addr))user_data.mutex.release()breakdef dispatch(recv_dic, conn):if recv_dic.get("type") in func_dic:func_dic.get(recv_dic["type"])(recv_dic, conn)else:back_dic = {"flag": False, "msg": "类型不合法"}common.send_back(back_dic, conn)

9.6.2 user_data

live_user={}
mutex=None

9.7 start

9.7.1 start

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