JAVA的FTP和SFTP相关操作工具类

一、FTP

文件传输协议（File Transfer Protocol，FTP）是用于在网络上进行文件传输的一套标准协议，它工作在 OSI 模型的第七层， TCP 模型的第四层， 即应用层， 使用 TCP 传输而不是 UDP， 客户在和服务器建立连接前要经过一个“三次握手”的过程， 保证客户与服务器之间的连接是可靠的， 而且是面向连接， 为数据传输提供可靠保证。

FTP允许用户以文件操作的方式（如文件的增、删、改、查、传送等）与另一主机相互通信。然而， 用户并不真正登录到自己想要存取的计算机上面而成为完全用户， 可用FTP程序访问远程资源， 实现用户往返传输文件、目录管理以及访问电子邮件等等， 即使双方计算机可能配有不同的操作系统和文件存储方式。

1.1 引入maven依赖

<dependency>
    <groupId>commons-net</groupId>
    <artifactId>commons-net</artifactId>
    <version>3.9.0</version>
</dependency>

1.2 FtpUtil工具类

import lombok.extern.slf4j.Slf4j;
import org.apache.commons.net.ftp.FTP;
import org.apache.commons.net.ftp.FTPClient;
import org.apache.commons.net.ftp.FTPReply;
import org.apache.commons.net.ftp.FTPSClient;

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

/**
 * @Author: huangyibo
 * @Date: 2023/5/15 15:39
 * @Description:
 */

@Slf4j
public class FtpUtil {

    /**
     * 获取FTPClient对象
     * @param ftpHost       FTP主机服务器
     * @param ftpPassword   FTP 登录密码
     * @param ftpUserName   FTP登录用户名
     * @param ftpPort       FTP端口 默认为21
     * @return
     */
    public static FTPClient getFTPClient(String ftpHost, String ftpUserName, String ftpPassword, int ftpPort, boolean ssl) {
        FTPClient ftpClient = new FTPClient();
        try {
            ftpClient = ssl ? new FTPSClient("TLS", true) : new FTPClient();
            // 中文支持
            ftpClient.setControlEncoding("UTF-8");
            // 连接FTP服务器
            ftpClient.connect(ftpHost, ftpPort);
            // 登陆FTP服务器
            ftpClient.login(ftpUserName, ftpPassword);
            if (ssl) {
                ((FTPSClient) ftpClient).execPBSZ(0);
                ((FTPSClient) ftpClient).execPROT("P");
            }
            ftpClient.setFileType(FTPClient.BINARY_FILE_TYPE);
            ftpClient.enterLocalPassiveMode();
            if (!FTPReply.isPositiveCompletion(ftpClient.getReplyCode())) {
                log.info("未连接到FTP，用户名或密码错误。");
                ftpClient.disconnect();
            } else {
                log.info("FTP连接成功。");
            }
        } catch (SocketException e) {
            e.printStackTrace();
            log.info("FTP的IP地址可能错误，请正确配置。");
        } catch (IOException e) {
            e.printStackTrace();
            log.info("FTP的端口错误,请正确配置。");
        }
        return ftpClient;
    }

    /**
     * 从FTP服务器下载文件
     * @param ftpHost             FTP IP地址
     * @param ftpUserName         FTP 用户名
     * @param ftpPassword         FTP用户名密码
     * @param ftpPort             FTP端口
     * @param ftpPath             FTP服务器中文件所在路径 格式： ftptest/aa
     * @param localPath           下载到本地的位置 格式：H:/download
     * @param fileName            FTP服务器上要下载的文件名称
     * @param targetFileName      下载到本地的文件名称
     */
    public static void downloadFtpFile(String ftpHost, String ftpUserName, String ftpPassword, int ftpPort, String ftpPath, String localPath, String fileName, String targetFileName, boolean ssl) {

        FTPClient ftpClient = null;
        try {
            ftpClient = getFTPClient(ftpHost, ftpUserName, ftpPassword, ftpPort, ssl);
            ftpClient.changeWorkingDirectory(ftpPath);
            System.out.println("连接成功,改变目录中...");
            ftpClient.makeDirectory("summer");

            //编码文件格式,解决中文文件名
            String f_ame = new String(fileName.getBytes("GBK"), FTP.DEFAULT_CONTROL_ENCODING);

            File localFile = new File(localPath + File.separatorChar + targetFileName);
            OutputStream os = new FileOutputStream(localFile);
            ftpClient.retrieveFile(f_ame, os);
            os.close();
            ftpClient.logout();

        } catch (FileNotFoundException e) {
            log.error("没有找到" + ftpPath + "文件");
            e.printStackTrace();
        } catch (SocketException e) {
            log.error("连接FTP失败.");
            e.printStackTrace();
        } catch (IOException e) {
            log.error("文件读取错误。");
            e.printStackTrace();
        }
    }

