纯Java实现模拟ssh终端

已于 2024-09-04 16:58:01 修改
阅读量327 收藏
点赞数 4
分类专栏： Java 文章标签： java ssh 开发语言
于 2024-08-28 16:09:24 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/guo__hang/article/details/141642909
版权

使用 jsch + jediterm 实现ssh连接虚拟终端

首先引入需要的maven依赖

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>

    <groupId>org.example</groupId>
    <artifactId>jediterm-test</artifactId>
    <version>1.0-SNAPSHOT</version>

    <properties>
        <maven.compiler.source>17</maven.compiler.source>
        <maven.compiler.target>17</maven.compiler.target>
        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
    </properties>

    <dependencies>
        <dependency>
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>
            <version>3.8.1</version>
            <scope>test</scope>
        </dependency>

        <dependency>
            <groupId>org.jetbrains.jediterm</groupId>
            <artifactId>jediterm-core</artifactId>
            <version>3.40</version>
        </dependency>
        <dependency>
            <groupId>org.jetbrains.jediterm</groupId>
            <artifactId>jediterm-ui</artifactId>
            <version>3.40</version>
        </dependency>
        <dependency>
            <groupId>org.jetbrains.jediterm</groupId>
            <artifactId>jediterm-pty</artifactId>
            <version>2.60</version>
        </dependency>
        <dependency>
            <groupId>org.jetbrains.jediterm</groupId>
            <artifactId>jediterm-typeahead</artifactId>
            <version>2.60</version>
        </dependency>
        <dependency>
            <groupId>org.jetbrains.pty4j</groupId>
            <artifactId>pty4j</artifactId>
            <version>0.12.25</version>
        </dependency>
        <!--org.jetbrains:annotations:24.0.1-->
        <dependency>
            <groupId>org.jetbrains</groupId>
            <artifactId>annotations</artifactId>
            <version>24.0.1</version>
        </dependency>
        <!--implementation("org.slf4j:slf4j-api:2.0.9")-->
        <dependency>
            <groupId>org.slf4j</groupId>
            <artifactId>slf4j-api</artifactId>
            <version>2.0.9</version>
        </dependency>
        <!--implementation("org.slf4j:slf4j-jdk14:2.0.9")-->
        <dependency>
            <groupId>org.slf4j</groupId>
            <artifactId>slf4j-jdk14</artifactId>
            <version>2.0.9</version>
        </dependency>
        <dependency>
            <groupId>log4j</groupId>
            <artifactId>log4j</artifactId>
            <version>1.2.12</version>
        </dependency>

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

    </dependencies>

    <repositories>
        <repository>
            <id>jetbrains</id>
            <url>https://packages.jetbrains.team/maven/p/ij/intellij-dependencies</url>
        </repository>
    </repositories>
</project>

示例一：根据 JschTerminal 示例代码实现 

BasicJschTerminalExample.java
package org.example.good;

import com.jcraft.jsch.ChannelShell;
import com.jcraft.jsch.JSch;
import com.jcraft.jsch.JSchException;
import com.jcraft.jsch.Session;
import com.jediterm.terminal.TtyConnector;
import com.jediterm.terminal.ui.JediTermWidget;
import com.jediterm.terminal.ui.settings.DefaultSettingsProvider;
import org.jetbrains.annotations.NotNull;

import javax.swing.*;
import java.awt.*;
import java.io.*;
import java.nio.charset.Charset;
import java.nio.charset.StandardCharsets;
import java.util.Set;
import java.util.SortedMap;

/**
 * @Author GuoHang
 * @Description 功能描述
 */
public class BasicJschTerminalExample {

    private static Session session = null;
    private static ChannelShell channel = null;
    private static OutputStream outputStream;
    private static InputStreamReader myInputStreamReader;
    private static final Charset encoding = StandardCharsets.UTF_8;

