Java SFTP文件操作全攻略:从列表获取到上传下载的完整工具类封装

告别乱码和截断:SAP PI/PO处理SFTP定长文件的编码与字节长度全攻略 本文详细解析了SAP PI/PO处理SFTP定长文件时常见的乱码和截断问题,提供了编码转换与字节长度计算的完整解决方案。通过配置示例和实战案例,帮助运维人员正确处理Shift_JIS等编码文件,确保数据完整性和准确性。 阅读详情

Java SFTP文件操作全攻略:从列表获取到上传下载的完整工具类封装

如果你是一名Java开发者,经常需要和远程服务器打交道,手动上传日志、同步数据或者备份文件,那么SFTP(SSH File Transfer Protocol)大概率是你绕不开的技术。它比传统的FTP安全,又比单纯的SCP功能丰富,尤其是在需要列出目录、检查文件属性或者进行复杂文件管理时。但每次写SFTP连接代码,都免不了要处理一堆JSch的Session、Channel,还有那些令人头疼的异常和资源关闭问题。代码散落在各个业务模块里,不仅重复,维护起来也像在走钢丝。

这篇文章就是为你准备的。我们不打算只教你如何用几行代码获取一个文件列表——那太基础了。我们要做的是,从工程化的角度,构建一个健壮、可复用、功能全面的SFTP工具类。这个工具类要能直接扔进你的生产环境,处理从简单的文件上传下载,到复杂的目录递归操作、连接池管理乃至监控埋点。我们会深入JSch的细节,但更关注如何在其之上搭建更优雅的抽象。无论你是要构建一个自动化的文件同步服务,还是为一个数据平台集成可靠的文件传输组件,这里的内容都能给你一套现成的“轮子”和打造“轮子”的完整思路。

1. 超越基础连接:构建可配置的SFTP客户端工厂

直接使用JSch的getSession和connect是最初级的做法。在生产环境中,我们需要考虑更多:连接超时设置、针对不同SSH服务端版本的算法适配、公私钥认证的支持,以及最重要的——如何优雅地管理连接的生命周期。一个简单的工具类构造函数远远不够。

1.1 连接参数的系统化配置

与其在代码里硬编码StrictHostKeyChecking为"no"(这在某些安全要求高的场景下是忌讳的),不如设计一个配置对象。这个对象集中管理所有连接参数,并提供合理的默认值。

/**
 * SFTP连接配置参数
 */
public class SftpConfig {
    private String host;
    private int port = 22; // 默认SFTP端口
    private String username;
    private String password;
    private String privateKeyPath; // 私钥路径,优先级高于密码
    private String passphrase; // 私钥口令
    private int connectTimeout = 30000; // 连接超时(毫秒)
    private int socketTimeout = 30000; // Socket读写超时
    private String encoding = "UTF-8"; // 文件名编码
    private boolean strictHostKeyChecking = false; // 是否严格检查主机密钥
    private String knownHostsFilePath; // 已知主机文件路径,如果strictHostKeyChecking为true则需提供

    // 省略getter/setter和builder方法...
}

使用建造者模式(Builder Pattern)来创建这个配置对象,会让客户端代码清晰很多:

SftpConfig config = SftpConfig.builder()
    .host("sftp.example.com")
    .username("data-user")
    .privateKeyPath("/home/user/.ssh/id_rsa")
    .connectTimeout(10000)
    .encoding("GBK") // 处理中文Windows服务器可能需要
    .build();

1.2 支持多种认证方式

很多生产环境出于安全考虑,禁止使用密码认证,要求使用SSH密钥。我们的工具类必须同时支持密码和私钥认证。

private Session createSession(SftpConfig config) throws JSchException {
    JSch jsch = new JSch();
    Session session = jsch.getSession(config.getUsername(), config.getHost(), config.getPort());

    // 1. 私钥认证优先
    if (StringUtils.isNotBlank(config.getPrivateKeyPath())) {
        File keyFile = new File(config.getPrivateKeyPath());
        if (!keyFile.exists()) {
            throw new FileNotFoundException("Private key file not found: " + config.getPrivateKeyPath());
        }
        if (StringUtils.isNotBlank(config.getPassphrase())) {
            jsch.addIdentity(config.getPrivateKeyPath(), config.getPassphrase());
        } else {
            jsch.addIdentity(config.getPrivateKeyPath());
        }
    } else if (StringUtils.isNotBlank(config.getPassword())) {
        // 2. 密码认证
        session.setPassword(config.getPassword());
    } else {
        throw new IllegalArgumentException("Either password or private key must be provided for authentication.");
    }

    // 配置连接属性
    Properties props = new Properties();
    props.put("StrictHostKeyChecking", config.isStrictHostKeyChecking() ? "yes" : "no");
    if (config.isStrictHostKeyChecking() && StringUtils.isNotBlank(config.getKnownHostsFilePath())) {
        jsch.setKnownHosts(config.getKnownHostsFilePath());
    }
    // 针对高版本OpenSSH服务器的算法兼容性配置
    props.put("kex", "diffie-hellman-group1-sha1,diffie-hellman-group14-sha1,diffie-hellman-group-exchange-sha256");
    props.put("server_host_key", "ssh-rsa,ssh-dss,ecdsa-sha2-nistp256");

    session.setConfig(props);
    session.setTimeout(config.getConnectTimeout());
    return session;
}