    /**
     * Description:             向FTP服务器上传文件
     * @param ftpHost              FTP服务器hostname
     * @param ftpPort              FTP服务器端口
     * @param ftpUserName          FTP登录账号
     * @param ftpPassword          FTP登录密码
     * @param ftpPath          FTP服务器文件存放路径。例如分日期存放：/2015/01/01。文件的路径为basePath+filePath
     * @param filename          上传到FTP服务器上的文件名
     * @param input             输入流
     * @return                  成功返回true，否则返回false
     */
    public static boolean uploadFile(String ftpHost, String ftpUserName, String ftpPassword, int ftpPort, String ftpPath, String filename, InputStream input, boolean ssl) {
        boolean result = false;
        FTPClient ftpClient = new FTPClient();
        try {
            int reply;
            ftpClient = getFTPClient(ftpHost, ftpUserName, ftpPassword, ftpPort, ssl);
            ftpClient.changeWorkingDirectory(ftpPath);

            reply = ftpClient.getReplyCode();
            if (!FTPReply.isPositiveCompletion(reply)) {
                ftpClient.disconnect();
                return result;
            }
            //编码文件名，支持中文文件名
            filename = new String(filename.getBytes("GBK"), FTP.DEFAULT_CONTROL_ENCODING);
            //上传文件
            if (!ftpClient.storeFile(filename, input)) {
                return result;
            }
            input.close();
            ftpClient.logout();
            result = true;
        } catch (IOException e) {
            log.error("文件上传错误", e);
            e.printStackTrace();
        } finally {
            if (ftpClient.isConnected()) {
                try {
                    ftpClient.disconnect();
                } catch (IOException ioe) {
                    log.error("ftpClient关闭错误", ioe);
                }
            }
        }
        return result;
    }
}

1.3 FtpUtils工具类

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 org.springframework.stereotype.Component;

import javax.annotation.PostConstruct;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.nio.file.Files;
import java.nio.file.StandardCopyOption;

/**
 * @Author: huangyibo
 * @Date: 2023/5/15 15:32
 * @Description:
 */

@Component
public class FtpUtils {

    @Value("${ftp.username}")
    private String fUsername;

    private  static String FTP_USER;

    @Value("${ftp.password}")
    private String fPassword;

    private  static String FTP_PASSWORD;

    @Value("${ftp.host}")
    private String fHost;

    private  static String FTP_IP;

    @Value("${ftp.port}")
    private Integer fPort;

    private  static Integer FTP_PORT;

    @Value("${ftp.charset.iso}")
    private String fCharsetIso;

    private  static String CHARSET_ISO;

    @PostConstruct
    public void init(){
        FTP_USER=fUsername;
        FTP_PASSWORD=fPassword;
        FTP_IP=fHost;
        FTP_PORT=fPort;
        CHARSET_ISO=fCharsetIso;
    }

