Spring中使用FTP进行上传下载和删除的工具类

最新推荐文章于 2024-08-07 14:54:11 发布
最新推荐文章于 2024-08-07 14:54:11 发布
阅读量3.4k 收藏 11
点赞数
分类专栏： Java Spring FTP
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_33328356/article/details/81906702
版权
Java 同时被 3 个专栏收录
14 篇文章 0 订阅
订阅专栏
Spring
7 篇文章 0 订阅
订阅专栏
FTP
1 篇文章 0 订阅
订阅专栏

1.引入依赖

        <!-- commons net -->
        <dependency>
            <groupId>commons-net</groupId>
            <artifactId>commons-net</artifactId>
            <version>3.6</version>
        </dependency>

2.自定义配置文件

（如果不使用spring则把Spring相关注解去除，自定义初始化参数）

#FTP客户端默认配置
#FTP服务器IP地址
ftp.default.ip=127.0.0.1
#FTP服务器开放端口号
ftp.default.port=21
#FTP服务器用户名
ftp.default.account=admin
#FTP服务器密码
ftp.default.password=***********
#默认工作目录
ftp.default.workingDir=NginxServer

3.工具类代码

package com.center.utils;

import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.io.UnsupportedEncodingException;
import java.net.SocketException;

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.springframework.beans.factory.annotation.Value;

import com.center.base.other.Charset;

/**
 * FTP传输工具
 * 
 * @Title: FtpUtils.java
 * @Package com.center.utils
 * @Description: TODO
 * @author Autumn、
 * @date 2018年8月20日
 */
@Component
public class FtpUtils {

    /**
     * 删除成功标志
     */
    public static final int DELETE_SUCCEED = 250;

    /**
     * FTP服务器IP
     */
    private static String defaultIp;

    /**
     * FTP服务器端口号
     */
    private static Integer defaultPort;

    /**
     * FTP服务器用户名
     */
    private static String defaultAccount;

    /**
     * 默认保存路径
     */
    private static String defaultWorkingDir;

    /**
     * FTP服务器密码
     */
    private static String defaultPassword;

    /**
     * @return the defaultIp
     */
    public static String getDefaultIp() {
        return defaultIp;
    }

    /**
     * @param defaultIp
     *            the defaultIp to set
     */
    @Value("${ftp.default.ip}")
    public void setDefaultIp(String defaultIp) {
        FtpUtils.defaultIp = defaultIp;
    }

    /**
     * @return the defaultPort
     */
    public static Integer getDefaultPort() {
        return defaultPort;
    }

    /**
     * @param defaultPort
     *            the defaultPort to set
     */
    @Value("${ftp.default.port}")
    public void setDefaultPort(Integer defaultPort) {
        FtpUtils.defaultPort = defaultPort;
    }

    /**
     * @return the defaultAccount
     */
    public static String getDefaultAccount() {
        return defaultAccount;
    }

    /**
     * @param defaultAccount
     *            the defaultAccount to set
     */
    @Value("${ftp.default.account}")
    public void setDefaultAccount(String defaultAccount) {
        FtpUtils.defaultAccount = defaultAccount;
    }

    /**
     * @return the defaultPassword
     */
    public static String getDefaultPassword() {
        return defaultPassword;
    }

    /**
     * @param defaultPassword
     *            the defaultPassword to set
     */
    @Value("${ftp.default.password}")
    public void setDefaultPassword(String defaultPassword) {
        FtpUtils.defaultPassword = defaultPassword;
    }

    /**
     * @return the defaultWorkingDir
     */
    public static String getDefaultWorkingDir() {
        return defaultWorkingDir;
    }

    /**
     * @param defaultWorkingDir
     *            the defaultWorkingDir to set
     */
    @Value("${ftp.default.workingDir}")
    public void setDefaultWorkingDir(String defaultWorkingDir) {
        FtpUtils.defaultWorkingDir = defaultWorkingDir;
    }

    /**
     * 初始化配置
     * 
     * @param defaultIp
     * @param defaultPort
     * @param defaultAccount
     * @param defaultPassword
     * @param defaultWorkingDir
     */
    public static void initDefaultConfig(String defaultIp, Integer defaultPort, String defaultAccount,
            String defaultPassword, String defaultWorkingDir) {
        FtpUtils.defaultIp = defaultIp;
        FtpUtils.defaultPort = defaultPort;
        FtpUtils.defaultAccount = defaultAccount;
        FtpUtils.defaultPassword = defaultPassword;
        FtpUtils.defaultWorkingDir = defaultWorkingDir;
    }