    // 与远程终端建立连接
    private static void buildConnection(String host, int port, String username, String password) {
        JSch jsch = new JSch();
        try {
            session = jsch.getSession(username, host, port);
            session.setPassword(password);
            session.setConfig("StrictHostKeyChecking", "no");
            session.setTimeout(60 * 1000 * 1000);
            session.connect();

            channel = openChannel(session);
            configureChannelShell(channel);
            channel.connect();

            InputStream inputStream = channel.getInputStream();
            myInputStreamReader = new InputStreamReader(inputStream, encoding);
            outputStream = channel.getOutputStream();
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

    protected static ChannelShell openChannel(Session session) throws JSchException {
        return (ChannelShell) session.openChannel("shell");
    }

    protected static void configureChannelShell(ChannelShell channel) {
        String lang = (String) System.getenv().get("LANG");
        channel.setEnv("LANG", lang != null ? lang : "zh_CN.UTF-8");
        channel.setPtyType("xterm");
    }

//    private void resizeImmediately() {
//        if (this.myPendingTermSize != null && this.myPendingPixelSize != null) {
//            this.setPtySize(channel, this.myPendingTermSize.width, this.myPendingTermSize.height, this.myPendingPixelSize.width, this.myPendingPixelSize.height);
//            this.myPendingTermSize = null;
//            this.myPendingPixelSize = null;
//        }
//    }

    protected void setPtySize(ChannelShell channel, int col, int row, int wp, int hp) {
        channel.setPtySize(col, row, wp, hp);
    }

    private static @NotNull JediTermWidget createTerminalWidget() {
        DefaultSettingsProvider defaultSettingsProvider = new DefaultSettingsProvider() {
            @Override
            public Font getTerminalFont() {
                // 设置字体，确保选择一个支持中文字符的字体
                String font_yahei_ui = "Microsoft YaHei UI";
                String font_yahei = "Microsoft YaHei";
                String font_nsongti = "NSimSun";
                String font_songti = "SimSun";
                return getFont(font_songti);
                // 使用默认的英文字体
//                return new Font("Consolas", Font.PLAIN, 14);
            }
        };

        JediTermWidget widget = new JediTermWidget(80, 24, defaultSettingsProvider);
        ExampleTtyConnector exampleTtyConnector = new ExampleTtyConnector();
        widget.setTtyConnector(exampleTtyConnector);
        widget.requestFocusInWindow();
        widget.start();
        return widget;
    }

    private static void createAndShowGUI() {
        JFrame frame = new JFrame("Basic Terminal Example");
        frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
        frame.setContentPane(createTerminalWidget());
        frame.pack();
        frame.setVisible(true);
    }

    // 设置字符编码 默认为UTF-8
    private static void setCharset() {
        // 支持的编码
        SortedMap<String, Charset> charsets = Charset.availableCharsets();
        Set<String> names = charsets.keySet();

        for (String name : names) {
            Charset charset = charsets.get(name);
            System.out.println(charset.name());
        }
    }

    // 按键序列(解决退格/删除键失效,乱码问题)
    private static void setKeySequence() {
        // Backspace退格键 "VT220 - Delete";"ASCII - Delete";"ASCII - Backspace";

        // Delete删除键
    }

    // 字体
    public static Font getFont(String name) {
        return getFont(name, 0, 12);
    }

    public static Font getFont(String name, int style, int size) {
        Font font = null;
        if (System.getProperty("os.name").toLowerCase().contains("win")) {
            File file = null;
            boolean loadFromFile = false;
            String path;
            if (name.equals("Microsoft YaHei")) {
                path = System.getenv("WINDIR") + "\\Fonts\\\\msyh1.ttc";
                file = new File(path);
                if (file.exists()) {
                    loadFromFile = true;
                }
            } else if (name.equals("Microsoft YaHei UI")) {
                path = System.getenv("WINDIR") + "\\Fonts\\\\msyh.ttc";
                if (style == 1) {
                    path = System.getenv("WINDIR") + "\\Fonts\\\\msyhbd.ttc";
                }

                file = new File(path);
                if (file.exists()) {
                    loadFromFile = true;
                }
            }

            if (loadFromFile) {
                try {
                    font = Font.createFont(0, new FileInputStream(file)).deriveFont(style, (float) size);
                } catch (IOException | FontFormatException var7) {
                    Exception e = var7;
                    ((Exception) e).printStackTrace();
                }
            } else {
                font = new Font(name, style, size);
            }
        } else {
            font = new Font(name, style, size);
        }
        return font;
    }

    public static void main(String[] args) {
        // Create and show this application's GUI in the event-dispatching thread.
        buildConnection("192.168.168.201", 22, "jy", "root");

        SwingUtilities.invokeLater(BasicJschTerminalExample::createAndShowGUI);
    }

    private static class ExampleTtyConnector implements TtyConnector {

        public ExampleTtyConnector() {
        }

        @Override
        public void close() {
        }

        @Override
        public String getName() {
            return null;
        }

        @Override
        public int read(char[] buf, int offset, int length) throws IOException {
            return myInputStreamReader.read(buf, offset, length);
        }

        @Override
        public void write(byte[] bytes) throws IOException {
            if (outputStream != null) {
                outputStream.write(bytes);
                outputStream.flush();
            }
        }

        @Override
        public boolean isConnected() {
            return true;
        }

        @Override
        public void write(String string) throws IOException {
            this.write(string.getBytes(encoding));
        }

        @Override
        public int waitFor() throws InterruptedException {
            while (channel != null && channel.getExitStatus() < 0 && channel.isConnected()) {
                Thread.sleep(100L);
            }
            return 0;
        }

        @Override
        public boolean ready() throws IOException {
            return myInputStreamReader.ready();
        }

    }

}

以上代码还存在的一些问题：

1.输入回显慢，问题可能是在 JschTerminal 框架 write 时。

2.中文乱码。

示例二： jsch + swing实现输入和回显同框

回显处理可能会出现一些问题

package org.example.jsch;

import com.jcraft.jsch.ChannelShell;
import com.jcraft.jsch.JSch;
import com.jcraft.jsch.JSchException;
import com.jcraft.jsch.Session;

import javax.swing.*;
import java.awt.*;
import java.awt.event.KeyEvent;
import java.awt.event.KeyListener;
import java.io.BufferedInputStream;
import java.io.IOException;
import java.io.PrintWriter;
import java.util.regex.Matcher;
import java.util.regex.Pattern;

/**
 * @Author GuoHang
 * @Description 功能描述
 */
public class JschDemo {
    private static Session session = null;
    private static ChannelShell channel = null;
    private static PrintWriter printWriter = null;
    private static BufferedInputStream bufferedInputStream = null;
    private static JTextArea area = null;

    private static boolean flag = true;
    private static boolean mark = true;
    private static int index = 0;
    private static int old_len = 0;

    public static void main(String[] args) {
        buildConnection(new DestHost("192.168.168.201", "jy", "root"));
        // 启动线程开始读取
        read();
        buildMain();
    }

    // 与远程终端建立连接
    private static void buildConnection(DestHost destHost) {
        JSch jsch = new JSch();
        try {
            session = jsch.getSession(destHost.getUsername(), destHost.getHost(), destHost.getPort());
            session.setPassword(destHost.getPassword());
            session.setConfig("StrictHostKeyChecking", "no");
            session.setTimeout(destHost.getTimeout());
            session.connect();

            channel = (ChannelShell) session.openChannel("shell");
            channel.setPty(true);
            channel.connect();

            bufferedInputStream = new BufferedInputStream(channel.getInputStream());
            printWriter = new PrintWriter(channel.getOutputStream(), true);
        } catch (JSchException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }

    // 刷新文本框内容
    private static void refreshJTextArea(String content) {
        area.setText("");
        area.append(content);
        area.paintImmediately(area.getBounds());// 让写入到文本框的内容立即显示
        old_len = area.getText().length();
    }

    // 实时读取远程终端执行完命令后的输入流并更新到文本框里
    private static void read() {
        new Thread(() -> {
            while (true) { // 让该线程永久运行下去，定时更新文本框内容
                StringBuilder sb = new StringBuilder();
                byte[] bytes = new byte[1024];
                try {
                    int count = 0;
                    int len = bufferedInputStream.available();// 避免阻塞
                    int now = 0;
                    // 使用mark和reset方法，从而可以多次读取同一输入流
                    bufferedInputStream.mark(0);
                    while (now < len) {
                        count = bufferedInputStream.read(bytes);
                        now += count;
                        String s = new String(bytes, 0, count);
                        // 用正则表达式过滤掉表示颜色的字符
                        String reg = "\\[\\d.*?m";
                        Pattern pattern = Pattern.compile(reg);
                        Matcher matcher = pattern.matcher(s);
                        s = matcher.replaceAll("");
                        sb.append(s);
                    }
                    if (mark && sb.length() > 0) {
                        refreshJTextArea(sb.toString());
                    }
                    bufferedInputStream.reset();
                } catch (IOException e) {
                    e.printStackTrace();
                }
                try {
                    Thread.sleep(200);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }).start();
    }

    // 构建GUI
    private static void buildMain() {
        JFrame frame = new JFrame("terminal");
        area = new JTextArea() {
            @Override
            public void append(String str) {
                super.append(str);
                this.setCaretPosition(getDocument().getLength());
            }

            @Override
            protected void processComponentKeyEvent(KeyEvent e) {
                if (e.getID() == KeyEvent.KEY_TYPED) { // 只允许输入字符
                    super.processComponentKeyEvent(e);
                } else if (e.getID() == KeyEvent.KEY_PRESSED) { // 阻止删除和修改操作
                    int keyCode = e.getKeyCode();
                    if (!(keyCode == KeyEvent.VK_BACK_SPACE || keyCode == KeyEvent.VK_DELETE)) {
                        super.processComponentKeyEvent(e);
                    }
                }
            }
        };
        area.setFont(new Font("宋体", Font.BOLD, 14));

        // 设置JTextArea为不可编辑
//        area.setEditable(false);

        // 把文本框加入到滚动面板中，内容溢出时可拉取
        JScrollPane scrollPane = new JScrollPane(area);
        scrollPane.setHorizontalScrollBarPolicy(JScrollPane.HORIZONTAL_SCROLLBAR_AS_NEEDED);
        scrollPane.setVerticalScrollBarPolicy(JScrollPane.VERTICAL_SCROLLBAR_AS_NEEDED);
        scrollPane.setBounds(15, 0, 750, 540);
        JPanel panel = new JPanel(null);
        panel.add(scrollPane);

        // 为文本框添加监听键盘事件
        area.addKeyListener(new KeyListener() {
            @Override
            public void keyTyped(KeyEvent e) {
            }

            @Override
            public void keyPressed(KeyEvent e) {
            }

            @Override
            public void keyReleased(KeyEvent e) {
                mark = false;
                if (flag) {
                    index = Math.min(area.getText().length(), old_len);
                    flag = false;
                }
                // 监听回车键
                if (e.getKeyChar() == '\n') {
                    area.paintImmediately(area.getBounds());
                    String content = area.getText();
                    // 获取输入的命令
                    content = content.substring(index);
                    // 发送给终端
                    printWriter.print(content);
                    printWriter.flush();
                    flag = true;
                    mark = true;
                }
            }
        });
        frame.add(panel);
        frame.setSize(800, 600);
        frame.setLocationRelativeTo(null);//设置居中显示
        frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
        frame.setVisible(true);
    }
}

连接信息实体类： 

package org.example.jsch;

/**
 * @Author GuoHang
 * @Description 功能描述
 */
public class DestHost {
    private String host;
    private String username;
    private String password;
    private int port = 22;
    private int timeout = 60 * 60 * 1000;

    public DestHost(String host, String username, String password) {
        this.host = host;
        this.username = username;
        this.password = password;
    }

    public String getHost() {
        return host;
    }

    public void setHost(String host) {
        this.host = host;
    }

    public String getUsername() {
        return username;
    }

    public void setUsername(String username) {
        this.username = username;
    }

    public String getPassword() {
        return password;
    }

    public void setPassword(String password) {
        this.password = password;
    }

    public int getPort() {
        return port;
    }

    public void setPort(int port) {
        this.port = port;
    }

    public int getTimeout() {
        return timeout;
    }

    public void setTimeout(int timeout) {
        this.timeout = timeout;
    }
}

示例三： jsch+swing实现输入框和回显框分离（相对于示例二比较稳定）

package org.example;

import com.jcraft.jsch.ChannelShell;
import com.jcraft.jsch.JSch;
import com.jcraft.jsch.Session;

import javax.swing.*;
import java.awt.*;
import java.io.*;
import java.util.concurrent.atomic.AtomicBoolean;

/**
 * @Author GuoHang
 * @Description 功能描述
 */
public class JschTerminalExample {

    private static Session session = null;
    private static ChannelShell channel = null;
    private static BufferedInputStream bufferedInputStream = null;
    private static OutputStream outputStream;

    private static JTextArea outputArea;
    private static JScrollPane scrollPane;

    // 与远程终端建立连接
    private static void buildConnection(String host, int port, String username, String password) {
        JSch jsch = new JSch();
        try {
            session = jsch.getSession(username, host, port);
            session.setPassword(password);
            session.setConfig("StrictHostKeyChecking", "no");
            session.setTimeout(60 * 60 * 1000);
            session.connect();

            channel = (ChannelShell) session.openChannel("shell");
            //解决终端高亮显示时颜色乱码问题
            channel.setPtyType("dumb");
            channel.setPty(true);
            channel.connect();

            bufferedInputStream = new BufferedInputStream(channel.getInputStream());
            outputStream = channel.getOutputStream();
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

    // 实时读取远程终端执行完命令后的输入流并更新到文本框里
    private static void read() {
        final AtomicBoolean running = new AtomicBoolean(true); // 添加一个标志控制循环是否继续

        new Thread(() -> {
            try { // 确保资源被正确关闭
                while (running.get()) { // 让该线程根据标志运行
                    byte[] buffer = new byte[1024];
                    do {
                        int i = bufferedInputStream.read(buffer, 0, 1024); // 直接读取，无需检查 available()
                        if (i < 0) {
                            break;
                        }
                        String s = new String(buffer, 0, i);
                        outputArea.append(s);
                        scrollToBottom();
                    } while (running.get()); // 根据标志决定是否继续循环
                }
            } catch (IOException e) {
                e.printStackTrace();
            } finally {
                running.set(false); // 确保循环退出
            }
        }).start();
    }

    public static void main(String[] args) {
        SwingUtilities.invokeLater(() -> {
            // 显示输入弹窗
            JTextField ipField = new JTextField();
            JTextField portField = new JTextField("22"); // 默认端口 22
            JTextField userField = new JTextField();
            JPasswordField passwordField = new JPasswordField();

            JPanel panel = new JPanel(new GridLayout(0, 1));
            panel.add(new JLabel("IP Address:"));
            panel.add(ipField);
            panel.add(new JLabel("Port:"));
            panel.add(portField);
            panel.add(new JLabel("Username:"));
            panel.add(userField);
            panel.add(new JLabel("Password:"));
            panel.add(passwordField);

            int result = JOptionPane.showConfirmDialog(null, panel,
                    "Enter SSH Connection Details", JOptionPane.OK_CANCEL_OPTION,
                    JOptionPane.PLAIN_MESSAGE);

            if (result == JOptionPane.OK_OPTION) {
                String ip = ipField.getText();
                int port = Integer.parseInt(portField.getText());
                String username = userField.getText();
                String password = new String(passwordField.getPassword());

                // Connect to SSH server
                connect(ip, port, username, password);
            }
        });

    }

    private static void connect(String ip, int port, String username, String password) {
        JFrame frame = new JFrame("Shell Window Example");
        frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
        frame.setSize(600, 400);

        // 创建一个文本区域用于显示回显
        outputArea = new JTextArea();
        outputArea.setEditable(false);
        outputArea.setLineWrap(true);
        outputArea.setWrapStyleWord(true);
        scrollPane = new JScrollPane(outputArea);
        scrollPane.setPreferredSize(new Dimension(600, 300));

        // 创建一个 JPanel
        JPanel panel = new JPanel();
        panel.setLayout(new BorderLayout());
        panel.add(scrollPane, BorderLayout.CENTER);

        // 创建隐藏的输入区域
        JTextField hiddenInput = new JTextField();
        hiddenInput.setPreferredSize(new Dimension(600, 30));
        hiddenInput.setFocusable(true);
        panel.add(hiddenInput, BorderLayout.SOUTH);

        frame.add(panel);
        frame.setVisible(true);

        // 启动后台进程或 shell
        buildConnection(ip, port, username, password);
        // 启动线程开始读取
        read();
        try {
            // 处理输入
            hiddenInput.addActionListener(e -> {
                String command = hiddenInput.getText();
                hiddenInput.setText("");
                try {
                    outputStream.write((command + "\n").getBytes());
                    outputStream.flush();
                } catch (IOException ioException) {
                    ioException.printStackTrace();
                }
            });

        } catch (Exception e) {
            e.printStackTrace();
        }
    }

    /**
     * 滚动到底部
     */
    private static void scrollToBottom() {
        SwingUtilities.invokeLater(() -> {
            JScrollBar verticalScrollBar = scrollPane.getVerticalScrollBar();
            verticalScrollBar.setValue(verticalScrollBar.getMaximum());
        });
    }

}

示例四：参考jsch 和前端 xterm.js 通过 websocket 实现web版终端

GitHub - NoCortY/WebSSH: 纯Java实现的WebSSH

今晚哒老虎
关注
专栏目录
java实现ssh_使用纯Java实现一个WebSSH项目
weixin_42149153的博客
02-12 1444
技术选型由于webssh需要实时数据交互，所以会选用长连接的WebSocket，为了开发的方便，框架选用SpringBoot，另外还自己了解了Java用户连接ssh的jsch和实现前端shell页面的xterm.js.所以，最终的技术选型就是 SpringBoot+Websocket+jsch+xterm.js。导入依赖一个简单的xterm案例由于xterm是一个冷门技术，所以很多同学并没有这方面...
Java（通过ganymed-ssh2-build210.jar）实现SSH远程连接linux终端
08-03
Java通过ganymed-ssh2-build210.jar库实现SSH远程连接Linux终端是一个常见的应用场景，主要用于自动化运维、系统管理或者开发过程中需要与Linux服务器交互的场景。ganymed-ssh2-build210.jar是Java的一个开源SSH库，...
使用纯Java实现一个WebSSH项目
weixin_44355857的博客
05-10 2357
webssh需要实时数据交互，选择长连接的WebSocket，为了开发的方便，框架选用SpringBoot，另外还自己了解了Java用户连接ssh的mina sshd和实现前端shell页面的xterm.js-- Mina sshd 支持 -->-- WebSocket 支持 -->5）mina sshd + websocket 核心业务逻辑实现其中涉及到的pojo及util。
Java模拟终端实现与远程终端交互
weixin_45685353的博客
03-25 1902
简介： 该项目是使用Java的GUI即swing构造的，借助jsch连接到远程的终端，通过读取对应的输入输出流，把本地的命令发送至远程终端，远程终端执行完命令后，再获取终端的输出日志到本地的JTextArea多行文本框中显示，可实现交互效果，具体的实现细节请看代码。 演示： 代码： 本项目使用Maven管理，需要用到第三方jar包，所以要添加jsch依赖到pom文件中，如下： <dependency> <groupId>com.jcraft</groupId>
Java 打造一款 SSH 客户端，已开源～
2401_85763764的博客
06-17 392
最终测试，页面就是下面这个样子：可以看到页面已经出现了类似与shell的样式，那就根据这个继续深入，实现一个webssh。后端实现由于xterm只要只是实现了前端的样式，并不能真正地实现与服务器交互，与服务器交互主要还是靠我们Java后端来进行控制的，所以我们从后端开始，使用jsch+websocket实现这部分内容。
智能一体化运维平台（一）java实现ssh连接
云来云去的博客
04-26 943
一、思路 （1）作为java的web后台应用，在做ssh连接的时候，比如需要导入所需要的协议jar包的，如ssh.jar,本次测试，本人使用的是。 （2） 导入jar包后，开始进入代码编程，首先需要进行创建用户名、密码、端口、ip地址等变量，用来存储对应连接的服务器信息。 （3）创建连接对象，同时在创建会话对象，在java中一切皆对象。 （4）判断连接是否成功，如果成功执行命令代码，如果失败，进行返回信息。 （5）在连接成功后，需要对接收的数据进行处理，此处...
Spring Boot 实现在线Web SSH（ Java Web版本的Xsehll）
2401_85124163的博客
06-17 1010
堡垒机，即在一个特定的网络环境下，为了保障网络和数据不受来自外部和内部用户的入侵和破坏，而运用各种技术手段监控和记录运维人员对网络内的服务器、网络设备、安全设备、数据库等设备的操作行为，以便集中报警及时处理及审计定责。来自百度百科实现webssh泛指一种技术可以在网页上实现一个SSH终端。从而无需Xshell之类的模拟终端工具进行SSH连接，将SSH这一比较低层的操作也从C/S架构扭成了B/S架构。工作原理WebSocket长连接，用于指令发送和响应的实时交互xterm.js。
Java实现通过ssh远程连接主机并执行命令
热门推荐
shimadear的博客
05-19 1万+
需要用到的jar包： 主体代码： import java.io.BufferedReader; import java.io.IOException; import java.io.InputStream; import java.io.InputStreamReader; import java.io.UnsupportedEncodingException; import org....
Java代码通过SSH协议远程Linux
qq_38220334的博客
03-19 699
业务背景：公司想要实现Java代码中操作Linux命令，在页面上点击按钮，选择几个参数就可以操作集群，并且记录日志 想要实现这个功能有几个点需要关注 一.Java代码怎么连接远程的服务器？ 大家可能都有一个想法，把项目直接打包发布到该服务器上，但是这样会非常麻烦，每次你修改命令测试，就得打包一次项目，非常消耗时间 我的想法是，测试阶段可以本地SSH连接自己电脑上的Linux做测试，这样大大节约了测试时间，本地测试的没问题了，再发布到服务器上进行测试 接下来就是怎么连接Linux了 1.下载ssh需要的jar
JediTerm纯Java终端模拟器。适用于SSH和PTY。
08-08
**JediTerm** 是一个专为 Java 开发者设计的终端模拟器，它允许用户在 Java 应用程序中直接进行 SSH（Secure Shell）连接和PTY（伪终端）操作。这款工具尤其适合那些希望在集成开发环境（IDE）中集成终端功能的...
android 实现 ssh功能
04-09
实现Android SSH功能，通常需要使用第三方库，如JSch (Java Secure Channel) 或 Android OpenSSH。这些库封装了SSH协议的复杂性，使得开发者可以方便地在Android应用中集成SSH功能。 3. **JSch库**： JSch是Java...
C语言 | 第十章 | 函数 作用域
最新发布
ZJC744575的博客
10-05 920
为完成某一功能的程序指令(语句)的集合,称为函数。在C语言中,函数分为:自定义函数、系统函数(查看C语言函数手册)函数还有其它叫法，比如方法等，在本视频课程中，我们统一称为 函数。返回类型 函数名（形参列表）{执行语句...;// 函数体return 返回值;// 可选形参列表：表示函数的输入函数中的语句：表示为了实现某一功能代码块函数可以有返回值,也可以没有, 如果没有返回值，返回类型 声明为 void。
JavaScript ArrayBuffer的读写与类型转换
白瑕 的博客
10-01 442
所有视图的基本单位是ArrayBuffer, ArrayBuffer中只存储二进制格式的数据.ArrayBuffer不可直接读写, 必须通过视图(比如DataView)暴露的API.
Spring Cloud全解析：服务调用之OpenFeign集成OkHttp
Lxn2zh的博客
09-30 841
HTTP连接需要进行TCP三次握手，是一个比较耗时的操作，一般我们不直接使用HttpURLConnection，而是使用HttpClient/okHttp等支持连接池的客户端工具，以Feign集成OkHttp为例。OpenFeign本质是HTTP来进行服务调用的，也就是需要集成一个Http客户端。默认是HttpURLConnection方式，也就是jdk中提供的最原始的那个。要开启OkHttp ,还需要在YML 中添加开启配置项，默认是关闭的。使用的是Client接口来进行请求的。
spring-boot 整合 mybatis
m0_72168501的博客
09-29 548
spring boot 整合 mybatis
Java内存布局
阿呆的专栏
10-01 802
64位 JVM 不启用指针压缩时：Object Header 大小是16字节。64位 JVM 启用指针压缩时（默认）：Object Header 大小是12字节。32位 JVM：Object Header 大小是8字节。JVM在默认情况下启用指针压缩，但如果堆内存超过32GB，就会禁用指针压缩。32GB是压缩指针的最大寻址范围。超过32GB的堆内存中，压缩指针带来的性能提升并不显著，而且需要解压指针反而可能增加开销。
java 实现类似xshell
09-22
Java可以通过使用Socket类和Java中提供的网络编程相关的API来实现类似Xshell的功能。Xshell是一款远程终端模拟软件，它通过SSH协议来连接和管理远程主机。 在Java中，可以使用Socket类来建立客户端和服务器之间的连接。通过使用Socket类，可以建立一个远程终端连接，并发送命令到远程服务器。 实现类似Xshell的功能，首先需要建立一个客户端和一个服务器。客户端负责连接服务器，并发送命令到服务器。服务器监听客户端的连接，并接收客户端发送的命令，然后执行相应的操作，并将结果返回给客户端。 客户端和服务器之间的通信可以通过使用Socket类的InputStream和OutputStream来实现。客户端通过OutputStream发送命令到服务器，服务器通过InputStream接收客户端发送的命令，并执行相应的操作，然后将结果通过OutputStream发送给客户端，客户端通过InputStream接收并显示结果。 此外，还可以在Java中使用SSH库来实现SSH协议的功能。SSH库可以提供更高级的功能，例如安全认证、加密通信等。 总结来说，通过使用Java的Socket类和网络编程相关的API，以及使用SSH库，可以实现类似Xshell的功能，实现远程终端连接和命令执行。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

今晚哒老虎

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值