    /**
     * 下载指定Ftp文件夹的全部文件
     * @param folderPath ftp文件夹路径
     * @param localPath 下载本地磁盘路径
     * @return
     */
    public static Boolean downLoadFolder(String folderPath,String localPath){
        FTPClient ftp = getFTPClient();
        try {
            if(ftp == null){
                return false;
            }
            ftp.enterLocalPassiveMode();
            //切换到文件目录
            ftp.changeWorkingDirectory(folderPath);
            //获取文件集合
            FTPFile[] files = ftp.listFiles();
            for(FTPFile file : files){
                if(file.isFile()){
                    try (OutputStream out = new FileOutputStream(localPath +  "\\\\" + file.getName())){
                        ftp.retrieveFile(new String(file.getName().getBytes(),CHARSET_ISO),out);
                        out.flush();
                    }
                }
            }
        }catch (Exception e){
            e.printStackTrace();
            return false;
        }finally {
            closeFtp(ftp);
        }
        return true;
    }

    /**
     * 文件下载
     * @param parentPath 文件在ftp上级路径
     * @param ftpFileName 文件在ftp名称
     * @param localPath 下载本地磁盘路径
     * @return
     */
    public static Boolean downLoad(String parentPath,String ftpFileName,String localPath){
        FTPClient ftp = getFTPClient();
        try {
            if(ftp == null){
                return false;
            }
            ftp.enterLocalPassiveMode();
            parentPath = parentPath + "/" +ftpFileName;
            System.out.println(parentPath);
            //根据文件名称获取输入流
            try (InputStream in = ftp.retrieveFileStream(new String(parentPath.getBytes(),CHARSET_ISO))){
                //写入本地文件目录
                File dest = new File(localPath, ftpFileName);
                if (!dest.getParentFile().exists()) {
                    System.out.println("创建文件夹.................");
                    dest.getParentFile().mkdirs();
                }
                Files.copy(in, dest.toPath(), StandardCopyOption.REPLACE_EXISTING);
                return true;
            }
        }catch (Exception e){
            e.printStackTrace();
        }finally {
            closeFtp(ftp);
        }
        return false;
    }

    /**
     * 文件上传
     * @param filePath 文件路径
     * @param ftpPath ftp路径
     * @return
     */
    public static Boolean upload(String filePath,String ftpPath){
        return upload(new File(filePath),ftpPath);
    }

    /**
     * 文件上传
     * @param file 文件对象
     * @param ftpPath ftp路径
     * @return
     */
    public static Boolean upload(File file,String ftpPath){
        FTPClient ftp = getFTPClient();
        try {
            if(ftp == null){
                return false;
            }
            //设置被动模式
            ftp.enterLocalPassiveMode();
            //二进制传输
            ftp.setFileType(FTPClient.BINARY_FILE_TYPE);
            //如果ftp目录不存在则创建目录
            if(!ftp.changeWorkingDirectory(ftpPath)){
                ftp.makeDirectory(ftpPath);
                //改变工作目录
                ftp.changeWorkingDirectory(ftpPath);
            }
            //文件名
            String fileName = file.getName();
            //上传文件
            if(ftp.storeFile(new String(fileName.getBytes(),CHARSET_ISO),new FileInputStream(file))){
                return true;
            }
        }catch (Exception e){
            e.printStackTrace();
        }finally {
            closeFtp(ftp);
        }
        return false;
    }

    /**
     * 获取Ftp客户端对象
     * @return
     */
    private static FTPClient getFTPClient(){
        try {
            FTPClient ftpClient = new FTPClient();
            ftpClient.connect(FTP_IP,FTP_PORT);
            //连接超时时间
            ftpClient.setConnectTimeout(2 * 60 * 1000);
            //传输超时时间
            ftpClient.setDataTimeout(2 * 60 * 1000);
            ftpClient.setControlEncoding("utf-8");
            //用户名密码登录
            ftpClient.login(FTP_USER,FTP_PASSWORD);
            //校验响应码
            if(!FTPReply.isPositiveCompletion(ftpClient.getReplyCode())){
                ftpClient.disconnect();
                return null;
            }
            return ftpClient;
        }catch (Exception e){
            e.printStackTrace();
        }
        return null;
    }

