• day8--socketserver作业


    fileno()文件描述符

    handle_request()处理单个请求

    server_forever(poll_interval=0.5)处理多个请求,poll_interval每0.5秒检测是否关闭,

    作业:开发一个支持多用户在线的FTP程序

    要求:

        1.用户加密认证;

        2.允许同时多用户登录;

        3.每个用户有自己的家目录,且只能访问自己的家目录;

        4.对用户进行磁盘配额,每个用户的可用空间不同;

        5.允许用户在ftp.server上随意切换目录;

        6.允许用户查看当前目录下文件;

        7.允许上传和下载文件,保证文件一致性;

        8.文件传输过程中显示进度条;

        9.附加功能,支持文件的断点续传。

    发送文件的大致思路:

    接收文件的大致思路:

    遍历空的文件,如果一个文件是空的,Python是不会执行后面缩进的代码的,空的文件。

    http://www.cnblogs.com/liujiacai/p/7417953.html

    http://www.cnblogs.com/lianzhilei/p/5869205.html

    http://www.bubuko.com/infodetail-1758633.html

        由于不是做运维的,对一些系统的操作不是很熟悉,因此首先完成了文件的上传与下载:下面来看看这两个功能:

       

        客户端:

    import socket,os,json,sys
    
    
    class Myclient(object):
        '''定义客户端'''
        def __init__(self):
            '''定义socket()实例'''
            self.client = socket.socket()                                         #生成soket()实例
    
        def connect(self,ip,port):
            """定义连接"""
            self.client.connect((ip,port))
    
        def interactive(self):
            '''定义和用户交互'''
            while True:
                cmd = input("请输入指令>>:").strip()                              #用户输入指令
                if len(cmd) == 0:
                    print("指令不能为空!!!")
                    continue                                                      #指令不能为空
                cmd_str = cmd.split()[0]                                          #指令由两种形式
                if hasattr(self,cmd_str):                                         #判断指令是否存在
                    func = getattr(self,cmd_str)                                  #指令存在,则获取对应的方法
                    func(cmd)
                elif cmd_str == 'q':
                    break
                else:
                    self.help()
                    continue
    
    
        def help(self):
            msg = """
            ls
            pwd
            cd
            put   filename
            get   filename
            """
            print("指令名称",msg)
    
        def put(self,cmd):
            '''定义上传数据接口'''
            cmd_list = cmd.split()
            if len(cmd_list) > 1:
                '''指令是由指令名和文件名构成'''
                filename = cmd_list[1]                                              #获取文件名
                if os.path.isfile(filename):                                        #检测上传的文件名是否存在
                    '''文件名存在,则要告诉服务器端上传的文件名,文件大小,并检测服务器是否有相应的方法'''
                    filesize = os.stat(filename).st_size
                    msg_dic = {
                        "action":"put",
                        "filename":filename,
                        "filesize":filesize
                    }
                    '''转换为字节码的形式进行传输'''
                    self.client.send(json.dumps(msg_dic).encode("utf-8"))           #转换为json格式进行上传,便于服务器接收后处理
                    server_response = self.client.recv(1024)                        #等待服务器传回信息,防止粘包
                    self.client.send("收到了".encode("utf-8"))
                    if int(server_response.decode("utf-8")):
                        '''根据客户端反馈,服务器端是否存在相同的文件名'''
                        file_exist = int(self.client.recv(1024).decode("utf-8"))
                        if file_exist:
                            '''服务器端存在相应的文件'''
                            while True:
                                cover_flag = input("文件已存在,是否覆盖原文件(y/n):")
                                if cover_flag == "y":
                                    self.client.send("y".encode("utf-8"))
                                    break
                                elif cover_flag == "n":
                                    new_filename = input("请输入新的文件名>>:")
                                    self.client.send(("n "+new_filename).encode("utf-8"))
                                    break
                                else:
                                    print("您输入的指令有误,请重新输入!!!")
                                    continue
                        else:
                            self.client.send("新创建".encode("utf-8"))
    
                        '''上面准备工作完毕,开始传输文件'''
                        with open(filename,'rb') as f:
                            for line in f:
                                self.client.send(line)                                  #发送数据
                        '''客户端等待服务器端传来消息,告知上传成功'''
                        response = self.client.recv(1024)
                        print(response.decode("utf-8"))                                 #数据是否上传成功,告知用户
                    else:
                        print("服务器端不存在相应的指令!!!")
    
                else:
                    print("要上传的文件名不存在!")
    
    
            else:
                print("没有输入要上传的文件名!!!")
    
        def get(self,cmd):
            '''从服务器端下载数据'''
            cmd_list = cmd.split()                                                    #获取用户输入指令
            if len(cmd_list) > 1:                                                     #是由指令和文件名构成
                filename = cmd_list[1]
                msg_dic = {
                    "filename":filename,
                    "action":"get"
                }                                                                     #把指令封装成字典发送给服务器
                self.client.send(json.dumps(msg_dic).encode("utf-8"))                 #把指令以json形式传给服务器
                server_response = int(self.client.recv(1024).decode("utf-8"))         #接收服务端发挥的指令,判断是否支持此方法
                self.client.send("收到指令!".encode("utf-8"))
                if server_response:
                    file_exists = int(self.client.recv(1024).decode("utf-8"))         #下载文件存在与否标识符
                    self.client.send("收到标识符".encode("utf-8"))                     #告知服务器收到标识符,防止粘包
                    if file_exists:
                        '''文件存在,则准备接收数据,会接收服务器发送过来的文件大小'''
                        file_mess = json.loads(self.client.recv(3072).decode("utf-8"))
                        self.client.send("文件信息接收成功,开始进行文件接收!".encode("utf-8"))
                        filesize = file_mess["filesize"]
                        while True:
                            '''确定文件名'''
                            if os.path.isfile(filename):
                                '''说明客户端存在文件,就要让用户选择是否覆盖'''
                                choice_cover = input("文件名重复,是否覆盖现有文件(y/n)>>:")
                                if choice_cover == "y":
                                    filename = filename
                                    break                                       #覆盖文件之后退出循环
                                elif choice_cover == "n":
                                    filename = input("请输入新的文件名>>:")
                                    '''由于用户输入了新的用户名,我们不知道此文件是否重名,因此重新检测一下,确保不重名'''
                                    continue
                            else:
                                filename = filename
                                break                                           #得到文件名之后退出循环
                        recvive_size = 0
                        with open(filename,'wb') as file:
                            while recvive_size < filesize:
                                data = self.client.recv(1024)
                                file.write(data)
                                recvive_size += len(data)
                            print("数据下载完成!!!")
                            self.client.send("接收完毕".encode("utf-8"))
                    else:
                        print("要下载的文件不存在!!!")
    
                else:
                    print("服务器不支持此功能!!!")
    
            else:
                print("对不起,输入有误!")
                self.help()
    
    if __name__ == "__main__":
        try:
            client = Myclient()
            client.connect("localhost",9998)
            client.interactive()
        except KeyboardInterrupt as e:
            print("客户端断开!!!",e)

        上面客户端只实现了上传和下载功能,没有实现其他系统操作有关的功能,后续将逐步完善;

        服务器端:

    '''定义服务器端'''
    import socketserver,json,os
    
    class MyTcpServer(socketserver.BaseRequestHandler):
        '''定义服务器端,socketserver,继承的是BaseRequestHandler类'''
        def handle(self):
            '''服务器端所有的功能都在handle()里面进行处理,因此接收数据也是在handle()中,只是处理的时候,调用下面模块而已'''
            while True:
                data = self.request.recv(3072)
                if len(data) == 0:
                    print("客户端断开")
                    break
                msg_dic = json.loads(data.decode("utf-8"))            #服务器端接收指令
                cmd = msg_dic["action"]
                if hasattr(self,cmd):                                                    #判断服务器是否有相应的指令
                    self.request.send("1".encode("utf-8"))
                    self.request.recv(1024)
                    func = getattr(self,cmd)
                    func(msg_dic)
                else:
                    self.request.send("0".encode("utf-8"))
                    self.request.recv(1024)
    
        def put(self,msg_dic):
            '''定义上传的服务器代码'''
            filename = msg_dic['filename']
            filesize = msg_dic["filesize"]
            '''判断服务器端是否存在对应的文件名'''
            recvive_size = 0
            if os.path.isfile(filename):
                '''如果服务器存在相应的文件名,则询问客户端是否覆盖'''
                self.request.send("1".encode("utf-8"))                              #文件存在,循环客户端是否覆盖
                response = self.request.recv(1024).decode("utf-8")
                response = response.split()
                '''如果用户让覆盖则覆盖,否则重新创建'''
    
                if response[0] == "y":
                    '''覆盖'''
                    with open(filename,"wb") as f1:
                       while recvive_size < filesize:
                           data = self.request.recv(1024)
                           f1.write(data)
                           recvive_size += len(data)
                    self.request.send("文件接收成功!".encode("utf-8"))
    
                else:
                    '''不覆盖,新创建'''
                    new_filename = response[1]
                    with open(new_filename,'wb') as f:
                        while recvive_size < filesize:
                            data1 = self.request.recv(1024)
                            f.write(data1)
                            recvive_size += len(data1)
                    self.request.send("文件接收成功!".encode("utf-8"))
    
            else:
                '''如果服务器不存在相应文件名,则创建'''
                self.request.send("0".encode("utf-8"))
                self.request.recv(1024)
                with open(filename,'wb') as f2:
                    while recvive_size < filesize:
                        data1 = self.request.recv(1024)
                        f2.write(data1)
                        recvive_size += len(data1)
                self.request.send("文件接收成功!".encode("utf-8"))
    
        def get(self,msg_dict):
            '''基础交流结束,服务器支持文件下载功能,开始文件下载操作'''
            filename = msg_dict["filename"]
            if os.path.isfile(filename):
                self.request.send("1".encode("utf-8"))                             #文件存在告知客户端
                self.request.recv(1024)
                filesize = os.stat(filename).st_size
                '''首先告知客户端文件大小,让这边做好接收准备'''
                file_mess = {
                    "filesize":filesize,
                }
                self.request.send(json.dumps(file_mess).encode("utf-8"))           #以json格式发送给客户端
                self.request.recv(1024)                                            #防止粘包,客户端回应服务器接收完毕
                with open(filename,"rb") as f_obj:
                    for line in f_obj:
                        self.request.send(line)
                self.request.recv(1024)
    
            else:
                self.request.send("0".encode("utf-8"))                             #文件不存在,告知客户端
                self.request.recv(1024)
    
    if __name__ == "__main__":
        try:
            IP,PORT = "localhost",9998
            server = socketserver.ThreadingTCPServer((IP,PORT),MyTcpServer)              #定义socketserver实例
            server.serve_forever()
        except KeyboardInterrupt as e:
            print("关闭服务器")

        上面代码是服务器端,客户端与服务器端其实是相呼应的,两者实现数据的交换;其实就是收发数据,中间掺杂我们想要实现的功能。

        下面来看几个容易犯错的地方:

        1、BrokenPipeError: [Errno 32] Broken pipe

      客户端代码:

    import socket,os,json,sys
    
    
    class Myclient(object):
        '''定义客户端'''
        def __init__(self):
            '''定义socket()实例'''
            self.client = socket.socket()                                         #生成soket()实例
    
        def connect(self,ip,port):
            """定义连接"""
            self.client.connect((ip,port))
    
        def interactive(self):
            '''定义和用户交互'''
            while True:
                cmd = input("请输入指令>>:").strip()                              #用户输入指令
                if len(cmd) == 0:
                    print("指令不能为空!!!")
                    continue                                                      #指令不能为空
                cmd_str = cmd.split()[0]                                          #指令由两种形式
                if hasattr(self,cmd_str):                                         #判断指令是否存在
                    func = getattr(self,cmd_str)                                  #指令存在,则获取对应的方法
                    func(cmd)
                elif cmd_str == 'q':
                    break
                else:
                    self.help()
                    continue
    
    
        def help(self):
            msg = """
            ls
            pwd
            cd
            put   filename
            get   filename
            """
            print("指令名称",msg)
    
        def put(self,cmd):
            '''定义上传数据接口'''
            cmd_list = cmd.split()
            if len(cmd_list) > 1:
                '''指令是由指令名和文件名构成'''
                filename = cmd_list[1]                                              #获取文件名
                if os.path.isfile(filename):                                        #检测上传的文件名是否存在
                    '''文件名存在,则要告诉服务器端上传的文件名,文件大小,并检测服务器是否有相应的方法'''
                    filesize = os.stat(filename).st_size
                    msg_dic = {
                        "action":"put",
                        "filename":filename,
                        "filesize":filesize
                    }
                    '''转换为字节码的形式进行传输'''
                    self.client.send(json.dumps(msg_dic).encode("utf-8"))           #转换为json格式进行上传,便于服务器接收后处理
                    server_response = self.client.recv(1024)                        #等待服务器传回信息,防止粘包
                    self.client.send("收到了".encode("utf-8"))
                    if int(server_response.decode("utf-8")):
                        '''根据客户端反馈,服务器端是否存在相同的文件名'''
                        file_exist = int(self.client.recv(1024).decode("utf-8"))
                        if file_exist:
                            '''服务器端存在相应的文件'''
                            while True:
                                cover_flag = input("文件已存在,是否覆盖原文件(y/n):")
                                if cover_flag == "y":
                                    self.client.send("y".encode("utf-8"))
                                    break
                                elif cover_flag == "n":
                                    new_filename = input("请输入新的文件名>>:")
                                    self.client.send(("n "+new_filename).encode("utf-8"))
                                    break
                                else:
                                    print("您输入的指令有误,请重新输入!!!")
                                    continue
                        else:
                            self.client.send("新创建".encode("utf-8"))
    
                        '''上面准备工作完毕,开始传输文件'''
                        with open(filename,'rb') as f:
                            for line in f:
                                self.client.send(line)                                  #发送数据
                        '''客户端等待服务器端传来消息,告知上传成功'''
                        response = self.client.recv(1024)
                        print(response.decode("utf-8"))                                 #数据是否上传成功,告知用户
                    else:
                        print("服务器端不存在相应的指令!!!")
    
                else:
                    print("要上传的文件名不存在!")
    
    
            else:
                print("没有输入要上传的文件名!!!")
    
        def get(self,cmd):
            '''从服务器端下载数据'''
            cmd_list = cmd.split()                                                    #获取用户输入指令
            if len(cmd_list) > 1:                                                     #是由指令和文件名构成
                filename = cmd_list[1]
                msg_dic = {
                    "filename":filename,
                    "action":"get"
                }                                                                     #把指令封装成字典发送给服务器
                self.client.send(json.dumps(msg_dic).encode("utf-8"))                 #把指令以json形式传给服务器
                server_response = int(self.client.recv(1024).decode("utf-8"))         #接收服务端发挥的指令,判断是否支持此方法
                self.client.send("收到指令!".encode("utf-8"))
                if server_response:
                    file_exists = int(self.client.recv(1024).decode("utf-8"))         #下载文件存在与否标识符
                    self.client.send("收到标识符".encode("utf-8"))                     #告知服务器收到标识符,防止粘包
                    if file_exists:
                        '''文件存在,则准备接收数据,会接收服务器发送过来的文件大小'''
                        file_mess = json.loads(self.client.recv(3072).decode("utf-8"))
                        self.client.send("文件信息接收成功,开始进行文件接收!".encode("utf-8"))
                        filesize = file_mess["filesize"]
                        while True:
                            '''确定文件名'''
                            if os.path.isfile(filename):
                                '''说明客户端存在文件,就要让用户选择是否覆盖'''
                                choice_cover = input("文件名重复,是否覆盖现有文件(y/n)>>:")
                                if choice_cover == "y":
                                    filename = filename
                                    break                                       #覆盖文件之后退出循环
                                elif choice_cover == "n":
                                    filename = input("请输入新的文件名>>:")
                                    '''由于用户输入了新的用户名,我们不知道此文件是否重名,因此重新检测一下,确保不重名'''
                                    continue
                            else:
                                filename = filename
                                break                                           #得到文件名之后退出循环
                        recvive_size = 0
                        with open(filename,'wb') as file:
                            while recvive_size < filesize:
                                data = self.client.recv(1024)
                                file.write(data)
                                recvive_size += len(data)
                            print("数据下载完成!!!")
                            self.client.send("接收完毕".encode("utf-8"))
                    else:
                        print("要下载的文件不存在!!!")
    
                else:
                    print("服务器不支持此功能!!!")
    
            else:
                print("对不起,输入有误!")
                self.help()
    
    if __name__ == "__main__":
        try:
            client = Myclient()
            client.connect("localhost",9998)
            client.interactive()
        except KeyboardInterrupt as e:
            print("客户端断开!!!",e)

        服务器端:

    '''定义服务器端'''
    import socketserver,json,os
    
    class MyTcpServer(socketserver.BaseRequestHandler):
        '''定义服务器端,socketserver,继承的是BaseRequestHandler类'''
        def handle(self):
            '''服务器端所有的功能都在handle()里面进行处理,因此接收数据也是在handle()中,只是处理的时候,调用下面模块而已'''
            # while True:
            data = self.request.recv(3072)
            if len(data) == 0:
                print("客户端断开")
                    # break
            msg_dic = json.loads(data.decode("utf-8"))            #服务器端接收指令
            cmd = msg_dic["action"]
            if hasattr(self,cmd):                                                    #判断服务器是否有相应的指令
                self.request.send("1".encode("utf-8"))
                self.request.recv(1024)
                func = getattr(self,cmd)
                func(msg_dic)
            else:
                self.request.send("0".encode("utf-8"))
                self.request.recv(1024)
    
        def put(self,msg_dic):
            '''定义上传的服务器代码'''
            filename = msg_dic['filename']
            filesize = msg_dic["filesize"]
            '''判断服务器端是否存在对应的文件名'''
            recvive_size = 0
            if os.path.isfile(filename):
                '''如果服务器存在相应的文件名,则询问客户端是否覆盖'''
                self.request.send("1".encode("utf-8"))                              #文件存在,循环客户端是否覆盖
                response = self.request.recv(1024).decode("utf-8")
                response = response.split()
                '''如果用户让覆盖则覆盖,否则重新创建'''
    
                if response[0] == "y":
                    '''覆盖'''
                    with open(filename,"wb") as f1:
                       while recvive_size < filesize:
                           data = self.request.recv(1024)
                           f1.write(data)
                           recvive_size += len(data)
                    self.request.send("文件接收成功!".encode("utf-8"))
    
                else:
                    '''不覆盖,新创建'''
                    new_filename = response[1]
                    with open(new_filename,'wb') as f:
                        while recvive_size < filesize:
                            data1 = self.request.recv(1024)
                            f.write(data1)
                            recvive_size += len(data1)
                    self.request.send("文件接收成功!".encode("utf-8"))
    
            else:
                '''如果服务器不存在相应文件名,则创建'''
                self.request.send("0".encode("utf-8"))
                self.request.recv(1024)
                with open(filename,'wb') as f2:
                    while recvive_size < filesize:
                        data1 = self.request.recv(1024)
                        f2.write(data1)
                        recvive_size += len(data1)
                self.request.send("文件接收成功!".encode("utf-8"))
    
        def get(self,msg_dict):
            '''基础交流结束,服务器支持文件下载功能,开始文件下载操作'''
            filename = msg_dict["filename"]
            if os.path.isfile(filename):
                self.request.send("1".encode("utf-8"))                             #文件存在告知客户端
                self.request.recv(1024)
                filesize = os.stat(filename).st_size
                '''首先告知客户端文件大小,让这边做好接收准备'''
                file_mess = {
                    "filesize":filesize,
                }
                self.request.send(json.dumps(file_mess).encode("utf-8"))           #以json格式发送给客户端
                self.request.recv(1024)                                            #防止粘包,客户端回应服务器接收完毕
                with open(filename,"rb") as f_obj:
                    for line in f_obj:
                        self.request.send(line)
                self.request.recv(1024)
    
            else:
                self.request.send("0".encode("utf-8"))                             #文件不存在,告知客户端
                self.request.recv(1024)
    
    if __name__ == "__main__":
        try:
            IP,PORT = "localhost",9998
            server = socketserver.ThreadingTCPServer((IP,PORT),MyTcpServer)              #定义socketserver实例
            server.serve_forever()
        except KeyboardInterrupt as e:
            print("关闭服务器")

        上面代码是我遇到的坑,客户端没有变,只变了服务器端接收的代码,因为socketserver.serve_forever()持续的响应链接。结果客户端输入命令如下:

    请输入指令>>:gcx
    指令名称 
            ls
            pwd
            cd
            put   filename
            get   filename
            
    请输入指令>>:put gcx
    文件已存在,是否覆盖原文件(y/n):y
    文件接收成功!
    请输入指令>>:put gcx
    Traceback (most recent call last):
      File "/home/zhuzhu/day8作业/FTP/Ftpclient/ftp_client.py", line 154, in <module>
        client.interactive()
      File "/home/zhuzhu/day8作业/FTP/Ftpclient/ftp_client.py", line 24, in interactive
        func(cmd)
      File "/home/zhuzhu/day8作业/FTP/Ftpclient/ftp_client.py", line 59, in put
        self.client.send("收到了".encode("utf-8"))
    BrokenPipeError: [Errno 32] Broken pipe

        上面客户端执行结果可以看出,第一次执行没有问题,程序成功的接收到了服务器下载的数据,但是第二次操作的时候,开始报错,提示BrokenPipeError,这是什么错误呢?
      
    ThreadingHTTPServer 实现的 http 服务,如果客户端在服务器返回前,主动断开连接则服务器端会报 [Errno 32] Broken pipe 错,并导致处理线程 crash.

        上面说明,我们交互一次之后,服务器端已经断开了,不是说socketserver()的客户端一直处在活跃状态吗?是处在活跃状态没错,但是上一个链接其实已经断开了,这是socket的特性,如果没有程序接收数据,接收一次就会断开,因此要修改接收的代码,如下:

    class MyTcpServer(socketserver.BaseRequestHandler):
        '''定义服务器端,socketserver,继承的是BaseRequestHandler类'''
        def handle(self):
            '''服务器端所有的功能都在handle()里面进行处理,因此接收数据也是在handle()中,只是处理的时候,调用下面模块而已'''
            while True:
                data = self.request.recv(3072)
                if len(data) == 0:
                    print("客户端断开")
                    break
                msg_dic = json.loads(data.decode("utf-8"))            #服务器端接收指令
                cmd = msg_dic["action"]
                if hasattr(self,cmd):                                                    #判断服务器是否有相应的指令
                    self.request.send("1".encode("utf-8"))
                    self.request.recv(1024)
                    func = getattr(self,cmd)
                    func(msg_dic)
                else:
                    self.request.send("0".encode("utf-8"))
                    self.request.recv(1024)

        上面只需修改handle()中的代码,让服务器端能够持续不断的接收数据,如上面代码所示,加上一个while循环,让服务器能够不断接收此链接的信息,除非这个链接断开,否则是不会终端这个链接与服务端的交互,socketserver()实现的功能时多个客户端与服务端能够同时进行交互,使其相互之间不受影响,本质上单个客户端与服务器之间的交互还是基础的socket实现的,如果不持续的接收,那么交互一次就会断开。

        上面的交互如下所示:

    请输入指令>>:put gcx
    文件已存在,是否覆盖原文件(y/n):y
    文件接收成功!
    请输入指令>>:put zmz
    文件已存在,是否覆盖原文件(y/n):y
    文件接收成功!
    请输入指令>>:put gcx
    文件已存在,是否覆盖原文件(y/n):y
    文件接收成功!
    请输入指令>>:客户端断开!!! 

        从上面代码可以看出,我们实现了持续的数据交换情况,没有发生太大的问题。

        2、反射的时候,反射是判断类中是否具有某种方法,hasattr(),getattr()是最常使用的方法;

        3、while a < b:

          with open(filename) as f:

            for line in f

        与

      wiht open(filename) as f:

        while a < b:

          for line in f

        上面两种写法是不一样的,为什么说呢,第一种方法,当文件遍历玩的时候,不管条件成立与否,文件都是要关闭的,这是因为with打开文件具有自动关闭文件的特性,当文件遍历完成之后,就会自动关闭文件。

      建议使用第二种方式,第二种方式就会杜绝这种情况,让程序能够即完成比较,由遍历完成文件。

        4、socketserver与socket的区别,其实两者本质都是一样的,原则上都是交互一次结束,只是socketserver封装了很多方法,能够实现不相互干扰下的交互;

        5、文件传输,要告知文件大小,方便接收,json的使用,序列化,让彼此接受的时候,容易得到之前存储的结果;

        6、规范化封装;   

  • 相关阅读:
    sql 数据库 初级 个人学习总结(一)
    parentViewController
    关于iOS9之后的loadViewIfNeeded
    判断版本号
    MagicalRecord(简化CoreData操作)
    coreData
    PureLayout(轻量级自动布局)
    MJRefresh(上拉加载下拉刷新)
    MJExtension(JSON到数据模型的自动转换)
    BaceModel
  • 原文地址:https://www.cnblogs.com/gengcx/p/7420714.html
Copyright © 2020-2023  润新知