Spring Boot Ftp Client 客户端示例支持断点续传

最新推荐文章于 2024-04-10 17:42:03 发布
最新推荐文章于 2024-04-10 17:42:03 发布
阅读量261 收藏 1
点赞数
文章标签： java 操作系统 开发工具
原文链接：http://www.cnblogs.com/fishpro/p/spring-boot-study-ftpclient.html
版权

本章介绍 Spring Boot 整合 Ftpclient 的示例，支持断点续传

本项目源码下载

1 新建 Spring Boot Maven 示例工程项目

注意：是用来 IDEA 开发工具

  1. File > New > Project，如下图选择 Spring Initializr 然后点击 【Next】下一步
  2. 填写 GroupId（包名）、Artifact（项目名） 即可。点击 下一步
    groupId=com.fishpro
    artifactId=ftpclient
  3. 选择依赖 Spring Web Starter 前面打钩。
  4. 项目名设置为 spring-boot-study-ftpclient.

2 引入依赖 Pom

<dependencies>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>

        <!-- apache ftp支持  -->
        <dependency>
            <groupId>commons-net</groupId>
            <artifactId>commons-net</artifactId>
            <version>3.6</version>
        </dependency>

        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-test</artifactId>
            <scope>test</scope>
        </dependency>
    </dependencies>

3 编写代码示例

这里主要编写一个 Ftp操作类，对Ftp 进行 连接、关闭、上传文件、创建服务器目录、下载。来源网络，具体引用哪里已经找不到了。

package com.fishpro.ftpclient.util;


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.slf4j.Logger;
import org.slf4j.LoggerFactory;

import java.io.*;

/**
 * 支持断点续传的FTP实用类
 *
 * @author xiongl
 * @version 0.1 实现基本断点上传下载
 * @version 0.2 实现上传下载进度汇报
 * @version 0.3 实现中文目录创建及中文文件创建，添加对于中文的支持
 */
public class FtpContinueClient
{
    private static final Logger logger = LoggerFactory.getLogger(FtpContinueClient.class);

    public FTPClient ftpClient = new FTPClient();

    public FtpContinueClient()
    {

        // 设置将过程中使用到的命令输出到控制台
        // 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 Exception {

        try
        {
            ftpClient.connect(hostname, port);
        }
        catch (Exception e)
        {
            throw new Exception("登陆异常，请检查主机端口");
        }
        ftpClient.setControlEncoding("GBK");
        if (FTPReply.isPositiveCompletion(ftpClient.getReplyCode()))
        {
            if (ftpClient.login(username, password))
            {
                return true;
            }
            else
                throw new Exception("登陆异常，请检查密码账号");
        }
        else
            throw new Exception("登陆异常");

    }

    public String[] getFileList(String filedir)
            throws IOException {
        ftpClient.enterLocalPassiveMode();

        FTPFile[] files = ftpClient.listFiles(filedir);

        String[] sfiles = null;
        if (files != null)
        {
            sfiles = new String[files.length];
            for (int i = 0; i < files.length; i++)
            {
                // System.out.println(files[i].getName());
                sfiles[i] = files[i].getName();
            }
        }
        return sfiles;
    }

