服务器间进行文件传输-SFTPSCP一篇搞定

1.简单介绍一下

在一些特殊场景，两台服务器之间需要进行文件传输的时候，或许我们会想到FTP，这也是我们常见的实现方式，但是如果我们不能操作远程服务器，无法判断远程服务器是否安装了FTP呢，众所周知，FTP使用的前提时确定服务器上配置了FTP服务，并且正在运行FTP服务器软件，这是最大的前提，如果我们不知道，那么就不能贸然的使用该方式。

我的需求是：我只知道对方服务器的ip、端口、用户名、密码，文件地址。其他的我一概不知。

那么还有什么方式呢，SFTP？SCP？

SFTP和FTP不就少了一个S，应该也需要安装FTP吧？答案是：NO

SFTP：是一种基于SSH协议的网络协议，用于在网络上安全的传输协议，SFTP提供了一个安全的文件传输机制，允许用户在传输过程中加密数据，从而保护数据免受窃听和篡改。

注意：OpenSSH支持SFTP，也就是说只要服务器中有OpenSSH，SFTP就可以使用。

FTP：是一种用于在网络上进行文件传输的协议。它是基于文本的协议，允许用户上传、下载、删除和重命名文件。

注意：需要安装配置FTP服务到服务器。

SCP：是一种用于在服务器之间安全复制文件的网络协议。基于SSH协议，提供了一个加密的方法来传输文件，确保数据在传输过程中的安全性。SCP是一个命令行工具，通常用于远程服务器管理、文件备份和系统维护。

注意：我认为只要服务器可以执行linux命令，应该都可以实现。

2.实现方式

我的实现方式是基于Spring Boot创建完成的哈，大家如果出现了什么问题，得放到评论区，得重新看看具体是什么原因。

2.1 FTP方式

这个大家就参考网上详细的文章哈，主要我的需求不能使用这个方式😄，所以没有代码😜。

2.2 SFTP方式

第一个肯定就是导入依赖

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

然后，咱们就得写一个工具类了

import com.jcraft.jsch.Channel;
import com.jcraft.jsch.ChannelSftp;
import com.jcraft.jsch.JSch;
import com.jcraft.jsch.Session;
import java.io.File;

public class ScpFileTransferUtil {

    // 远程服务器的IP地址
    private static final String IP = "192.xxx.xxx.xx";
    // 远程服务器的SSH端口
    private static final int PORT = xxxx;
    // 远程服务器的用户名
    private static final String USER_NAME = "root";
    // 远程服务器的密码
    private static final String PASSWORD = "xxxxxx";

    /**
     * 从远程服务器下载文件到本地
     *
     * @param remotePath 远程文件路径
     * @param localPath  本地目标目录
     */
    public static void scpFromRemote(String remotePath, String localPath) {
        try {
            JSch jsch = new JSch();
            Session session = jsch.getSession(USER_NAME, IP, PORT);
            session.setPassword(PASSWORD);

            // 设置配置项
            java.util.Properties config = new java.util.Properties();
            config.put("StrictHostKeyChecking", "no");
            session.setConfig(config);

            // 连接会话
            System.out.println("Connecting to SSH server...");
            session.connect();

            // 打开 SFTP 通道
            Channel channel = session.openChannel("sftp");
            channel.connect();
            ChannelSftp sftpChannel = (ChannelSftp) channel;

            // 解析远程文件路径中的文件名
            String fileName = extractFileNameFromPath(remotePath);

            // 创建本地文件路径
            File localFile = new File(localPath, fileName);

            // 创建本地目标目录
            File directory = localFile.getParentFile();
            if (!directory.exists()) {
                boolean mkdirResult = directory.mkdirs();
                if (mkdirResult) {
                    System.out.println("创建文件夹成功");
                } else {
                    System.out.println("创建文件夹失败");
                    throw new RuntimeException("创建文件夹失败！");
                }
            }

            // 下载文件
            System.out.println("Downloading file from remote path: " + remotePath);
            sftpChannel.get(remotePath, localFile.getAbsolutePath());

            System.out.println("文件下载成功");

            // 关闭通道和会话
            channel.disconnect();
            session.disconnect();

        } catch (Exception e) {
            e.printStackTrace();
            System.err.println("文件下载失败：" + e.getMessage());
        }
    }

    /**
     * 从路径中提取文件名
     *
     * @param path 完整路径
     * @return 文件名
     */
    private static String extractFileNameFromPath(String path) {
        int lastSeparatorIndex = path.lastIndexOf(File.separator);
        return path.substring(lastSeparatorIndex + 1);
    }

    public static void main(String[] args) {
        System.out.println("Main method started.");
        //获取开始时间
        long startTime = System.currentTimeMillis();
        String remotePath = "/data/ceshiDown/eac207eeeb2095cc560f94b6e7e33f49_4.mp4"; // 远程文件路径
        String localPath = "E:\\mnt\\data_process_net\\token"; // 本地目标目录

        scpFromRemote(remotePath, localPath);
        System.out.println("Main method finished.");
        //获取结束时间
        long endTime = System.currentTimeMillis();
        System.out.println("程序运行时间：" + (endTime - startTime)/1000 + "s");
    }
}

这段代码应该不需要我讲解一下了吧，我相信兄弟们都可以看懂的，必要的注释我都加上啦。

