实现ftp断点下载和上传

scmchtmlxu

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();
}

}