`
sydxide2006
  • 浏览: 69883 次
  • 性别: Icon_minigender_1
  • 来自: 广州
社区版块
存档分类
最新评论

java 网络文件传输

Java网络协议SocketVC++Linux 
阅读更多

平台要求：<o:p></o:p>

1.         Windows或Unix/Linux

2.         JAVA／VC／BCB／Delphi

<o:p> </o:p>

功能要求：<o:p></o:p>

1.         通过SOCKET实现点对点的文件交换功能

2.         支持连接握手、登录校验、文件传输请求应答、出错重传等交互的通信协议机制

3.         提供简单的用户界面或命令行界面

java 代码
java 代码
  1. package filetranslate;   
  2.   
  3. import java.io.BufferedInputStream;   
  4. import java.io.BufferedOutputStream;   
  5. import java.io.DataInputStream;   
  6. import java.io.DataOutputStream;   
  7. import java.io.File;   
  8. import java.io.IOException;   
  9. import java.io.InputStream;   
  10. import java.io.OutputStream;   
  11. import java.io.RandomAccessFile;   
  12. import java.net.Socket;   
  13. import java.util.HashMap;   
  14.   
  15. public class FileServ extends Thread{   
  16.        
  17.     Socket sc=null;   
  18.     InputStream in =null;   
  19.     OutputStream out=null;   
  20.     DataInputStream inStream = null;   
  21.     DataOutputStream outStream = null;   
  22.     BufferedInputStream bn =null;   
  23.     BufferedOutputStream bo =null;   
  24.     String servercepath="d:/socketserver/";   
  25.        
  26.     String tempfilename=null;   
  27.     static int point=0;   
  28.        
  29.     HashMap hs=new HashMap();   
  30.   
  31.     public FileServ(){   
  32.            
  33.     }   
  34.        
  35.     public FileServ(Socket sc){   
  36.         this.sc=sc;   
  37.         try {   
  38.             bn=new BufferedInputStream( new DataInputStream(sc.getInputStream()));   
  39.             bo=new BufferedOutputStream(new DataOutputStream(sc.getOutputStream()));   
  40.         } catch (IOException e) {   
  41.             e.printStackTrace();   
  42.         }   
  43.            
  44.     }   
  45.     /**   
  46.      * 接受发送消息  
  47.      * @return 返回的消息  
  48.      * @throws IOException   
  49.      */  
  50.     public String receiverMessage() throws IOException {   
  51.         int num = 0;   
  52.         byte[] br = null;   
  53.         br = new byte[2048];   
  54.         num = bn.read(br);   
  55.         if(num!=-1){   
  56.             return new String(br, 0, num);     
  57.         }else{   
  58.             return null;   
  59.         }   
  60.            
  61.            
  62.     }/**   
  63.      * 接受文件  
  64.      * @return  
  65.      */    
  66.     public boolean receviceFile(){   
  67.         //使用本地文件系统接受网络数据并存为新文件   
  68.         File file=new File(servercepath+tempfilename);   
  69.         RandomAccessFile raf=null;   
  70.         int count=0;   
  71.         try {   
  72.             file.createNewFile();   
  73.             raf=new RandomAccessFile(file,"rw");   
  74.             byte[] buf=new byte[2048];   
  75.             int num=bn.read(buf);   
  76.                
  77.             while(num!=(-1)){//是否读完所有数据   
  78.                    raf.write(buf,0,num);//将数据写往文件   
  79.                    count=count+num;   
  80.                    raf.skipBytes(num);//顺序写文件字节   
  81.                    num=bn.read(buf);//继续从网络中读取文件   
  82.             }   
  83.             bn.close();   
  84.             raf.close();   
  85.                
  86.         } catch (IOException e) {   
  87.             hs.put(tempfilename, new Integer(count));   
  88.             e.printStackTrace();   
  89.             return false;   
  90.         }finally{   
  91.             if(raf!=null){   
  92.                 try {   
  93.                     raf.close();   
  94.                 } catch (IOException e) {   
  95.                     return false;   
  96.                 }   
  97.             }   
  98.                
  99.         }   
  100.         hs.put(tempfilename, new Integer(count));   
  101.         return true;   
  102.  }   
  103.   
  104. /**   
  105. * 接受断点文件  
  106. * @return  
  107. */  
  108.     public boolean recevicefollowFile(){   
  109.         //使用本地文件系统接受网络数据并存为新文件   
  110.         File file=new File(servercepath+tempfilename);   
  111.         RandomAccessFile raf=null;   
  112.         int count=0;   
  113.         try {   
  114.             raf=new RandomAccessFile(file,"rw");   
  115.             byte[] buf=new byte[2048];   
  116.             int num=bn.read(buf);   
  117.             while(num!=(-1)){//是否读完所有数据   
  118.                    raf.skipBytes(point);//顺序写文件字节   
  119.                    raf.write(buf,0,num);//将数据写往文件   
  120.                    count=count+num;   
  121.                    raf.skipBytes(num);//顺序写文件字节   
  122.                    num=bn.read(buf);//继续从网络中读取文件   
  123.             }   
  124.             bn.close();   
  125.             raf.close();   
  126.                
  127.         } catch (IOException e) {   
  128.             hs.put(tempfilename, new Integer(count));   
  129.             e.printStackTrace();   
  130.             return false;   
  131.         }finally{   
  132.             if(raf!=null){   
  133.                 try {   
  134.                     raf.close();   
  135.                 } catch (IOException e) {   
  136.                     return false;   
  137.                 }   
  138.             }   
  139.                
  140.         }   
  141.         hs.put(tempfilename, new Integer(count));   
  142.         return true;   
  143.  }   
  144.     /**   
  145.      * 发送消息  
  146.      * @return 返回的消息  
  147.      * @throws IOException   
  148.      */  
  149.     public void sendMessage(String str) throws IOException {   
  150.         byte[] bw = str.getBytes();   
  151.         try {   
  152.             bo.write(bw);   
  153.             bo.flush();   
  154.         } catch (IOException e1) {   
  155.             e1.printStackTrace();   
  156.         }   
  157.             }   
  158.     /**  
  159.      * 关闭流和socket  
  160.      *   
  161.      */  
  162.     public void destory() {   
  163.         if (bo != null) {   
  164.             try {   
  165.                 bo.close();   
  166.             } catch (IOException e) {   
  167.                 e.printStackTrace();   
  168.             }   
  169.         }   
  170.         if (bn != null) {   
  171.             try {   
  172.                 bn.close();   
  173.             } catch (IOException e) {   
  174.                 e.printStackTrace();   
  175.             }   
  176.             if (sc != null) {   
  177.                 try {   
  178.                     sc.close();   
  179.                 } catch (IOException e) {   
  180.                     e.printStackTrace();   
  181.                 }   
  182.             }      
  183.   
  184.         }   
  185.     }   
  186.     public void run() {   
  187.         while(true){   
  188.             try {   
  189.                 String str=receiverMessage()    ;   
  190.                 if(str!=null){   
  191.                 if(str.substring(0, 1).equalsIgnoreCase("1")){   
  192.                     System.out.println("认证处理");   
  193.                     String [] strarry=str.split(",");   
  194.                     if(strarry[1].equalsIgnoreCase("admin")&&strarry[2].equalsIgnoreCase("admin")){   
  195.                         System.out.println("认证成功");   
  196.                         sendMessage("ok");   
  197.                     }else{   
  198.                         System.out.println("认证失败");   
  199.                         sendMessage("error");   
  200.                            
  201.                     }   
  202.                 }else if(str.substring(0, 1).equalsIgnoreCase("2")){//上传请求处理   
  203.                     String [] strarry=str.split(",");   
  204.                     tempfilename=strarry[1].substring(strarry[1].lastIndexOf("/")+1);   
  205.                     System.out.println("文件接受:文件名为"+tempfilename);   
  206.                     if(!hs.containsKey(tempfilename)){   
  207.                         sendMessage("2,ok");   
  208.                         if(receviceFile()){   
  209.                         System.out.println("文件接受成功");   
  210.                         }else{   
  211.                         System.out.println("文件接受失败");   
  212.                         }   
  213.                         break;   
  214.                     }else{   
  215.                         sendMessage("2,error,"+((Integer)hs.get(tempfilename)).intValue());   
  216.                            
  217.                     }   
  218.                        
  219.                 }else if(str.substring(0, 1).equalsIgnoreCase("3")){//重传处理3,1.  续传3,2   
  220.                     String [] strarry=str.split(",");   
  221.                     if(strarry[1].equalsIgnoreCase("1")){   
  222.                         System.out.println("客户端重新上传文件");   
  223.                         sendMessage("3,ok");   
  224.                         File fl=new File(servercepath+tempfilename);   
  225.                         if(fl.exists())   
  226.                         {   
  227.                         fl.delete();       
  228.                         }   
  229.                         hs.remove(tempfilename);   
  230.                         if(receviceFile()){   
  231.                             System.out.println("文件接受成功");   
  232.                             }else{   
  233.                             System.out.println("文件接受失败");   
  234.                             }   
  235.                         break;   
  236.                     }else if(strarry[1].equalsIgnoreCase("2")){   
  237.                         System.out.println("客户端续传文件");   
  238.                         sendMessage("3,ok");   
  239.                         hs.remove(tempfilename);   
  240.                         if(receviceFile()){   
  241.                             System.out.println("续传接受成功");   
  242.                             }else{   
  243.                             System.out.println("续传接受失败");   
  244.                             }   
  245.                         break;   
  246.                     }   
  247.                        
  248.                 }   
  249.                 }   
  250.             } catch (IOException e) {   
  251.                    
  252.             }   
  253.                
  254.     }   
  255.     }   
  256.        
  257. }   
java 代码
  1. package filetranslate;   
  2.   
  3. import java.io.*;   
  4. import java.net.*;   
  5. import java.util.HashMap;   
  6. /**   
  7.  * 文件传输服务器端口  
  8.  * @author sydxide  
  9.  *  
  10.  */  
  11.   
  12. public class FileServer {   
  13.     ServerSocket ss = null;   
  14.   
  15.     Socket s = null;   
  16.   
  17.     DataInputStream inStream = null;   
  18.   
  19.     DataOutputStream outStream = null;   
  20.        
  21.     String servercepath="d:/socketserver/";   
  22.        
  23.     String tempfilename=null;   
  24.     static int point=0;   
  25.        
  26.     HashMap hs=new HashMap();   
  27.   
  28.     public FileServer() {   
  29.         try {   
  30.             ss = new ServerSocket(5678);   
  31.             init();   
  32.         } catch (Exception e) {   
  33.             System.out.println(e.toString());   
  34.         }   
  35.     }   
  36. /**   
  37.  * 初始化SOCKET  
  38.  * @throws Exception  
  39.  */  
  40.     public void init() throws Exception {   
  41.            
  42.         s = ss.accept();   
  43.         System.out.println("客户端连接了服务器 "+s.getInetAddress());   
  44.         if(inStream==null){   
  45.         inStream = new DataInputStream(s.getInputStream());}   
  46.         if(outStream==null){   
  47.         outStream = new DataOutputStream(s.getOutputStream());}   
  48.         process();   
  49.     }   
  50.        
  51.     /**   
  52.      * 接受发送消息  
  53.      * @return 返回的消息  
  54.      * @throws IOException   
  55.      */  
  56.     public String receiverMessage() throws IOException {   
  57.         int num = 0;   
  58.         byte[] br = null;   
  59.         br = new byte[2048];   
  60.         num = inStream.read(br);   
  61.         if(num!=-1){   
  62.             return new String(br, 0, num);     
  63.         }else{   
  64.             return null;   
  65.         }   
  66.            
  67.            
  68.     }   
  69.     /**   
  70.      * 根据接受的参数进行处理  
  71.      *  
  72.      */  
  73.         public  void process(){   
  74.         while(true){   
  75.                 try {   
分享到：
| 现有Mysql数据库，写Spring + Hibernate的 ...
评论
1 楼 nise 2010-07-23  
代码不全？
发表评论

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

相关推荐

    Java网络文件传输

    Java网络文件传输是一种在计算机网络中通过Java编程语言实现的文件共享技术。它涉及网络通信协议、I/O流处理和多线程等核心概念。在这个主题中，我们将深入探讨Java如何实现这一功能，并通过源代码分析来理解其实现...

    java网络文件传输

    Java网络文件传输是一种在两台计算机之间通过网络交换文件的技术，通常涉及到TCP/IP协议栈、套接字编程以及多线程等核心概念。本示例中的"FileTranClient"和"FileTranServer"是两个关键文件，分别代表客户端和服务器...

    java网络文件传输（c/s）

    【Java网络文件传输（C/S）详解】 在网络开发中，文件传输是一项重要的功能，无论是文本文件还是图像文件，都需要能够高效、稳定地在网络之间传递。本文将深入探讨使用Java实现客户端/服务器（C/S）模式的文件传输...

    使用java实现网络文件的传输

    为了编译和运行Java网络文件传输程序，需要执行以下步骤： - 使用`javac`命令编译`.java`源文件，生成`.class`字节码文件。 - 在命令行中，分别使用`java SendFileSocket`启动服务器，和`java SendFileClient ...

    java实现网络文件传输

    本项目以"java实现网络文件传输"为主题，涵盖了服务器和客户端的编程实现，涉及到的关键技术包括Socket编程、接口设计以及源码解析。下面将详细介绍这些知识点。 1. **Java Socket编程**： Java Socket是Java提供...

    [毕业设计]JAVA网络文件传输系统的开发(源代码+论文+开题报告).zip

    [毕业设计]JAVA网络文件传输系统的开发(源代码+论文+开题报告)

    如何利用Java实现QQ文件传输功能

    本知识点将围绕Java网络编程中的Socket通信和文件传输的实现原理进行详细探讨。 1. Java网络编程基础 Java网络编程提供了两个基本的类来实现网络通信，分别是Socket和ServerSocket类。Socket代表客户端的套接字，它...

    用java代码编写的网络传输文件

    以下是一个简单的网络文件传输的概述： 1. **服务器端**： - 首先，服务器创建一个`ServerSocket`实例，并绑定到特定的IP地址和端口号，然后调用`accept()`方法开始监听客户端的连接请求。 - 当客户端连接请求...

    Java网络编程-Socket-文件传输小案例

    9. **断点续传**：在实际应用中，文件传输可能需要支持断点续传功能，即在传输中断后可以从上次断开的位置继续传输。这需要服务器和客户端保存并交换已传输的数据状态。 10. **安全性**：对于敏感的文件传输，可以...

    java文件p2p传输

    Java P2P文件传输利用P2P网络架构，其中每个节点既是服务的消费者也是服务的提供者。在Java中，这通常涉及到创建客户端和服务器端的类，分别用于发起请求和响应请求。这些节点可以动态地加入和离开网络，形成一个去...

    java局域网文件传输源码

    Java局域网文件传输源码是一个实用的编程项目，它允许...通过学习和分析这个Java局域网文件传输源码，开发者可以深入理解Java网络编程、文件I/O、多线程以及可能涉及的其他高级技术，对于提升Java编程技能非常有帮助。

    Java 局域网文件传输

    5. **断点续传**：在大文件传输时，断点续传功能非常有用。这需要在发送文件时保存已传输的字节数，并在连接恢复时从上次中断的位置继续传输。 6. **进度条显示**：为了让用户了解传输进度，可以在程序中添加进度条...

    java局域网文件传输

    在实际开发中，如果希望实现类似飞鸽传书的效果，可以考虑实现一个轻量级的文件传输协议，确保文件传输的可靠性和安全性。 项目中的"src"目录下的"ui"包被提到是实验性的，且未被使用。这可能表明项目采用命令行...

    java文件传输工具

    Java文件传输工具是一种基于Java开发的应用程序，设计用于实现基本的点对点（P2P）文件传输功能。这个工具提供了简单易用的界面，让用户能够方便地在两台计算机之间共享和移动文件。以下是对该工具核心特性和技术...

    Java大文件传输示例额

    在Java编程环境中，大文件传输是一项常见的挑战，尤其是在网络上传输或者处理大量数据时。本示例主要关注如何高效地传输大文件，通过将大文件分解为较小的数据块，然后逐个传输这些小块，最后在接收端进行组装。这种...

    java1071网络文件传输系统2借鉴.pdf

    本文设计了一个基于FTP协议的Java网络文件传输系统，该系统利用Java的网络编程能力，结合多线程和断点续传技术，提供了高效、安全的文件传输环境。尽管FTP本身存在一些限制，但通过合理的设计和优化，本系统能够满足...

    java版文件传输的小程序

    在Java编程语言中，文件传输是一项基础且重要的任务，它涉及到数据的读取、写入以及在网络中的发送和接收。这个“java版文件传输的小程序”可能是为了演示如何使用Java API来实现文件的本地操作或者网络上的文件共享...

    Java Tcp 文件传输

    Java TCP文件传输是一种基于网络的通信方式，利用TCP（传输控制协议）的可靠连接特性来实现文件在不同设备之间的安全传输。在这个过程中，通常需要创建一个服务器端来监听客户端的连接请求，然后客户端通过建立连接...

    基于java文件传输示例

    Java作为一种广泛应用的编程语言，提供了多种方式实现文件在网络间的传输，其中，基于Socket的文件传输因其高效、稳定的特点而备受青睐。本文将深入探讨基于Java和Socket技术的文件传输原理，并通过一个实际示例，...

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