注意:将StrictHostKeyChecking设置为"no"会带来中间人攻击(Man-in-the-Middle)的风险。在可信的内部网络或测试环境可以这样用,但对于外部或生产环境,建议设置为"yes"并正确配置known_hosts文件。

1.3 连接池的初步思考

对于高频调用SFTP操作的应用,为每次操作都创建新连接是巨大的性能开销。一个自然的优化思路是引入连接池。虽然JSch本身不提供池化功能,但我们可以利用Apache Commons Pool这样的库来包装我们的SFTP客户端。

这里先勾勒一个简单的池化客户端接口,后续章节会展开实现:

public interface PooledSftpClient {
    /**
     * 从池中借用一个SFTP客户端
     */
    SftpOperationTemplate borrowClient() throws Exception;

    /**
     * 将客户端返还给池
     */
    void returnClient(SftpOperationTemplate client);

    /**
     * 执行一个带有返回值的操作
     */
    <T> T execute(SftpCallback<T> callback) throws Exception;
}

2. 核心操作封装:从单文件到批量处理

有了稳固的连接层,接下来就是实现具体的文件操作。我们的目标是将ChannelSftp那些略显原始的API,封装成更符合Java开发者习惯、更健壮的方法。

2.1 安全的目录切换与列表获取

ChannelSftp.cd()和ls()是最常用的方法,但直接使用它们,如果目录不存在或没有权限,会直接抛出SftpException。我们需要更友好的封装。

首先,实现一个安全的目录存在性检查方法,它比简单地捕获异常更高效:

public boolean directoryExists(String remotePath) {
    try {
        sftpChannel.lstat(remotePath); // lstat不会追踪符号链接
        return true;
    } catch (SftpException e) {
        if (e.id == ChannelSftp.SSH_FX_NO_SUCH_FILE) {
            return false;
        }
        // 其他异常如权限不足,重新抛出或记录日志
        throw new SftpOperationException("Failed to check directory existence: " + remotePath, e);
    }
}

接着,封装一个获取文件列表并过滤的方法。原始的ls()返回Vector,且包含.和..目录。我们通常需要更结构化的信息:

/**
 * 列出指定目录下的文件项(可选择过滤)
 * @param remoteDir 远程目录
 * @param filter 文件名过滤器,支持通配符,如 "*.csv"
 * @param includeHidden 是否包含隐藏文件(以.开头)
 * @return 文件信息列表
 */
public List<FileInfo> listFiles(String remoteDir, String filter, boolean includeHidden) throws SftpOperationException {
    List<FileInfo> result = new ArrayList<>();
    try {
        Vector<?> rawList = sftpChannel.ls(remoteDir + "/" + (filter != null ? filter : "*"));
        for (Object obj : rawList) {
            ChannelSftp.LsEntry entry = (ChannelSftp.LsEntry) obj;
            String filename = entry.getFilename();

            // 过滤掉当前目录和上级目录
            if (".".equals(filename) || "..".equals(filename)) {
                continue;
            }
            // 过滤隐藏文件
            if (!includeHidden && filename.startsWith(".")) {
                continue;
            }

            SftpATTRS attrs = entry.getAttrs();
            FileInfo info = new FileInfo();
            info.setFilename(filename);
            info.setDirectory(attrs.isDir());
            info.setSize(attrs.getSize());
            info.setLastModified(attrs.getMTime() * 1000L); // 转换为毫秒
            info.setPermissions(attrs.getPermissionsString());
            result.add(info);
        }
    } catch (SftpException e) {
        throw new SftpOperationException("Failed to list directory: " + remoteDir, e);
    }
    return result;
}

这里我们引入了一个FileInfo数据传输对象(DTO),它比原始的LsEntry更易于序列化和使用。

2.2 可靠的文件上传与下载

文件传输是SFTP的核心。ChannelSftp.put()和get()方法虽然简单,但缺乏进度反馈、断点续传等高级功能。我们先从增强可靠性和用户体验做起。

上传文件时,一个常见的需求是自动创建不存在的父目录:

