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

使用org.apache.commons.net.ftp包开发FTP客户端,实现进度汇报,实现断点续传,中文支持

    博客分类:
  • java
阅读更多

使用org.apache.commons.net.ftp包开发FTP客户端,实现进度汇报,实现断点续传,中文支持
利用org.apache.commons.net.ftp包实现一个简单的ftp客户端实用类。主要实现一下功能

1.支持上传下载。支持断点续传

2.支持进度汇报

3.支持对于中文目录及中文文件创建的支持。

import java.io.File;  
import java.io.FileOutputStream;  
import java.io.IOException;  
import java.io.InputStream;  
import java.io.OutputStream;  
import java.io.PrintWriter;  
import java.io.RandomAccessFile;  
 
import open.mis.data.DownloadStatus;  
import open.mis.data.UploadStatus;  
 
import org.apache.commons.net.PrintCommandListener;  
import org.apache.commons.net.ftp.FTP;  
import org.apache.commons.net.ftp.FTPClient;  
import org.apache.commons.net.ftp.FTPFile;  
import org.apache.commons.net.ftp.FTPReply;  
 
/** *//** 
* 支持断点续传的FTP实用类 
* @author BenZhou  http://www.bt285.cn
* @version 0.1 实现基本断点上传下载 
* @version 0.2 实现上传下载进度汇报 
* @version 0.3 实现中文目录创建及中文文件创建,添加对于中文的支持 
*/ 
public class ContinueFTP {  
    public FTPClient ftpClient = new FTPClient();  
      
    public ContinueFTP(){  
        //设置将过程中使用到的命令输出到控制台  
        this.ftpClient.addProtocolCommandListener(new PrintCommandListener(new PrintWriter(System.out)));  
    }  
      
    /** *//** 
     * 连接到FTP服务器 
     * @param hostname 主机名 
     * @param port 端口 
     * @param username 用户名 
     * @param password 密码 
     * @return 是否连接成功 
     * @throws IOException 
     */ 
    public boolean connect(String hostname,int port,String username,String password) throws IOException{  
        ftpClient.connect(hostname, port);  
        ftpClient.setControlEncoding("GBK");  
        if(FTPReply.isPositiveCompletion(ftpClient.getReplyCode())){  
            if(ftpClient.login(username, password)){  
                return true;  
            }  
        }  
        disconnect();  
        return false;  
    }  
      