    /**
     * 创建目录
     * 
     * @param workingDir
     *            要创建的目录
     * @return 创建结果
     * @throws IOException
     */
    public static Boolean createDirecroty(String workingDir) throws IOException {
        return FtpUtils.createDirecroty(FtpUtils.createFTPClient(), workingDir);
    }

    /**
     * 自定义ftp服务器创建目录
     * 
     * @param workingDir
     *            要创建的目录
     * @return 创建结果
     * @throws IOException
     */
    public static Boolean createDirecroty(String ip, Integer port, String account, String password, String workingDir)
            throws IOException {
        return FtpUtils.createDirecroty(FtpUtils.createFTPClient(ip, port, account, password), workingDir);
    }

    /**
     * 自定义ftp客户端创建目录
     * 
     * @param workingDir
     *            要创建的目录
     * @return 创建结果
     * @throws IOException
     */
    public static Boolean createDirecroty(FTPClient ftpClient, String workingDir) throws IOException {
        String[] dirs = workingDir.split("/");
        for (int i = 0; i < dirs.length; i++) {
            String dir = dirs[i];
            if (dir.indexOf(".") > -1) {
                if (i != dirs.length - 1) {
                    return false;
                }
                break;
            }
            if (!existFile(ftpClient, FtpUtils.chineseNameConversion(dir))) {
                ftpClient.makeDirectory(dir);
            }
            ftpClient.changeWorkingDirectory(dir);
        }
        return true;
    }

    /**
     * 判断ftp服务器文件/文件夹是否存在
     * 
     * @param path
     *            路径或文件全路径
     * @return 存在返回true，否则返回false
     * @throws IOException
     */
    public static Boolean existFile(FTPClient ftpClient, String path) throws IOException {
        boolean flag = false;
        FTPFile[] ftpFileArr = ftpClient.listFiles(path);
        if (ftpFileArr.length > 0) {
            flag = true;
        }
        return flag;
    }

    /**
     * 使用默认配置上传文件并使用原文件名
     * 
     * @param file
     *            文件
     * @param workingDir
     *            服务器存储的绝对路径
     * @return 上传结果
     * @throws IOException
     * @throws FileNotFoundException
     */
    public static Boolean uploadFile(File file, String workingDir) throws FileNotFoundException, IOException {
        return FtpUtils.uploadFile(file, workingDir, file.getName());
    }

    /**
     * 使用自定义ftp客户端上传文件并使用原文件名
     * 
     * @param ftpClient
     *            ftp客户端
     * @param file
     *            文件
     * @param workingDir
     *            服务器存储的绝对路径
     * @return 上传结果
     * @throws FileNotFoundException
     * @throws IOException
     */
    public static Boolean uploadFile(FTPClient ftpClient, File file, String workingDir)
            throws FileNotFoundException, IOException {
        return FtpUtils.uploadFile(ftpClient, file, workingDir, file.getName());
    }

    /**
     * 使用默认配置上传文件
     * 
     * @param file
     *            文件
     * @param workingDir
     *            ftp 服务器存储图片的绝对路径
     * @param fileName
     *            上传到ftp 服务器文件名
     * @return 上传结果
     * @throws IOException
     * @throws FileNotFoundException
     */
    public static Boolean uploadFile(File file, String workingDir, String fileName)
            throws FileNotFoundException, IOException {
        return FtpUtils.uploadFile(defaultIp, defaultPort, defaultAccount, defaultPassword, file, workingDir, fileName);
    }

    /**
     * 使用自定义ftp客户端上传文件
     * 
     * @param ftpClient
     *            ftp客户端
     * @param file
     *            文件
     * @param workingDir
     *            ftp 服务器存储图片的绝对路径
     * @param fileName
     *            上传到ftp 服务器文件名
     * @return 上传结果
     * @throws IOException
     * @throws FileNotFoundException
     */
    public static Boolean uploadFile(FTPClient ftpClient, File file, String workingDir, String fileName)
            throws FileNotFoundException, IOException {
        return FtpUtils.uploadFile(ftpClient, new FileInputStream(file), workingDir, fileName);
    }

