java ssh 连接之 jsch-0.1.55.jar 试用

最新推荐文章于 2024-04-12 15:31:15 发布
最新推荐文章于 2024-04-12 15:31:15 发布
阅读量2.8k 收藏 5
点赞数 1
分类专栏： 开船 文章标签： java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/szlcy/article/details/107530902
版权

JSch 是一个纯 java 的 ssh2 实现。主要用来连接 ssh 和 sftp。

官网在此: http://www.jcraft.com/jsch/

1, MAVEN 引入依赖

<!-- https://mvnrepository.com/artifact/com.jcraft/jsch -->
<dependency>
    <groupId>com.jcraft</groupId>
    <artifactId>jsch</artifactId>
    <version>0.1.55</version>
</dependency>

2, 编写工具类

JSCHUtil 类主要有以下方法：

  1. 远程执行命令: remoteExecute
  2. scp 文件至远程服务器: scpTo
  3. 从远程服务器 scp 文件: scpFrom
  4. 显示 sftp 的目录内容: listFilesInSFTP
  5. 上传文件至 sftp 目录: uploadToSFTP
  6. 从 sftp 下载文件: downloadFromSFTP
# vim d:/temp/JSCHUtil.java

import com.jcraft.jsch.*;

import java.io.*;
import java.nio.file.Files;
import java.nio.file.Paths;
import java.util.ArrayList;
import java.util.List;
import java.util.Vector;

public class JSCHUtil {

    private static JSch jsch = new JSch();

    public static void main(String[] args) throws JSchException {

        Session session = JSCHUtil.createSession("10.161.97.205", 22, "root", "<!--你的密码 -->");

        JSCHUtil.remoteExecute(session, "df -Th");

        long l1 = JSCHUtil.scpTo(session, "d:/temp/README.md", "/root/README.md");
        System.out.println(l1);

        long l2 = JSCHUtil.scpFrom(session, "/root/README.md", "d:/temp/README.txt");
        System.out.println(l2);

        List<String> strings = JSCHUtil.listFilesOnSFTP(session, "/root");
        for (String name: strings) {
            System.out.println("/" + name);
        }
        
        boolean b1 = JSCHUtil.uploadToSFTP(session, "d:/temp/README.md", "/root/README.SFTP");
        System.out.println(b1);
        
        boolean b2 = JSCHUtil.downloadFromSFTP(session, "/root/README.SFTP", "d:/temp/README.SFTP");
        System.out.println(b2);
        
        session.disconnect();
    }

    public static Session createSession(String ip, int port, String user, String password) throws JSchException {
        JSch jSch = new JSch();
        Session session = jSch.getSession(user, ip, port);
        session.setPassword(password);
        session.setConfig("StrictHostKeyChecking", "no");
        session.connect();
        return session;
    }

    public static List<String> remoteExecute(Session session, String command) throws JSchException {

        List<String> resultLines = new ArrayList<>();
        ChannelExec channel = null;
        try {
            channel = (ChannelExec) session.openChannel("exec");
            channel.setCommand(command);
            InputStream input = channel.getInputStream();
            channel.connect();
            try {
                BufferedReader inputReader = new BufferedReader(new InputStreamReader(input));
                String inputLine = null;
                while ((inputLine = inputReader.readLine()) != null) {
                    System.out.println(inputLine);
                    resultLines.add(inputLine);
                }
            } finally {
                if (input != null) {
                    try {
                        input.close();
                    } catch (Exception e) {
                        e.printStackTrace();
                    }
                }
            }
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            if (channel != null) {
                try {
                    channel.disconnect();
                } catch (Exception e) {
                    e.printStackTrace();
                }
            }
        }
        return resultLines;
    }

