FTPFTP文件上传下载-支持断点续传

Posted ssslinppp

tags:

篇首语：本文由小常识网(cha138.com)小编为大家整理，主要介绍了FTPFTP文件上传下载-支持断点续传相关的知识，希望对你有一定的参考价值。

  • Jar包：apache的commons-net包；
  • 支持断点续传
  • 支持进度监控(有时出不来，搞不清原因)

相关知识点

  • 编码格式: UTF-8等;
  • 文件类型： 包括[BINARY_FILE_TYPE(常用)]和[ASCII_FILE_TYPE]两种;
  • 数据连接模式：一般使用LocalPassiveMode模式，因为大部分客户端都在防火墙后面；
              1. LocalPassiveMode：服务器端打开数据端口，进行数据传输；
              2. LocalActiveMode：客户端打开数据端口，进行数据传输；
  • 系统类型：UNIX/WINDOWS等，默认为Unix

流程

  • 步骤1： 创建FTPClient对象，设置ftpClient属性：如编码格式、连接超时、文件上传下载进度监听器等;
  • 步骤2： 使用ftpClient连接远程server：connect()；
  • 步骤3： 获取connect()的返回码getReplyCode()，判断是否连接成功：isPositiveCompletion()；
  • 步骤4： 登录远程server：login(),并转到相应目录，必要时要递归创建目录;
  • 步骤5： 设置ftpClient属性：如缓存大小、文件类型、超时时间、数据连接模式等；
  • 步骤6： ftp相关操作：如文件上传、下载等；
  • 步骤7： 断开连接，释放资源：logout()/disconnect();

程序

FTP连接和登录


文件上传


文件下载

测试程序