    /**
     * 使用默认配置上传文件
     * 
     * @param inputStream
     *            文件流
     * @param workingDir
     *            ftp 服务器存储图片的绝对路径
     * @param fileName
     *            上传到ftp服务器文件名
     * @return 上传结果
     * @throws IOException
     */
    public static Boolean uploadFile(InputStream inputStream, String workingDir, String fileName) throws IOException {
        return uploadFile(defaultIp, defaultPort, defaultAccount, defaultPassword, inputStream, workingDir, fileName);
    }

    /**
     * ftp 上传方法
     * 
     * @param ip
     *            ftp 服务器ip地址
     * @param port
     *            ftp 服务器port，默认是21
     * @param account
     *            ftp 服务器用户名
     * @param password
     *            ftp 服务器密码
     * @param file
     *            文件
     * @param workingDir
     *            ftp 服务器存储图片的绝对路径
     * @return 上传结果
     * @throws IOException
     * @throws FileNotFoundException
     * @throws Exception
     * 
     */
    public static Boolean uploadFile(String ip, Integer port, String account, String password, File file,
            String workingDir) throws FileNotFoundException, IOException {
        return FtpUtils.uploadFile(ip, port, account, password, new FileInputStream(file), workingDir, file.getName());
    }

    /**
     * ftp 上传方法
     * 
     * @param ip
     *            ftp 服务器ip地址
     * @param port
     *            ftp 服务器port，默认是21
     * @param account
     *            ftp 服务器用户名
     * @param password
     *            ftp 服务器密码
     * @param file
     *            文件
     * @param workingDir
     *            ftp 服务器存储图片的绝对路径
     * @param fileName
     *            上传到ftp 服务器文件名
     * @return 上传结果
     * @throws IOException
     * @throws FileNotFoundException
     * @throws Exception
     * 
     */
    public static Boolean uploadFile(String ip, Integer port, String account, String password, File file,
            String workingDir, String fileName) throws FileNotFoundException, IOException {
        return FtpUtils.uploadFile(ip, port, account, password, new FileInputStream(file), workingDir, fileName);
    }

    /**
     * ftp 上传方法
     * 
     * @param ip
     *            ftp 服务器ip地址
     * @param port
     *            ftp 服务器port，默认是21
     * @param account
     *            ftp 服务器用户名
     * @param password
     *            ftp 服务器密码
     * @param inputStream
     *            文件流
     * @param workingDir
     *            ftp 服务器存储图片的绝对路径
     * @param fileName
     *            上传到ftp 服务器文件名
     * @return 上传结果
     * @throws IOException
     * 
     */
    public static Boolean uploadFile(String ip, Integer port, String account, String password, InputStream inputStream,
            String workingDir, String fileName) throws IOException {
        FTPClient ftpClient = createFTPClient(ip, port, account, password);
        return FtpUtils.uploadFile(ftpClient, inputStream, workingDir, fileName);
    }

    /**
     * 使用自定义ftp客户端上传文件
     * 
     * @param ftpClient
     *            ftp客户端
     * @param inputStream
     *            文件流
     * @param workingDir
     *            服务器存储图片的绝对路径
     * @param fileName
     *            上传到ftp 服务器文件名
     * @return 上传结果
     * @throws IOException
     */
    public static Boolean uploadFile(FTPClient ftpClient, InputStream inputStream, String workingDir, String fileName)
            throws IOException {
        boolean result = false;
        if (!FtpUtils.existFile(ftpClient, workingDir)) {
            FtpUtils.createDirecroty(ftpClient, workingDir);
        }
        ftpClient.changeWorkingDirectory(workingDir);
        ftpClient.setFileType(FTP.BINARY_FILE_TYPE);
        if (!ftpClient.storeFile(chineseNameConversion(fileName), inputStream)) {
            return result;
        }
        inputStream.close();
        ftpClient.logout();
        result = true;
        return result;
    }