    /**
     * 从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("远程文件不存在");
            logger.info("远程文件不存在");
            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)
            {
                logger.info("本地文件大于远程文件，下载中止");
                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"));
            try
            {
                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)
                            logger.info("下载进度：" + process);
                        // TODO 更新文件下载进度,值存放在process变量中
                    }
                }
            }
            catch (Exception e)
            {
            }
            finally
            {
                if (in != null)
                    in.close();
                if (out != null)
                    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"));
            try
            {
                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)
                            logger.info("下载进度：" + process);
                        // TODO 更新文件下载进度,值存放在process变量中
                    }
                }
            }
            catch (Exception e)
            {
            }
            finally
            {
                if (in != null)
                    in.close();
                if (out != null)
                    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 按照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 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)
    {
        FtpContinueClient myFtp = new FtpContinueClient();
        try
        {
            //myFtp.connect("192.168.1.245", 21, "aircom", "123456");
            // 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("E:\\yw.flv", "/yw.flv",5));
            // System.out.println(myFtp.upload("E:\\走西口24.mp4","/央视走西口/新浪网/走西口24.mp4"));
            //System.out.println(myFtp.download("2.txt", "H:\\sfa.txt"));
            //myFtp.disconnect();
        }
        catch (Exception e)
        {

            System.out.println("连接FTP出错：" + e.getMessage());
        }
    }

    public enum DownloadStatus
    {
        Remote_File_Noexist, // 远程文件不存在
        Local_Bigger_Remote, // 本地文件大于远程文件
        Download_From_Break_Success, // 断点下载文件成功
        Download_From_Break_Failed, // 断点下载文件失败
        Download_New_Success, // 全新下载文件成功
        Download_New_Failed; // 全新下载文件失败
    }

    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; // 删除远程文件失败
    }
}

在启动文件中

@SpringBootApplication
public class FtpclientApplication {

    public static void main(String[] args) {

        SpringApplication.run(FtpclientApplication.class, args);

        /*FtpContinueClient*/
        FtpContinueClient ftp=new FtpContinueClient();
        String filePath="";
        String filename="";
        try{
            ftp.connect("192.168.0.1",21,"administrator","xxdfsdfs^");
            FtpContinueClient.UploadStatus uploadStatus= ftp.upload(filePath,"/"+filename);
            ftp.disconnect();

        }catch (Exception ex){
            ex.printStackTrace();
        }finally {

        }
    }

}

本示例支持断点续传，能够解决大部分FTP客户端上传问题(代码来源网络)

本项目源码下载

转载于:https://www.cnblogs.com/fishpro/p/spring-boot-study-ftpclient.html