    /** *//** 
     * 从FTP服务器上下载文件,支持断点续传,上传百分比汇报 
     * @param remote 远程文件路径 
     * @param local 本地文件路径 
     * @return 上传的状态 
     * @throws IOException 
     */ 
    public DownloadStatus download(String remote,String local) throws IOException{  
        //设置被动模式  
        ftpClient.enterLocalPassiveMode();  
        //设置以二进制方式传输  
        ftpClient.setFileType(FTP.BINARY_FILE_TYPE);  
        DownloadStatus result;  
          
        //检查远程文件是否存在  
        FTPFile[] files = ftpClient.listFiles(new String(remote.getBytes("GBK"),"iso-8859-1"));  
        if(files.length != 1){  
            System.out.println("远程文件不存在");  
            return DownloadStatus.Remote_File_Noexist;  
        }  
          
        long lRemoteSize = files[0].getSize();  
        File f = new File(local);  
        //本地存在文件,进行断点下载  
        if(f.exists()){  
            long localSize = f.length();  
            //判断本地文件大小是否大于远程文件大小  
            if(localSize >= lRemoteSize){  
                System.out.println("本地文件大于远程文件,下载中止");  
                return DownloadStatus.Local_Bigger_Remote;  
            }  
              
            //进行断点续传,并记录状态  
            FileOutputStream out = new FileOutputStream(f,true);  
            ftpClient.setRestartOffset(localSize);  
            InputStream in = ftpClient.retrieveFileStream(new String(remote.getBytes("GBK"),"iso-8859-1"));  
            byte[] bytes = new byte[1024];  
            long step = lRemoteSize /100;  
            long process=localSize /step;  
            int c;  
            while((c = in.read(bytes))!= -1){  
                out.write(bytes,0,c);  
                localSize+=c;  
                long nowProcess = localSize /step;  
                if(nowProcess > process){  
                    process = nowProcess;  
                    if(process % 10 == 0)  
                        System.out.println("下载进度:"+process);  
                    //TODO 更新文件下载进度,值存放在process变量中  
                }  
            }  
            in.close();  
            out.close();  
            boolean isDo = ftpClient.completePendingCommand();  
            if(isDo){  
                result = DownloadStatus.Download_From_Break_Success;  
            }else {  
                result = DownloadStatus.Download_From_Break_Failed;  
            }  
        }else {  
            OutputStream out = new FileOutputStream(f);  
            InputStream in= ftpClient.retrieveFileStream(new String(remote.getBytes("GBK"),"iso-8859-1"));  
            byte[] bytes = new byte[1024];  
            long step = lRemoteSize /100;  
            long process=0;  
            long localSize = 0L;  
            int c;  
            while((c = in.read(bytes))!= -1){  
                out.write(bytes, 0, c);  
                localSize+=c;  
                long nowProcess = localSize /step;  
                if(nowProcess > process){  
                    process = nowProcess;  
                    if(process % 10 == 0)  
                        System.out.println("下载进度:"+process);  
                    //TODO 更新文件下载进度,值存放在process变量中  
                }  
            }  
            in.close();  
            out.close();  
            boolean upNewStatus = ftpClient.completePendingCommand();  
            if(upNewStatus){  
                result = DownloadStatus.Download_New_Success;  
            }else {  
                result = DownloadStatus.Download_New_Failed;  
            }  
        }  
        return result;  
    }  
      
    /** *//** 
     * 上传文件到FTP服务器,支持断点续传 
     * @param local 本地文件名称,绝对路径 
     * @param remote 远程文件路径,使用/home/directory1/subdirectory/file.ext或是 http://www.guihua.org /subdirectory/file.ext 按照Linux上的路径指定方式,支持多级目录嵌套,支持递归创建不存在的目录结构 
     * @return 上传结果 
     * @throws IOException 
     */ 
    public UploadStatus upload(String local,String remote) throws IOException{  
        //设置PassiveMode传输  
        ftpClient.enterLocalPassiveMode();  
        //设置以二进制流的方式传输  
        ftpClient.setFileType(FTP.BINARY_FILE_TYPE);  
        ftpClient.setControlEncoding("GBK");  
        UploadStatus result;  
        //对远程目录的处理  
        String remoteFileName = remote;  
        if(remote.contains("/")){  
            remoteFileName = remote.substring(remote.lastIndexOf("/")+1);  
            //创建服务器远程目录结构,创建失败直接返回  
            if(CreateDirecroty(remote, ftpClient)==UploadStatus.Create_Directory_Fail){  
                return UploadStatus.Create_Directory_Fail;  
            }  
        }  
          
        //检查远程是否存在文件  
        FTPFile[] files = ftpClient.listFiles(new String(remoteFileName.getBytes("GBK"),"iso-8859-1"));  
        if(files.length == 1){  
            long remoteSize = files[0].getSize();  
            File f = new File(local);  
            long localSize = f.length();  
            if(remoteSize==localSize){  
                return UploadStatus.File_Exits;  
            }else if(remoteSize > localSize){  
                return UploadStatus.Remote_Bigger_Local;  
            }  
              
            //尝试移动文件内读取指针,实现断点续传  
            result = uploadFile(remoteFileName, f, ftpClient, remoteSize);  
              
            //如果断点续传没有成功,则删除服务器上文件,重新上传  
            if(result == UploadStatus.Upload_From_Break_Failed){  
                if(!ftpClient.deleteFile(remoteFileName)){  
                    return UploadStatus.Delete_Remote_Faild;  
                }  
                result = uploadFile(remoteFileName, f, ftpClient, 0);  
            }  
        }else {  
            result = uploadFile(remoteFileName, new File(local), ftpClient, 0);  
        }  
        return result;  
    }  
    /** *//** 
     * 断开与远程服务器的连接 
     * @throws IOException 
     */ 
    public void disconnect() throws IOException{  
        if(ftpClient.isConnected()){  
            ftpClient.disconnect();  
        }  
    }  
      