    public static long scpTo(Session session, String source, String destination) {
        FileInputStream fileInputStream = null;
        try {
            ChannelExec channel = (ChannelExec) session.openChannel("exec");
            OutputStream out = channel.getOutputStream();
            InputStream in = channel.getInputStream();
            boolean ptimestamp = false;
            String command = "scp";
            if (ptimestamp) {
                command += " -p";
            }
            command += " -t " + destination;
            channel.setCommand(command);
            channel.connect();
            if (checkAck(in) != 0) {
                return -1;
            }
            File _lfile = new File(source);
            if (ptimestamp) {
                command = "T " + (_lfile.lastModified() / 1000) + " 0";
                // The access time should be sent here,
                // but it is not accessible with JavaAPI ;-<
                command += (" " + (_lfile.lastModified() / 1000) + " 0\n");
                out.write(command.getBytes());
                out.flush();
                if (checkAck(in) != 0) {
                    return -1;
                }
            }
            //send "C0644 filesize filename", where filename should not include '/'
            long fileSize = _lfile.length();
            command = "C0644 " + fileSize + " ";
            if (source.lastIndexOf('/') > 0) {
                command += source.substring(source.lastIndexOf('/') + 1);
            } else {
                command += source;
            }
            command += "\n";
            out.write(command.getBytes());
            out.flush();
            if (checkAck(in) != 0) {
                return -1;
            }
            //send content of file
            fileInputStream = new FileInputStream(source);
            byte[] buf = new byte[1024];
            long sum = 0;
            while (true) {
                int len = fileInputStream.read(buf, 0, buf.length);
                if (len <= 0) {
                    break;
                }
                out.write(buf, 0, len);
                sum += len;
            }
            //send '\0'
            buf[0] = 0;
            out.write(buf, 0, 1);
            out.flush();
            if (checkAck(in) != 0) {
                return -1;
            }
            return sum;
        } catch (JSchException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            if (fileInputStream != null) {
                try {
                    fileInputStream.close();
                } catch (Exception e) {
                    e.printStackTrace();
                }
            }
        }
        return -1;
    }

    public static long scpFrom(Session session, String source, String destination) {
        FileOutputStream fileOutputStream = null;
        try {
            ChannelExec channel = (ChannelExec) session.openChannel("exec");
            channel.setCommand("scp -f " + source);
            OutputStream out = channel.getOutputStream();
            InputStream in = channel.getInputStream();
            channel.connect();
            byte[] buf = new byte[1024];
            //send '\0'
            buf[0] = 0;
            out.write(buf, 0, 1);
            out.flush();
            while (true) {
                if (checkAck(in) != 'C') {
                    break;
                }
            }
            //read '644 '
            in.read(buf, 0, 4);
            long fileSize = 0;
            while (true) {
                if (in.read(buf, 0, 1) < 0) {
                    break;
                }
                if (buf[0] == ' ') {
                    break;
                }
                fileSize = fileSize * 10L + (long) (buf[0] - '0');
            }
            String file = null;
            for (int i = 0; ; i++) {
                in.read(buf, i, 1);
                if (buf[i] == (byte) 0x0a) {
                    file = new String(buf, 0, i);
                    break;
                }
            }
            // send '\0'
            buf[0] = 0;
            out.write(buf, 0, 1);
            out.flush();
            // read a content of lfile
            if (Files.isDirectory(Paths.get(destination))) {
                fileOutputStream = new FileOutputStream(destination + File.separator + file);
            } else {
                fileOutputStream = new FileOutputStream(destination);
            }
            long sum = 0;
            while (true) {
                int len = in.read(buf, 0, buf.length);
                if (len <= 0) {
                    break;
                }
                sum += len;
                if (len >= fileSize) {
                    fileOutputStream.write(buf, 0, (int) fileSize);
                    break;
                }
                fileOutputStream.write(buf, 0, len);
                fileSize -= len;
            }
            return sum;
        } catch (JSchException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            if (fileOutputStream != null) {
                try {
                    fileOutputStream.close();
                } catch (Exception e) {
                    e.printStackTrace();
                }
            }
        }
        return -1;
    }

    private static int checkAck(InputStream in) throws IOException {
        int b = in.read();
        // b may be 0 for success,
        //          1 for error,
        //          2 for fatal error,
        //          -1
        if (b == 0) return b;
        if (b == -1) return b;
        if (b == 1 || b == 2) {
            StringBuffer sb = new StringBuffer();
            int c;
            do {
                c = in.read();
                sb.append((char) c);
            }
            while (c != '\n');
            if (b == 1) { // error
                System.out.println(sb.toString());
            }
            if (b == 2) { // fatal error
                System.out.println(sb.toString());
            }
        }
        return b;
    }


    public static List<String> listFilesInSFTP(Session session, String path) {

        ArrayList<String> fileList = new ArrayList<String>();
        try {
            ChannelSftp channel = (ChannelSftp) session.openChannel("sftp");
            channel.connect();

            Vector vv = channel.ls(path);

            if (vv != null) {
                for (int ii = 0; ii < vv.size(); ii++) {
                    Object obj = vv.elementAt(ii);
                    if (obj instanceof com.jcraft.jsch.ChannelSftp.LsEntry) {
                        fileList.add(((com.jcraft.jsch.ChannelSftp.LsEntry) obj).getFilename());
                    }
                }
            }
        } catch (SftpException e) {
            e.printStackTrace();
        } catch (JSchException e) {
            e.printStackTrace();
        }
        return fileList;
    }