    /**
     * 使用默认配置下载文件并使用原文件名
     * 
     * @param file
     *            文件
     * @param workingDir
     *            服务器存储的绝对路径
     * @return 下载结果
     * @throws IOException
     * @throws FileNotFoundException
     */
    public static Boolean downloadFile(File file, String workingDir) throws FileNotFoundException, IOException {
        return FtpUtils.downloadFile(file, workingDir, file.getName());
    }

    /**
     * 使用自定义Ftp客户端下载文件并使用原文件名
     * 
     * @param ftpClient
     *            ftp客户端
     * @param file
     *            文件
     * @param workingDir
     *            服务器存储的绝对路径
     * @return 下载结果
     * @throws FileNotFoundException
     * @throws IOException
     */
    public static Boolean downloadFile(FTPClient ftpClient, File file, String workingDir)
            throws FileNotFoundException, IOException {
        return FtpUtils.downloadFile(ftpClient, file, workingDir, file.getName());
    }

    /**
     * 使用默认配置下载文件
     * 
     * @param file
     *            文件
     * @param workingDir
     *            ftp 服务器存储的绝对路径
     * @param fileName
     *            上传到ftp 服务器文件名
     * @return 下载结果
     * @throws IOException
     * @throws FileNotFoundException
     */
    public static Boolean downloadFile(File file, String workingDir, String fileName)
            throws FileNotFoundException, IOException {
        return FtpUtils.downloadFile(defaultIp, defaultPort, defaultAccount, defaultPassword, file, workingDir,
                fileName);
    }

    /**
     * 使用自定义客户端下载文件
     * 
     * @param ftpClient
     *            自定义ftp客户端
     * @param file
     *            文件
     * @param workingDir
     *            ftp 服务器存储的绝对路径
     * @param fileName
     *            上传到ftp 服务器文件名
     * @return 下载结果
     * @throws FileNotFoundException
     * @throws IOException
     */
    public static Boolean downloadFile(FTPClient ftpClient, File file, String workingDir, String fileName)
            throws FileNotFoundException, IOException {
        if (!file.exists()) {
            file.getParentFile().mkdirs();
            file.createNewFile();
        }
        boolean result = FtpUtils.downloadFile(ftpClient, new FileOutputStream(file), workingDir, fileName);
        if (!result) {
            file.delete();
        }
        return result;
    }

    /**
     * 使用默认配置上传文件
     * 
     * @param inputStream
     *            文件流
     * @param workingDir
     *            ftp 服务器存储图片的绝对路径
     * @param fileName
     *            上传到ftp 服务器文件名
     * @return
     * @throws IOException
     */
    public static Boolean downloadFile(OutputStream outputStream, String workingDir, String fileName)
            throws IOException {
        return downloadFile(defaultIp, defaultPort, defaultAccount, defaultPassword, outputStream, workingDir,
                fileName);
    }

    /**
     * ftp 下载
     * 
     * @param ip
     *            ftp 服务器ip地址
     * @param port
     *            ftp 服务器port，默认是21
     * @param account
     *            ftp 服务器用户名
     * @param password
     *            ftp 服务器密码
     * @param file
     *            文件
     * @param workingDir
     *            ftp 服务器存储图片的绝对路径
     * @throws IOException
     * @throws FileNotFoundException
     * @throws Exception
     * 
     */
    public static Boolean downloadFile(String ip, Integer port, String account, String password, File file,
            String workingDir) throws FileNotFoundException, IOException {
        if (!file.exists()) {
            file.getParentFile().mkdirs();
            file.createNewFile();
        }
        boolean result = FtpUtils.downloadFile(ip, port, account, password, new FileOutputStream(file), workingDir,
                file.getName());
        if (!result) {
            file.delete();
        }
        return result;
    }

    /**
     * ftp 下载方法
     * 
     * @param ip
     *            ftp 服务器ip地址
     * @param port
     *            ftp 服务器port，默认是21
     * @param account
     *            ftp 服务器用户名
     * @param password
     *            ftp 服务器密码
     * @param file
     *            文件
     * @param workingDir
     *            ftp 服务器存储图片的绝对路径
     * @param fileName
     *            上传到ftp 服务器文件名
     * @throws IOException
     * @throws FileNotFoundException
     * @throws Exception
     * 
     */
    public static Boolean downloadFile(String ip, Integer port, String account, String password, File file,
            String workingDir, String fileName) throws FileNotFoundException, IOException {
        if (!file.exists()) {
            file.getParentFile().mkdirs();
            file.createNewFile();
        }
        boolean result = FtpUtils.downloadFile(ip, port, account, password, new FileOutputStream(file), workingDir,
                fileName);
        if (!result) {
            file.delete();
        }
        return result;
    }