    /** *//** 
     * 递归创建远程服务器目录 
     * @param remote 远程服务器文件绝对路径 
     * @param ftpClient FTPClient对象 
     * @return 目录创建是否成功 
     * @throws IOException 
     */ 
    public UploadStatus CreateDirecroty(String remote,FTPClient ftpClient) throws IOException{  
        UploadStatus status = UploadStatus.Create_Directory_Success;  
        String directory = remote.substring(0,remote.lastIndexOf("/")+1);  
        if(!directory.equalsIgnoreCase("/")&&!ftpClient.changeWorkingDirectory(new String(directory.getBytes("GBK"),"iso-8859-1"))){  
            //如果远程目录不存在,则递归创建远程服务器目录  
            int start=0;  
            int end = 0;  
            if(directory.startsWith("/")){  
                start = 1;  
            }else{  
                start = 0;  
            }  
            end = directory.indexOf("/",start);  
            while(true){  
                String subDirectory = new String(remote.substring(start,end).getBytes("GBK"),"iso-8859-1");  
                if(!ftpClient.changeWorkingDirectory(subDirectory)){  
                    if(ftpClient.makeDirectory(subDirectory)){  
                        ftpClient.changeWorkingDirectory(subDirectory);  
                    }else {  
                        System.out.println("创建目录失败");  
                        return UploadStatus.Create_Directory_Fail;  
                    }  
                }  
                  
                start = end + 1;  
                end = directory.indexOf("/",start);  
                  
                //检查所有目录是否创建完毕  
                if(end <= start){  
                    break;  
                }  
            }  
        }  
        return status;  
    }  
      
    /** *//** 
     * 上传文件到服务器,新上传和断点续传 
     * @param remoteFile 远程文件名,在上传之前已经将服务器工作目录做了改变 
     * @param localFile 本地文件File句柄,绝对路径 
     * @param processStep 需要显示的处理进度步进值 
     * @param ftpClient FTPClient引用 
     * @return 
     * @throws IOException 
     */ 
    public UploadStatus uploadFile(String remoteFile,File localFile,FTPClient ftpClient,long remoteSize) throws IOException{  
        UploadStatus status;  
        //显示进度的上传  
        long step = localFile.length() / 100;  
        long process = 0;  
        long localreadbytes = 0L;  
        RandomAccessFile raf = new RandomAccessFile(localFile,"r");  
        OutputStream out = ftpClient.appendFileStream(new String(remoteFile.getBytes("GBK"),"iso-8859-1"));  
        //断点续传  
        if(remoteSize>0){  
            ftpClient.setRestartOffset(remoteSize);  
            process = remoteSize /step;  
            raf.seek(remoteSize);  
            localreadbytes = remoteSize;  
        }  
        byte[] bytes = new byte[1024];  
        int c;  
        while((c = raf.read(bytes))!= -1){  
            out.write(bytes,0,c);  
            localreadbytes+=c;  
            if(localreadbytes / step != process){  
                process = localreadbytes / step;  
                System.out.println("上传进度:" + process);  
                //TODO 汇报上传状态  
            }  
        }  
        out.flush();  
        raf.close();  
        out.close();  
        boolean result =ftpClient.completePendingCommand();  
        if(remoteSize > 0){  
            status = result?UploadStatus.Upload_From_Break_Success:UploadStatus.Upload_From_Break_Failed;  
        }else {  
            status = result?UploadStatus.Upload_New_File_Success:UploadStatus.Upload_New_File_Failed;  
        }  
        return status;  
    }  
      
