我之前在处理生产环境的SFTP大日志读取需求时，也踩过全量下载文件的坑——几十GB的日志文件下载下来耗时极长，完全不实用。下面分享两个不用全量下载就能实现目标的方案，核心思路是利用SFTP协议支持的远程文件随机访问，直接定位到文件末尾附近读取，同时记录偏移量方便后续向上读取更多内容。

方案一：使用JSch库（Java生态最常用的SFTP实现） #

JSch是Java中处理SFTP的老牌库，支持直接指定文件偏移量读取内容，我们可以通过反向读取缓冲区统计换行符的方式，精准获取末尾N行。

实现代码 #

import com.jcraft.jsch.*;
import java.io.*;

public class SftpTailLog {
    private static final int TARGET_LINES = 30; // 要读取的末尾行数
    private static final int BUFFER_SIZE = 4096; // 每次远程读取的缓冲区大小，可根据行平均长度调整

    public static void main(String[] args) throws JSchException, SftpException, IOException {
        // 初始化SFTP会话
        JSch jsch = new JSch();
        Session session = jsch.getSession("your-username", "your-host", 22);
        session.setPassword("your-password");
        // 跳过主机密钥检查（生产环境建议配置信任密钥）
        session.setConfig("StrictHostKeyChecking", "no");
        session.connect();

        ChannelSftp channelSftp = (ChannelSftp) session.openChannel("sftp");
        channelSftp.connect();

        String remoteLogPath = "/path/to/your/large-log.log";
        // 获取文件元数据，拿到文件总大小
        SftpATTRS fileAttrs = channelSftp.stat(remoteLogPath);
        long totalFileSize = fileAttrs.getSize();

        long currentOffset = totalFileSize;
        int foundLines = 0;
        ByteArrayOutputStream tempOutput = new ByteArrayOutputStream();

        // 从文件末尾反向读取，直到找到目标行数或文件开头
        while (currentOffset > 0 && foundLines < TARGET_LINES) {
            int readBytes = (int) Math.min(BUFFER_SIZE, currentOffset);
            currentOffset -= readBytes;

            // 从指定偏移量读取对应大小的内容
            InputStream remoteStream = channelSftp.get(remoteLogPath, currentOffset, readBytes);
            byte[] buffer = new byte[readBytes];
            remoteStream.read(buffer);
            remoteStream.close();

            // 反向遍历缓冲区，统计换行符
            for (int i = readBytes - 1; i >= 0 && foundLines < TARGET_LINES; i--) {
                if (buffer[i] == '\n') {
                    foundLines++;
                    // 找到目标行数后，修正偏移量到该行的起始位置
                    if (foundLines == TARGET_LINES) {
                        currentOffset += (i + 1);
                        break;
                    }
                }
                tempOutput.write(buffer[i]);
            }
        }

        // 反转字节流，得到正确顺序的日志行
        byte[] reversedContent = tempOutput.toByteArray();
        reverseByteArray(reversedContent);
        System.out.println("读取到的末尾日志行：\n" + new String(reversedContent));

        // 记录当前读取的起始偏移量，后续向上读取时从该位置继续反向查找
        System.out.println("\n下次读取的起始偏移量：" + currentOffset);

        // 关闭资源
        channelSftp.disconnect();
        session.disconnect();
    }

    private static void reverseByteArray(byte[] array) {
        for (int i = 0; i < array.length / 2; i++) {
            byte temp = array[i];
            array[i] = array[array.length - 1 - i];
            array[array.length - 1 - i] = temp;
        }
    }
}

关键说明 #

• 通过channelSftp.stat()获取文件大小，避免全量下载
• 分块反向读取缓冲区，统计换行符数量，直到凑够目标行数
• 记录的currentOffset是本次读取内容的起始位置，后续向上读取更多行时，只需从该偏移量继续反向查找即可
• 缓冲区大小可根据日志行的平均长度调整，减少远程IO次数

方案二：使用Apache Commons VFS2（更简洁的封装） #

Apache Commons VFS2封装了多种文件系统（包括SFTP），提供了随机访问文件的API，代码更简洁。

实现代码 #

import org.apache.commons.vfs2.*;
import org.apache.commons.vfs2.provider.sftp.SftpFileSystemConfigBuilder;
import java.io.IOException;
import java.io.RandomAccessFile;

public class VfsSftpTailLog {
    private static final int TARGET_LINES = 30;

    public static void main(String[] args) throws IOException {
        FileSystemManager fsManager = VFS.getManager();
        // SFTP地址格式：sftp://用户名:密码@主机地址/文件路径
        String remoteUri = "sftp://your-username:your-password@your-host/path/to/large-log.log";
        FileObject logFile = fsManager.resolveFile(remoteUri);

        // 配置SFTP（跳过主机密钥检查）
        FileSystemOptions options = new FileSystemOptions();
        SftpFileSystemConfigBuilder.getInstance().setStrictHostKeyChecking(options, "no");

        // 获取随机访问文件对象
        try (RandomAccessFile raf = (RandomAccessFile) logFile.getContent().getRandomAccessContent().getRandomAccessFile("r")) {
            long totalSize = raf.length();
            long currentOffset = totalSize;
            int foundLines = 0;
            StringBuilder contentBuilder = new StringBuilder();

            while (currentOffset > 0 && foundLines < TARGET_LINES) {
                raf.seek(--currentOffset);
                char currentChar = (char) raf.read();
                if (currentChar == '\n') {
                    foundLines++;
                    if (foundLines == TARGET_LINES) {
                        currentOffset++; // 跳过换行符，定位到该行起始位置
                        break;
                    }
                }
                contentBuilder.append(currentChar);
            }

            // 反转内容得到正确顺序
            System.out.println("读取到的末尾日志行：\n" + contentBuilder.reverse().toString());
            System.out.println("\n下次读取的起始偏移量：" + currentOffset);
        } finally {
            logFile.close();
        }
    }
}

额外注意事项 #

• 动态日志滚动处理：如果日志文件会被logrotate等工具滚动（比如重命名为.log.1并生成新文件），需要额外监控文件的元数据变化（比如修改时间、文件大小），判断文件是否被替换，避免基于旧文件的偏移量读取错误内容
• 偏移量持久化：建议将偏移量和文件的唯一标识（比如文件名+最后修改时间）一起存储，确保下次读取时文件未被替换
• 性能优化：如果日志行长度比较稳定，可以提前估算每行平均长度，直接从文件末尾往前跳过TARGET_LINES * 平均行长度的字节，再开始查找换行符，减少读取次数

内容的提问来源于stack exchange，提问作者Borș Nicolae