public void uploadFile(String localFilePath, String remoteFilePath, boolean createParentDirs) throws SftpOperationException {
    File localFile = new File(localFilePath);
    if (!localFile.exists() || !localFile.isFile()) {
        throw new IllegalArgumentException("Local file does not exist or is not a file: " + localFilePath);
    }

    try (FileInputStream fis = new FileInputStream(localFile)) {
        if (createParentDirs) {
            createParentDirectories(remoteFilePath);
        }
        // 使用OVERWRITE模式,如果文件存在则覆盖
        sftpChannel.put(fis, remoteFilePath, ChannelSftp.OVERWRITE);
        log.info("File uploaded successfully: {} -> {}", localFilePath, remoteFilePath);
    } catch (IOException | SftpException e) {
        throw new SftpOperationException("Failed to upload file: " + localFilePath, e);
    }
}

private void createParentDirectories(String remoteFilePath) throws SftpException {
    int lastSlash = remoteFilePath.lastIndexOf('/');
    if (lastSlash > 0) {
        String parentDir = remoteFilePath.substring(0, lastSlash);
        if (!directoryExists(parentDir)) {
            // 递归创建父目录
            mkdirs(parentDir);
        }
    }
}

private void mkdirs(String remoteDir) throws SftpException {
    String[] folders = remoteDir.split("/");
    String path = "";
    for (String folder : folders) {
        if (folder.isEmpty()) continue;
        path += "/" + folder;
        if (!directoryExists(path)) {
            sftpChannel.mkdir(path);
        }
    }
}

下载文件时,除了基本的流复制,我们还可以增加完整性校验(如MD5校验)和自动重试机制:

public void downloadFile(String remoteFilePath, String localFilePath, int maxRetries) throws SftpOperationException {
    SftpOperationException lastException = null;
    for (int i = 0; i <= maxRetries; i++) {
        try {
            sftpChannel.get(remoteFilePath, localFilePath);
            // 可选:下载后进行文件校验
            if (verifyDownload(remoteFilePath, localFilePath)) {
                log.info("File downloaded and verified: {} -> {}", remoteFilePath, localFilePath);
                return;
            } else {
                log.warn("File verification failed, will retry: {}", remoteFilePath);
                // 删除可能不完整的本地文件
                new File(localFilePath).delete();
            }
        } catch (SftpException e) {
            lastException = new SftpOperationException("Download failed on attempt " + (i + 1), e);
            log.warn("Download attempt {} failed for {}", i + 1, remoteFilePath, e);
            if (i < maxRetries) {
                try {
                    Thread.sleep(1000 * (long) Math.pow(2, i)); // 指数退避
                } catch (InterruptedException ie) {
                    Thread.currentThread().interrupt();
                    throw lastException;
                }
            }
        }
    }
    throw lastException; // 所有重试都失败后抛出异常
}

2.3 批量操作与递归处理

单个文件传输是基础,但实际场景中更常见的是批量处理整个目录。例如,下载一个目录下所有.log文件,或者上传一个本地文件夹及其所有子文件夹。

下面是一个递归下载目录的示例,它展示了如何处理嵌套的目录结构:

public void downloadDirectory(String remoteDir, String localDir, Predicate<FileInfo> filter) throws SftpOperationException {
    File localBaseDir = new File(localDir);
    if (!localBaseDir.exists() && !localBaseDir.mkdirs()) {
        throw new SftpOperationException("Failed to create local directory: " + localDir);
    }

    try {
        List<FileInfo> entries = listFiles(remoteDir, null, false);
        for (FileInfo entry : entries) {
            String remotePath = remoteDir + "/" + entry.getFilename();
            String localPath = localDir + "/" + entry.getFilename();

            if (entry.isDirectory()) {
                // 递归处理子目录
                downloadDirectory(remotePath, localPath, filter);
            } else {
                // 应用过滤器,只下载符合条件的文件
                if (filter == null || filter.test(entry)) {
                    downloadFile(remotePath, localPath, 3); // 最多重试3次
                }
            }
        }
    } catch (SftpOperationException e) {
        throw new SftpOperationException("Failed to download directory: " + remoteDir, e);
    }
}

对应的,批量上传也有类似模式。但这里有一个性能优化点:对于大量小文件,为每个文件单独建立数据传输通道(put)会有开销。虽然SFTP协议本身每个文件独立传输,但我们可以通过并行化来提升整体吞吐量。

3. 高级特性与生产级考量

一个能在生产环境稳定运行的工具类,绝不能只满足于功能实现。它还需要考虑异常处理、日志监控、性能优化和资源管理。

3.1 统一的异常处理与状态码

JSch抛出的SftpException包含一个id字段,对应SFTP协议的状态码(如SSH_FX_NO_SUCH_FILE, SSH_FX_PERMISSION_DENIED)。我们应该捕获这些异常,并转换为更有业务意义的自定义异常。