    /**
     * ftp 下载方法
     * 
     * @param ip
     *            ftp 服务器ip地址
     * @param port
     *            ftp 服务器port，默认是21
     * @param account
     *            ftp 服务器用户名
     * @param password
     *            ftp 服务器密码
     * @param outputStream
     *            文件流
     * @param workingDir
     *            ftp 服务器存储图片的绝对路径
     * @param fileName
     *            上传到ftp 服务器文件名
     * @throws SocketException
     * @throws IOException
     * 
     */
    public static Boolean downloadFile(String ip, Integer port, String account, String password,
            OutputStream outputStream, String workingDir, String fileName) throws SocketException, IOException {
        FTPClient ftpClient = createFTPClient(ip, port, account, password);
        return downloadFile(ftpClient, outputStream, workingDir, fileName);
    }

    /**
     * 使用自定义客户端上传文件
     * 
     * @param ftpClient
     *            自定义客户端
     * @param inputStream
     *            文件流
     * @param workingDir
     *            ftp 服务器存储图片的绝对路径
     * @param fileName
     *            上传到ftp 服务器文件名
     * @return
     * @throws IOException
     */
    public static Boolean downloadFile(FTPClient ftpClient, OutputStream outputStream, String workingDir,
            String fileName) throws IOException {
        boolean result = false;
        if (!FtpUtils.existFile(ftpClient, workingDir)) {
            FtpUtils.createDirecroty(ftpClient, workingDir);
        }
        ftpClient.changeWorkingDirectory(workingDir);
        FTPFile[] ftpFiles = ftpClient.listFiles();
        for (FTPFile file : ftpFiles) {
            if (file.getName().equalsIgnoreCase(FtpUtils.chineseNameConversion(fileName))) {
                ftpClient.retrieveFile(file.getName(), outputStream);
                outputStream.close();
                result = true;
            }
        }
        ftpClient.logout();
        return result;
    }

    /**
     * 自定义客户端使用默认配置的工作路径删除文件
     * 
     * @param ftpClient
     *            自定义ftp客户端
     * @param fileName
     *            文件名称
     * @return 删除结果
     * @throws SocketException
     * @throws IOException
     */
    public static Boolean deleteFile(FTPClient ftpClient, String fileName) throws SocketException, IOException {
        return deleteFile(ftpClient, defaultWorkingDir, fileName);
    }

    /**
     * 使用默认配置删除文件
     * 
     * @param fileName
     *            文件名称
     * @return 删除结果
     * @throws SocketException
     * @throws IOException
     */
    public static Boolean deleteFile(String fileName) throws SocketException, IOException {
        return deleteFile(defaultIp, defaultPort, defaultAccount, defaultPassword, defaultWorkingDir, fileName);
    }

    /**
     * 删除文件
     * 
     * @param workingDir
     *            文件所在路径
     * @param fileName
     *            文件名称
     * @return 删除结果
     * @throws SocketException
     * @throws IOException
     */
    public static Boolean deleteFile(String workingDir, String fileName) throws SocketException, IOException {
        return deleteFile(defaultIp, defaultPort, defaultAccount, defaultPassword, workingDir, fileName);
    }

    /**
     * 删除文件
     * 
     * @param ip
     *            ftp 服务器ip地址
     * @param port
     *            ftp 服务器port，默认是21
     * @param account
     *            ftp 服务器用户名
     * @param password
     *            ftp 服务器密码
     * @param workingDir
     *            文件所在路径
     * @param fileName
     *            文件名称
     * @return 删除结果
     * @throws SocketException
     * @throws IOException
     */
    public static Boolean deleteFile(String ip, Integer port, String account, String password, String workingDir,
            String fileName) throws SocketException, IOException {
        return deleteFile(createFTPClient(ip, port, account, password), workingDir, fileName);
    }