搞定！

2.3 SCP方式

SCP的实现方式，有一些稍微的麻烦，需要写一个expect脚本，为什么使用脚本呢，说明一下，在我们使用scp命令在拷贝远程服务器的时候，我们中间需要输入密码。

但是我们在执行代码的时候，可以自动识别需要输入密码，然后自动化输入密码吗？答案是不能的。

所以这里介入expect脚本的作用就是识别哪里需要输入密码，然后自动化输入密码。

这里应该不需要安装任何的依赖的。

直接就是工具类：

import lombok.extern.slf4j.Slf4j;

import java.io.BufferedReader;
import java.io.File;
import java.io.IOException;
import java.io.InputStreamReader;
@Slf4j
public class ScpUtil {


    public static void scpFromRemoteUsingExpect(String expectScriptPath, String user, String host, int port, String remotePath, String localPath, String password) {
        Process process = null;
        try {
            // 确保目标目录存在
            File localDir = new File(localPath);
            if (!localDir.exists()) {
                boolean created = localDir.mkdirs(); // 创建多级目录
                if (!created) {
                    throw new IOException("无法创建目标目录: " + localPath);
                }
            }
            // 构建 expect 脚本的命令行参数
            String[] params = {user, host, Integer.toString(port), remotePath, localPath, password};
            String command = expectScriptPath + " " + String.join(" ", params);

            // 执行 expect 脚本
            process = Runtime.getRuntime().exec(command);

            // 读取命令的输出
            BufferedReader reader = new BufferedReader(new InputStreamReader(process.getInputStream()));
            String line;
            while ((line = reader.readLine()) != null) {
                System.out.println(line);
            }

            // 等待命令执行完成
            int exitCode = process.waitFor();
            if (exitCode == 0) {
                log.info("文件下载成功");
            } else {
                log.info("文件下载失败，退出代码：{}", exitCode);
            }
        } catch (Exception e) {
            e.printStackTrace();
            log.info("文件下载失败：{}", e.getMessage());
        }finally {
            // 确保资源被释放
            if (process != null) {
                process.destroy();
            }
        }
    }



    public static void scpDirectoryFromRemoteUsingExpect(String expectScriptPath, String user, String host, int port, String remotePath, String localPath, String password) {
        Process process = null;
        try {
            // 确保目标目录存在
            File localDir = new File(localPath);
            if (!localDir.exists()) {
                boolean created = localDir.mkdirs(); // 创建多级目录
                if (!created) {
                    throw new IOException("无法创建目标目录: " + localPath);
                }
            }
            // 构建 expect 脚本的命令行参数，确保 remotePath 是一个目录
            String[] params = {user, host, Integer.toString(port), remotePath + "/", localPath, password};
            String command = expectScriptPath + " " + String.join(" ", params);

            // 执行 expect 脚本
            process = Runtime.getRuntime().exec(command);

            // 读取命令的输出
            BufferedReader reader = new BufferedReader(new InputStreamReader(process.getInputStream()));
            String line;
            while ((line = reader.readLine()) != null) {
                System.out.println(line);
            }

            // 等待命令执行完成
            int exitCode = process.waitFor();
            if (exitCode == 0) {
                System.out.println("文件夹下载成功");
            } else {
                System.err.println("文件夹下载失败，退出代码：" + exitCode);
            }
        } catch (IOException e) {
            e.printStackTrace();
            log.info("文件夹下载失败：{}", e.getMessage());
        } catch (InterruptedException e) {
            Thread.currentThread().interrupt(); // 重新设置中断状态
            e.printStackTrace();
            log.info("文件夹下载被中断：{}", e.getMessage());
        } finally {
            // 确保资源被释放
            if (process != null) {
                try {
                    process.getInputStream().close();
                    process.getOutputStream().close();
                    process.getErrorStream().close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
                process.destroy();
            }
        }
    }

    public static void main(String[] args) {
        log.info("Main method started.");
        // 获取开始时间
        long startTime = System.currentTimeMillis();
        String expectScriptPath = "/script/scp_download_directory.exp"; // expect 脚本的路径
        String remotePath = "/data/ceshiDown/";
        String localPath = "/data/ceshi2";
        ScpUtil.scpDirectoryFromRemoteUsingExpect(expectScriptPath, USER_NAME, IP, PORT, remotePath, localPath, PASSWORD);
        log.info("Main method finished.");
        // 获取结束时间
        long endTime = System.currentTimeMillis();
        System.out.println("程序运行时间：" + (endTime - startTime) / 1000 + "s");
    }
}

上面这个工具类呢，scpFromRemoteUsingExpect()方法是复制文件的，scpDirectoryFromRemoteUsingExpect()是复制文件夹的。注意一下哦。

最终要的来啦，脚本怎么写呢。
复制文件的脚本下载地址：scp复制远程服务器文件至本地服务器expect脚本

复制文件夹的脚本下载地址：scp复制远程服务器文件夹至本地服务器expect脚本

若是文件下载不了，千万别花钱下载，联系我，我发你。

这里我就不测试了，我是在服务器测试的，是行得通的。
完结！撒花！以上内容，若有任何问题，欢迎在评论区留言，在此，若有更好的解决方案的兄弟，也请留言，让我学习一下哈