public class SftpOperationException extends RuntimeException {
    private final int sftpErrorCode;

    public SftpOperationException(String message, SftpException cause) {
        super(message, cause);
        this.sftpErrorCode = cause.id;
    }

    public int getSftpErrorCode() {
        return sftpErrorCode;
    }

    public boolean isFileNotFound() {
        return sftpErrorCode == ChannelSftp.SSH_FX_NO_SUCH_FILE;
    }

    public boolean isPermissionDenied() {
        return sftpErrorCode == ChannelSftp.SSH_FX_PERMISSION_DENIED;
    }

    // ... 其他状态码判断方法
}

在工具类的方法中,我们统一进行转换:

try {
    sftpChannel.ls(path);
} catch (SftpException e) {
    throw new SftpOperationException("Operation failed for path: " + path, e);
}

3.2 连接池的完整实现

现在,让我们深入实现之前提到的连接池。使用Apache Commons Pool 2,我们可以创建一个SftpClient对象的池。

首先,定义池化对象的工厂:

public class SftpClientPooledObjectFactory extends BasePooledObjectFactory<SftpOperationTemplate> {
    private final SftpConfig config;

    public SftpClientPooledObjectFactory(SftpConfig config) {
        this.config = config;
    }

    @Override
    public SftpOperationTemplate create() throws Exception {
        return new SftpOperationTemplateImpl(config); // 这是我们封装的核心工具类
    }

    @Override
    public PooledObject<SftpOperationTemplate> wrap(SftpOperationTemplate client) {
        return new DefaultPooledObject<>(client);
    }

    @Override
    public void destroyObject(PooledObject<SftpOperationTemplate> p) throws Exception {
        p.getObject().disconnect(); // 关闭连接
        super.destroyObject(p);
    }

    @Override
    public boolean validateObject(PooledObject<SftpOperationTemplate> p) {
        // 验证连接是否仍然有效
        return p.getObject().isConnected();
    }
}

然后,创建并配置连接池:

public class SftpClientPool {
    private final GenericObjectPool<SftpOperationTemplate> pool;

    public SftpClientPool(SftpConfig config) {
        SftpClientPooledObjectFactory factory = new SftpClientPooledObjectFactory(config);
        GenericObjectPoolConfig<SftpOperationTemplate> poolConfig = new GenericObjectPoolConfig<>();
        poolConfig.setMaxTotal(10); // 最大连接数
        poolConfig.setMaxIdle(5);   // 最大空闲连接数
        poolConfig.setMinIdle(2);   // 最小空闲连接数
        poolConfig.setTestOnBorrow(true); // 借出时验证
        poolConfig.setTestWhileIdle(true); // 空闲时验证
        poolConfig.setTimeBetweenEvictionRuns(Duration.ofSeconds(30)); // 驱逐检查间隔

        this.pool = new GenericObjectPool<>(factory, poolConfig);
    }

    public <T> T execute(SftpCallback<T> callback) throws Exception {
        SftpOperationTemplate client = pool.borrowObject();
        try {
            return callback.doInSftp(client);
        } finally {
            pool.returnObject(client);
        }
    }

    public void close() {
        pool.close();
    }
}

使用方式变得非常简洁和安全:

sftpPool.execute(client -> {
    List<FileInfo> files = client.listFiles("/data/logs", "*.log.gz", false);
    files.forEach(f -> client.downloadFile("/data/logs/" + f.getFilename(), "/backup/" + f.getFilename(), 2));
    return files.size();
});

3.3 监控、日志与性能追踪

在生产环境,我们需要知道SFTP操作的健康状况:连接成功率、传输速度、错误类型分布等。可以在工具类的关键方法中加入监控埋点。

例如,使用Micrometer这样的指标库:

public class MonitoredSftpClient implements SftpOperationTemplate {
    private final SftpOperationTemplate delegate;
    private final MeterRegistry meterRegistry;
    private final Timer uploadTimer;
    private final Counter failureCounter;

    public MonitoredSftpClient(SftpOperationTemplate delegate, MeterRegistry meterRegistry) {
        this.delegate = delegate;
        this.meterRegistry = meterRegistry;
        this.uploadTimer = Timer.builder("sftp.upload.duration")
                .description("SFTP file upload duration")
                .register(meterRegistry);
        this.failureCounter = Counter.builder("sftp.operation.failure")
                .description("Count of failed SFTP operations")
                .register(meterRegistry);
    }