    /**
     * 删除文件
     * 
     * @param ftpClient
     *            自定义ftp客户端
     * @param workingDir
     *            文件所在路径
     * @param fileName
     *            文件名称
     * @return 删除结果
     * @throws IOException
     */
    public static Boolean deleteFile(FTPClient ftpClient, String workingDir, String fileName) throws IOException {
        boolean result = false;
        ftpClient.changeWorkingDirectory(workingDir);
        int flag = ftpClient.dele(FtpUtils.chineseNameConversion(fileName));
        if (flag == DELETE_SUCCEED) {
            result = true;
        }
        return result;
    }

    /**
     * 中文名称转换，处理FTP中文乱码问题
     * 
     * @param name
     *            待转换的中文名称
     * @return 转换后的中文名
     * @throws UnsupportedEncodingException
     */
    public static String chineseNameConversion(String name) throws UnsupportedEncodingException {
        if (name == null) {
            return null;
        }
        return new String(name.getBytes(Charset.GBK), Charset.ISO88591);
    }

    /**
     * 使用默认配置创建FTPClient
     * 
     * @return FTPClient
     * @throws IOException
     * @throws SocketException
     */
    public static FTPClient createFTPClient() throws SocketException, IOException {
        return FtpUtils.createFTPClient(defaultIp, defaultPort, defaultAccount, defaultPassword, defaultWorkingDir);
    }

    /**
     * 使用默认配置创建FTPClient
     * 
     * @param workingDir
     *            服务器存储的绝对路径
     * @return FTPClient
     * @throws SocketException
     * @throws IOException
     */
    public static FTPClient createFTPClient(String workingDir) throws SocketException, IOException {
        return FtpUtils.createFTPClient(defaultIp, defaultPort, defaultAccount, defaultPassword, workingDir);
    }

    /**
     * 创建FTPClient
     * 
     * @param ip
     *            ftp 服务器ip地址
     * @param port
     *            ftp 服务器port，默认是21
     * @param account
     *            ftp 服务器用户名
     * @param password
     *            ftp 服务器密码
     * @return FTPClient
     * @throws IOException
     * @throws SocketException
     */
    public static FTPClient createFTPClient(String ip, Integer port, String account, String password)
            throws SocketException, IOException {
        return FtpUtils.createFTPClient(ip, port, account, password, null);
    }

