`
lizh0912
  • 浏览: 1371 次
  • 性别: Icon_minigender_2
  • 来自: 北京
最近访客 更多访客>>
文章分类
社区版块
存档分类
最新评论

实现ftp断点下载和上传

阅读更多
1、 实现类
package ftp.test.continueDown;
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 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; 
import org.apache.log4j.Logger;
/**
* 利用org.apache.commons.net.ftp包实现一个简单的ftp客户端实用类。主要实现一下功能

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

2.支持进度汇报

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

* 支持断点续传的FTP实用类 
* @version 0.1 实现基本断点上传下载 
* @version 0.2 实现上传下载进度汇报 
* @version 0.3 实现中文目录创建及中文文件创建,添加对于中文的支持 
* @author shang_xying
*
*/

public class ContinueFTP {

private final Logger log = Logger.getLogger(ContinueFTP.class);

private static class continueFtp{
static ContinueFTP instance = new ContinueFTP();
}

public static ContinueFTP getInstance(){
return continueFtp.instance;
}

//枚举类UploadStatus
public enum UploadStatus {
  CREATE_DIRECTORY_FAIL, // 远程服务器相应目录创建失败
  CREATE_DIRECTORY_SUCCESS, // 远程服务器闯将目录成功
  UPLOAD_NEW_FILE_SUCCESS, // 上传新文件成功
  UPLOAD_NEW_FILE_FAILED, // 上传新文件失败
  FILE_EXITS, // 文件已经存在
  REMOTE_BIGGER_LOCAL, // 远程文件大于本地文件
  UPLOAD_FROM_BREAK_SUCCESS, // 断点续传成功
  UPLOAD_FROM_BREAK_FAILED, // 断点续传失败
  DELETE_REMOTE_FAILD; // 删除远程文件失败
}
//枚举类DownloadStatus
public enum DownloadStatus {
  REMOTE_FILE_NOEXIST, // 远程文件不存在
  LOCAL_BIGGER_REMOTE, // 本地文件大于远程文件
  DOWNLOAD_FROM_BREAK_SUCCESS, // 断点下载文件成功
  DOWNLOAD_FROM_BREAK_FAILED, // 断点下载文件失败
  DOWNLOAD_NEW_SUCCESS, // 全新下载文件成功
  DOWNLOAD_NEW_FAILED; // 全新下载文件失败
}
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")); //控制台输出乱码
        FTPFile[] files = ftpClient.listFiles(new String(remote.getBytes("UTF-8")));   //remote.getBytes()控制台输出也无乱码
        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"));  //控制台输出乱码
            InputStream in = ftpClient.retrieveFileStream(new String(remote.getBytes("UTF-8"))); //remote.getBytes()控制台输出也无乱码
            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+"%");  
                    //更新文件下载进度,值存放在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")); //控制台输出乱码
            InputStream in= ftpClient.retrieveFileStream(new String(remote.getBytes("UTF-8")));  //remote.getBytes()控制台输出也无乱码
            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+"%");  
                    //更新文件下载进度,值存放在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);  
                //汇报上传状态  
            }  
        }  
        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.51.11", 21, "user", "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("/Book/IT健康/IT人健康宝典V2版.pdf", "E:\\temp\\IT人健康宝典V2版.pdf"));  
            myFtp.disconnect();  
        } catch (IOException e) {  
            System.out.println("连接FTP出错:"+e.getMessage());  
        }  
    }  
   
    public void timerContinueFtp(){
    //ContinueFTP myFtp = new ContinueFTP();  
        try {  
            connect("192.168.51.11", 21, "user", "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(download("/Book/架构设计/Java与模式(清晰书签版).pdf", "E:\\temp\\Java与模式(清晰书签版).pdf"));  
            DownloadStatus downStatus = download("/Book/架构设计/Java与模式(清晰书签版).pdf", "E:\\temp\\Java与模式(清晰书签版).pdf");
            if(downStatus.equals(DownloadStatus.DOWNLOAD_NEW_SUCCESS)){
            log.info("新下载文件成功!");
            }
            disconnect();  
        } catch (IOException e) {  
            System.out.println("连接FTP出错:"+e.getMessage());  
        }
    }
}

2、输出处理类, 可以从网上找到源码
/*
    * Copyright 2001-2010 The Apache Software Foundation
    *
    * Licensed under the Apache License, Version 2.0 (the "License");
    * you may not use this file except in compliance with the License.
    * You may obtain a copy of the License at
    *
    * http://www.apache.org/licenses/LICENSE-2.0
    *
    * Unless required by applicable law or agreed to in writing, software
    * distributed under the License is distributed on an "AS IS" BASIS,
    * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
    * See the License for the specific language governing permissions and
    * limitations under the License.
*form : http://kickjava.com/src/examples/PrintCommandListener.java.htm#ixzz0v1nJPJdO
  */

package ftp.test.continueDown;

import java.io.PrintWriter;

import org.apache.commons.net.ProtocolCommandEvent;
import org.apache.commons.net.ProtocolCommandListener;
/***
    * This is a support class for some of the example programs. It is
    * a sample implementation of the ProtocolCommandListener interface
    * which just prints out to a specified stream all command/reply traffic.
    * <p>
    ***/
public class PrintCommandListener implements ProtocolCommandListener {

private PrintWriter __writer;

    public PrintCommandListener(PrintWriter writer)
    {
        __writer = writer;
    }
public void protocolCommandSent(ProtocolCommandEvent event) {
__writer.print(event.getMessage());
__writer.flush();
}

public void protocolReplyReceived(ProtocolCommandEvent event) {
__writer.print(event.getMessage());
        __writer.flush();
}

}
分享到:
评论

相关推荐

    java ftp断点上传和下载

    以上就是使用Java和Apache Commons Net库实现FTP断点续传的基本步骤。在实际应用中,你可能还需要处理异常,优化文件读写性能,以及考虑其他因素,如重试机制、错误处理等。了解这些知识点将使你能够高效地实现在...

    FTP断点上传与断点下载

    综上所述,FTP断点上传和断点下载是提高大文件传输效率的关键技术,VS2005提供了一套完善的工具和类库来实现这些功能。开发者可以通过理解FTP的工作原理和.NET Framework的FTP支持,创建可靠的断点续传功能,提升...

    WPF ftp断点上传下载

    在WPF中实现FTP断点上传和下载通常会结合MVVM(Model-View-ViewModel)设计模式。MVVM是一种流行的设计模式,它将应用程序分为三个主要部分:模型(数据源)、视图(用户界面)和视图模型(连接模型与视图的逻辑)。...

    ftp 断点续传实现

    断点续传的实现方法可以分为下载和上传两部分。 下载: 1. 客户端发送“REST + 本地文件长度”命令,告诉服务器,客户端要断点下载了。 2. 客户端发送"RETR + 文件名"命令,通知服务器要下载的文件名。 3. 客户端...

    利用libcurl实现ftp断点续传

    要利用libcurl实现FTP断点续传,首先需要了解libcurl的基本用法。在提供的压缩包中,可能包含libcurl的动态链接库(dll)、静态库(lib)、头文件(.h)以及示例代码(cpp)。这些文件是构建使用libcurl的C/C++程序...

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

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

    iOS FTP断点下载

    为了实现FTP下载,我们需要创建一个URLSessionConfiguration对象,设置其协议类型为FTP,并创建一个URLSession实例。 FTP下载的核心在于掌握FTP的命令和响应。在iOS中,这通常通过FTP客户端库来实现,如CocoaFTP或...

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

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

    C语言实现ftp断点续传.rar.rar

    在C语言中实现FTP断点续传涉及到以下几个关键知识点: 1. **FTP协议基础**:首先,你需要理解FTP协议的基本工作原理,包括连接、登录、命令交互、数据传输等过程。FTP使用TCP作为传输层协议,通过控制连接和数据...

    VS2008实现ftp断点续传的代码

    以下是一些关于如何在VS2008中实现FTP断点续传的关键知识点: 1. **FTP基础知识**:理解FTP的工作原理,包括命令结构、数据连接类型(主动和被动模式)以及FTP的控制和数据通道。 2. **FtpWebRequest类**:这是...

    MFC 实现FTP客户端的上传下载(断点续传)

    本项目“MFC实现FTP客户端的上传下载(断点续传)”是基于MFC技术实现的,能够实现在FTP服务器上进行文件的上传和下载,并且具备断点续传功能,这对于大文件传输来说尤其重要,因为如果在传输过程中中断,可以从上次...

    C语言实现ftp断点续传

    综上所述,这个C语言实现的FTP断点续传项目涵盖了网络编程、文件操作、错误处理等多个方面,对于深入理解FTP协议和C语言的网络编程有极大的帮助。开发者通过这个项目,不仅可以学习到如何编写FTP客户端,还能了解到...

    多线程实现ftp断点续传

    实现FTP断点续传的关键在于保存和恢复传输状态。这包括文件的当前位置、文件大小以及上一次传输的结束位置。在Java等编程语言中,可以使用`java.net.Socket`类和`java.io`包中的流对象来建立FTP连接并处理数据传输。...

    java ftp 上传 下载 断点续传

    在本文中,我们将深入探讨Java FTP上传、下载以及断点续传的核心概念和实现方法。 1. FTP基本原理: FTP是一种基于TCP/IP协议的应用层协议,主要用于在客户端和服务器之间传输文件。它定义了两组命令和响应,一组...

    java登录FTP下载文件,支持断点下载

    以上是实现FTP下载的基本流程,其中断点续传的关键在于本地文件状态的跟踪和FTPClient的`setRestartOffset()`方法。`DowndLoadFile`可能是项目中的具体实现类或文件名,你可以参考这个类来了解更详细的实现细节。在...

    FTP上传(断点续传)更新进度条

    实现FTP断点续传的关键在于保存和识别已传输的数据位置。这通常通过记录文件的当前位置(偏移量)和已传输的字节数来完成。当上传暂停后,客户端可以记住这个位置,再次连接时,只需从上次断开的地方开始继续传输。 ...

    c#制作FTP上传(支持断点续传)

    在本文中,我们将深入探讨如何使用C#编程语言来实现FTP(文件传输协议)上传功能,特别是支持断点续传的特性。FTP是一种标准网络协议,用于在客户端和服务器之间交换文件。C#中的System.Net命名空间提供了丰富的类库...

    自己收集的多个Java FTP断点续传的例子源码

    java实现FTP多线程断点续传,上传下载! - java学习与交流 - j2ee学习网 - j2ee学习网 (2012年5月21日) 用 Java 实现断点续传 (HTTP) (2012年5月21日) Java写的支持断点续传的FTP--crybaby的博客 (2012年5月21日) ...

Global site tag (gtag.js) - Google Analytics