    public static void main(String[] args) {  
        ContinueFTP myFtp = new ContinueFTP();  
        try {  
            myFtp.connect("192.168.21.181", 21, "nid", "123");  
//          myFtp.ftpClient.makeDirectory(new String("电视剧".getBytes("GBK"),"iso-8859-1"));  
//          myFtp.ftpClient.changeWorkingDirectory(new String("电视剧".getBytes("GBK"),"iso-8859-1"));  
//          myFtp.ftpClient.makeDirectory(new String("走西口".getBytes("GBK"),"iso-8859-1"));  
//          System.out.println(myFtp.upload("http://www.5a520.cn /yw.flv", "/yw.flv",5));  
//          System.out.println(myFtp.upload("http://www.5a520.cn /走西口24.mp4","/央视走西口/新浪网/走西口24.mp4"));  
            System.out.println(myFtp.download("/央视走西口/新浪网/走西口24.mp4", "E:\\走西口242.mp4"));  
            myFtp.disconnect();  
        } catch (IOException e) {  
            System.out.println("连接FTP出错:"+e.getMessage());  
        }  
    }  

分享到:
评论

相关推荐

    基于java的ftp客户端设计与实现

    此外,`org.apache.commons.net.ftp`库(如`FTPClient`和`FTP pymysql`)提供了更高级的FTP功能,如文件上传、下载、目录操作等,使得开发更为便捷。 3. 多线程技术: 为了提高文件传输效率,该项目可能采用了多...

    FTP断点续传

    下面是一个简单的示例代码片段,展示如何使用Java实现FTP断点续传的基本流程: ```java import org.apache.commons.net.ftp.FTPClient; public class FtpClientExample { public static void main(String[] args)...

    commons-net源码包

    1. **FTP协议实现**:Apache Commons Net包含了一个完整的FTP客户端库,支持主动和被动模式,断点续传,FTP上传和下载,以及FTP服务器的命令交互。源码中`org.apache.commons.net.ftp`包下的类,如`FTP`、`FTPClient...

    xuchuanftp_java_FTP断点续传_

    标题"XuChuanFTP_Java_FTP断点续传"可能是指一个Java实现的FTP客户端库或者一个示例项目,专注于支持FTP的断点续传功能。这个项目可能是为了帮助开发者更方便地处理大文件的上传任务,尤其是在网络不稳定的情况下。 ...

    ftp.rar_Java FTP上传_ftp_ftp 上传 进度_java ftp

    FTP上传功能通常包括断点续传和进度显示,这对于大型文件的传输尤其重要,因为它们允许在中断后从上次停止的位置继续,同时也提供了用户友好的反馈体验。 在Java中,我们可以使用Apache Commons Net库来实现FTP...

    java实现ftp断点续传Java实用源码整理learns

    本文将深入探讨如何使用Java实现FTP断点续传,并提供相关的源码整理。 FTP断点续传的核心原理是通过FTP协议中的REST(Restart)命令来实现。REST命令告诉服务器从指定的位置开始继续传输数据,而不是重新开始。在...

    Java开发FTP客户端

    `java.io`包中的流类来处理数据传输,同时为了方便地处理FTP命令,可以使用`org.apache.commons.net.ftp`库,它是Apache Commons Net的一部分,提供了丰富的FTP客户端功能。 1. **FTP协议基础**: FTP协议基于TCP/...

    java ftp 多线程 断点续传等知识

    在Java中,我们可以使用`java.net`包中的`Socket`类来实现基本的FTP功能,但更常见的是使用Apache Commons Net库,它提供了更丰富的FTP功能,包括多线程和断点续传。 FTP服务器是运行FTP服务的计算机,它存储着可供...

    javaFTPclient.rar_Ftp客户端__ftp_ftp客户端_ftp客户端 java_java ftp客户端