    /**
     * 创建FTPClient
     * 
     * @param ip
     *            ftp 服务器ip地址
     * @param port
     *            ftp 服务器port，默认是21
     * @param account
     *            ftp 服务器用户名
     * @param password
     *            ftp 服务器密码
     * @param workingDir
     *            ftp 服务器存储的绝对路径
     * @return FTPClient
     * @throws IOException
     * @throws SocketException
     */
    public static FTPClient createFTPClient(String ip, Integer port, String account, String password, String workingDir)
            throws SocketException, IOException {
        FTPClient ftpClient = new FTPClient();
        ftpClient.connect(ip, port == null ? 21 : port);
        ftpClient.login(account, password);
        int reply = ftpClient.getReplyCode();
        if (!FTPReply.isPositiveCompletion(reply)) {
            ftpClient.disconnect(); // 如果返回状态不再 200 ~ 300 则认为连接失败
            throw new RuntimeException("FTP链接失败");
        }
        if (workingDir != null && !"".equals(workingDir)) {
            ftpClient.changeWorkingDirectory(workingDir);
        }
        return ftpClient;
    }

}
烟囱里一只猫、
关注
  • 0
    点赞
  • 踩
  • 11
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
高可用的Spring FTP上传下载工具类
残雪飞扬的博客
05-25 650
前言 ftp服务器进行交互关于ftp上传下载的工具类大致有两种。 　　第一种是单例模式的类。 　　第二种是另外定义一个Service，直接通过Service来实现ftp的上传下载删除。 　　这两种感觉都有利弊。 　　第一种实现了代码复用，但是配置信息全需要写在类中，维护比较复杂。 　　第二种如果是spring框架，可以通过propertis文件，动态的注入配置信息，但是又不能代码复用。 　　所以我打算自己实现一个工具类，来把上面的两种优点进行整合。顺便把一些上传过程中一些常见的问题也给解决了。
高可用的Spring FTP上传下载工具类（已解决上传过程常见问题）
bishe_teacher的博客
08-20 255
其他分类 自学教程 高可用的Spring FTP上传下载工具类（已解决上传过程常见问题） 前言 最近在项目中需要和ftp服务器进行交互，在网上找了一下关于ftp上传下载的工具类，大致有两种。 第一种是单例模式的类。 第二种是另外定义一个Service，直接通过Service来实现ftp的上传下载删除。 这两种感觉都有利弊。 第一种实现了代码复用，但是配置信息全需要写在类中，维护比较复杂。 第二种如果是spring框架，可以通过propertis文件，动态的注入配置信息，但是又不能代码复用。 所以我打算自己实
基于springboot的FtpUtil工具类.zip
04-08
可以用于毕业设计（项目源码+项目说明）目前在window10/11测试环境一切正常，用于演示的图片和部署教程说明都在压缩包里
spring环境实现FTP文件上传下载
nicew的博客
02-09 2765
package com.test.action; import java.io.IOException; import java.io.InputStream; import java.io.OutputStream; import javax.servlet.http.HttpServletRequest; import javax.servlet.http.HttpServletRespo
spring boot 从ftp下载文件 commons-net 下载问题
最新发布
fenglanzhu的博客
08-07 204
commons-net BUG FTP
Springboot项目FTP工具类实现
guaotianxia的博客
10-19 901
在项目中涉及ftp文件操作一般有两种方式，一种是ftp操作，使用21号端口，一种是sftp操作，使用22号端口。sftp因为文件传输进行加密，会比ftp安全，但是导致了传输速度低不少，在项目中可以根据对安全性和性能要求，选择哪种ftp操作方式。本文将介绍两种方式的工具类实现。
ftp上传下载
qq_33830052的博客
11-07 917
实现步骤： 1、FTP上传和下载的bat脚本。 脚本分为两部分：可执行bat脚本和ftp命令文件； 可执行bat脚本：
JAVA实现FTP文件上传下载
猫寻
01-17 2937
JAVA实现FTP文件上传下载 首先在pom文件中添加FTP相关Jar坐标: &amp;amp;amp;lt;dependency&amp;amp;amp;gt; &amp;amp;amp;lt;groupId&amp;amp;amp;gt;commons-net&amp;amp;amp;lt;/groupId&amp;amp;amp;gt; &amp;amp;amp;lt;artifactId&amp;amp;
SpringBoot 整合 Ftp 上传、下载、删除文件
m0_51985332的博客
02-06 2530
SpringBoot 整合 Ftp 上传、下载、删除文件
Spring Boot整合FTP实现文件的上传和下载
anhao的博客
12-18 4450
第一步： pom.xml文件中引入依赖包 <!-- FtpClient依赖包 --> <dependency> <groupId>commons-net</groupId> <artifactId>commons-net</artifactId> <version>3.3</ve...
springboot-FtpUtil-master_springbootftputil_ftp_attentioniwd_DEM
10-04
这是一个springboot项目ftp工具类使用的demo，可供参考学习
springboot集成ftp连接池工具
04-18
springboot集成ftp连接池工具，很好的解决了并发大用户上传附件慢的问题
spring mvc上传 下载ftp文件
03-16
spring mvc上传 下载ftp文件
Spring boot ftp server
01-31
spring boot ftp server示例。只有server没有client.被动模式上传 博客说明: https://blog.csdn.net/joe_storm/article/details/84872975
ftp的上传、下载
Wym_private的博客
02-09 288
ftp的上传、下载
FTP上传下载
flyyhz的博客
03-26 401
/** * ftp上传下载工具类 * &lt;p&gt;Title: FtpUtil&lt;/p&gt; * &lt;p&gt;Description: &lt;/p&gt; * &lt;p&gt;xxx&lt;/p&gt;  * @author  * @date  * @version  */public class FtpUtil { /**  * Description: 向FTP服务器上...
ftp文件上传下载
zhaodeng_2017的博客
07-21 1296
java ftp 文件上传下载
整合Spring FTP工具类及常见问题解决
总结来说，本文提供的Spring FTP工具类实现是一种结合了单例模式和Spring依赖注入的优化方法，旨在解决FTP操作中配置管理和代码复用的问题。在实际项目中，这种设计思路能够帮助开发者更好地管理和使用FTP服务，同时...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值