weixin_30697239
关注
震撼，java面试题整合（良心制作）11万多字拿去。持续更新【可以收藏】
jason的java世界
12-12 1402
一、javaSE面试题整合 Java部分 JDK中哪些类是不能继承的？【信雅达面试题】 【参考答案】 不能继承的是类是那些用final关键字修饰的类。一般比较基本的类型或防止扩展类无意间破坏原来方法的实现的类型都应该是final的。 String是最基本的数据类型吗? 【天能智健面试题】 【参考答案】 基本数据类型包括byte、int、char、long、float、double、boolean和short。 所以String不属于基本数据类型范畴内，但String属于最常见一种引用类型。
2021 Java面试真题集锦
热门推荐
GL1765852966的博客
12-26 8万+
目录 … 1 大厂面试的基本流程 17 字节跳动 17 阿里 17 腾讯 18 网易游戏 18 面试前需要准备： 18 面试中可以借鉴的套路 19 用简历争取到更多的面试机会 19 自我介绍时，立即全面抛出技术栈和亮点 20 先介绍项目背景，打消面试官疑问 21 通过说项目管理工具，说明你不仅会写代码 22 用 SPRING BOOT 项目举例，说明你的技术基本面 23 用实例说明你在内存调优方面的经验 24 展示你在数据库调优方面的经验 25 总结前文说辞 26 准备项目说辞时，更可以准备后继面试官的问
FTPClient上传下载(支持断点续传)
01-25
该资源源于网络，支持断点续传，资源不错，与大家分享
springboot-ftpclient:@Service示例，用于使用Spring Boot从FTP服务器连接，上传和下载文件
05-15
springboot-ftpclient @Service示例，用于使用Spring Boot从FTP服务器连接，上传和下载文件。 该项目实现了@Service Spring Boot，该服务启用并提供了一个简单的API，以便其他开发人员可以重用它来连接到实现FTP协议的服务器。 它提供了4种主要方法的API： connectToFTP（字符串主机，字符串用户，字符串传递） uploadFileToFTP（文件文件，字符串ftpHostDir，字符串serverFilename） downloadFileFromFTP（字符串ftpRelativePath，字符串copytoPath） 无效disconnectFTP（） 方法的名称很直观，要在您的项目中使用，只需注入FTPService接口，请参见代码中的示例MainController。 如果您喜欢这个项目，请给我一颗星
SpringBoot项目集成FTP
Ijiran的博客
10-25 1034
theme: vue-pro 小知识，大挑战！本文正在参与“程序员必备小知识”创作活动。 写在前面 FTP是一个文件传输协议，被开发人员广泛用于在互联网中文件传输的一套标准协议。 而我们通常在开发过程中也要通过FTP来搭建文件系统，用于存储系统文件等。 目前正值SpringBoot热潮，所以我们接下来会一起学习一下SpringBoot如何集成FTP，以及相关的FTP组件包，还有其主要...
Java Springboot整合FTPClient线程池
chengmin123456789的博客
02-19 3149
1、引入依赖 <dependency> <groupId>commons-net</groupId> <artifactId>commons-net</artifactId> <version>3.6</version> </dependency> <dependency>
模拟面试面试题汇总 
u011526274的博客
04-27 3037
模拟面试面试题汇总 第一轮面试题 一、描述下数据库中的事务--ACID各个的特点。 原子性：事务中的操作要么全部成功要么全部失败。 一致性：事务前后数据的完整性必须保持一致。 隔离性：多个并发的事务之间是相互隔离的，互不干扰的。 持久性：事务提交后，数据是永久改变的。 二、什么是springboot？你们公司是用的哪个版本？ SpringBoot是Spring推出用于解决传统框架配置文件冗余,装配组件繁杂的基于Maven的解决方案,旨在快速搭建单个微服务。 版本号：2...
支持断点续传的ftp客户端组件
11-05
这是我用ATL些的FTP客户端组件，支持断点续传
webmagic采集CSDN的Java_WebDevelop页面
hepanlaurence的专栏
05-23 1万+
使用webmagic采集博客类的网站示例
ftpclient可断点续传 经测试可用（转载）
weixin_30619101的博客
03-31 439
using System;using System.Net;using System.IO;using System.Text;using System.Net.Sockets;using System.Diagnostics;using System.Runtime.Remoting;using System.Runtime.Remoting.Messaging;/** FTP Client ...
spring boot实现大文件断点续传
10-18
使用spring boot整合google的断点续传框架事项大文件断点续传功能
SpringBoot-集成FTP(上传、下载、删除)
孟孟的博客
06-30 9333
由于服务在内网部署，需要使用ftp服务器管理文件，总结如下。
springboot集成ftp实现文件上传
qq_43623447的博客
11-25 1万+
文章目录1,FileUtil2,application.properties3, UploadController4,ftp查看 1,FileUtil package io.renren.modules.oss.utils; import org.apache.commons.net.ftp.FTPClient; import org.springframework.beans.factory.annotation.Value; import org.springframework.stereotype
Spring boot ftp server
01-31
spring boot ftp server示例。只有server没有client.被动模式上传 博客说明: https://blog.csdn.net/joe_storm/article/details/84872975
FTP客户端实现断点续传
Jacob
05-19 3037
FTP客户端是自己做的的第一个C项目，大二暑假做的。现在拿出来看看，当时只是初学者，暑假在学校一个人做了1个多星期。当代码成功运行时，瞬间感到C的强大与编程的乐趣。不懂的朋友可以问我。 connect.c #include #include #include #include #include #include #include #define SERV_IP
在JAVA Spring中使用FTPClient
weixin_43424993的博客
12-01 572
Java中使用的FTPClient来源于： <dependency> <groupId>commons-net</groupId> <artifactId>commons-net</artifactId> <version>3.6</version> </dependency> 可以使用yml配置文件来进行FTP服务器相应的配置，下面是一些可以使用的函数 首先是创建FTPClien
Springboot项目搭建有ftpClientPool的Ftp工具类
wxyh的博客
11-26 1万+
本文基于commons-pool2的ObjectPool接口构建了ftpClientPool，并以ftpClientPool为基础构建了FTPUtil工具类。 可以实现FTPClient的复用，以减少频繁创建FTPClient对象而造成的性能开销； 可以实现线程安全的并发访问FTP服务器。
springboot整合ftp
L_xioabai_L的博客
07-29 1517
搭建centos环境，main方法启动测试。
FTP超大文件下载入库--断点续传发
最新发布
qq_44361270的博客
04-10 780
dao层，这个使用多线程读取文件，读一条addBatch();一条，需要批量提交。如果将所有一个文件的所有数据加载到内存中，会出现内存溢出问题。原因是因为默认缓冲区大小是1024，也就是1K，当然慢了，在调用上传API之前重新修改以下默认设置即可，如将缓冲区改为10M。FTP断点续传代码（公司ftp不支持多线程下载文件，可以设置多线程进行文件下载）对下载好的数据进行入库操作server层。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值