    @Override
    public void uploadFile(String localFilePath, String remoteFilePath, boolean createParentDirs) throws SftpOperationException {
        uploadTimer.record(() -> {
            try {
                delegate.uploadFile(localFilePath, remoteFilePath, createParentDirs);
            } catch (SftpOperationException e) {
                failureCounter.increment();
                Tags tags = Tags.of("error.code", String.valueOf(e.getSftpErrorCode()));
                meterRegistry.counter("sftp.operation.failure.detail", tags).increment();
                throw e;
            }
        });
    }
    // ... 其他方法的类似包装
}

日志方面,避免在每个方法开始结束都打INFO日志,那样会产生大量噪音。建议在DEBUG级别记录详细操作,在WARN或ERROR级别记录异常和重试信息,并使用结构化的日志格式(如JSON)以便后续分析。

4. 实战:构建一个文件同步微服务组件

最后,让我们把前面所有的模块组合起来,看一个更贴近真实场景的例子:一个用于微服务架构的SFTP文件同步组件。这个组件需要从配置中心读取多个SFTP服务器的配置,定时同步指定目录的文件,并将结果报告给监控系统。

4.1 配置与任务定义

首先,定义同步任务的配置模型:

public class SyncTaskConfig {
    private String taskId;
    private SftpConfig sourceConfig; // 源服务器配置
    private SftpConfig targetConfig; // 目标服务器配置(可选,如果为空则下载到本地)
    private String sourceDir;
    private String targetDir;
    private String filePattern; // 如 "data_*.csv"
    private SyncMode mode; // 枚举:UPLOAD, DOWNLOAD, MIRROR
    private boolean deleteSourceAfterSync; // 同步后删除源文件
    private CronExpression schedule; // 调度表达式
    private int retentionDays; // 本地保留天数

    // 省略其他字段和getter/setter
}

4.2 任务执行引擎

任务执行器负责管理连接池、执行具体的同步逻辑并处理错误:

@Component
public class SftpSyncTaskExecutor {
    private final Map<String, SftpClientPool> poolCache = new ConcurrentHashMap<>();
    private final TaskConfigRepository configRepository;
    private final MeterRegistry meterRegistry;

    public void executeTask(String taskId) {
        SyncTaskConfig config = configRepository.findById(taskId)
                .orElseThrow(() -> new TaskNotFoundException(taskId));

        SftpClientPool sourcePool = getOrCreatePool(config.getSourceConfig());
        SftpClientPool targetPool = config.getTargetConfig() != null ?
                getOrCreatePool(config.getTargetConfig()) : null;

        try {
            if (config.getMode() == SyncMode.DOWNLOAD) {
                executeDownloadTask(config, sourcePool);
            } else if (config.getMode() == SyncMode.MIRROR) {
                executeMirrorTask(config, sourcePool, targetPool);
            }
            // ... 其他模式
            recordSuccess(taskId);
        } catch (Exception e) {
            recordFailure(taskId, e);
            // 根据错误类型决定是否重试或告警
            handleFailure(taskId, e);
        }
    }

    private void executeDownloadTask(SyncTaskConfig config, SftpClientPool sourcePool) throws Exception {
        sourcePool.execute(sourceClient -> {
            List<FileInfo> files = sourceClient.listFiles(config.getSourceDir(), config.getFilePattern(), false);
            for (FileInfo file : files) {
                String remotePath = config.getSourceDir() + "/" + file.getFilename();
                String localPath = config.getTargetDir() + "/" + file.getFilename();

                sourceClient.downloadFile(remotePath, localPath, 3);

                if (config.isDeleteSourceAfterSync()) {
                    sourceClient.deleteFile(remotePath);
                }
            }
            return files.size();
        });
    }

    private SftpClientPool getOrCreatePool(SftpConfig sftpConfig) {
        String key = sftpConfig.getHost() + ":" + sftpConfig.getPort() + ":" + sftpConfig.getUsername();
        return poolCache.computeIfAbsent(key, k -> new SftpClientPool(sftpConfig));
    }
}

4.3 错误处理与重试策略

对于网络操作, transient error(临时性错误)很常见。我们需要一个更智能的重试策略,例如使用Spring Retry库:

@Retryable(
    value = {SftpOperationException.class},
    maxAttempts = 4,
    backoff = @Backoff(delay = 1000, multiplier = 2, maxDelay = 10000),
    exclude = {SftpOperationException.class} // 权限错误等非临时性错误不重试
)
public void executeDownloadWithRetry(SyncTaskConfig config) {
    // 核心下载逻辑
}

同时,为不同的错误类型定义不同的处理策略:

错误类型 (SFTP错误码)是否可重试建议处理方式
SSH_FX_CONNECTION_LOST (4)是等待后重试,重试多次后告警
SSH_FX_NO_SUCH_FILE (2)否记录警告,继续处理其他文件
SSH_FX_PERMISSION_DENIED (3)否立即失败并告警,需人工介入
SSH_FX_FAILURE (4)视情况记录详细日志,根据子错误码判断