    /**
     * 关闭Ftp客户端
     * @param ftp
     */
    private static void closeFtp(FTPClient ftp){
        try {
            if(ftp != null){
                ftp.logout();
            }
        }catch (Exception e){
            e.printStackTrace();
        }finally {
            try {
                if(ftp != null){
                    ftp.disconnect();
                }
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }
}

二、SFTP

摘自百度百科：SSH文件传输协议，是一种数据流链接，提供文件访问、传输和管理功能的网络传输协议。

SFTP允许用户以文件操作的方式（如文件的增、删、改、查、传送等）与另一主机相互通信。

2.1 引入maven依赖

<dependency>
    <groupId>com.jcraft</groupId>
    <artifactId>jsch</artifactId>
    <version>0.1.55</version>
</dependency>

2.2 SftpUtil

import com.jcraft.jsch.Channel;
import com.jcraft.jsch.ChannelSftp;
import com.jcraft.jsch.JSch;
import com.jcraft.jsch.JSchException;
import com.jcraft.jsch.Session;
import com.jcraft.jsch.SftpException;

import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.InputStream;
import java.io.OutputStream;
import java.util.Properties;

/**
 * @Author: huangyibo
 * @Date: 2023/5/15 15:55
 * @Description:
 * sftp工具类，包含以下功能：
 * 获取sftp链接
 * 关闭sftp链接
 * 下载文件
 * 上传文件
 * 删除文件
 * 查找文件
 * 更多功能自行拓展
 */

public class SftpUtil {

    /**
     * 获取一个sftp链接
     * @param host sftp服务器ip
     * @param port 端口
     * @param username 用户名
     * @param password 密码
     * @return 返回ChannelSftp
     * @throws Exception 获取通道时的异常
     */
    public static ChannelSftp getSftpChannel(String host, Integer port, String username, String password) throws Exception{
        Session session;
        Channel channel = null;
        JSch jSch = new JSch();
        try {
            session = jSch.getSession(username, host, port);
            session.setPassword(password);

            // 配置链接的属性
            Properties properties = new Properties();
            properties.setProperty("StrictHostKeyChecking","no");
            session.setConfig(properties);

            // 进行sftp链接
            session.connect();

            // 获取通信通道
            channel = session.openChannel("sftp");
            channel.connect();
        } catch (JSchException e) {
            e.printStackTrace();
            throw e;
        }
        return (ChannelSftp)channel;
    }

    /**
     * 上传文件
     * @param channelSftp sftp通道
     * @param localFile 本地文件
     * @param remoteFile 远程文件
     */
    public static void upload(ChannelSftp channelSftp, String localFile, String remoteFile){
        InputStream inputStream = null;
        try {
            inputStream = new FileInputStream(localFile);
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        }

        try {
            channelSftp.put(inputStream, remoteFile);
        } catch (SftpException e) {
            e.printStackTrace();
        }
    }

    /**
     * 从sftp服务器上下载文件
     * @param channelSftp sftp通道
     * @param remoteFile 远程文件
     * @param localFile 本地文件
     */
    public static void download(ChannelSftp channelSftp, String remoteFile, String localFile){
        OutputStream outputStream = null;
        try {
            outputStream = new FileOutputStream(localFile);
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        }

        try {
            channelSftp.get(remoteFile, outputStream);
        } catch (SftpException e) {
            e.printStackTrace();
        }
    }

    /**
     * 删除文件
     * @param channelSftp sftp通道
     * @param remoteFile 远程文件
     */
    public static void deleteFile(ChannelSftp channelSftp, String remoteFile) throws Exception{
        try {
            channelSftp.rm(remoteFile);
        } catch (SftpException e) {
            e.printStackTrace();
            throw e;
        }
    }

    /**
     * 关闭sftp链接
     * @param channelSftp sftp通道
     * @throws Exception 关闭session的异常
     */
    public static void closeSession(ChannelSftp channelSftp) throws Exception{
        if(channelSftp == null){
            return;
        }

        Session session = null;
        try {
            session = channelSftp.getSession();
        } catch (JSchException e) {
            e.printStackTrace();
            throw e;
        }finally {
            if(session != null){
                session.disconnect();
            }
        }
    }
}