    Java的`org.apache.commons.net.ftp.FTPClient`库提供了这两种模式的支持。 4. **文件传输**:Java FTP客户端支持ASCII和二进制模式的文件传输。ASCII模式适用于文本文件,而二进制模式适用于所有其他类型的文件,...

    apache_ftp 开发包

    这个版本(3.3)提供了对FTP协议的新特性和优化,比如支持TLS/SSL加密连接,断点续传,以及更完善的错误处理机制。 `mina-core-2.0.4.jar`是Apache MINA库,它是一个网络应用框架,专注于简化异步I/O编程,尤其适用...

    java_apache_ftp断点续传(资料及实例)

    在这个资料包中,你将找到使用Apache Commons Net进行FTP断点续传的相关资料和实例,以及可能包含MyEclipse 9.0的开发环境配置和FileZilla服务器的设置指南。 Apache Commons Net库提供了FTPClient类,它是Java实现...

    android实现ftp断点续传下载类,完成后自动通知调用程序

    在Android平台上实现FTP断点续传下载功能,可以极大地提高用户下载大文件的效率和体验。断点续传允许应用程序在文件下载中断后从上次停止的地方继续,而不是重新开始整个下载过程。以下是对这一主题的详细阐述: 1....

    java ftp客户端,服务端

    此外,Java还提供了一个名为`org.apache.commons.net.ftp`的第三方库,它简化了FTP客户端和服务端的开发。这个库包含了FTPClient和FTPServer类,提供了许多预定义的方法来处理FTP操作,如登录、上传、下载、删除文件...

    java实现ftp的几种方式.doc

    Java 实现 FTP (File Transfer Protocol) 通常涉及使用 FTP 客户端库来与FTP服务器进行交互,以完成文件的上传、下载、删除等操作。本文将介绍几种使用 Java 实现 FTP 的方法,重点关注第三方库的使用。 1. **使用 ...

    JAVA FTP 文件传输 服务端 客户端

    1. **Java FTPClient库**: 如Apache Commons Net中的`FTPClient`类,提供了丰富的API来实现FTP客户端功能,如连接服务器、登录、上传/下载文件、断点续传等。 2. **连接管理**: 客户端需要正确管理FTP连接,包括...

    commons-net-3.0.1.jar ftp4j

    Ftp4j提供了一个完整的FTP客户端实现,包括基本的文件操作和更高级的功能,如断点续传、多线程下载、文件列表解析等。其API简洁且灵活,允许开发者根据需求自定义各种行为。Ftp4j还支持FTPS(FTP over TLS/SSL)和...

    java ftp 上传 下载 断点续传

    Java FTP(File Transfer Protocol)是Java编程中用于与FTP服务器交互的一种技术,它允许程序员编写应用程序来上传、下载文件,并实现断点续传功能。在本文中,我们将深入探讨Java FTP上传、下载以及断点续传的核心...

    java实现FTP断点续传

    Java 实现 FTP 断点续传是一项常见的...总的来说,实现Java中的FTP断点续传涉及理解FTP协议,使用适当的库,以及处理可能出现的网络和文件系统问题。在开发过程中,注意错误处理和性能优化,确保功能的稳定性和效率。

    基于Java的FTP客户端源代码

    这些源代码通常会有详细的注释,指导你如何处理异常、优化性能以及实现更复杂的功能,比如断点续传、多线程下载等。 总之,Java FTP客户端源代码提供了一个平台,让你可以利用Java的强大力量来实现文件的上传、下载...

    java实现FTP多线程断点续传

    ### Java实现FTP多线程断点续传:深入解析与技术要点 在现代软件开发中,数据传输是一项基本且关键的任务,特别是在处理...通过理解并应用上述关键技术点,开发者可以在自己的项目中实现高效、稳定的FTP断点续传功能。

Global site tag (gtag.js) - Google Analytics