4.4 与现有技术栈集成

这个SFTP同步组件可以轻松集成到Spring Boot应用中。通过@ConfigurationProperties绑定配置,使用@Scheduled注解驱动定时任务,并通过Spring Events在任务完成或失败时发布事件,让其他组件(如通知服务)能够响应。

@Configuration
@EnableConfigurationProperties(SftpSyncProperties.class)
@EnableScheduling
public class SftpSyncAutoConfiguration {

    @Bean
    @ConditionalOnMissingBean
    public SftpSyncTaskExecutor sftpSyncTaskExecutor(MeterRegistry meterRegistry) {
        return new SftpSyncTaskExecutor(meterRegistry);
    }

    @Bean
    public SftpSyncScheduler sftpSyncScheduler(SftpSyncTaskExecutor executor,
                                                TaskConfigRepository repository) {
        return new SftpSyncScheduler(executor, repository);
    }
}

在实际项目中,我遇到过因为服务器SSH版本升级导致原有加密算法被禁用,整个文件同步服务瘫痪的情况。那次的教训是,配置的灵活性至关重要。我们的工具类将算法配置、超时时间等参数外化,就是为了能快速响应这类环境变化,而无需修改代码重新部署。另一个踩过的坑是文件句柄泄漏,某个异常分支没有正确关闭InputStream,运行几周后服务就达到文件打开上限。因此,在封装工具类时,我坚持使用try-with-resources,并在disconnect方法中加入防御性判断,确保资源在任何情况下都能被释放。

上传文件到Linux服务器全攻略:从scp到rsync,一文搞定 远程文件传输是运维与开发日常工作中最基础也最关键的操作之一。无论是配置文件同步、日志归档,还是程序包上传,选用正确的传输方案直接影响效率与可靠性。命令行工具scp、rsync和sftp基于SSH协议,分别适合单文件快速传输、增量同步与交互式目录管理;图形化客户端则降低了上手门槛。大文件场景下,断点续传与分段传输成为刚需,rsync的--partial参数、split分块合并以及rz/sz工具均可应对。同时,Web直传、Java程序内SFTP上传提供了自动化解决路径。本文结合实操经验,梳理各方案原理、对比选型 阅读详情

相关推荐

Mac用户必看:FinalShell 4.6.3最新版安装与SSH加速配置全攻略

本文为Mac用户提供FinalShell 4.6.3最新版的详细安装与配置指南。重点解析其内置的SSH加速功能,通过优化网络链路显著提升连接海外服务器的操作流畅度,并涵盖Java环境准备、安装验证、节点选择策略及高级功能应用,助力开发与运维人员实现高效的一体化服务器管理。

weixin_29209825的博客 519

java常用的sftp 工具包

2、ssh-j新秀工具包 最低支持java8 搭配try-with-resource 代码量很少 不支持文件流上传,原因嘛 实际的上传方法进行了一系列的判断 是不是文件 、是不是文件夹 我觉得暂时不支持 ,以后应该会支持的,只不过要改动一下底层的逻辑。1、jsch 挺老的工具包 jdk可以最低支持到1.6 目前最高版本0.1.55 已经多年没有更新,jsch功能其实挺强大的,只不过时间的原因,java7后的新写法 jsch都不支持 ,如果自己封装一下 也是挺好用的,毕竟他支持文件和文件流上传。

风林火山 1237

Ubuntu20.04下FinalShell安装全攻略:从下载到配置的避坑指南

本文提供了在Ubuntu20.04系统上安装和配置FinalShell的详细指南。内容涵盖系统准备、一键安装脚本执行、常见问题排查、首次启动配置,以及如何建立SSH连接(包括本地虚拟机和云服务器)。旨在帮助用户,特别是Linux新手,高效部署这款功能强大的远程工具,实现一站式服务器管理。

t8u9v0的博客 880

java操作sftp

目录一、引入依赖二、工具类三、测试 一、引入依赖 <!-- https://mvnrepository.com/artifact/com.jcraft/jsch --> <dependency> <groupId>com.jcraft</groupId> <artifactId>jsch</artifactId> <version>0.1.55</version> </depe..

码易的博客 994

CentOS 7下JDK17离线安装全攻略:从下载到环境变量配置一步到位

本文详细介绍了在CentOS 7系统下进行JDK17离线安装的全过程,包括资源获取、解压配置、环境变量设置及验证步骤。特别针对企业内网环境优化操作流程,确保无外网连接时也能高效搭建Java开发环境,涵盖从下载到环境变量配置的一站式解决方案。

dream的博客 1093

Cobalt Strike安装配置全攻略:从Java环境到TeamServer部署