    public static boolean uploadToSFTP(Session session, String source, String destination) {

        try {
            ChannelSftp channel = (ChannelSftp) session.openChannel("sftp");
            channel.connect();

            try {
                channel.put(source, destination);
                return true;
            } catch (SftpException e) {
                e.printStackTrace();
            }

        } catch (JSchException e) {
            e.printStackTrace();
        }
        return false;
    }

    public static boolean downloadFromSFTP(Session session, String source, String destination) {

        try {
            ChannelSftp channel = (ChannelSftp) session.openChannel("sftp");
            channel.connect();

            try {
                channel.get(source, destination);
                return true;
            } catch (SftpException e) {
                e.printStackTrace();
            }

        } catch (JSchException e) {
            e.printStackTrace();
        }
        return false;
    }
}

3, 编译运行

# 将 jsch-0.1.55.jar 解压至 D:\temp, 注意，com 目录与 JSCHUtil.java 文件在同一父目录下。
# 编译
D:\temp>javac -cp . JSCHUtil.java
# 运行
D:\temp>java JSCHUtil
文件系统                   类型      容量  已用  可用 已用% 挂载点
/dev/mapper/centos-lv_root xfs        50G   22G   28G   45% /
/dev/xvde1                 xfs       500G  158G  343G   32% 
/dev/xvda1                 xfs      1014M  207M  808M   21% /boot
/dev/mapper/centos-home    xfs        42G  386M   41G    1% 
5804
5805
/.ssh
/.bash_profile
/README.md
/README.SFTP
true
true
szlcy
关注
  • 1
    点赞
  • 踩
  • 5
    收藏
    觉得还不错? 一键收藏
  • 3
    评论