完整程序

  1. package com.sssppp.Communication;
  3. import java.io.File;
  4. import java.io.FileOutputStream;
  5. import java.io.IOException;
  6. import java.io.InputStream;
  7. import java.io.OutputStream;
  8. import java.io.PrintWriter;
  9. import java.io.RandomAccessFile;
  11. import org.apache.commons.net.PrintCommandListener;
  12. import org.apache.commons.net.ftp.FTP;
  13. import org.apache.commons.net.ftp.FTPClient;
  14. import org.apache.commons.net.ftp.FTPClientConfig;
  15. import org.apache.commons.net.ftp.FTPFile;
  16. import org.apache.commons.net.ftp.FTPReply;
  17. import org.apache.commons.net.io.CopyStreamEvent;
  18. import org.apache.commons.net.io.CopyStreamListener;
  20. /**
  21.  * FTP进行文件上传和下载；
  22.  * 支持断点续传；
  23.  */
  24. public final class FTPUtil {
  25.   private final FTPClient ftp = new FTPClient();
  27.   /**
  28.    * 
  29.    * @param hostname
  30.    *            如：IP
  31.    * @param port
  32.    * @param username
  33.    * @param password
  34.    * @return
  35.    * @throws IOException
  36.    */
  37.   public boolean connect(String hostname, int port, String username,
  38.       String password) throws IOException {
  39.     boolean debug = false;
  40.     if (debug) {
  41.       // 设置将过程中使用到的命令输出到控制台
  42.       this.ftp.addProtocolCommandListener(new PrintCommandListener(
  43.           new PrintWriter(System.out), true));
  44.     }
  46.     //设置系统类型
  47.     final FTPClientConfig config = new FTPClientConfig(
  48.         FTPClientConfig.SYST_UNIX);
  49.     this.ftp.configure(config);
  51.     try {
  52.       this.ftp.connect(hostname, port);
  53.       if (!FTPReply.isPositiveCompletion(this.ftp.getReplyCode())) {
  54.         this.ftp.disconnect();
  55.         System.err.println("FTP server refused connection.");
  56.         return false;
  57.       }
  58.     } catch (IOException e) {
  59.       if (this.ftp.isConnected()) {
  60.         try {
  61.           this.ftp.disconnect();
  62.         } catch (IOException f) {
  63.         }
  64.       }
  65.       System.err.println("Could not connect to server.");
  66.       e.printStackTrace();
  67.       return false;
  68.     }
  70.     if (!this.ftp.login(username, password)) {
  71.       this.ftp.logout();
  72.       System.err.println("Could not login to server.");
  73.       return false;
  74.     }
  76.     return true;
  77.   }
  78.   
  79.   public void disconnect() throws IOException {
  80.     if (this.ftp.isConnected()) {
  81.       try {
  82.         this.ftp.logout();
  83.         this.ftp.disconnect();
  84.       } catch (IOException f) {
  85.       }
  86.     }
  87.   }
  89.   /**
  90.    * 
  91.    * @param absSrcFileName
  92.    * @param destDir
  93.    * @param destFileName
  94.    * @throws IOException
  95.    */
  96.   public void upLoadByFtp(String absSrcFileName, String destDir,
  97.       String destFileName) throws IOException {
  98.     // 创建并转到工作目录
  99.     String absDstDir = this.ftp.printWorkingDirectory() + "/" + destDir;
  100.     absDstDir = absDstDir.replaceAll("//", "/");
  101.     createDirectory(absDstDir, this.ftp);
  103.     // 设置各种属性
  104.     this.ftp.setFileType(FTP.BINARY_FILE_TYPE);
  105.     // Use passive mode as default because most of us are behind firewalls these days.
  106.     this.ftp.enterLocalPassiveMode();
  107.     this.ftp.setControlEncoding("utf-8");
  108.     this.ftp.setBufferSize(1024);
  110.     // 进度监听
  111.     File srcFile = new File(absSrcFileName);
  112.     this.ftp.setCopyStreamListener(new MyCopyStreamListener(srcFile.length()));
  114.     FTPFile[] files = this.ftp.listFiles(destFileName);
  115.     if (files.length == 1) {// 断点续传
  116.       long dstFileSize = files[0].getSize();
  117.       if (srcFile.length() <= dstFileSize) {// 文件已存在
  118.         return;
  119.       }
  120.       boolean b = uploadFile(destFileName, srcFile, this.ftp, dstFileSize);
  121.       if (!b) {// 如果断点续传没有成功，则删除服务器上文件，重新上传
  122.         if (this.ftp.deleteFile(destFileName)) {
  123.           uploadFile(destFileName, srcFile, this.ftp, 0);
  124.         }else {
  125.           System.err.println("Delete file fail.");
  126.         }
  127.       }
  128.     } else {
  129.       uploadFile(destFileName, srcFile, this.ftp, 0);
  130.     }
  131.   }
  132.   
  133.   /**
  134.    * 
  135.    * @param remoteFileName
  136.    * @param localFileName
  137.    * @throws IOException
  138.    */
  139.   public void downLoadByFtp(String remoteFileName, String localFileName)
  140.       throws IOException {
  141.     InputStream input = null;
  142.     FileOutputStream fos = null;
  144.     // 设置各种属性
  145.     this.ftp.setBufferSize(1024);
  146.     this.ftp.setDataTimeout(1000 * 10);
  147.     this.ftp.setFileType(FTPClient.BINARY_FILE_TYPE);
  148.     this.ftp.enterLocalPassiveMode();
  149.     
  150.     // 判断远程文件是否存在
  151.     FTPFile[] files = this.ftp.listFiles(remoteFileName);
  152.     if (files.length != 1) {
  153.       System.err.println("Remote file not exist.");
  154.       return;
  155.     }
  157.     //进度监听
  158.     long remoteSize = files[0].getSize();
  159.     this.ftp.setCopyStreamListener(new MyCopyStreamListener(remoteSize));
  161.     File file = new File(localFileName);
  162.     if (file.exists()) {
  163.       long localSize = file.length();
  164.       if (localSize >= remoteSize) {
  165.         return;
  166.       }
  167.       System.out.println("@@@Break point download.@@@");
  168.       fos = new FileOutputStream(file, true);// append模式
  169.       this.ftp.setRestartOffset(localSize);
  170.     } else {
  171.       fos = new FileOutputStream(file); // override模式
  172.     }
  174.     input = this.ftp.retrieveFileStream(remoteFileName);
  175.     byte[] b = new byte[8192];
  176.     int n = 0;
  177.     while (-1 != (n = input.read(b))) {
  178.       if (Thread.currentThread().isInterrupted()) {
  179.         break;
  180.       }
  181.       fos.write(b, 0, n);
  182.     }
  184.     if (input != null) {
  185.       input.close();
  186.     }
  187.     if (fos != null) {
  188.       fos.flush();
  189.       fos.close();
  190.     }
  192.     if (!this.ftp.completePendingCommand()) {
  193.       System.err.println("Download file fail.");
  194.       this.ftp.logout();
  195.       this.ftp.disconnect();
  196.     }
  197.   }
  198.   
  199.   /**
  200.    * 
  201.    * @param destFileName
  202.    * @param srcFile
  203.    * @param ftpClient
  204.    * @param dstFileSize 文件写入的起始位置； >0:表示断点续传，<=0:表示上传新文件
  205.    * @return
  206.    * @throws IOException
  207.    */
  208.   private boolean uploadFile(String destFileName, File srcFile,
  209.       FTPClient ftpClient, long dstFileSize) throws IOException {
  210.     RandomAccessFile input = null;
  211.     OutputStream fout = null;
  212.     
  213.     input = new RandomAccessFile(srcFile, "r"); // 只读模式
  214.     if (dstFileSize > 0) {// 断点续传
  215.       fout = ftpClient.appendFileStream(destFileName);
  216.       input.seek(dstFileSize);
  217.       ftpClient.setRestartOffset(dstFileSize);
  218.     } else {
  219.       fout = ftpClient.storeFileStream(destFileName);
  220.     }
  222.     byte[] b = new byte[8192]; // 缓存大小
  223.     int n = 0;
  224.     while (-1 != (n = input.read(b))) {
  225.       if (Thread.currentThread().isInterrupted()) {
  226.         break;
  227.       }
  228.       fout.write(b, 0, n);
  229.     }
  231.     if (input != null) {
  232.       input.close();
  233.     }
  234.     if (fout != null) {
  235.       fout.flush();
  236.       fout.close();
  237.     }
  238.     if (!ftpClient.completePendingCommand()) {
  239.       System.err.println("Upload file fail.");
  240.       ftpClient.logout();
  241.       ftpClient.disconnect();
  242.       return false;
  243.     }
  244.     return true;
  245.   }
  247.   /**
  248.    * 在FTP服务器上创建并转到工作目录
  249.    * 
  250.    * @param relativePath
  251.    *            相对工作路径，不包含文件名：如 dd/11/22/33
  252.    * @param ftpClient
  253.    *            录创建是否成功
  254.    * @return
  255.    * @throws IOException
  256.    */
  257.   private boolean createDirectory(String relativePath, FTPClient ftpClient)
  258.       throws IOException {
  259.     if (!relativePath.startsWith("/")) {
  260.       relativePath = "/" + relativePath;
  261.     }
  262.     String dir = (ftpClient.printWorkingDirectory().equals("/") ? ""
  263.         : ftpClient.printWorkingDirectory()) + relativePath;
  264.     if (!ftpClient.changeWorkingDirectory(dir)) {
  265.       //目录不存在，则创建各级目录
  266.       for (String subDir : relativePath.split("/")) {
  267.         if (!subDir.equals("")) {
  268.           String newDir = ftpClient.printWorkingDirectory以上是关于FTPFTP文件上传下载-支持断点续传的主要内容，如果未能解决你的问题，请参考以下文章
     

     大文件上传下载实现思路，分片断点续传代码实现，以及webUpload组件
    

     文件下载之断点续传（客户端与服务端的实现）
    

     网络编程 下载任务，支持断点续传
    

     文件上传控件-如何上传文件-大文件断点续传
    

     Android 多线程下载，断点续传，线程池
    

     Java单线程文件下载，支持断点续传功能