Java环境配置是许多安全工具运行的基础,其核心在于正确设置JAVA_HOME和Path系统变量,确保命令行能识别java和javac命令。这一原理不仅关系到单个应用的启动,更影响着依赖Java虚拟机的各类安全测试平台的稳定性。对于渗透测试和红队演练而言,一个稳定、兼容的运行环境是执行后续高级操作的先决条件,能够有效避免因环境问题导致的功能异常或测试中断。特别是在部署Cobalt Strike这类综合性红队平台时,Java 8的兼容性配置直接决定了客户端图形界面能否正常显示与交互。本文聚焦于Cobalt S

weixin_34332905的博客 544

基于java的SFTP工具类

【代码】基于java的SFTP工具类。

感谢关注点赞,笔芯啾咪! 1975

CentOS 7下Nexus 3.21.1安装全攻略:从迅雷加速到安全组配置

本文提供了在CentOS 7系统上安装和配置Nexus Repository Manager 3.21.1的完整实战指南。针对国内网络环境,详细介绍了如何通过迅雷加速下载安装包,并逐步完成Java环境部署、Nexus解压配置、系统服务集成等关键步骤。最后,重点解析了云服务器环境下防火墙与安全组(如阿里云、腾讯云)的配置方法,确保服务可被外部稳定访问,是搭建私有Maven仓库的实用手册。

weixin_29214199的博客 261

sftp 工具类

sftp 工具类

Gblfy_Blog 965

Java实现文件FTP上传下载全攻略

Apache Commons Net是一个开源Java类库,用于模拟许多常见的网络协议,如FTP、FTPS(FTP over SSL)、Telnet、Wake-on-LAN、finger、rEXEC等。它为开发者提供了高级的API来建立和管理与这些协议的网络连接。使用这个库,开发者能够轻松地编写能够与网络服务器交互的Java应用程序。对于FTP协议而言,Apache Commons Net库可以实现许多复杂的操作,包括但不限于文件的上传下载、目录的创建与删除、权限的设置,以及远程服务器上的文件管理。

weixin_35433448的博客 894

Sftp操作工具类(java)&jar包

内含jar包和java实现代码 工具类含以下功能 1 得到当前工作目录地址 2 改变目录为配置的远程目录 3 取文件目录列表 4 取文件列表 5 下载文件 6 复制文件 7 删除文件 8 目录是否存在 文件是否存在 9 移动文件

【JAVA】SFTP文件上传下载工具类

我将分享一下我在项目中用到的SFTP文件上传下载的工具类。

遇见【自己】的博客 670

TSMaster实战:如何用LIN总线唤醒你的汽车电子系统(附波形分析)

本文通过TSMaster工具实战解析LIN总线唤醒机制。详细介绍了LIN网络唤醒的协议要求、时序参数计算,并演示了如何在TSMaster中配置唤醒信号、捕获分析波形,以及验证休眠流程。文章结合常见问题排查,为汽车电子工程师提供了从理论到实践的完整调试指南。

weixin_28308325的博客 464

终极指南:如何用Java SSH库JSch安全连接远程服务器(2025最新版)

JSch是一款强大的Java SSH2协议库,让开发者轻松实现远程服务器的安全连接与文件传输。本文将带你快速掌握JSch的核心功能、安装配置及实战技巧,助你在企业级应用和DevOps工具链中构建可靠的SSH通信方案 ???? ## 为什么选择JSch?三大核心优势解析 ### ✅ 企业级安全标准 默认禁用不安全的RSA/SHA1签名算法,优先支持RSA/SHA256、RSA/SHA512等强加密方...

gitblog_01075的博客 579

星空组网 vs 蒲公英 vs Tailscale:2024年国内免费异地组网工具横评(含实测数据)

本文对2024年国内主流免费异地组网工具星空组网、蒲公英和Tailscale进行了深度横向评测。基于实测数据,重点分析了三者在P2P成功率、中继延迟、传输速度及稳定性方面的表现,为中小企业、远程办公及个人开发者提供了清晰的选择指南。星空组网在国内网络环境下展现出优秀的平衡性。

weixin_29217235的博客 1448

排除 AcroForm 中 JavaScript 脚本的 Bug

本文介绍了Acrobat JavaScript脚本故障排除的基本方法。首先应检查控制台窗口的错误报告,通过具体示例演示了5类常见错误:语法错误(如缺少大括号)、未终止字符串、未定义变量、运算符混淆及变量作用域问题,并逐步给出修复方案。文章还提供了调试流程UML图和实用经验总结,强调关注细节(如分隔符匹配)、正确使用运算符和变量作用域等要点。最后建议采用系统化调试方法,包括关闭/重新打开表单等完整性测试。

小猫三两只。 1506

CentOS 7离线部署Java开发环境全攻略:从资源准备到安全加固

