`
coconut_zhang
  • 浏览: 543779 次
  • 性别: Icon_minigender_1
  • 来自: 天津
社区版块
存档分类
最新评论

Java Socket实战之七 使用Socket通信传输文件 .

    博客分类：
  • java
 
阅读更多

前面几篇文章介绍了使用Java的Socket编程和NIO包在Socket中的应用，这篇文章说说怎样利用Socket编程来实现简单的文件传输。

这里由于前面一片文章介绍了NIO在Socket中的应用，所以这里在读写文件的时候也继续使用NIO包，所以代码看起来会比直接使用流的方式稍微复杂一点点。

下面的示例演示了客户端向服务器端发送一个文件，服务器作为响应给客户端会发一个文件。这里准备两个文件E:/test/server_send.log和E:/test/client.send.log文件，在测试完毕后在客户端和服务器相同目录下会多出两个文件E:/test/server_receive.log和E:/test/client.receive.log文件。

下面首先来看看Server类，主要关注其中的sendFile和receiveFile方法。

 

[java] view plaincopyprint?
  1. package com.googlecode.garbagecan.test.socket.nio;  
  2.   
  3. import java.io.File;  
  4. import java.io.FileInputStream;  
  5. import java.io.FileOutputStream;  
  6. import java.io.IOException;  
  7. import java.net.InetSocketAddress;  
  8. import java.nio.ByteBuffer;  
  9. import java.nio.channels.ClosedChannelException;  
  10. import java.nio.channels.FileChannel;  
  11. import java.nio.channels.SelectionKey;  
  12. import java.nio.channels.Selector;  
  13. import java.nio.channels.ServerSocketChannel;  
  14. import java.nio.channels.SocketChannel;  
  15. import java.util.Iterator;  
  16. import java.util.logging.Level;  
  17. import java.util.logging.Logger;  
  18.   
  19. public class MyServer4 {  
  20.   
  21.     private final static Logger logger = Logger.getLogger(MyServer4.class.getName());  
  22.       
  23.     public static void main(String[] args) {  
  24.         Selector selector = null;  
  25.         ServerSocketChannel serverSocketChannel = null;  
  26.           
  27.         try {  
  28.             // Selector for incoming time requests   
  29.             selector = Selector.open();  
  30.   
  31.             // Create a new server socket and set to non blocking mode   
  32.             serverSocketChannel = ServerSocketChannel.open();  
  33.             serverSocketChannel.configureBlocking(false);  
  34.               
  35.             // Bind the server socket to the local host and port   
  36.             serverSocketChannel.socket().setReuseAddress(true);  
  37.             serverSocketChannel.socket().bind(new InetSocketAddress(10000));  
  38.               
  39.             // Register accepts on the server socket with the selector. This   
  40.             // step tells the selector that the socket wants to be put on the   
  41.             // ready list when accept operations occur, so allowing multiplexed   
  42.             // non-blocking I/O to take place.   
  43.             serverSocketChannel.register(selector, SelectionKey.OP_ACCEPT);  
  44.       
  45.             // Here's where everything happens. The select method will   
  46.             // return when any operations registered above have occurred, the   
  47.             // thread has been interrupted, etc.   
  48.             while (selector.select() > 0) {  
  49.                 // Someone is ready for I/O, get the ready keys   
  50.                 Iterator<SelectionKey> it = selector.selectedKeys().iterator();  
  51.       
  52.                 // Walk through the ready keys collection and process date requests.   
  53.                 while (it.hasNext()) {  
  54.                     SelectionKey readyKey = it.next();  
  55.                     it.remove();  
  56.                       
  57.                     // The key indexes into the selector so you   
  58.                     // can retrieve the socket that's ready for I/O   
  59.                     doit((ServerSocketChannel) readyKey.channel());  
  60.                 }  
  61.             }  
  62.         } catch (ClosedChannelException ex) {  
  63.             logger.log(Level.SEVERE, null, ex);  
  64.         } catch (IOException ex) {  
  65.             logger.log(Level.SEVERE, null, ex);  
  66.         } finally {  
  67.             try {  
  68.                 selector.close();  
  69.             } catch(Exception ex) {}  
  70.             try {  
  71.                 serverSocketChannel.close();  
  72.             } catch(Exception ex) {}  
  73.         }  
  74.     }  
  75.   
  76.     private static void doit(final ServerSocketChannel serverSocketChannel) throws IOException {  
  77.         SocketChannel socketChannel = null;  
  78.         try {  
  79.             socketChannel = serverSocketChannel.accept();  
  80.               
  81.             receiveFile(socketChannel, new File("E:/test/server_receive.log"));  
  82.             sendFile(socketChannel, new File("E:/test/server_send.log"));  
  83.         } finally {  
  84.             try {  
  85.                 socketChannel.close();  
  86.             } catch(Exception ex) {}  
  87.         }  
  88.           
  89.     }  
  90.       
  91.     private static void receiveFile(SocketChannel socketChannel, File file) throws IOException {  
  92.         FileOutputStream fos = null;  
  93.         FileChannel channel = null;  
  94.           
  95.         try {  
  96.             fos = new FileOutputStream(file);  
  97.             channel = fos.getChannel();  
  98.             ByteBuffer buffer = ByteBuffer.allocateDirect(1024);  
  99.   
  100.             int size = 0;  
  101.             while ((size = socketChannel.read(buffer)) != -1) {  
  102.                 buffer.flip();  
  103.                 if (size > 0) {  
  104.                     buffer.limit(size);  
  105.                     channel.write(buffer);  
  106.                     buffer.clear();  
  107.                 }  
  108.             }  
  109.         } finally {  
  110.             try {  
  111.                 channel.close();  
  112.             } catch(Exception ex) {}  
  113.             try {  
  114.                 fos.close();  
  115.             } catch(Exception ex) {}  
  116.         }  
  117.     }  
  118.   
  119.     private static void sendFile(SocketChannel socketChannel, File file) throws IOException {  
  120.         FileInputStream fis = null;  
  121.         FileChannel channel = null;  
  122.         try {  
  123.             fis = new FileInputStream(file);  
  124.             channel = fis.getChannel();  
  125.             ByteBuffer buffer = ByteBuffer.allocateDirect(1024);  
  126.             int size = 0;  
  127.             while ((size = channel.read(buffer)) != -1) {  
  128.                 buffer.rewind();  
  129.                 buffer.limit(size);  
  130.                 socketChannel.write(buffer);  
  131.                 buffer.clear();  
  132.             }  
  133.             socketChannel.socket().shutdownOutput();  
  134.         } finally {  
  135.             try {  
  136.                 channel.close();  
  137.             } catch(Exception ex) {}  
  138.             try {  
  139.                 fis.close();  
  140.             } catch(Exception ex) {}  
  141.         }  
  142.     }  
  143. }  

下面是Client程序代码，也主要关注sendFile和receiveFile方法

 

 

[java] view plaincopyprint?
  1. package com.googlecode.garbagecan.test.socket.nio;  
  2.   
  3. import java.io.File;  
  4. import java.io.FileInputStream;  
  5. import java.io.FileOutputStream;  
  6. import java.io.IOException;  
  7. import java.net.InetSocketAddress;  
  8. import java.net.SocketAddress;  
  9. import java.nio.ByteBuffer;  
  10. import java.nio.channels.FileChannel;  
  11. import java.nio.channels.SocketChannel;  
  12. import java.util.logging.Level;  
  13. import java.util.logging.Logger;  
  14.   
  15. public class MyClient4 {  
  16.   
  17.     private final static Logger logger = Logger.getLogger(MyClient4.class.getName());  
  18.       
  19.     public static void main(String[] args) throws Exception {  
  20.         new Thread(new MyRunnable()).start();  
  21.     }  
  22.       
  23.     private static final class MyRunnable implements Runnable {  
  24.         public void run() {  
  25.             SocketChannel socketChannel = null;  
  26.             try {  
  27.                 socketChannel = SocketChannel.open();  
  28.                 SocketAddress socketAddress = new InetSocketAddress("localhost", 10000);  
  29.                 socketChannel.connect(socketAddress);  
  30.   
  31.                 sendFile(socketChannel, new File("E:/test/client_send.log"));  
  32.                 receiveFile(socketChannel, new File("E:/test/client_receive.log"));  
  33.             } catch (Exception ex) {  
  34.                 logger.log(Level.SEVERE, null, ex);  
  35.             } finally {  
  36.                 try {  
  37.                     socketChannel.close();  
  38.                 } catch(Exception ex) {}  
  39.             }  
  40.         }  
  41.   
  42.         private void sendFile(SocketChannel socketChannel, File file) throws IOException {  
  43.             FileInputStream fis = null;  
  44.             FileChannel channel = null;  
  45.             try {  
  46.                 fis = new FileInputStream(file);  
  47.                 channel = fis.getChannel();  
  48.                 ByteBuffer buffer = ByteBuffer.allocateDirect(1024);  
  49.                 int size = 0;  
  50.                 while ((size = channel.read(buffer)) != -1) {  
  51.                     buffer.rewind();  
  52.                     buffer.limit(size);  
  53.                     socketChannel.write(buffer);  
  54.                     buffer.clear();  
  55.                 }  
  56.                 socketChannel.socket().shutdownOutput();  
  57.             } finally {  
  58.                 try {  
  59.                     channel.close();  
  60.                 } catch(Exception ex) {}  
  61.                 try {  
  62.                     fis.close();  
  63.                 } catch(Exception ex) {}  
  64.             }  
  65.         }  
  66.   
  67.         private void receiveFile(SocketChannel socketChannel, File file) throws IOException {  
  68.             FileOutputStream fos = null;  
  69.             FileChannel channel = null;  
  70.               
  71.             try {  
  72.                 fos = new FileOutputStream(file);  
  73.                 channel = fos.getChannel();  
  74.                 ByteBuffer buffer = ByteBuffer.allocateDirect(1024);  
  75.   
  76.                 int size = 0;  
  77.                 while ((size = socketChannel.read(buffer)) != -1) {  
  78.                     buffer.flip();  
  79.                     if (size > 0) {  
  80.                         buffer.limit(size);  
  81.                         channel.write(buffer);  
  82.                         buffer.clear();  
  83.                     }  
  84.                 }  
  85.             } finally {  
  86.                 try {  
  87.                     channel.close();  
  88.                 } catch(Exception ex) {}  
  89.                 try {  
  90.                     fos.close();  
  91.                 } catch(Exception ex) {}  
  92.             }  
  93.         }  
  94.     }  
  95. }  

首先运行MyServer4类启动监听，然后运行MyClient4类来向服务器发送文件以及接受服务器响应文件。运行完后，分别检查服务器和客户端接收到的文件。

分享到：
| Java Socket实战之六 使用NIO包实现Sock ...
评论
发表评论

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

相关推荐

    Java Socket实战之二 多线程通信 .

    我们将结合"Java Socket实战之二 多线程通信"这篇博文进行深入解析。 首先，了解Socket的基本概念。Socket在计算机网络中扮演着客户端与服务器之间通信的桥梁角色。它提供了低级别的、面向连接的、基于TCP/IP协议的...

    基于socket的文件传输

    本项目“基于socket的文件传输”是针对Java Socket编程的一次实战练习，旨在实现单方文件的传输功能。在这个过程中，我们将深入探讨Socket编程的核心概念、步骤以及如何应用它们来实现文件的网络传输。 Socket，...

    Java Socket网络编程.pdf

    完整的Socket通信过程包括四个步骤： 1. 建立网络连接：客户端发起连接请求，服务器端监听并响应，生成新的Socket。 2. 打开Socket的输入/输出流：获取Socket的I/O流，为数据传输做好准备。 3. 数据读写：通过输入流...

    java Socket通信实现.zip

    Java Socket通信是网络编程中的基础概念，主要用于两台计算机之间的数据传输。Socket在Java中被封装为类，提供了客户端和服务器端进行双向通信的能力。在这个"java Socket通信实现.zip"的压缩包中，可能包含了关于...

    java socket教程.

    Java Socket教程是学习Java网络编程的核心内容，它涵盖了如何通过Java API进行客户端和服务器之间的通信。Socket在计算机网络中扮演着桥梁的角色，允许两台计算机（客户端和服务器）通过TCP/IP协议交换数据。本教程...

    java socket 编程文档

    Java套接字编程是网络通信的核心技术之一，它允许Java应用程序之间或应用程序与远程服务器之间的双向数据传输。本文将深入探讨Java Socket编程的基础知识、关键概念以及如何在实践中应用。 一、Socket概述 Socket，...

    java socket 中文教程

    这将加深对Socket通信机制的理解，提高实际编程能力。 本Java Socket中文教程旨在全面讲解Socket编程的核心概念和实践技巧，帮助开发者构建自己的网络应用程序。阅读HTML文档，你可以找到更多关于Socket编程的实例...

    基于Java的源码-Java Socket通信实现.zip

    10. **实战应用**：Java Socket通信不仅限于命令行程序，还可以嵌入到Web应用、桌面应用中，例如，WebSocket协议就是基于TCP的Socket实现的，用于在Web浏览器和服务器之间进行全双工通信。 以上是对"基于Java的源码...

    java socket教程java socket教程

    总结，Java Socket教程涵盖了从基础的Socket通信机制到高级特性的全面内容。通过学习，开发者可以构建功能丰富的网络应用程序，满足各种需求。实践中，理解Socket的工作原理，掌握异常处理和资源管理，是提升Java...

    java socket 学习资料

    Socket在Java中被广泛用于构建客户端-服务器应用，例如创建Web服务器、聊天应用程序、文件传输等。以下是一些关于Java Socket的重要知识点： 1. **Socket类与ServerSocket类**： - `Socket`类代表网络通信中的...

    java socket通信h

    Java Socket通信是网络编程中的重要组成部分，主要用于实现客户端与服务器之间的双向通信。Socket在Java中提供了TCP（传输控制协议）的编程接口，使得开发者能够构建可靠的、基于连接的数据传输通道。下面将详细介绍...

    JAVA Socket 网络编程教程

    Java Socket网络编程是Java开发中一个重要的组成部分，它允许应用程序通过网络进行通信，实现客户端与服务器之间的数据交换。本教程将深入探讨Java Socket编程的基本概念、原理和实践应用。 一、Socket基本概念 ...

    Java Socket源码

    - 编译好的Socket通信示例程序，可以直接运行体验Socket通信的过程。 - 用于测试Socket性能的工具，例如并发连接测试、数据传输速率测试等。 通过深入研究Java Socket的源码，开发者能够更好地理解网络编程的底层...

    java socket tcpip多线程网络通信服务器客户端

    在“java socket tcpip多线程网络通信服务器客户端”这个主题中，我们将深入探讨如何使用Java Socket实现基于TCP/IP协议的多线程服务器和客户端通信。 TCP（传输控制协议）是一种面向连接的、可靠的、基于字节流的...

    java的socket编程课件~~~

    它们共同构建了Socket通信的基本框架。 1. **创建Socket连接**： - 客户端通过`Socket(String host, int port)`构造函数建立到指定服务器的连接。`host`是服务器的IP地址或域名，`port`是服务器监听的端口号。 - ...

    Java Socket示例

    - **安全通信**：为了增强安全性，可以引入SSL/TLS来加密Socket通信，防止数据在传输过程中被窃取或篡改。 综上所述，"Java Socket示例"是一个展示如何在Java中使用Socket进行网络通信的基础应用，它涉及到了网络...

    Java socket tcp/ip

    Java套接字（Socket）是Java编程中用于网络通信的核心组件，它基于传输控制协议/因特网协议（TCP/IP）模型。TCP/IP是互联网上应用最广泛的一种通信协议，确保了数据的可靠传输。本篇文章将深入探讨Java中如何使用...

    java基于socket手写协议的在线考试系统

    在Java中，`java.net.Socket`类和`ServerSocket`类是实现Socket通信的核心。开发者需要定义客户端和服务端的交互协议，包括数据格式、请求类型和响应格式等，这正是“手写协议”的含义。 在这个系统中，协议设计至...

    Android手机客户端与服务器之间通信socket

    在Android应用开发中，手机客户端与服务器之间的通信是至关重要的，而Socket通信提供了一种可靠的、基于连接的数据传输方式。本文将深入探讨Android客户端如何利用Socket进行与服务器的交互。 一、Socket基础知识 ...

    java socket，javasocket教程

    Java Socket是Java编程语言中用于网络通信的核心API，它提供了低级别的、面向连接的、基于TCP/IP的通信机制。在Java Socket编程中，我们可以创建服务器端（ServerSocket）来监听客户端（Socket）的连接请求，然后...

Magicbox
Global site tag (gtag.js) - Google Analytics