专栏目录
jsch-0.1.50.jar（Jmeter 操作 Linux 所必须的两Jar包之一）
03-22
jsch-0.1.50.jar（Jmeter 操作 Linux 所必须的两Jar包之一）
jsch-0.1.55.jar 包
04-22
`jsch-0.1.55.jar` 提供了强大的SSH2连接和命令执行能力，对于需要在Java应用程序中执行远程Linux操作的开发者来说，这是一个不可或缺的工具。通过理解JSCH的工作原理和使用方法，开发者可以构建出安全、可靠的远程...
解决JSCH的sftp连接时出现的com.jcraft.jsch.JSchException: Session.connect: java.io.IOException: End of IO Stre
热门推荐
tzydzj的博客
06-23 1万+
问题描述 如题，今天遇到个问题，使用JSCH的jsch-0.1.54.jar实现的sftp在连接目标服务器时报com.jcraft.jsch.JSchException: Session.connect: java.io.IOException: End of IO Stream Read异常，经查后发现是由于目标服务器的openssh升级至OpenSSH_7.4p1版本后导致的（可在服务器使用ssh -V命令查看openssh版本），原因如下：我使用的jdk是1.6的，jdk1.6支持的加密算法较少(jd
OpenSSH8.0对应jsch jar包版本
weixin_42740540的博客
12-29 6507
由于连接sftp所用jar最终会使用jsch的包。然而jsch的包会有各种版本问题。来梳理一下， 根源是jdk1.6支持的加密算法较少(jdk8支持了大多数加密算法)，而openSSH8.0默认屏蔽了jdk1.6支持的加密算法,如：diffie-hellman-group1-sha1等。openSSH7的版本能支持1.6的算法。 首先查看主机ssh命令，执行ssh -v 因为一台...
【JAVA 访问SFTP的方法 sshj/Jsch】
最新发布
qq_37537164的博客
04-12 602
java 使用私钥访问 SFTP, 用Jsch 访问SFTP ,用Sshj 访问SFTP
jar包下载网站及下载方法
oysqtlmy的博客
04-28 1503
需要下载cors-filter-1.7.jar，Java-property-utils-1.9.jar 两个文件，找到两个下载网站及相应的方法。 一，下载网站 https://mvnrepository.com/仓库服务 二 、下载方法 以下载Java-property-utils-1.9.jar 为例 ，进入 https://mvnrepository.com/ 后，用Java-property-utils搜索。 点击 下图红框处，会直接下载， 也可以根据这些参数，进入第二个网..
jar包国内镜像站--下载
qq_43843708的博客
10-18 1725
Java
各种jar包官方下载地址--持续更新
nich002的专栏
07-09 1万+
从接触java开始我们就和jar包死磕上了, 总是在不停的下载新的jar, 可是由于找不到官网, 有时找到官网也不知道点哪里下载, 所以经常到各种网站上面下载搬运过来的jar包, 可需要各种积分, 很麻烦.
jsch-0.1.55.jar中文-英文对照文档.zip
03-04
中文-英文对照文档,中英对照文档,java,jar包,Maven,第三方jar包,组件,开源组件,第三方组件,Gradle,中文API文档,手册,开发手册,使用手册,参考手册 # 使用方法： 解压 【***.jar中文文档.zip】，再解压其中的 【***-...
jsch-0.1.55_jsch_JSCH0.1._55_服务器_jsch0.1.55_
09-30
JSch 是SSH2的一个纯Java实现。它允许你连接到一个sshd 服务器，使用端口转发，X11转发，文件传输等等。你可以将它的功能集成到你自己的 程序中。同时该项目也提供一个J2ME版本用来在手机上直连SSHD服务器
jsch-0.1.55，包含jar和source
01-17
在压缩包内，有两个文件："jsch-0.1.55.jar"是编译后的二进制库，可以直接在Java项目中作为依赖使用，而"jsch-0.1.55"很可能包含的是源代码，开发者可以通过阅读这些源代码来理解JSch的工作原理，或者对其进行修改以...
jsch的jar包，包含0.1.51，0.1.52，0.1.53，0.1.54等这几个版本
04-05
jsch的jar包，其中包含0.1.51，0.1.52，0.1.53，0.1.54等这几个版本
jsch-0.1.55jar&&javadoc&&sources.zip
11-28
java ssh远程linux 产用类库： jsch-0.1.55.jar jsch-0.1.55-sources.jar jsch-0.1.55-javadoc.jar
jsch的jar包最新版
10-29
jsch-0.1.54.jar最新版本的jar包。JSch 是SSH2的一个纯Java实现。它允许你连接到一个sshd 服务器，使用端口转发，X11转发，文件传输等等。你可以将它的功能集成到你自己的 程序中。同时该项目也提供一个J2ME版本用来在手机上直连SSHD服务器。同时该开发包也提供 J2ME 下的版本
jsch-0.1.55.jar
12-21
jsch.jar 常用的java通过代码登录远程linux服务器并执行linux命令需要的jar
jsch-0.1.55.jar java语言linux系统文件安全传输工具包 - 亲测可用，请放心下载
12-24
1. **添加依赖**：首先，将`jsch-0.1.55.jar`文件添加到项目类路径中，如果是Maven或Gradle项目，需要在相应的构建配置文件中声明依赖。 2. **创建Session**：初始化JSch实例，设置用户名、主机名和端口号，然后...
常用jar包下载地址汇总
weixin_30779691的博客
03-22 1055
《常用开发包下载地址汇总》 下载Jackson http://www.java2s.com/Code/Jar/j/Downloadjacksonjar.htm 下载Simple Logging Facade for Java (SLF4J) https://www.slf4j.org/ 下载Apache Axis2 http://axis.apache.org...
Java通过ssh向服务器上传下载删除文件和操作Linux
赵广陆
05-07 2531
目录1 JSch介绍2 编码使用2.1 JSch的引用2.2 JSch连接配置代码2.3 使用JSch上传下载删除文件代码2.4 拓展功能java使用命令操作linux 1 JSch介绍 JSch是SSH2的纯Java实现 。JSch允许您连接到sshd服务器并使用端口转发，X11转发，文件传输等，您可以将其功能集成到您自己的Java程序中。本文主要介绍利用JSch实现sftp通过ssh上传下载文件和一些相关配置。 2 编码使用 2.1 JSch的引用 1）项目中导入jsch-0.1.53.jar包 下载
linux 5.5\jdk1.6\jsch-0.1.52 远程ssh openssh8.8 End of IO Stream Read
风林火山
11-13 280
其实只需要把jsch 版本升级到0.1.55就行了。1、升级JDK到1.8。3、给1.6jdk加插件。
jsch-0.1.55-API
05-12
以下是 jsch-0.1.55 版本的主要 API： 1. JSch 类：这是 JSch 的核心类，它提供了创建 SSH 客户端连接的方法。 2. Session 类：用于表示一个 SSH 会话，它提供了连接、断开连接、执行命令等方法。 3. Channel 类...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 3
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值