精华内容
下载资源
问答
  • 简单学习了TCP通信,想实现一个本地服务器上传文件的程序。由于现在还没有服务器,就用本地服务器自娱自乐一下子。 服务端 public class Server { public static void main(String[] args) throws IOException ...

    简单学习了TCP通信,想实现一个本地向服务器上传文件的程序。由于现在还没有服务器,就用本地当服务器自娱自乐一下子。

    服务端

    public class Server {
        public static void main(String[] args) throws IOException {
            ServerSocket server = new ServerSocket(8888);
            while (true) {
                Socket socket = server.accept();
                new Thread(new Runnable() {
                    @Override
                    public void run() {
                        try {
                            InputStream is = socket.getInputStream();
                            BufferedReader br = new BufferedReader(new InputStreamReader(is));
                            PrintStream ps = new PrintStream(socket.getOutputStream());
                            String fileName = br.readLine();                                                        //获取客户端传来的文件名
                            File dir = new File("packet");                                                //在服务端创建一个接受客户端文件的文件夹
                            dir.mkdir();    
                            File file = new File(dir, fileName);
                            if (file.exists()) {                                                                   //判断该文件是否存在
                                ps.println("exist");                                                               
                                socket.close();
                                return;
                            }else{
                                ps.println("no exist");
                            }
                            BufferedOutputStream bos = new BufferedOutputStream(new FileOutputStream(file));       //讲客户端的文件写入服务端的本地
                            int b;
                            while ((b = is.read())!=-1)
                                bos.write(b);
                            bos.close();
                            socket.close();
                        } catch (IOException e) {
                            e.printStackTrace();
                        }
                    }
                }).start();
            }
        }
    }
    

    客户端

    public class Client {
        public static void main(String[] args) throws IOException {
            File file = getFile();                                                                     //获取文件
            Socket socket = new Socket("127.0.0.1", 8888);
            BufferedReader br = new BufferedReader(new InputStreamReader(socket.getInputStream()));
            PrintStream ps = new PrintStream(socket.getOutputStream());
            ps.println(file.getName());                                                                //把文件名发送给服务端
            String result = br.readLine();
            if ("exist".equals(result)) {                                                              //接受服务端传来的是否存在信息
                System.out.println("服务器存在该文件,不要重复上传");
                socket.close();
                return;
            }
            BufferedInputStream bis = new BufferedInputStream(new FileInputStream(file));              //将文件写入服务端
            int b;
            while ((b = bis.read())!=-1)
                ps.write(b);
            bis.close();
            socket.close();
        }
    
        private static File getFile() {
            Scanner cin = new Scanner(System.in);
            System.out.println("请输入一个文件路径:");
            while (true) {
                String line = cin.nextLine();
                File file = new File(line);
                if (!file.exists())
                    System.out.println("文件路径不存在,请重新录入");
                else if (file.isDirectory())
                    System.out.println("录入的是文件夹路径,请输入文件路径");
                else
                    return file;
            }
        }
    }
    
    展开全文
  • (可将当前TomCat文件复制一份,将复制的那份更改xml文件相当于外服务器) 建立一个jsp文件: <a href="${pageContext.request.contextPath }/UpFile.jsp">上传图片</a> 建立Upfile.jsp:body内容...

    当前项目地址localhost:8080/qvod
    文件上传地址localhost:9090/img
    (可将当前TomCat文件复制一份,将复制的那份更改xml文件相当于外服务器)

    建立一个jsp文件:
    <a href="${pageContext.request.contextPath }/UpFile.jsp">上传图片</a>
    
    建立Upfile.jsp:body内容如下
    <form action="${pageContext.request.contextPath }/fileUpServlet2" 
    method="post" enctype="multipart/form-data">
    		<input type="text" name="mytext"> <br>
    		<input type="file" name="headPicure"> <br>
    		<input type="submit">
    	</form>
    

    注意:因为是上传文件,enctype一定要修改为multipart/form-data 提交方式也要更改为post

    之后建立名字为fileUpServlet2的Servlet

    重写doGet方法:

    	DiskFileItemFactory dfif = new DiskFileItemFactory();
    	ServletFileUpload sfu = new ServletFileUpload(dfif);
    	try {
    		List<FileItem> items = sfu.parseRequest(request);
    		for (FileItem item:items) {
    			if (item.isFormField()) {
    				System.out.println(item.getFieldName()+"========"+item.getString("UTF-8"));
    			}
    			else {
    				String uuid = UUID.randomUUID().toString();
    				String imgPath =(String) this.getServletContext().getAttribute("imgBasicPath");
    				String imgName = item.getName();
    				if (item.getSize()>0) {
    					String savePath = imgPath+"/"+uuid+imgName;
    					Client c = Client.create();
    					WebResource res = c.resource(savePath);
    					res.put(item.getInputStream());
    				}
    			}
    		}
    	} catch (FileUploadException e) {
    		// TODO Auto-generated catch block
    		e.printStackTrace();
    	}
    }`
    

    需要注意的是:因为之前文件的解码类型是multipart/form-data与默认的提交类型不一样,因此正常的reuqest.getparameter()等方法就不能取到结果,文件上传需要专门使用文件上传类也就是DiskFileItemFactory 和ServletFileUpload

    运行前两个虚拟主机确保开启状态,运行结果如下:
    在这里插入图片描述
    在这里插入图片描述

    展开全文
  • 建立两个py文件,分别打开两个cmd界面,即可进行通信。服务器端运用多进程,连续不断的处理从客户端接收到的数据;客户端通过一个list不断给客户端发送数据。 (每个连接都必须创建新线程(或进程)来处理,否则,...

    建立两个py文件,分别打开两个cmd界面,即可进行通信。服务器端运用多进程,连续不断的处理从客户端接收到的数据;客户端通过一个list不断给客户端发送数据。

    (每个连接都必须创建新线程(或进程)来处理,否则,单线程在处理连接的过程中,无法接受其他客户端的连接。)本例中,多进程其实没有起到作用。

    代码以及解释如下:

    # 服务器端
    # 1 创建套接字,绑定套接字到当地地址,然后开始监听连接。就是socket,bind,listen。 # 2 进入循环,不断接受客户端的连接请求,然后接收传来的数据,当然也可以发送给对方数据。就是accept一个连接,然后recv数据。 # 3 接收完毕可以关闭套接字,close。 # 这个过程的伪代码如下:
    ss=socket()    #创建服务器套接字
    ss.bind() #把本地地址绑到套接字上
    ss.listen() #监听连接
    inf_loop: #服务器无限循环
    cs=ss.accept() #接受客户端的连接
    comm._loop: #通信循环
    cs.recv()/cs.send() #对话
    cs.close() #关闭客户套接字
    ss.close() #关闭服务器套接字

      

    #客户端
    #   1 创建套接字,然后连接远端地址,socket ,connect。
    #  2 建立连接之后开始发送数据。Send(data),当然可以从缓冲区读取服务器发来的数据。Recv(BUFF)
    #   3 完毕后,关闭套接字。Close
    #   伪代码如下:
    cs=socket()       #创建客户套接字
    cs.connect()       #尝试连接服务器
    comm._loop:     #通信循环
    cs.send()/cs.recv()  #对话
    cs.close()          #关闭套接字

     

     

    #socket服务器端程序
    import socket
    import time
    from multiprocessing import Process         #多进程和多线程一样的用法
    
    def tcplink(sock1,addr1):                   #新建一个函数,用来接收客户端发来的信息
        print('Accept new connection......')
        sock1.send(b'welcom')                   #若连接建立成果,服务器给客户端发送一个welcome
        while 1:                                #服务器持续接收客户端发送过来的数据,直到服务器收到exit时,退出不在接收数据
            data = sock1.recv(1024)             #接收数据
            time.sleep(1)                       #延时1s
    
            '''data为客户端发送给服务器的数据,服务器给客户端发送hello,%data ,全部转为utf-8编码'''
            sock1.send(('hello,%s'%data.decode('utf-8')).encode('utf-8'))
    
            if not data or data.decode('utf-8') == 'exit':
                break
    
        sock1.close()                           #连接关闭
        print('connection form %s is close....'%addr1)
    
    if __name__ == "__main__":
        s = socket.socket(socket.AF_INET, socket.SOCK_STREAM)           #建立一个套接字
        '''监听端口127.0.0.1表示客户端和服务器必须都为本机才能运行。
        我们要绑定监听的地址和端口。服务器可能有多块网卡,可以绑定到
        某一块网卡的IP地址上,也可以用0.0.0.0绑定到所有的网络地址,还
        可以用127.0.0.1绑定到本机地址。127.0.0.1是一个特殊的IP地址,表
        示本机地址,如果绑定到这个地址,客户端必须同时在本机运行才能连接
        ,也就是说,外部的计算机无法连接进来。端口号需要预先指定。因为我
        们写的这个服务不是标准服务,所以用9999这个端口号。请注意,小于1024
        的端口号必须要有管理员权限才能绑定:'''
        s.bind(('127.0.0.1', 9999))            #绑定端口
    
        s.listen(1)                                     #同时接收连接的最大数量
        print('Waiting for connecting......')
    
        while 1:                                        #服务器通过一个循环来一直接收来之客户端发送的信息
            sock,addr = s.accept()                      #s.accept返回两个数据
            t = Process(target=tcplink,args=(sock,addr))    #多线程
            t.start()                                       #开启多线程

    #socket客户端程序
    #同chenhang001.py
    import socket
    
    s = socket.socket(socket.AF_INET,socket.SOCK_STREAM)        #新建一个套接字
    s.connect(('127.0.0.1',9999))                               #建立连接,为什么是双括号
    
    print(s.recv(1024).decode('utf-8'))                         #打印接收到的数据
    
    #发送数据,定义一个list,
    for data111 in [b'chenhang',b'wangyadan',b'wuhankejidaxue',b'wuchangfenxiao']:
        s.send(data111)
        print(s.recv(1024).decode('utf-8'))
    # for a in range(100):
    #     s.send(b(a))
    
    s.send(b'exit')             #发送exit字符,服务器退出接收数据

     

    转载于:https://www.cnblogs.com/hanggegege/p/5745033.html

    展开全文
  • 客户端可以从文件库中下载文件本地。 客户端可以上传一个本地文件文件库。 使用print在客户端打印命令输入提示,引导操作 服务端 # 导入相关模块 from socket import * from multiprocessing import Process ...
  • 客户端可以查看服务器文件库中有什么文件。 客户端可以从文件库中下载文件本地。 客户端可以上传一个本地文件文件库。 使用print在客户端打印命令输入提示,引导操作 服务端 # 导入相关模块 from socket import...

    分为服务端和客户端,要求可以有多个客户端同时操作。
    客户端可以查看服务器文件库中有什么文件。
    客户端可以从文件库中下载文件到本地。
    客户端可以上传一个本地文件到文件库。
    使用print在客户端打印命令输入提示,引导操作

    服务端

    # 导入相关模块
    from socket import *
    from multiprocessing import Process
    import signal, os, time
    
    # 绑定IP地址
    IP = "127.0.0.1"
    # 绑定端口
    PORT = 8888
    ADDR = (IP, PORT)
    # 绑定服务器的指定目录
    DIR = "/home/max/ftp"
    
    
    # 处理查看文件请求
    def browse(c):
        # 列表方式查看文件
        list = os.listdir("%s" % DIR)
        # 按通信协议格式组织数据
        msg = "B  " + ";".join(list)
        # 发送到客户端
        c.send(msg.encode())
    
    
    # 处理客户端下载文件请求
    def download(c, file):
        # 判断文件是否存在且是否是文件
        if file in os.listdir(DIR) and os.path.isfile("%s/%s" % (DIR, file)):
            # 打开文件
            f = open("%s/%s" % (DIR, file), "rb")
            # 发送下载代码,告知客户端进入"D"
            c.send(("D %s " % file).encode())
            # 等待客户端先进入"D"模式下的recv阻塞函数
            time.sleep(0.1)
            # 循环发送文件
            while True:
                data = f.read(1000)
                if not data:
                    # 设置间隔,等待文件传输完整
                    time.sleep(0.1)
                    # 约定的信息让客户端退出接收循环
                    c.send(b"finished")
                    break
                c.send(data)
            f.close()
        # 否则按协议格式发送错误代码
        else:
            c.send(b"D fileerror ")
    
    
    # 处理客户端上传文件请求
    def upload(c, file):
        # 创建文件
        f = open("%s/%s" % (DIR, file), "wb")
        # 循环接收文件
        while True:
            data = c.recv(1024)
            # 收到约定的信息退出循环
            if data == b"finished":
                break
            f.write(data)
        f.close()
    
    
    # 处理客户端退出请求
    def login_out(c):
        # 按协议格式组织信息
        msg = "O closed "
        # 发给客户端的recv_msg进程
        c.send(msg.encode())
    
    
    def deal(c):
        # 发送代码告知客户端连接成功
        c.send(b"K  ")
        while True:
            # 循环接收客户端请求,约定通信协议为"* ** ****"格式
            msg = c.recv(1024)
            # 如果客户端崩了,解除该子进程
            if not msg:
                break
            # 解析请求
            req = msg.decode().split(" ", 2)
            # 处理查看文件请求,跳入browse函数
            if req[0] == "B":
                browse(c)
            # 处理客户端下载文件请求,跳入download函数
            elif req[0] == "D":
                download(c, req[1])
            # 处理客户端上传文件请求,跳入upload函数
            elif req[0] == "U":
                upload(c, req[1])
            # 处理客户端退出请求,跳入login_out函数
            elif req[0] == "O":
                login_out(c)
                # 跳出循环,结束子进程
                break
    
    
    # 主程序,父进程用于接收客户端请求并循环创建子进程,子程序处理请求
    def main():
    	# 创建tcp套接字
    	s = socket()
    	# 绑定服务器地址
    	s.bind(ADDR)
    	# 设置监听套接字
    	s.listen()
    	# 处理僵尸进程
    	signal.signal(signal.SIGCHLD, signal.SIG_IGN)
        while True:
            # 连接客户端
            c, addr = s.accept()
            # 创建子进程,用以处理客户端请求,跳入deal函数
            p = Process(target=deal, args=(c,))
            # 子程序开始执行
            p.start()
    
    
    if __name__ == '__main__':
        main()
    

    客户端

    # 导入相关模块
    from socket import *
    import os, sys, time
    
    # 绑定服务端IP地址
    IP = "127.0.0.1"
    # 绑定服务端端口
    PORT = 8888
    ADDR = (IP, PORT)
    
    
    # 收到约定的信息退出循环
    # 发送消息进程
    def send_msg(s):
        # 等待接收进程先运行到"K"分支
        time.sleep(0.1)
        while True:
            try:
                # 输入指令
                data = input(">>>")
            except:
                # 客户端错误,向服务端发送O
                data = "O"
            if data == "B":  # 查看目录
                msg = "B  "
                s.send(msg.encode())
            elif data == "D":  # 下载文件
                # 输入想要下载的文件
                want = input("download ? file:")
                msg = "D %s " % want
                s.send(msg.encode())
            elif data == "U":  # 上传文件
                file = input("upload ? file:")
                # 判断文件是否在客户端文件所在的目录且是文件
                if file in os.listdir(os.getcwd()) and os.path.isfile("%s/%s" % (os.getcwd(), file)):
                    msg = "U %s " % file
                    s.send(msg.encode())
                    f = open("%s" % file, "rb")
                    # 等待服务端进入upload的recv阻塞函数
                    time.sleep(0.1)
                    while True:
                        data = f.read(1000)
                        if not data:
                            # 设置间隔,等待文件传输完整
                            time.sleep(0.1)
                            # 约定的信息让客户端退出接收循环
                            s.send(b"finished")
                            break
                        s.send(data)
                    f.close()
                    print("upload succussfully")
                # 否则按协议格式显示错误代码
                else:
                    print("file not exist\ninput BDUO to forward\n", end="")
            elif data == "O":  # 断开连接
                msg = "O  "
                s.send(msg.encode())
                sys.exit()
            # 指令错误
            else:
                print("input error")
    
    
    # 接收消息进程
    def recv_msg(s):
        while True:
            data = s.recv(1024)
            # 解析数据
            msg = data.decode().split(" ", 2)
            if msg[0] == "K":  # 登录成功反馈
                print(
                    "login in successfully\ninput B to browse,D to download,U to upload,O to login out")
            elif msg[0] == "B":  # 查看目录反馈
                # 如果文件库不为空
                if msg[2]:
                    print("files:", msg[2], "\n>>>", end="")
                else:
                    print("files: no files", "\n>>>", end="")
            elif msg[0] == "D":
                # 服务端文件不存在
                if msg[1] == "fileerror":
                    print("file not exist\ninput BDUO to forward\n>>>", end="")
                    continue
                # 服务端文件存在
                else:
                    f = open("%s" % msg[1], "wb")
                    while True:
                        data = s.recv(1024)
                        # 收到约定的信息退出循环
                        if data == b"finished":
                            break
                        f.write(data)
                    f.close()
                    print("download successfully\n>>>", end="")
            elif msg[0] == "O":  # 收到来自发送消息进程发送到服务端的断开请求
                # 进程退出并打印提示
                sys.exit("login out successfully")
    
    
    # 主程序
    def main():
        # 创建tcp套接字
        s = socket()
        # 连接服务端
        s.connect(ADDR)
        # 创建多进程,子进程用于发送消息,父进程用于接收消息
        pid = os.fork()
        if pid < 0:
            print("system error")
        # 子进程
        elif pid == 0:
            send_msg(s)
        # 父进程
        else:
            recv_msg(s)
    
    
    if __name__ == '__main__':
        main()
    
    展开全文
  • 客户端可以查看服务器文件库中有什么文件。客户端可以从文件库中下载文件本地。客户端可以上传一个本地文件文件库。使用print在客户端打印命令输入提示,引导操作服务端# 导入相关模块from socket import *from ...
  • 本文实例为大家分享了java客户端向服务器上传文件的具体代码...客户端读取服务器发送的数据文件上传步骤:客户端使用本地字节输入流,指定上传数据的数据源。客户端使用网络字节输出流,把读取的本地文件上传到服务...
  • 利用json-server快速搭建本地服务器模拟后台数据的请求。 1.首先你的电脑中需要安装nodejs,建议使用最新版本,并且利用vue-cli初始化好项目,然后安装json server npm install json-server --save 2.提供json...
  • //上传到本地,模拟上传到fastdfs文件服务器 String filePath= "E:\\fastdfs\\"; String path = filePath + filename; //文件存储路径 File dest = new File(path); if (!dest.getParentFile().exists()){ dest....
  • 微信小程序系列之使用缓存在本地模拟服务器数据库现在将data.js这个文件视作是本地数据库的初始化数据,要做的第一件事就是讲这些初始化数据装进缓存中,以形成数据库的初始化数据整个应用程序的生命周期,类比一下...
  • 本地模拟服务器CDN(静态HTML,CSS,JS)开发 所谓本地开发环境就是和线上cdn(a.longencdn.cn)一样的目录结构和功能,提供了一个本地镜像,开发者直接在本地镜像的对应目录中作开发即可,包括一些html静态文件,css...
  • * 模拟下载本地Excel文件 * @param response * @throws IOException */ @GetMapping("/downloadLocal") public void downloadFromLocalFile(HttpServletResponse response) throws IOException { response....
  • 先是用ngrok内网穿透把本地 ip映射到外网域名上,访问域名就是访问本地的项目。后来发现不支持https。。(我是没弄通,感觉应该可以, 还是不死心)。 换个思路,本地ip映射,cmd 到C:\Windows\System32\...
  • 此插件可在本地计算机上模拟和,以加快开发周期。 为此,它将启动一个HTTP服务器,该服务器像APIG一样处理请求的生命周期,并调用您的处理程序。 特征: , ,λ运行时间。 速度模板支持。 延迟加载处理程序...
  • java复习第9天---9.2---网络编程---综合案例-模拟文件上传和模拟BS服务器 目录 文章目录1、模拟文件上传1.1、实现原理1.2、客户端代码1.3、服务端代码1.4、代码阻塞1.5、代码优化2、模拟B/S服务器案例2.1、B/S通信...
  • 为什么需要在自己的电脑安装本地测试服务器呢...原因如下当你用浏览器来测试你写出来的代码文件的时候,可能会出现这两种问题 所以,还是让你的电脑既充当客户端(浏览器),又暂且模拟一下服务器吧。那么如何让你的...
  • a.php 上传本地文件服务器 <?php //php使用curl模拟form表单提交数据 /* * $post_data 提交的数据数组 * //要上传的本地文件地址"@F:/xampp/php/php.ini"上传时候,上传路径前面要有@符号 * eg. $furl =...
  • Android客服端可以用过模拟HTTP的Post方式提交表单的方式来上传本地图片到服务器端。  为了模拟Http提交表单,我们可以先来看看通过网页提交表单来请求服务器时,客户端提交了什么数据给服务端的(HTTP Header中都...
  • 环境:win10 64位 工具:Eclipse IDE 客户端代码: package net.csdn;...import java.io.FileInputStream;...文件上传案例的客户端:读取本地文件,上传到服务器,读取服务器回写的数据 明确: 数据源:.
  • 先来了解一下客户端与服务器Tcp通信的基本步骤:  服务器端先启动,然后启动客户端向服务器端发送数据。 服务器端收到客户端发送的数据,...2.客户端使用网络字节输出流,把读取的本地文件上传到服务器。 3...
  • 下载之后打开readme.md阅读文档 # mock自动化配置 ## 安装必要的配置 ...npm express body-parse connect-multiparty --save-dev ...配置之后会自动创建文件,之后根据mock语法 去修改data下的数据即可
  • 1.背景 ...Linux服务器环境,利用Xshell模拟终端连接Linux服务器实现在windows下远程控制终端。通过sublime text中的sftp插件实现同步本地 文件服务器中。 2.开发工具 sublime text ,Xshell, VMware
  • 从远程服务器拷贝文件/目录到本地服务器 scp命令作用 scp命令作用:主要是两台服务器上之间传输文件 使用到的环境 为了模拟两台服务器,我先安装了两个linux系统,分别安装CentOS7 下文中使用环境是基于linux安装...
  • 本地http服务器 页面实时刷新 可以模拟ajax请求 第一步,新建package.json文件。用到了gulp、gulp-webserver、gulp-livereload package.json的内容如下: { "name": "localserver", "version": "1....
  • 当使用谷歌浏览器访问我们本地的json文件时,如果没有安装Apache等本地服务器,直接访问时json文件时,浏览器会报错,提示跨域相关的问题:Cross origin requests are only supported for protocol schemes: http, ...
  • 在开发环境中本地运行时,您需要以某种方式向应用程序提供这些服务:您可以依赖远程部署,在本地启动服务或模拟它们。 mock-server是一个命令行工具,可以帮助您采用第三种方法,使您可以轻松地创建并运行模拟HTTP...
  • 本文是制作一个简单的模拟web服务器模拟练习浏览器和服务器之间的数据传输,输入本地的iP地址和端口就可以返回本地指定的文件了。 编写完成之后直接打开谷歌浏览器,输入127.0.0.1:1314既可以看效果import socket...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 728
精华内容 291
关键字:

本地模拟文件服务器