精华内容
下载资源
问答
  • Socket实现文件传输

    万次阅读 多人点赞 2018-07-25 17:46:03
    Socket实现文件传输 1.客户端 通过new Socket("ip",port)连接服务端 创建文件输入流读取文件 创建返回套接字的输出流 写入文章名称,长度等属性 读取、写入文章操作 关闭流 package com.company;...

    Socket实现文件传输

    1.客户端

    通过new Socket("ip",port)连接服务端

    创建文件输入流读取文件

    创建返回套接字的输出流

    写入文章名称,长度等属性

    读取、写入文章操作

    关闭流

    package com.company;
    
    import javax.xml.crypto.Data;
    import java.io.*;
    import java.net.Socket;
    
    //客户端
    public class Client extends Socket{
    	private  final String SERVER_IP="192.168.201.104";
    	private final int SERVER_PORT=8999;
    	private Socket client;
    	private FileInputStream fis;
    	private DataOutputStream dos;
    
    	//创建客户端,并指定接收的服务端IP和端口号
    	public Client() throws IOException{
    		this.client=new Socket(SERVER_IP,SERVER_PORT);
    		System.out.println("成功连接服务端..."+SERVER_IP);
    	}
    
    	//向服务端传输文件
    	public void sendFile(String url) throws IOException {
    		File file=new File(url);
    		try {
    			 fis = new FileInputStream(file);
    			//BufferedInputStream bi=new BufferedInputStream(new InputStreamReader(new FileInputStream(file),"GBK"));
    			dos = new DataOutputStream(client.getOutputStream());//client.getOutputStream()返回此套接字的输出流
    			//文件名、大小等属性
    			dos.writeUTF(file.getName());
    			dos.flush();
    			dos.writeLong(file.length());
    			dos.flush();
    			// 开始传输文件
    			System.out.println("======== 开始传输文件 ========");
    			byte[] bytes = new byte[1024];
    			int length = 0;
    			
    			while ((length = fis.read(bytes, 0, bytes.length)) != -1) {
    				dos.write(bytes, 0, length);
    				dos.flush();
    			}
    			System.out.println("======== 文件传输成功 ========");
    		}catch(IOException e){
    			e.printStackTrace();
    			System.out.println("客户端文件传输异常");
    		}finally{
    			fis.close();
    			dos.close();
    		}
    	}
    	public static void main(String[] args) {
    		try {
    			Client client = new Client(); // 启动客户端连接
    			client.sendFile("E:/dxn/aaa.txt"); // 传输文件
    		} catch (Exception e) {
    			e.printStackTrace();
    		}
    	}
    }
    
    

    2服务端

    启动服务端new ServerSocket(port)

    接收连接服务端的客户端对象

    创建返回套接字的输入流

    创建文件输出流写出文件

    读取文章名称,长度等属性

    读取、写入文章操作

    关闭流

    package com.company;
    
    import java.io.*;
    import java.net.ServerSocket;
    import java.net.Socket;
    
    public class FileServer extends ServerSocket{
    
            private static final int SERVER_PORT = 8999; // 服务端端口
            private ServerSocket server;
            private Socket socket;
            private DataInputStream dis;
            private FileOutputStream fos;
    
            public FileServer() throws Exception {
                server=new ServerSocket(SERVER_PORT);
            }
    
            public void task() throws IOException{
                System.out.println("======== 等待连接 ========");
                Socket socket = server.accept();
                System.out.println(" Ip:"+socket.getInetAddress()+"已连接");
                try {
                    dis = new DataInputStream(socket.getInputStream());
                    // 文件名和长度
                    String fileName = dis.readUTF();
                    long fileLength = dis.readLong();
                    File directory = new File("E:/a");
                    if(!directory.exists()) {
                        directory.mkdir();
                    }
                    File file = new File(directory.getAbsolutePath() + File.separatorChar + fileName);
    
                    fos = new FileOutputStream(file);
                    System.out.println("file。。。。。。。。。。。。。。"+file);
                    System.out.println("fileName。。。。。。。。。。。。。。"+fileName);
    
                    System.out.println("======== 开始接收文件 ========");
                    byte[] bytes = new byte[1024];
                    int length = 0;
                    while((length = dis.read(bytes, 0, bytes.length)) != -1) {
                        fos.write(bytes, 0, length);
                        fos.flush();
                    }
    
                    System.out.println("======== 文件接收成功 ========");
                    } catch (Exception e) {
                        e.printStackTrace();
                    } finally {
                        try {
                            if(fos != null)
                                fos.close();
                            if(dis != null)
                                dis.close();
                            socket.close();
                        } catch (IOException e) {
                            e.printStackTrace();
                        }
                    }
                }
    
            public static void main(String[] args) {
                try {
                    FileServer server = new FileServer(); // 启动服务端
                    server.task();
                } catch (Exception e) {
                    e.printStackTrace();
                }
            }
        }
    
    

    3. 每接收到一个Socket就建立一个新的线程来处理它

    package com.company;
    
    
    import java.io.DataInputStream;
    import java.io.File;
    import java.io.FileOutputStream;
    import java.net.ServerSocket;
    import java.net.Socket;
    
    public class Server extends ServerSocket {
    
    	private static final int SERVER_PORT = 8999; // 服务端端口
    
    	private ServerSocket server;
    
    	public Server() throws Exception {
    		server=new ServerSocket(SERVER_PORT);
    	}
    
    	/**
    	 * 使用线程处理每个客户端传输的文件
    	 * @throws Exception
    	 */
    	public void load() throws Exception {
    		while (true) {
    			System.out.println("-----------等待连接-------- ");
    			Socket socket = server.accept();//接收连接服务端的客户端对象
    			System.out.println("ip" + socket.getInetAddress() + "已连接");
    			new Thread(new Transfer(socket),"thread1").start();// 每接收到一个Socket就建立一个新的线程来处理它
    			System.out.println(Thread.currentThread().getName());
    		}
    	}
    
    	/**
    	 * 处理客户端传输过来的文件线程类
    	 */
    	class Transfer implements Runnable {
    
    		private Socket socket;
    		private DataInputStream dis;
    		private FileOutputStream fos;
    
    		public Transfer(Socket socket) {
    			this.socket = socket;
    		}
    
    		@Override
    		public void run() {
    			try {
    				dis = new DataInputStream(socket.getInputStream());
    
    				// 文件名和长度
    				String fileName = dis.readUTF();
    				long fileLength = dis.readLong();
    				File directory = new File("E:/xn");
    				if(!directory.exists()) {
    					directory.mkdir();
    				}
    				File file = new File(directory.getAbsolutePath() + File.separatorChar + fileName);
    				System.out.println("file"+file);
    				fos = new FileOutputStream(file);
    
    				// 开始接收文件
    				byte[] bytes = new byte[1024];
    				int length = 0;
    				while((length = dis.read(bytes, 0, bytes.length)) != -1) {
    					fos.write(bytes, 0, length);
    					fos.flush();
    				}
    				System.out.println("======== 文件接收成功 [File Name:" + fileName + "] ");
    			} catch (Exception e) {
    				e.printStackTrace();
    			} finally {
    				try {
    					if(fos != null)
    						fos.close();
    					if(dis != null)
    						dis.close();
    
    				} catch (Exception e) {
    					e.printStackTrace();
    				}
    			}
    		}
    	}
    	public static void main(String[] args) {
    		try {
    			Server server = new Server(); // 启动服务端
    			server.load();
    		} catch (Exception e) {
    			e.printStackTrace();
    		}
    	}
    }
    
    
    

     4.DataInputStream:数据输入流     读取基本 Java 数据类型

    DataOutputStream:数据输出流      写出基本 Java 数据类型

     

     

    展开全文
  • 编写TCP socket实现文件传输,文件(Linux GCC源码,Windows VC++源码) 适合网络新手学习的源代码
  • socket实现文件传输

    2014-08-05 08:44:59
    socket实现文件传输在MFC中实现客户端和服务器的连接,相互通信。
  • Java Socket实现文件传输

    万次阅读 多人点赞 2016-09-01 17:00:26
    A:1核2GB1M服务器年86元 B:1核2GB1M服务器三年229元 C:2核4GB3M服务器三年799元(强烈推荐) D:2核8GB5M服务器三年1399元 ...最近学Socket学上瘾了,就写了一个简单的文件传输程序。 客户端设计思路:客户...

    阿里云双11服务器优惠(年度最佳优惠):
    A:1核2GB 1M 服务器年84元
    B:1核2GB 1M 服务器三年254元
    C:2核4GB 3M 服务器三年664元(强烈推荐)
    D:4核8GB 5M 服务器三年3001元
    以上均需新人才可以参加,同时还有企业专享服务器年2575元。
    活动地址:https://tb.am/6jbfl

     

    最近学Socket学上瘾了,就写了一个简单的文件传输程序。

    客户端设计思路:客户端与服务端建立连接,选择客户端本地文件,先将文件名及大小等属性发送给服务端,再将文件通过流的方式传输给服务端。传输的进度打印到控制台中,直到传输完成。

    服务端设计思路:服务端接收客户端的请求(阻塞式),每接收到一个客户端请求连接后,就新开一个处理文件的线程,开始写入流,将文件到服务器的指定目录下,并与传输过来的文件同名。
    下面是客户端和服务端的代码实现:

     

    客户端代码:

     

    import java.io.DataOutputStream;
    import java.io.File;
    import java.io.FileInputStream;
    import java.net.Socket;
    
    /**
     * 文件传输Client端<br>
     * 功能说明:
     *
     * @author 大智若愚的小懂
     * @Date 2016年09月01日
     * @version 1.0
     */
    public class FileTransferClient extends Socket {
    
        private static final String SERVER_IP = "127.0.0.1"; // 服务端IP
        private static final int SERVER_PORT = 8899; // 服务端端口
    
        private Socket client;
    
        private FileInputStream fis;
    
        private DataOutputStream dos;
    
        /**
         * 构造函数<br/>
         * 与服务器建立连接
         * @throws Exception
         */
        public FileTransferClient() throws Exception {
            super(SERVER_IP, SERVER_PORT);
            this.client = this;
            System.out.println("Cliect[port:" + client.getLocalPort() + "] 成功连接服务端");
        }
    
        /**
         * 向服务端传输文件
         * @throws Exception
         */
        public void sendFile() throws Exception {
            try {
                File file = new File("E:\\JDK1.6中文参考手册(JDK_API_1_6_zh_CN).CHM");
                if(file.exists()) {
                    fis = new FileInputStream(file);
                    dos = new DataOutputStream(client.getOutputStream());
    
                    // 文件名和长度
                    dos.writeUTF(file.getName());
                    dos.flush();
                    dos.writeLong(file.length());
                    dos.flush();
    
                    // 开始传输文件
                    System.out.println("======== 开始传输文件 ========");
                    byte[] bytes = new byte[1024];
                    int length = 0;
                    long progress = 0;
                    while((length = fis.read(bytes, 0, bytes.length)) != -1) {
                        dos.write(bytes, 0, length);
                        dos.flush();
                        progress += length;
                        System.out.print("| " + (100*progress/file.length()) + "% |");
                    }
                    System.out.println();
                    System.out.println("======== 文件传输成功 ========");
                }
            } catch (Exception e) {
                e.printStackTrace();
            } finally {
                if(fis != null)
                    fis.close();
                if(dos != null)
                    dos.close();
                client.close();
            }
        }
    
        /**
         * 入口
         * @param args
         */
        public static void main(String[] args) {
            try {
                FileTransferClient client = new FileTransferClient(); // 启动客户端连接
                client.sendFile(); // 传输文件
            } catch (Exception e) {
                e.printStackTrace();
            }
        }
    
    }

     

     

     

    服务端代码:

     

    import java.io.DataInputStream;
    import java.io.File;
    import java.io.FileOutputStream;
    import java.math.RoundingMode;
    import java.net.ServerSocket;
    import java.net.Socket;
    import java.text.DecimalFormat;
    
    /**
     * 文件传输Server端<br>
     * 功能说明:
     *
     * @author 大智若愚的小懂
     * @Date 2016年09月01日
     * @version 1.0
     */
    public class FileTransferServer extends ServerSocket {
    
        private static final int SERVER_PORT = 8899; // 服务端端口
    
        private static DecimalFormat df = null;
    
        static {
            // 设置数字格式,保留一位有效小数
            df = new DecimalFormat("#0.0");
            df.setRoundingMode(RoundingMode.HALF_UP);
            df.setMinimumFractionDigits(1);
            df.setMaximumFractionDigits(1);
        }
    
        public FileTransferServer() throws Exception {
            super(SERVER_PORT);
        }
    
        /**
         * 使用线程处理每个客户端传输的文件
         * @throws Exception
         */
        public void load() throws Exception {
            while (true) {
                // server尝试接收其他Socket的连接请求,server的accept方法是阻塞式的
                Socket socket = this.accept();
                /**
                 * 我们的服务端处理客户端的连接请求是同步进行的, 每次接收到来自客户端的连接请求后,
                 * 都要先跟当前的客户端通信完之后才能再处理下一个连接请求。 这在并发比较多的情况下会严重影响程序的性能,
                 * 为此,我们可以把它改为如下这种异步处理与客户端通信的方式
                 */
                // 每接收到一个Socket就建立一个新的线程来处理它
                new Thread(new Task(socket)).start();
            }
        }
    
        /**
         * 处理客户端传输过来的文件线程类
         */
        class Task implements Runnable {
    
            private Socket socket;
    
            private DataInputStream dis;
    
            private FileOutputStream fos;
    
            public Task(Socket socket) {
                this.socket = socket;
            }
    
            @Override
            public void run() {
                try {
                    dis = new DataInputStream(socket.getInputStream());
    
                    // 文件名和长度
                    String fileName = dis.readUTF();
                    long fileLength = dis.readLong();
                    File directory = new File("D:\\FTCache");
                    if(!directory.exists()) {
                        directory.mkdir();
                    }
                    File file = new File(directory.getAbsolutePath() + File.separatorChar + fileName);
                    fos = new FileOutputStream(file);
    
                    // 开始接收文件
                    byte[] bytes = new byte[1024];
                    int length = 0;
                    while((length = dis.read(bytes, 0, bytes.length)) != -1) {
                        fos.write(bytes, 0, length);
                        fos.flush();
                    }
                    System.out.println("======== 文件接收成功 [File Name:" + fileName + "] [Size:" + getFormatFileSize(fileLength) + "] ========");
                } catch (Exception e) {
                    e.printStackTrace();
                } finally {
                    try {
                        if(fos != null)
                            fos.close();
                        if(dis != null)
                            dis.close();
                        socket.close();
                    } catch (Exception e) {}
                }
            }
        }
    
        /**
         * 格式化文件大小
         * @param length
         * @return
         */
        private String getFormatFileSize(long length) {
            double size = ((double) length) / (1 << 30);
            if(size >= 1) {
                return df.format(size) + "GB";
            }
            size = ((double) length) / (1 << 20);
            if(size >= 1) {
                return df.format(size) + "MB";
            }
            size = ((double) length) / (1 << 10);
            if(size >= 1) {
                return df.format(size) + "KB";
            }
            return length + "B";
        }
    
        /**
         * 入口
         * @param args
         */
        public static void main(String[] args) {
            try {
                FileTransferServer server = new FileTransferServer(); // 启动服务端
                server.load();
            } catch (Exception e) {
                e.printStackTrace();
            }
        }
    }

     

     

     

    测试的结果(客户端):

    测试的结果(服务端):

     

     

    展开全文
  • socket实现文件传输功能

    万次阅读 2017-06-03 21:12:11
    实现的功能为:client 从 server 下载一个文件并保存到本地。 编写这个程序需要注意两个问题: 1) 文件大小不确定,有可能比缓冲区大很多,调用一次 write()/send() 函数不能完成文件内容的发送。接收数据时也会...

    要实现的功能为:client 从 server 下载一个文件并保存到本地。

    编写这个程序需要注意两个问题:
    1) 文件大小不确定,有可能比缓冲区大很多,调用一次 write()/send() 函数不能完成文件内容的发送。接收数据时也会遇到同样的情况。

    要解决这个问题,可以使用 while 循环,例如:

    1. //Server 代码
    2. int nCount;
    3. while( (nCount = fread(buffer, 1, BUF_SIZE, fp)) > 0 ){
    4. send(sock, buffer, nCount, 0);
    5. }
    6.  
    7. //Client 代码
    8. int nCount;
    9. while( (nCount = recv(clntSock, buffer, BUF_SIZE, 0)) > 0 ){
    10. fwrite(buffer, nCount, 1, fp);
    11. }

    对于 Server 端的代码,当读取到文件末尾,fread() 会返回 0,结束循环。

    对于 Client 端代码,有一个关键的问题,就是文件传输完毕后让 recv() 返回 0,结束 while 循环。

    注意:读取完缓冲区中的数据 recv() 并不会返回 0,而是被阻塞,直到缓冲区中再次有数据。

    2) Client 端如何判断文件接收完毕,也就是上面提到的问题——何时结束 while 循环。

    最简单的结束 while 循环的方法当然是文件接收完毕后让 recv() 函数返回 0,那么,如何让 recv() 返回 0 呢?recv() 返回 0 的唯一时机就是收到FIN包时。

    FIN 包表示数据传输完毕,计算机收到 FIN 包后就知道对方不会再向自己传输数据,当调用 read()/recv() 函数时,如果缓冲区中没有数据,就会返回 0,表示读到了”socket文件的末尾“。

    这里我们调用 shutdown() 来发送FIN包:server 端直接调用 close()/closesocket() 会使输出缓冲区中的数据失效,文件内容很有可能没有传输完毕连接就断开了,而调用 shutdown() 会等待输出缓冲区中的数据传输完毕。

    本节以Windows为例演示文件传输功能,Linux与此类似,不再赘述。请看下面完整的代码。

    服务器端 server.cpp:

    1. #include <stdio.h>
    2. #include <stdlib.h>
    3. #include <winsock2.h>
    4. #pragma comment (lib, "ws2_32.lib") //加载 ws2_32.dll
    5.  
    6. #define BUF_SIZE 1024
    7.  
    8. int main(){
    9. //先检查文件是否存在
    10. char *filename = "D:\\send.avi"; //文件名
    11. FILE *fp = fopen(filename, "rb"); //以二进制方式打开文件
    12. if(fp == NULL){
    13. printf("Cannot open file, press any key to exit!\n");
    14. system("pause");
    15. exit(0);
    16. }
    17.  
    18. WSADATA wsaData;
    19. WSAStartup( MAKEWORD(2, 2), &wsaData);
    20. SOCKET servSock = socket(AF_INET, SOCK_STREAM, 0);
    21.  
    22. sockaddr_in sockAddr;
    23. memset(&sockAddr, 0, sizeof(sockAddr));
    24. sockAddr.sin_family = PF_INET;
    25. sockAddr.sin_addr.s_addr = inet_addr("127.0.0.1");
    26. sockAddr.sin_port = htons(1234);
    27. bind(servSock, (SOCKADDR*)&sockAddr, sizeof(SOCKADDR));
    28. listen(servSock, 20);
    29.  
    30. SOCKADDR clntAddr;
    31. int nSize = sizeof(SOCKADDR);
    32. SOCKET clntSock = accept(servSock, (SOCKADDR*)&clntAddr, &nSize);
    33.  
    34. //循环发送数据,直到文件结尾
    35. char buffer[BUF_SIZE] = {0}; //缓冲区
    36. int nCount;
    37. while( (nCount = fread(buffer, 1, BUF_SIZE, fp)) > 0 ){
    38. send(clntSock, buffer, nCount, 0);
    39. }
    40.  
    41. shutdown(clntSock, SD_SEND); //文件读取完毕,断开输出流,向客户端发送FIN包
    42. recv(clntSock, buffer, BUF_SIZE, 0); //阻塞,等待客户端接收完毕
    43.  
    44. fclose(fp);
    45. closesocket(clntSock);
    46. closesocket(servSock);
    47. WSACleanup();
    48.  
    49. system("pause");
    50. return 0;
    51. }


    客户端代码:

    1. #include <stdio.h>
    2. #include <stdlib.h>
    3. #include <WinSock2.h>
    4. #pragma comment(lib, "ws2_32.lib")
    5.  
    6. #define BUF_SIZE 1024
    7.  
    8. int main(){
    9. //先输入文件名,看文件是否能创建成功
    10. char filename[100] = {0}; //文件名
    11. printf("Input filename to save: ");
    12. gets(filename);
    13. FILE *fp = fopen(filename, "wb"); //以二进制方式打开(创建)文件
    14. if(fp == NULL){
    15. printf("Cannot open file, press any key to exit!\n");
    16. system("pause");
    17. exit(0);
    18. }
    19.  
    20. WSADATA wsaData;
    21. WSAStartup(MAKEWORD(2, 2), &wsaData);
    22. SOCKET sock = socket(PF_INET, SOCK_STREAM, IPPROTO_TCP);
    23.  
    24. sockaddr_in sockAddr;
    25. memset(&sockAddr, 0, sizeof(sockAddr));
    26. sockAddr.sin_family = PF_INET;
    27. sockAddr.sin_addr.s_addr = inet_addr("127.0.0.1");
    28. sockAddr.sin_port = htons(1234);
    29. connect(sock, (SOCKADDR*)&sockAddr, sizeof(SOCKADDR));
    30.  
    31. //循环接收数据,直到文件传输完毕
    32. char buffer[BUF_SIZE] = {0}; //文件缓冲区
    33. int nCount;
    34. while( (nCount = recv(sock, buffer, BUF_SIZE, 0)) > 0 ){
    35. fwrite(buffer, nCount, 1, fp);
    36. }
    37. puts("File transfer success!");
    38.  
    39. //文件接收完毕后直接关闭套接字,无需调用shutdown()
    40. fclose(fp);
    41. closesocket(sock);
    42. WSACleanup();
    43. system("pause");
    44. return 0;
    45. }

    在D盘中准备好send.avi文件,先运行 server,再运行 client:
    Input filename to save: D:\\recv.avi↙
    //稍等片刻后
    File transfer success!

    打开D盘就可以看到 recv.avi,大小和 send.avi 相同,可以正常播放。

    注意 server.cpp 第42行代码,recv() 并没有接收到 client 端的数据,当 client 端调用 closesocket() 后,server 端会收到FIN包,recv() 就会返回,后面的代码继续执行。

    展开全文
  • windows环境下使用C++&Socket实现文件传输

    服务端开启监听端口,当客户端连接后,服务端发送文件到客户端。

    Server服务端

    #include <stdio.h>
    #include <iostream>
    #include <cstring>
    #include <fstream>
    #include <winsock2.h>
    
    #pragma comment(lib, "ws2_32.lib")
    
    using namespace std;
    
    SOCKET m_Client; 
    void SendFile();
    
    int main(int argc, char* argv[])  
    {  
        //初始化WSA  
        WORD sockVersion = MAKEWORD(2,2);  
        WSADATA wsaData;  
        if(WSAStartup(sockVersion, &wsaData)!=0)  
        {  
            return 0;  
        }  
      
        //创建套接字  
        SOCKET slisten = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);  
        if(slisten == INVALID_SOCKET)  
        {  
            printf("socket error !");  
            return 0;  
        }  
      
        //绑定IP和端口  
        sockaddr_in sin;  
        sin.sin_family = AF_INET;  
        sin.sin_port = htons(8888);  
        sin.sin_addr.S_un.S_addr = INADDR_ANY;   
        if(bind(slisten, (LPSOCKADDR)&sin, sizeof(sin)) == SOCKET_ERROR)  
        {  
            printf("bind error !");  
        }  
      
        //开始监听  
        if(listen(slisten, 5) == SOCKET_ERROR)  
        {  
            printf("listen error !");  
            return 0;  
        }  
      
        //循环接收数据  
        sockaddr_in remoteAddr;  
        int nAddrlen = sizeof(remoteAddr);  
        char revData[255];   
        while (true)  
        {  
            printf("等待连接...\n");  
            m_Client = accept(slisten, (SOCKADDR *)&remoteAddr, &nAddrlen);  
            if(m_Client == INVALID_SOCKET)  
            {  
                printf("accept error !");  
                continue;  
            }  
            printf("接受到一个连接:%s \r\n", inet_ntoa(remoteAddr.sin_addr));  
            SendFile();
            closesocket(m_Client);  
        }   
        closesocket(slisten);  
        WSACleanup();  
        return 0;  
    } 
    void SendFile(){
        int haveSend = 0;
        const int bufferSize = 1024;
        char buffer[bufferSize] = {0};
        int readLen = 0;
        string srcFileName = "in";
        ifstream srcFile;
        srcFile.open(srcFileName.c_str(),ios::binary);
        if(!srcFile){
            return;
        }
        while(!srcFile.eof()){
            srcFile.read(buffer,bufferSize);
            readLen = srcFile.gcount();
            send(m_Client,buffer,readLen,0);
            haveSend += readLen;    
        }
        srcFile.close();
        cout<<"send: "<<haveSend<<"B"<<endl;
    }

    Client客户端

    #include <stdio.h>
    #include <iostream>
    #include <cstring>
    #include <fstream>
    #include <winsock2.h>
    
    #pragma comment(lib, "ws2_32.lib")
    
    using namespace std;
     
    SOCKET m_Client; 
    
    void RecvFile();
    
    int main()
    {
        WORD sockVersion = MAKEWORD(2, 2);
        WSADATA data;
        if(WSAStartup(sockVersion, &data)!=0)
        {
            return 0;
        }
        //while(true){
            m_Client = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
            if(m_Client == INVALID_SOCKET)
            {
                printf("invalid socket!");
                return 0;
            }
            
            sockaddr_in serAddr;
            serAddr.sin_family = AF_INET;
            serAddr.sin_port = htons(8888);
            serAddr.sin_addr.S_un.S_addr = inet_addr("127.0.0.1");
            if(connect(m_Client, (sockaddr *)&serAddr, sizeof(serAddr)) == SOCKET_ERROR)
            {  //连接失败 
                printf("connect error !");
                closesocket(m_Client);
                return 0;
            }
            RecvFile();
            closesocket(m_Client);
        //}
        
        
        WSACleanup();
        return 0;
        
    }
    
    void RecvFile(){
        cout<<"start recv!"<<endl;
        const int bufferSize = 1024;
        char buffer[bufferSize] = {0};
        int readLen = 0;
        string desFileName = "new_in";
        ofstream desFile;
        desFile.open(desFileName.c_str(), ios::binary);
        if (!desFile)
        {
            return ;
        }
        do 
        {
            readLen = recv(m_Client,buffer,bufferSize, 0);
            if (readLen == 0)
            {
                break;
            }
            else
            {
                desFile.write(buffer, readLen);
            }
        } while(true);
        desFile.close();
    }

     

    展开全文
  • Linux 利用socket实现文件传输

    千次阅读 2019-10-29 10:34:37
      利用Linux Socket进行文件传输,本次只支持client端向sever端上传文件   二、实现提示: client.c client的参数有两个,分别是服务器主机名和端口; 在while循环中输入你想要传输的文件名,然后建立socket...
  • Java Socket实现文件传输示例代码

    千次阅读 2017-02-07 14:00:24
    这篇文章主要介绍了Java Socket实现文件传输示例代码,小编觉得挺不错的,现在分享给大家,也给大家做个参考。一起跟随小编过来看看吧 最近学Socket学上瘾了,就写了一个简单的文件传输程序。 客户端设计思路...
  • C语言+Socket实现文件传输

    热门讨论 2010-10-05 09:37:07
    实现文件传输功能~使用与初学者对socket的了解和深一步的研究!希望能给大家带来帮助
  • java语言通过Socket实现文件传输

    热门讨论 2008-12-17 22:27:39
    在Unix/Linux/Windows环境下,通过Socket方式实现一个基于Client/Server或P2P模式的文件传输程序。
  • Python通过Socket实现文件传输

    千次阅读 2018-03-15 19:41:43
    import socket import argparse import os import hashlib import pickle def parse_args(): parser = argparse.ArgumentParser() parser.add_argument("-f","--file",help="th...
  • Python编程:socket实现文件传输

    千次阅读 2018-01-18 23:47:11
    思路: 读取文件名 检测文件是否存在 打开文件 检测文件大小 发送文件大小和MD5值给客户端 ...import hashlibserver = socket.socket()server.bind(("localhost", 6969)) # 绑定监听端口server.listen(5) # 监听pr
  • 当java实现socket信息传输后,在进一步实现文件传输的时候经常会发生文件了出去,但接收方收不到,即生成的文件大小为0字节。这是因为接收的时候没有做好判断导致的。 主要判断模块如下所示: while ((length = s...
  • 本例中以client作为发送端 server作为接收端 #server import socket import json ...sk.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1) sk.bind(('127.0.0.1',8080)) sk.listen() con, addr = sk.ac
  • 为了加强对socket及java IO流编程的回顾,本文作了一个文件传输的实例。针对java不同对IO流的不同实现,本文也分别基于BIO、NIO、AIO实现三种传输,同时本文采用了缓冲输入/输出流来包装输出流,再采用数据输入/输出...
  • 本博客主要实现了简单win7系统下,两台电脑之间(客户机与服务器)的文件传输,主要是基于Windows网络编程中winsock来实现的,当然这个只是简单的实现,你可以根据你的需求在你的项目里面进行更改。这里主要实现的...
  • Windows用socket实现文件传输

    万次阅读 2016-05-14 17:04:07
    这里只写客户端代码。如果链接失败加上libws2_32.a链接库。 ... ... //SOCK_STREAM 提供有序的、可靠的、双向的和基于... printf("文件传输完成"); closesocket(clientSocket); WSACleanup(); return 0; }
  • NIO Socket实现文件传输

    2013-05-15 14:50:53
    http://blog.csdn.net/kongxx/article/details/7319410
  • 用.net中的socket实现文件传输

    千次阅读 2007-03-21 22:56:00
    socket是网络套接字,使用它我们可以很方便的实现网络的数据传输。在.net中提供了socket类来帮助开发者调用socket的使用,从而... 编程思路:在这个简单的例子中我们将通过socket实现文件的网络传输和接收功能。要实
  • socket是网络套接字,使用它我们可以很方便的实现网络的数据传输。在.net中提供了socket类来帮助开发者调用socket的使用,从而... 编程思路:在这个简单的例子中我们将通过socket实现文件的网络传输和接收功能。要实
  • socket通信,完成文件传输  本文是一个基于TCP,一对多的文件传输小案例代码如下: 服务端: /** * 服务端 * */ public class server extends ServerSocket { /** * 构造函数 * */ public server()throws ...
  • 用vb.net中的socket实现文件传输

    千次阅读 2008-01-28 19:32:00
    来源:不详 socket是网络套接字,使用它我们可以很方便的实现网络的数据传输。在.net中提供了socket类来帮助开发者调用socket的使用,从而避免了调用... 编程思路:在这个简单的例子中我们将通过socket实现文件
  • 使用socket实现文件传输[PHP CLI]

    千次阅读 2009-07-27 17:50:00
    目前使用的socket传输原理Demo #!/usr/bin/php<?php define("SEPARATOR", "|=+=|");//used for explode filename and contents//client$filename = "data";$fp = fsockopen("127.0.0.1", 20000, $errno, $err

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 174,515
精华内容 69,806
关键字:

socket实现文件传输