`

socket网络传输实例

SocketJavaOS.netLinux 
阅读更多
(1)简单实现文件在网络中的传输，要实现高级功能，在此基础上进行修改即可。
分2个类实现，FileSender负责文件发送，FileIncepter负责文件接受：

用socket传输文件本质：发送端：打开文件，将文件中字符串发给接收端；接收端接收字符串，写入文件中即可。

writeLong(long)
将一 long 作为八字节值，写入该基本输出流，高字节优先。
writeShort(int)
将一 short 作为两字节值，写入该基本输出流，高字节优先。
writeUTF(String)
使用独立于机器的 UTF-8 编码格式，将一个串写入该基本输出流。 

import java.io.BufferedInputStream; 
import java.io.DataInputStream; 
import java.io.DataOutputStream; 
import java.io.File; 
import java.io.FileInputStream; 
import java.io.IOException; 
import java.net.ServerSocket; 
import java.net.Socket; 

public class FileSender { 

  private ServerSocket ss = null; 

  public FileSender() { 

  } 

  public void startSend(String filePath, int port) { 
    // socket输出流 
    DataOutputStream os = null; 
    // 文件输入流 
    DataInputStream is = null; 
    // 建立socket连接 
    Socket socket = null; 
    try { 
      // 选择进行传输的文件 
      File file = new File(filePath); 

      // 建立socket监听 
      ss = new ServerSocket(port); 

      socket = ss.accept(); 

      os = new DataOutputStream(socket.getOutputStream()); 

      // 将文件名及长度传给客户端。这里要真正适用所有平台，例如中文名的处理，还需要加工， 
      // 具体可以参见Think In Java 4th里有现成的代码。 
      os.writeUTF(file.getName()); 
      os.flush(); 
      os.writeLong((long) file.length()); 
      os.flush(); 

      is = new DataInputStream(new BufferedInputStream( 
          new FileInputStream(filePath))); 
      // 缓冲区大小 
      int bufferSize = 8192; 
      // 缓冲区 
      byte[] buf = new byte[bufferSize]; 
      // 传输文件 
      while (true) { 
        int read = 0; 
        if (is != null) { 
          read = is.read(buf); 
        } 

        if (read == -1) { 
          break; 
        } 
        os.write(buf, 0, read); 
      } 
      os.flush(); 

    } catch (IOException e) { 
      e.printStackTrace(); 
    } finally { 
      // 关闭所有连接 
      try { 
        if (os != null) 
          os.close(); 
      } catch (IOException e) { 
      } 
      try { 
        if (is != null) 
          is.close(); 
      } catch (IOException e) { 
      } 
      try { 
        if (socket != null) 
          socket.close(); 
      } catch (IOException e) { 
      } 
      try { 
        if (ss != null) 
          ss.close(); 
      } catch (IOException e) { 
      } 
    } 

  } 

  public static void main(String[] args) { 
    new FileSender().startSend("E:\\JDK_API_1_6_zh_CN.CHM", 8821); 
  } 
} 


import java.io.BufferedInputStream; 
import java.io.BufferedOutputStream; 
import java.io.DataInputStream; 
import java.io.DataOutputStream; 
import java.io.FileOutputStream; 
import java.io.IOException; 
import java.net.Socket; 
import java.net.UnknownHostException; 

public class FileIncepter { 

  public FileIncepter() { 

  } 

  public void getFile(String savePath, String ip, int port) { 
    // 建立socket连接 
    Socket socket = null; 
    try { 
      socket = new Socket(ip, port); 
    } catch (UnknownHostException e1) { 
      e1.printStackTrace(); 
    } catch (IOException e1) { 
      e1.printStackTrace(); 
    } 
    // 建立socket输入流 
    DataInputStream inputStream = null; 
    try { 
      inputStream = new DataInputStream(new BufferedInputStream(socket 
          .getInputStream())); 
    } catch (IOException e1) { 
      e1.printStackTrace(); 
    } 
    try { 
      // 缓冲区大小 
      int bufferSize = 8192; 
      // 缓冲区 
      byte[] buf = new byte[bufferSize]; 
      int passedlen = 0; 
      long len = 0; 
      // 获取文件名称 
      savePath += inputStream.readUTF(); 
      DataOutputStream fileOut = new DataOutputStream( 
          new BufferedOutputStream(new BufferedOutputStream( 
              new FileOutputStream(savePath)))); 
      // 获取文件长度 
      len = inputStream.readLong(); 

      System.out.println("文件的长度为:" + len + "    KB"); 
      System.out.println("开始接收文件!"); 

      // 获取文件 
      while (true) { 
        int read = 0; 
        if (inputStream != null) { 
          read = inputStream.read(buf); 
        } 
        passedlen += read; 
        if (read == -1) { 
          break; 
        } 
        System.out.println("文件接收了" + (passedlen * 100 / len) + "%"); 
        fileOut.write(buf, 0, read); 
      } 
      System.out.println("接收完成，文件存为" + savePath); 
      fileOut.close(); 
    } catch (Exception e) { 
      e.printStackTrace(); 
      return; 
    } 
  } 

  public static void main(String[] args) { 
    new FileIncepter().getFile("F:\\", "localhost", 8821); 
  } 
}
 
(2)
 最近需要进行网络传输大文件，于是对基于socket的文件传输作了一个初步的了解。在一位网友提供的程序基础上，俺进行了一些加工，采用了缓冲输入/输出流来包装输出流，再采用数据输入/输出输出流进行包装，加快传输的速度。废话少说，先来看服务器端的程序。 
1.服务器端 

package sterning; 

import java.io.BufferedInputStream; 
import java.io.DataInputStream; 
import java.io.DataOutputStream; 
import java.io.File; 
import java.io.FileInputStream; 
import java.net.ServerSocket; 
import java.net.Socket; 

public class ServerTest { 
        int port = 8821; 

        void start() { 
                Socket s = null; 
                try { 
                        ServerSocket ss = new ServerSocket(port); 
                        while (true) { 
                                // 选择进行传输的文件 
                                String filePath = "D:\\lib.rar"; 
                                File fi = new File(filePath); 

                                System.out.println("文件长度:" + (int) fi.length()); 

                                // public Socket accept() throws 
                                // IOException侦听并接受到此套接字的连接。此方法在进行连接之前一直阻塞。 

                                s = ss.accept(); 
                                System.out.println("建立socket链接"); 
                                DataInputStream dis = new DataInputStream(new BufferedInputStream(s.getInputStream())); 
                                dis.readByte(); 

                                DataInputStream fis = new DataInputStream(new BufferedInputStream(new FileInputStream(filePath))); 
                                DataOutputStream ps = new DataOutputStream(s.getOutputStream()); 
                                //将文件名及长度传给客户端。这里要真正适用所有平台，例如中文名的处理，还需要加工，具体可以参见Think In Java 4th里有现成的代码。 
                                ps.writeUTF(fi.getName()); 
                                ps.flush(); 
                                ps.writeLong((long) fi.length()); 
                                ps.flush(); 

                                int bufferSize = 8192; 
                                byte[] buf = new byte[bufferSize]; 

                                while (true) { 
                                        int read = 0; 
                                        if (fis != null) { 
                                                read = fis.read(buf); 
                                        } 

                                        if (read == -1) { 
                                                break; 
                                        } 
                                        ps.write(buf, 0, read); 
                                } 
                                ps.flush(); 
                                // 注意关闭socket链接哦，不然客户端会等待server的数据过来， 
                                // 直到socket超时，导致数据不完整。                                
                                fis.close(); 
                                s.close();                                
                                System.out.println("文件传输完成"); 
                        } 

                } catch (Exception e) { 
                        e.printStackTrace(); 
                } 
        } 

        public static void main(String arg[]) { 
                new ServerTest().start(); 
        } 
}


2.socket的Util辅助类 

package sterning; 

import java.net.*; 
import java.io.*; 

public class ClientSocket { 
        private String ip; 

        private int port; 

        private Socket socket = null; 

        DataOutputStream out = null; 

        DataInputStream getMessageStream = null; 

        public ClientSocket(String ip, int port) { 
                this.ip = ip; 
                this.port = port; 
        } 

        /** *//** 
         * 创建socket连接 
         * 
         * @throws Exception 
         *                         exception 
         */ 
        public void CreateConnection() throws Exception { 
                try { 
                        socket = new Socket(ip, port); 
                } catch (Exception e) { 
                        e.printStackTrace(); 
                        if (socket != null) 
                                socket.close(); 
                        throw e; 
                } finally { 
                } 
        } 

        public void sendMessage(String sendMessage) throws Exception { 
                try { 
                        out = new DataOutputStream(socket.getOutputStream()); 
                        if (sendMessage.equals("Windows")) { 
                                out.writeByte(0x1); 
                                out.flush(); 
                                return; 
                        } 
                        if (sendMessage.equals("Unix")) { 
                                out.writeByte(0x2); 
                                out.flush(); 
                                return; 
                        } 
                        if (sendMessage.equals("Linux")) { 
                                out.writeByte(0x3); 
                                out.flush(); 
                        } else { 
                                out.writeUTF(sendMessage); 
                                out.flush(); 
                        } 
                } catch (Exception e) { 
                        e.printStackTrace(); 
                        if (out != null) 
                                out.close(); 
                        throw e; 
                } finally { 
                } 
        } 

        public DataInputStream getMessageStream() throws Exception { 
                try { 
                        getMessageStream = new DataInputStream(new BufferedInputStream(socket.getInputStream())); 
                        return getMessageStream; 
                } catch (Exception e) { 
                        e.printStackTrace(); 
                        if (getMessageStream != null) 
                                getMessageStream.close(); 
                        throw e; 
                } finally { 
                } 
        } 

        public void shutDownConnection() { 
                try { 
                        if (out != null) 
                                out.close(); 
                        if (getMessageStream != null) 
                                getMessageStream.close(); 
                        if (socket != null) 
                                socket.close(); 
                } catch (Exception e) { 

                } 
        } 
} 

3.客户端 

package sterning; 

import java.io.BufferedOutputStream; 
import java.io.DataInputStream; 
import java.io.DataOutputStream; 
import java.io.FileOutputStream; 

public class ClientTest { 
        private ClientSocket cs = null; 

        private String ip = "localhost";// 设置成服务器IP 

        private int port = 8821; 

        private String sendMessage = "Windwos"; 

        public ClientTest() { 
                try { 
                        if (createConnection()) { 
                                sendMessage(); 
                                getMessage(); 
                        } 

                } catch (Exception ex) { 
                        ex.printStackTrace(); 
                } 
        } 

        private boolean createConnection() { 
                cs = new ClientSocket(ip, port); 
                try { 
                        cs.CreateConnection(); 
                        System.out.print("连接服务器成功!" + "\n"); 
                        return true; 
                } catch (Exception e) { 
                        System.out.print("连接服务器失败!" + "\n"); 
                        return false; 
                } 

        } 

        private void sendMessage() { 
                if (cs == null) 
                        return; 
                try { 
                        cs.sendMessage(sendMessage); 
                } catch (Exception e) { 
                        System.out.print("发送消息失败!" + "\n"); 
                } 
        } 

        private void getMessage() { 
                if (cs == null) 
                        return; 
                DataInputStream inputStream = null; 
                try { 
                        inputStream = cs.getMessageStream(); 
                } catch (Exception e) { 
                        System.out.print("接收消息缓存错误\n"); 
                        return; 
                } 

                try { 
                        //本地保存路径，文件名会自动从服务器端继承而来。 
                        String savePath = "E:\\"; 
                        int bufferSize = 8192; 
                        byte[] buf = new byte[bufferSize]; 
                        int passedlen = 0; 
                        long len=0; 
                        
                        savePath += inputStream.readUTF(); 
                        DataOutputStream fileOut = new DataOutputStream(new BufferedOutputStream(new BufferedOutputStream(new FileOutputStream(savePath)))); 
                        len = inputStream.readLong(); 
                        
                        System.out.println("文件的长度为:" + len + "\n"); 
                        System.out.println("开始接收文件!" + "\n"); 
                                        
                        while (true) { 
                                int read = 0; 
                                if (inputStream != null) { 
                                        read = inputStream.read(buf); 
                                } 
                                passedlen += read; 
                                if (read == -1) { 
                                        break; 
                                } 
                                //下面进度条本为图形界面的prograssBar做的，这里如果是打文件，可能会重复打印出一些相同的百分比 
                                System.out.println("文件接收了" +    (passedlen * 100/ len) + "%\n"); 
                                fileOut.write(buf, 0, read); 
                        } 
                        System.out.println("接收完成，文件存为" + savePath + "\n"); 

                        fileOut.close(); 
                } catch (Exception e) { 
                        System.out.println("接收消息错误" + "\n"); 
                        return; 
                } 
        } 

        public static void main(String arg[]) { 
                new ClientTest(); 
        } 
}
这就实现了从服务器端向客户端发送文件的过程,当然,反过来,也一样.稍有不同.代码中对跨平台的细节没有实现,有时间或兴趣的朋友可以提供一下
分享到：
| 验证码的应用
评论
2 楼 xulu286880921 2011-08-20   
[url][/url][flash=200,200][/flash]
引用






  

    1 楼
    xulu286880921
    2011-08-20  
    
    
  

  
 





    
    
  


  

    
发表评论

            
   您还没有登录,请您登录后再发表评论 

      

  

  





  

    
相关推荐

    
    
    
        
        
    
          
    
            
            
    
              
                
                
                
    
                  
    
                    
                      Socket文件传输实例
                    
                  
    
                  
    Socket文件传输实例是一种在两台计算机之间通过网络交换文件的技术，通常基于TCP/IP协议栈中的Socket接口实现。在这个实例中，我们看到一个简单的Server端和Client端程序，用于演示如何利用Java的Socket类进行文件...
    
                
    
                
              
                
                
                
    
                  
    
                    
                      Java socket文件传输实例
                    
                  
    
                  
    在这个"Java socket文件传输实例"中，我们将深入探讨如何使用Java的Socket类进行文件的发送和接收，这对于理解网络编程的基本原理以及在实际应用中构建文件共享系统至关重要。  首先，Java Socket是基于TCP/IP协议的...
    
                
    
                
              
                
                
                
    
                  
    
                    
                      两种SOCKET文件传输实例
                    
                  
    
                  
    本主题将深入探讨两种基于SOCKET的文件传输实例，这些实例提供了详细注释的代码，有助于理解如何通过网络进行文件交换。  首先，我们要了解什么是SOCKET。SOCKET是操作系统提供的接口，它允许应用程序通过网络发送和...
    
                
    
                
              
                
                
                
    
                  
    
                    
                      socket传输文件实例
                    
                  
    
                  
    总结，Socket传输文件实例涉及到网络通信基础、Socket编程、文件操作以及错误处理等多个方面，通过理解这些知识点，我们可以构建自己的文件传输系统，实现两台计算机之间的文件共享。在实践中，我们应根据具体需求...
    
                
    
                
              
                
                
                
    
                  
    
                    
                      socket文件传输（TCP）源码实例
                    
                  
    
                  
    在这个文件传输实例中，服务器接收来自客户端的数据块，通常是文件内容，然后写入到本地文件系统中。  7. **关闭（Close）**：在数据传输完成后，客户端和服务器都需要调用`close()`函数关闭socket，释放资源。  在...
    
                
    
                
              
                
                
                
    
                  
    
                    
                      Socket异步传输C#实例
                    
                  
    
                  
    本实例是一个基于C#的Socket异步传输项目，设计了一个简单的聊天工具，包括服务端和客户端两部分。通过这个实例，我们可以深入理解Socket异步传输的工作原理和实现方式。  1. **Socket基础知识**  Socket是网络通信...
    
                
    
                
              
                
                
                
    
                  
    
                    
                      c# Socket网络编程实例
                    
                  
    
                  
    总之，C#中的Socket网络编程允许开发者构建功能强大的网络应用程序，如聊天应用、文件传输工具等。通过理解和实践这样的实例，你可以深入掌握网络通信的核心原理，从而更好地利用网络资源。这个实例是一个很好的起点...
    
                
    
                
              
                
                
                
    
                  
    
                    
                      HPSocket--UDP传输客户端应用实例
                    
                  
    
                  
    本文将深入解析标题为“HPSocket--UDP传输客户端应用实例”的技术要点，以及如何利用HPsocket框架实现UDP协议的客户端功能。  首先，HPSocket是一款强大的网络通信组件，它提供了丰富的接口，支持多种协议（如TCP、...
    
                
    
                
              
                
                
                
    
                  
    
                    
                      Socket异步传输数据实例(客户端服务端)
                    
                  
    
                  
    本文将深入探讨“Socket异步传输数据实例(客户端服务端)”这一主题，涉及并发处理、异步操作以及`SocketAsyncEventArgs`对象池和内存地址池等关键知识点。  首先，我们要理解Socket的基本概念。Socket是网络编程的...
    
                
    
                
              
                
                
                
    
                  
    
                    
                      Socket网络编程实例
                    
                  
    
                  
    Socket网络编程是计算机网络通信中的基础...在这个“Socket网络编程实例”中，通过分析和理解SocketServer的代码，我们可以深入学习Socket通信的原理和实践，掌握网络编程的基础，并为构建更复杂的分布式系统打下基础。
    
                
    
                
              
                
                
                
    
                  
    
                    
                      socket网络编程实例代码_socket服务端编程实例代码_
                    
                  
    
                  
    本实例主要探讨了如何使用C语言实现Socket服务端和客户端的编程，通过`server.c.txt`和`client.c.txt`两个文件来展示具体的操作流程。  首先，我们来看服务端的编程。在`server.c.txt`中，服务端主要完成了以下步骤...
    
                
    
                
              
                
                
                
    
                  
    
                    
                      C语言实现Linux下的socket文件传输实例
                    
                  
    
                  
    本文实例讲述了C语言实现Linux下的socket文件传输。分享给大家供大家参考。具体如下： server.c如下：  //////////////////////////////////// //服务器代码 /////////////////////////////////// //本文件是服务器...
    
                
    
                
              
                
                
                
    
                  
    
                    
                      Socket网络编程_TCP实例
                    
                  
    
                  
    本实例主要探讨如何在C#环境中利用Socket类进行TCP网络编程。  首先，我们需要理解C#中的Socket类。Socket是.NET Framework提供的一个基类，它封装了底层网络通信协议，如TCP或UDP，允许开发者发送和接收数据。创建...
    
                
    
                
              
                
                
                
    
                  
    
                    
                      Socket 网络通信实例代码
                    
                  
    
                  
    1. **创建Socket**：使用`socket()`函数创建一个Socket描述符，该函数需要指定协议类型（如TCP或UDP）和传输层协议（如IP）。  2. **地址解析**：使用`gethostbyname()`或`getaddrinfo()`函数获取目标服务器的IP地址...
    
                
    
                
              
                
                
                
    
                  
    
                    
                      C#Socket文件传输简单例子（将文件名和文件同时传输）
                    
                  
    
                  
    在C#编程中，Socket是网络通信的基本组件，它提供了进程间、网络间的数据传输能力。本示例主要探讨如何使用C#的Socket类进行文件的传输，包括文件名和文件内容的同步发送与接收。这里我们将详细讲解实现这一功能的...
    
                
    
                
              
                
                
                
    
                  
    
                    
                      Socket高级编程实例
                    
                  
    
                  
    总之，Socket高级编程实例是一个非常有价值的资源，它可以帮助学习者巩固理论知识，提升实战技能，为成为专业的网络程序员奠定坚实基础。在学习过程中，不断实践和调试代码，理解网络通信的本质，将使你在网络编程...
    
                
    
                
              
                
                
                
    
                  
    
                    
                      android Socket文件传输
                    
                  
    
                  
    总之，Android的Socket文件传输涉及网络编程、文件操作和多线程等技术，通过合理的优化策略，即使是大文件也能流畅地进行传输。在实际项目中，开发者需要根据需求进行定制，以满足特定的性能和安全要求。
    
                
    
                
              
                
                
                
    
                  
    
                    
                      Socket网络编程实例代码
                    
                  
    
                  
    Socket网络编程是计算机网络通信中的一个重要概念，它提供了一种标准接口，允许应用程序通过网络进行数据传输。在本实例中，我们将重点讨论如何使用C#语言实现Socket编程，特别是TCP协议下的客户端和服务器端的通信...
    
                
    
                
              
                
                
                
    
                  
    
                    
                      socket通信完整实例
                    
                  
    
                  
    Socket通信是一种基于TCP/IP协议族实现网络间进程通信的技术，它是Internet上进程间通信的一种标准方法。...通过学习和实践Socket通信，你将能够构建起网络应用的基础，例如聊天程序、文件传输、远程控制等。
    
                
    
                
              
                
                
                
    
                  
    
                    
                      MFC socket 文件传输
                    
                  
    
                  
    将MFC与Socket结合，我们可以创建一个具有图形用户界面的应用程序，实现文件的网络传输。  标题"“MFC socket 文件传输”"指出，这个项目或教程主要关注如何使用MFC库来构建一个文件传输应用，该应用利用Socket技术...
    
                
    
                
              
            
    
          
    
        
    
    

  





  
    Magicbox
  













      

      
        

          

            

              

                

                
              

            

            


            

          

        

            
    

    
    
  

  



   Global site tag (gtag.js) - Google Analytics