在Linux服务器运维与开发环境搭建中,离线部署是金融、军工等隔离网络环境下的常见需求。其核心原理在于通过预先下载软件包并手动传输,解决无法连接外部软件源的问题。这项技术的价值在于保障了内网安全合规的同时,实现了基础开发环境的自主可控。典型的应用场景包括部署在内网的CentOS服务器配置Java开发环境。本文将围绕离线资源准备、传输策略、环境变量配置等关键环节,结合glibc版本兼容性、环境变量配置等热词,详细解析如何高效完成从JDK安装到后期维护的全流程,为运维工程师和开发者提供一套可复用的离线部署方法论

weixin_30920853的博客 433

人脸情绪识别(使用深度学习和OpenCV)

基于opencv与深度学习的人脸情绪识别系统

mx0390304的博客 8251

FinalShell连接Linux虚拟机全攻略:从SSH到常用命令

SSH是远程管理Linux服务器的标准协议,然而传统命令行界面存在操作不可见、文件传输繁琐、服务器状态难以感知等痛点,常让新手在连接虚拟机或云服务器时屡屡受挫。图形化SSH客户端将终端、文件管理、资源监控与历史记录整合于同一面板,有效降低了学习门槛。通过可视化文件结构,用户可以直观理解Linux目录组织,配合高频命令如ls、chmod、systemctl等,快速完成日常运维操作。在虚拟机网络配置、权限管理、压缩解压等典型场景中,这类工具能显著提升排错效率。本文以FinalShell为例,系统梳理从环境准备、

weixin_34127717的博客 358

告警不是闹钟:AI 如何把告警过滤成真正的“求救信号”?

告警不是闹钟:AI 如何把告警过滤成真正的“求救信号”?

Echo_Wish 243

Android系统开发工程师面试指南与参考答案

本文整理了Android系统开发工程师面试常见问题与参考答案。核心内容涵盖:1)Framework层定制方法,如修改HAL和系统服务;2)ANR问题分析工具(systrace)与解决方案;3)性能优化实践,包括开机加速和功耗管理;4)四大组件工作机制与应用案例;5)Native崩溃调试技巧。文章强调通过AOSP源码研究、工具使用和项目案例准备来提升面试表现,重点考察应聘者的系统开发深度和实操能力。参考答案均基于实际开发经验,提供可量化的优化成果说明。

郑伟强dev的专栏 259

SpringBoot项目部署与Nginx配置全攻略

宝塔部署Java 项目,配置HTTPS

685

详细介绍用MATLAB实现基于A*算法的路径规划(附完整的代码,代码逐行进行解释)(一)--------A*算法简介和环境的创建

   本系列文章主要介绍基于A*算法的路径规划的实现,并使用MATLAB进行仿真演示。    一、 A*算法简介       A*(A-Star)算法是一种静态路网中求解最短路径最有效的直接搜索方法,也是解决许多搜索问题的有效算法。算法中的距离估算值与实际值越接近,最终搜索速度越快。      公式表示为: f(n)=g(n)+h(n),其中, f(n) 是从初始状态经由状态n到目标状态的代价估计,g(n) 是在状态空间中从初始状态到状态n的实际代价,h(n) 是从状态n到目标状态的最佳路径的估计代价。

慕羽★的博客 7万+

大厂Java面试全攻略:从基础八股到场景应用实战

Java面试的核心不只是背诵基础概念,更要理解底层原理并能在真实业务场景中灵活运用。从集合容器、动态代理到并发编程的线程协作机制,每一处都体现着语言设计与工程实践的深度。熟练掌握HashMap的存储结构、JVM垃圾回收策略以及Redis缓存穿透等问题的应对方案,是构建完整知识体系的关键。这类技术能力直接影响高并发系统、异步处理和中间件优化等实际场景的落地质量。本文围绕Java开发者关心的容器、动态代理、线程等待完成等高频技术点,梳理出一条从基础语法到微服务场景应用的备考主线,帮助求职者在面试中展现出真正的工

weixin_30086969的博客 200

如何提高电路的抗干扰能力

本内容详细介绍了电源传导干扰处理,包括滤波、Feedthrough电容器、磁环、磁珠、屏蔽的使用与选型,EMC电磁兼容测试项目简介与要求,单片机与电源抗干扰处理等。

让你爱上电路设计 8609

OV9734 DATASHEET,完整规格书

OV9734完整规格书,包括电气参数,尺寸规格,寄存器配置表等

上一篇: Python IDLE新手必看:从安装到画爱心代码实战(Windows11版)
下一篇: 避坑指南:STM32Cube.AI模型转换中那些没人告诉你的参数设置(实测TFLite量化效果对比)
android
博客等级 码龄22年 48粉丝 1455原创
评论
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符  | 博主筛选后可见
 
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明:

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

余额充值