精华内容
下载资源
问答
  • 网页版Xshell

    2020-03-12 15:09:00
    就像是我们平常再用SecureCRT或者XShell连接服务器时一样。 下面是官网上的入门案例: doctype ...

    在公众号看见的一篇文章,推荐一下,挺实用。

    技术选型

    由于webssh需要实时数据交互,所以会选用长连接的WebSocket,为了开发的方便,框架选用SpringBoot,另外还自己了解了Java用户连接ssh的jsch和实现前端shell页面的xterm.js.

    所以,最终的技术选型就是 SpringBoot+Websocket+jsch+xterm.js

    导入依赖

    <parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>2.1.7.RELEASE</version>
        <relativePath /> <!-- lookup parent from repository -->
    </parent>
    <dependencies>
        <!-- Web相关 -->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>
        <!-- jsch支持 -->
        <dependency>
            <groupId>com.jcraft</groupId>
            <artifactId>jsch</artifactId>
            <version>0.1.54</version>
        </dependency>
        <!-- WebSocket 支持 -->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-websocket</artifactId>
        </dependency>
        <!-- 文件上传解析器 -->
        <dependency>
            <groupId>commons-io</groupId>
            <artifactId>commons-io</artifactId>
            <version>1.4</version>
        </dependency>
        <dependency>
            <groupId>commons-fileupload</groupId>
            <artifactId>commons-fileupload</artifactId>
            <version>1.3.1</version>
        </dependency>
    </dependencies> 

    一个简单的xterm案例

    由于xterm是一个冷门技术,所以很多同学并没有这方面的知识支撑,我也是为了实现这个功能所以临时学的,所以在这给大家介绍一下。

    xterm.js是一个基于WebSocket的容器,它可以帮助我们在前端实现命令行的样式。就像是我们平常再用SecureCRT或者XShell连接服务器时一样。

    下面是官网上的入门案例:

    <!doctype html>
     <html>
      <head>
        <link rel="stylesheet" href="node_modules/xterm/css/xterm.css" />
        <script src="node_modules/xterm/lib/xterm.js"></script>
      </head>
      <body>
        <div id="terminal"></div>
        <script>
          var term = new Terminal();
          term.open(document.getElementById('terminal'));
          term.write('Hello from \x1B[1;3;31mxterm.js\x1B[0m $ ')
        </script>
      </body>
     </html 

    可以看到页面已经出现了类似与shell的样式,那就根据这个继续深入,实现一个webssh。

    后端实现

    由于xterm只要只是实现了前端的样式,并不能真正地实现与服务器交互,与服务器交互主要还是靠我们Java后端来进行控制的,所以我们从后端开始,使用jsch+websocket实现这部分内容。

    WebSocket配置

    由于消息实时推送到前端需要用到WebSocket,不了解WebSocket的同学可以先去自行了解一下,这里就不过多介绍了,我们直接开始进行WebSocket的配置 

     /**
      * @Description: websocket配置
      * @Author: NoCortY
      * @Date: 2020/3/8
      */
      @Configuration
      @EnableWebSocket
      public class WebSSHWebSocketConfig implements WebSocketConfigurer{
          @Autowired
          WebSSHWebSocketHandler webSSHWebSocketHandler;
          @Override
          public void registerWebSocketHandlers(WebSocketHandlerRegistry webSocketHandlerRegistry) {
              //socket通道
              //指定处理器和路径,并设置跨域
              webSocketHandlerRegistry.addHandler(webSSHWebSocketHandler, "/webssh")
                      .addInterceptors(new WebSocketInterceptor())
                      .setAllowedOrigins("*");
          }
      }

    处理器(Handler)和拦截器(Interceptor)的实现

    刚才我们完成了WebSocket的配置,并指定了一个处理器和拦截器。所以接下来就是处理器和拦截器的实现。

    拦截器

      public class WebSocketInterceptor implements HandshakeInterceptor {
          /**
           * @Description: Handler处理前调用
           * @Param: [serverHttpRequest, serverHttpResponse, webSocketHandler, map]
           * @return: boolean
           * @Author: NoCortY
           * @Date: 2020/3/1
           */
          @Override
          public boolean beforeHandshake(ServerHttpRequest serverHttpRequest, ServerHttpResponse serverHttpResponse, WebSocketHandler webSocketHandler, Map<String, Object> map) throws Exception {
              if (serverHttpRequest instanceof ServletServerHttpRequest) {
                  ServletServerHttpRequest request = (ServletServerHttpRequest) serverHttpRequest;
                  //生成一个UUID,这里由于是独立的项目,没有用户模块,所以可以用随机的UUID
                  //但是如果要集成到自己的项目中,需要将其改为自己识别用户的标识
                  String uuid = UUID.randomUUID().toString().replace("-","");
                  //将uuid放到websocketsession中
                  map.put(ConstantPool.USER_UUID_KEY, uuid);
                  return true;
              } else {
                  return false;
              }
          }
    
          @Override
          public void afterHandshake(ServerHttpRequest serverHttpRequest, ServerHttpResponse serverHttpResponse, WebSocketHandler webSocketHandler, Exception e) {
    
          }
      } 

    处理器

      /**
      * @Description: WebSSH的WebSocket处理器
      * @Author: NoCortY
      * @Date: 2020/3/8
      */
      @Component
      public class WebSSHWebSocketHandler implements WebSocketHandler{
          @Autowired
          private WebSSHService webSSHService;
          private Logger logger = LoggerFactory.getLogger(WebSSHWebSocketHandler.class);
    
          /**
           * @Description: 用户连接上WebSocket的回调
           * @Param: [webSocketSession]
           * @return: void
           * @Author: Object
           * @Date: 2020/3/8
           */
          @Override
          public void afterConnectionEstablished(WebSocketSession webSocketSession) throws Exception {
              logger.info("用户:{},连接WebSSH", webSocketSession.getAttributes().get(ConstantPool.USER_UUID_KEY));
              //调用初始化连接
              webSSHService.initConnection(webSocketSession);
          }
    
          /**
           * @Description: 收到消息的回调
           * @Param: [webSocketSession, webSocketMessage]
           * @return: void
           * @Author: NoCortY
           * @Date: 2020/3/8
           */
          @Override
          public void handleMessage(WebSocketSession webSocketSession, WebSocketMessage<?> webSocketMessage) throws Exception {
              if (webSocketMessage instanceof TextMessage) {
                  logger.info("用户:{},发送命令:{}", webSocketSession.getAttributes().get(ConstantPool.USER_UUID_KEY), webSocketMessage.toString());
                  //调用service接收消息
                  webSSHService.recvHandle(((TextMessage) webSocketMessage).getPayload(), webSocketSession);
              } else if (webSocketMessage instanceof BinaryMessage) {
    
              } else if (webSocketMessage instanceof PongMessage) {
    
              } else {
                  System.out.println("Unexpected WebSocket message type: " + webSocketMessage);
              }
          }
    
          /**
           * @Description: 出现错误的回调
           * @Param: [webSocketSession, throwable]
           * @return: void
           * @Author: Object
           * @Date: 2020/3/8
           */
          @Override
          public void handleTransportError(WebSocketSession webSocketSession, Throwable throwable) throws Exception {
              logger.error("数据传输错误");
          }
    
          /**
           * @Description: 连接关闭的回调
           * @Param: [webSocketSession, closeStatus]
           * @return: void
           * @Author: NoCortY
           * @Date: 2020/3/8
           */
          @Override
          public void afterConnectionClosed(WebSocketSession webSocketSession, CloseStatus closeStatus) throws Exception {
              logger.info("用户:{}断开webssh连接", String.valueOf(webSocketSession.getAttributes().get(ConstantPool.USER_UUID_KEY)));
              //调用service关闭连接
              webSSHService.close(webSocketSession);
          }
    
          @Override
          public boolean supportsPartialMessages() {
              return false;
          }
      } 

    需要注意的是,我在拦截器中加入的用户标识是使用了随机的UUID,这是因为作为一个独立的websocket项目,没有用户模块,如果需要将这个项目集成到自己的项目中,需要修改这部分代码,将其改为自己项目中识别一个用户所用的用户标识。

    WebSSH的业务逻辑实现(核心)

    刚才我们实现了websocket的配置,都是一些死代码,实现了接口再根据自身需求即可实现,现在我们将进行后端主要业务逻辑的实现,在实现这个逻辑之前,我们先来想想,WebSSH,我们主要想要呈现一个什么效果。

    我这里做了一个总结:

    1.首先我们得先连接上终端(初始化连接)

    2.其次我们的服务端需要处理来自前端的消息(接收并处理前端消息)

    3.我们需要将终端返回的消息回写到前端(数据回写前端)

    4.关闭连接

    根据这四个需求,我们先定义一个接口,这样可以让需求明了起来。

      /**
       * @Description: WebSSH的业务逻辑
       * @Author: NoCortY
       * @Date: 2020/3/7
       */
      public interface WebSSHService {
          /**
           * @Description: 初始化ssh连接
           * @Param:
           * @return:
           * @Author: NoCortY
           * @Date: 2020/3/7
           */
          public void initConnection(WebSocketSession session);
    
          /**
           * @Description: 处理客户段发的数据
           * @Param:
           * @return:
           * @Author: NoCortY
           * @Date: 2020/3/7
           */
          public void recvHandle(String buffer, WebSocketSession session);
    
          /**
           * @Description: 数据写回前端 for websocket
           * @Param:
           * @return:
           * @Author: NoCortY
           * @Date: 2020/3/7
           */
          public void sendMessage(WebSocketSession session, byte[] buffer) throws IOException;
    
          /**
           * @Description: 关闭连接
           * @Param:
           * @return:
           * @Author: NoCortY
           * @Date: 2020/3/7
           */
          public void close(WebSocketSession session);
      } 

    现在我们可以根据这个接口去实现我们定义的功能了。

    1.初始化连接

    由于我们的底层是依赖jsch实现的,所以这里是需要使用jsch去建立连接的。而所谓初始化连接,实际上就是将我们所需要的连接信息,保存在一个Map中,这里并不进行任何的真实连接操作。为什么这里不直接进行连接?因为这里前端只是连接上了WebSocket,但是我们还需要前端给我们发来linux终端的用户名和密码,没有这些信息,我们是无法进行连接的。

       public void initConnection(WebSocketSession session) {
                 JSch jSch = new JSch();
                 SSHConnectInfo sshConnectInfo = new SSHConnectInfo();
                 sshConnectInfo.setjSch(jSch);
                 sshConnectInfo.setWebSocketSession(session);
                 String uuid = String.valueOf(session.getAttributes().get(ConstantPool.USER_UUID_KEY));
                 //将这个ssh连接信息放入map中
                 sshMap.put(uuid, sshConnectInfo);
         } 

    2.处理客户端发送的数据

    在这一步骤中,我们会分为两个分支。

    • 第一个分支:如果客户端发来的是终端的用户名和密码等信息,那么我们进行终端的连接。

    • 第二个分支:如果客户端发来的是操作终端的命令,那么我们就直接转发到终端并且获取终端的执行结果。

    具体代码实现:

      public void recvHandle(String buffer, WebSocketSession session) {
                 ObjectMapper objectMapper = new ObjectMapper();
                 WebSSHData webSSHData = null;
                 try {
                     //转换前端发送的JSON
                     webSSHData = objectMapper.readValue(buffer, WebSSHData.class);
                 } catch (IOException e) {
                     logger.error("Json转换异常");
                     logger.error("异常信息:{}", e.getMessage());
                     return;
                 }
             //获取刚才设置的随机的uuid
                 String userId = String.valueOf(session.getAttributes().get(ConstantPool.USER_UUID_KEY));
                 if (ConstantPool.WEBSSH_OPERATE_CONNECT.equals(webSSHData.getOperate())) {
                     //如果是连接请求
                     //找到刚才存储的ssh连接对象
                     SSHConnectInfo sshConnectInfo = (SSHConnectInfo) sshMap.get(userId);
                     //启动线程异步处理
                     WebSSHData finalWebSSHData = webSSHData;
                     executorService.execute(new Runnable() {
                         @Override
                         public void run() {
                             try {
                                 //连接到终端
                                 connectToSSH(sshConnectInfo, finalWebSSHData, session);
                             } catch (JSchException | IOException e) {
                                 logger.error("webssh连接异常");
                                 logger.error("异常信息:{}", e.getMessage());
                                 close(session);
                             }
                         }
                     });
                 } else if (ConstantPool.WEBSSH_OPERATE_COMMAND.equals(webSSHData.getOperate())) {
                     //如果是发送命令的请求
                     String command = webSSHData.getCommand();
                     SSHConnectInfo sshConnectInfo = (SSHConnectInfo) sshMap.get(userId);
                     if (sshConnectInfo != null) {
                         try {
                             //发送命令到终端
                             transToSSH(sshConnectInfo.getChannel(), command);
                         } catch (IOException e) {
                             logger.error("webssh连接异常");
                             logger.error("异常信息:{}", e.getMessage());
                             close(session);
                         }
                     }
                 } else {
                     logger.error("不支持的操作");
                     close(session);
                 }
         } 

    3.数据通过websocket发送到前端

     public void sendMessage(WebSocketSession session, byte[] buffer) throws IOException {
                 session.sendMessage(new TextMessage(buffer));
         } 

    4.关闭连接

     public void close(WebSocketSession session) {
             //获取随机生成的uuid
                 String userId = String.valueOf(session.getAttributes().get(ConstantPool.USER_UUID_KEY));
                 SSHConnectInfo sshConnectInfo = (SSHConnectInfo) sshMap.get(userId);
                 if (sshConnectInfo != null) {
                     //断开连接
                     if (sshConnectInfo.getChannel() != null) sshConnectInfo.getChannel().disconnect();
                     //map中移除该ssh连接信息
                     sshMap.remove(userId);
                 }
         } 

    至此,我们的整个后端实现就结束了,由于篇幅有限,这里将一些操作封装成了方法,就不做过多展示了,重点讲逻辑实现的思路吧。接下来我们将进行前端的实现。

    前端实现

    前端工作主要分为这么几个步骤:

    1. 页面的实现

    2. 连接WebSocket并完成数据的接收并回写

    3. 数据的发送

    所以我们一步一步来实现它。

    页面实现

    页面的实现很简单,我们只不过需要在一整个屏幕上都显示终端那种大黑屏幕,所以我们并不用写什么样式,只需要创建一个div,之后将terminal实例通过xterm放到这个div中,就可以实现了。

    <!doctype html>
      <html>
      <head>
          <title>WebSSH</title>
          <link rel="stylesheet" href="../css/xterm.css" />
      </head>
      <body>
      <div id="terminal" style="width: 100%;height: 100%"></div>
    
      <script src="../lib/jquery-3.4.1/jquery-3.4.1.min.js"></script>
      <script src="../js/xterm.js" charset="utf-8"></script>
      <script src="../js/webssh.js" charset="utf-8"></script>
      <script src="../js/base64.js" charset="utf-8"></script>
      </body>
      </html>

    连接WebSocket并完成数据的发送、接收、回写

      openTerminal( {
          //这里的内容可以写死,但是要整合到项目中时,需要通过参数的方式传入,可以动态连接某个终端。
              operate:'connect',
              host: 'ip地址',
              port: '端口号',
              username: '用户名',
              password: '密码'
          });
          function openTerminal(options){
              var client = new WSSHClient();
              var term = new Terminal({
                  cols: 97,
                  rows: 37,
                  cursorBlink: true, // 光标闪烁
                  cursorStyle: "block", // 光标样式  null | 'block' | 'underline' | 'bar'
                  scrollback: 800, //回滚
                  tabStopWidth: 8, //制表宽度
                  screenKeys: true
              });
    
              term.on('data', function (data) {
                  //键盘输入时的回调函数
                  client.sendClientData(data);
              });
              term.open(document.getElementById('terminal'));
              //在页面上显示连接中...
              term.write('Connecting...');
              //执行连接操作
              client.connect({
                  onError: function (error) {
                      //连接失败回调
                      term.write('Error: ' + error + '\r\n');
                  },
                  onConnect: function () {
                      //连接成功回调
                      client.sendInitData(options);
                  },
                  onClose: function () {
                      //连接关闭回调
                      term.write("\rconnection closed");
                  },
                  onData: function (data) {
                      //收到数据时回调
                      term.write(data);
                  }
              });
          } 

    效果展示

    连接

    命令操作

    ls命令:

    vim编辑器:

    top命令:

    结语

    Github:https://github.com/NoCortY/WebSSH

    感觉websocket还是很有必要学习的,后面等有时间的,想要系统的去学一下

     

    展开全文
  •   上个周末的时候,在方志朋老师的公众号上看见了一篇《教你用纯Java实现一个网页版Xshell(附源码)》的文章,非常感兴趣,这不正好这周六稍有闲时,就好好的研究了研究,顺便记录一下学习心得。   github...
    1、前言

      上个周末的时候,在方志朋老师的公众号上看见了一篇《教你用纯Java实现一个网页版的Xshell(附源码)》的文章,非常感兴趣,这不正好这周六稍有闲时,就好好的研究了研究,顺便记录一下学习心得。
      github项目开源地址:https://github.com/NoCortY/WebSSH,感兴趣的童鞋们,可以自己运行该项目,需要注意的是:首先,环境需要运行在一个可以使用Xshell的环境中,不然没有办法测试,其次,在运行该项目时,需要修改连接到服务的地址、用户名密码等,在webssh.html文件中进行修改。

    2、技术选型

      最终的技术选型就是: SpringBoot+Websocket+jsch+xterm.js。

      在方志朋老师的文章中,已经分析了为什么做这种技术选型,这里分别在把用到的这几种技术,在详细的记录一下,毕竟有些东西在实际工作中,用的不是太多。

    SpringBoot

      首先就是SpringBoot框架,这个就不展开说了,基本上是现在构建JavaWeb项目的首选了。毕竟使用SpringBoot可以很大程度的提高环境搭建的效率,也有助于Spring生态圈中一些框架的集成应用。

    Websocket

      由于webssh需要实时数据交互,所以会选用长连接的WebSocket。

      WebSocket协议是基于TCP的一种新的网络协议。它实现了浏览器与服务器全双工(full-duplex)通信——允许服务器主动发送信息给客户端。HTTP 协议有一个缺陷:通信只能由客户端发起,HTTP 协议做不到服务器主动向客户端推送信息,所以WebSocket就是为了弥补HTTP协议的这种缺陷,而产生的。

      在SpringBoot中配置Websocket的方式有两种:一种是通过@ServerEndpoint注解进行配置,一种是通过继承WebSocketConfigurer配置文件来实现(有多种形式)。在这篇内容中就是通过第二种,继承WebSocketConfigurer类,然后把处理器(Handler)和拦截器(Interceptor)注册到WebSocket的Java配置类中,这里不再展开,后续专门学习相关内容。

    JSCH

      JSCH是Java Secure Channel的缩写。JSCH是一个SSH2的纯Java实现。它允许你连接到一个SSH服务器,并且可以使用端口转发,X11转发,文件传输等,当然你也可以集成它的功能到你自己的应用程序,即JSCH是这篇文章中实现SSH通信的核心API。

      JSCH的API地址:http://epaul.github.io/jsch-documentation/javadoc/com/jcraft/jsch/package-summary.html

      在这篇内容中主要应用到了一下几个类:

    • JSch 核心配置类作用,同时也作为创建会话(Session)的工厂类
    • Session 通信的会话。主要提供了一些配置会话参数、连接SSH服务,打开Channel通道等方法。
    • Channel 通道,用于Shell命令的执行,包括的子类有ChannelExec, ChannelShell, ChannelSubsystem等。
    • ChannelSftp 文件通道,相关的类还有 SftpATTRS 、SftpProgressMonitor等。
    • UserInfo、UIKeyboardInteractive 用户信息接口,用于保存和获取在Session中的用户信息。
    xterm

      xterm 是一个使用 TypeScript 编写的前端终端组件,可以直接在浏览器中实现一个命令行终端应用。
    在这里插入图片描述
    主要特性:

    • 终端应用程序正常工作:Xterm.js适用于大多数终端应用程序,如bash,vim和tmux,这包括对基于curses的应用程序和鼠标事件支持的支持
    • Performant:Xterm.js 非常快,它甚至还包括一个GPU加速的渲染器
    • 丰富的 unicode 支持:支持CJK,表情符号和IME
    • 自包含:零依赖性
    • 可访问:可以使用screenReaderMode选项打开屏幕阅读器支持
    • 还有更多:链接,主题,插件,记录良好的API等。

    具体用户可以参考官方文档:《xtermjs文档》

    3、源码解读

      在方志朋老师的文章中,整个后台代码的逻辑讲解的已经比较详细了,我这里按照自己学习源码的思路把所有的类,汇总一下,方便后期再次代码的基础上,在扩展其他新的功能和用法。

    • WebSSHStarter
        首先是SpringBoot的启动类WebSSHStarter,最简单的启动类。对应的应用参数,在config/application.yml配置文件中进行了配置。

    • WebSSHWebSocketConfig
        SpringBoot配置WebSocket的类,前面提到过,这里使用了继承WebSocketConfigurer类的方法进行了实现。在这个配置类中,把处理器(Handler)和拦截器(Interceptor)都注册到了WebSocket的注册器中了。

    • WebSocketInterceptor
        在方志朋老师提供的实例中,这个拦截器的意义不太大,只是拦截了request请求,并随机生成了一个UUID作为用户标识,传到了后续的逻辑中,在实际生成环境中,这里可以实现用户认证的代码逻辑。

    • WebSSHWebSocketHandler
        该处理器类实现了WebSocketHandler接口,主要用来完成Websocket消息和WebSocket生命周期中事件的处理,即这个类是WebSocket事件回调方法的入口。其实,在这类中,方志朋老师是通过调用WebSSHService接口的具体实现类来实现了具体的业务逻辑,所以在于SSH服务进行通信的核心代码是在WebSSHService接口的实现类中进行的。

    • WebSSHService接口、WebSSHServiceImpl实现类
        在WebSSHService接口中定义了四个方法,分别是:初始化、处理请求、回写响应数据、关闭连接。
        其中,在初始化方法中,主要实现了JSch对象的初始化,包括当前用户的信息的维护;处理请求方法中,主要处理两类请求,一类是连接操作请求,一类是命令操作请求,在该方法中用到了线程池ExecutorService的概念;回写响应数据方法,这里通过在进行连接操作的时候,就创建了一个线程,一直在监听是否有需要回写的数据,如果有的话,就直接通过org.springframework.web.socket.WebSocketSession的sendMessage()方法回写到客户端;关闭连接,主要是在连接断开后,会清理释放被占用的资源。

    • POJO类、常量类
        基础类。

    • RouterController类
        提供的进入控制台界面的入口类,对用的界面是webssh.html。

    • 前端实现
        在static文件夹下是前端页面的实现,需要注意:在运行该项目时,需要修改连接到服务的地址、用户名密码等,在webssh.html文件中进行修改。

    4、结尾

      在方志朋老师的文章中,讲解的已经比较详细了,这里主要是针对在学习这篇文章中的记录的一些笔记,后续会在这个项目的基础上进行进一步的开发,大致的方向是:

    1. 连接服务的用户密码,可以让用户可以配置
    2. 提供可以连接多个服务的方式,即同时创建多个会话,类似xShell的选项卡。
    3. 提供附件处理的功能,在这个实例中,没有实现相关内容。

      新项目的地址在:https://gitee.com/hsh2015/webshh.git。该项目还在持续开发中。

    展开全文
  • 就像是我们平常再用SecureCRT或者XShell连接服务器时一样。 下面是官网上的入门案例: 最终测试,页面就是下面这个样子: 可以看到页面已经出现了类似与shell的样式,那就根据这个继续深入,实现一个webssh。 后端...

    17b7d2704d27c94f2a54c9f114ec1b88.png

    前言

    最近由于项目需求,项目中需要实现一个WebSSH连接终端的功能,由于自己第一次做这类型功能,所以首先上了GitHub找了找有没有现成的轮子可以拿来直接用,当时看到了很多这方面的项目,例如:GateOne、webssh、shellinabox等,这些项目都可以很好地实现webssh的功能。

    但是最终并没有采用,原因是在于这些底层大都是python写的,需要依赖很多文件,自己用的时候可以使用这种方案,快捷省事,但是做到项目中供用户使用时,总不能要求用户做到服务器中必须包含这些底层依赖,这显然不太合理,所以我决定自己动手写一个WebSSH的功能,并且作为一个独立的项目开源出来。

    github项目开源地址:https://github.com/NoCortY/WebSSH

    技术选型

    由于webssh需要实时数据交互,所以会选用长连接的WebSocket,为了开发的方便,框架选用SpringBoot,另外还自己了解了Java用户连接ssh的jsch和实现前端shell页面的xterm.js.

    所以,最终的技术选型就是 SpringBoot+Websocket+jsch+xterm.js

    导入依赖

    <parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>2.1.7.RELEASE</version>
        <relativePath /> <!-- lookup parent from repository -->
    </parent>
    <dependencies>
        <!-- Web相关 -->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>
        <!-- jsch支持 -->
        <dependency>
            <groupId>com.jcraft</groupId>
            <artifactId>jsch</artifactId>
            <version>0.1.54</version>
        </dependency>
        <!-- WebSocket 支持 -->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-websocket</artifactId>
        </dependency>
        <!-- 文件上传解析器 -->
        <dependency>
            <groupId>commons-io</groupId>
            <artifactId>commons-io</artifactId>
            <version>1.4</version>
        </dependency>
        <dependency>
            <groupId>commons-fileupload</groupId>
            <artifactId>commons-fileupload</artifactId>
            <version>1.3.1</version>
        </dependency>
    </dependencies>
    

    一个简单的xterm案例

    由于xterm是一个冷门技术,所以很多同学并没有这方面的知识支撑,我也是为了实现这个功能所以临时学的,所以在这给大家介绍一下。

    xterm.js是一个基于WebSocket的容器,它可以帮助我们在前端实现命令行的样式。就像是我们平常再用SecureCRT或者XShell连接服务器时一样。

    下面是官网上的入门案例:

    <!doctype html>
     <html>
      <head>
        <link rel="stylesheet" href="node_modules/xterm/css/xterm.css" />
        <script src="node_modules/xterm/lib/xterm.js"></script>
      </head>
      <body>
        <div id="terminal"></div>
        <script>
          var term = new Terminal();
          term.open(document.getElementById('terminal'));
          term.write('Hello from x1B[1;3;31mxterm.jsx1B[0m $ ')
        </script>
      </body>
     </html>
    

    最终测试,页面就是下面这个样子:

    cf7a870ca87e7559c40207783773fd20.png

    可以看到页面已经出现了类似与shell的样式,那就根据这个继续深入,实现一个webssh。

    后端实现

    由于xterm只要只是实现了前端的样式,并不能真正地实现与服务器交互,与服务器交互主要还是靠我们Java后端来进行控制的,所以我们从后端开始,使用jsch+websocket实现这部分内容。

    WebSocket配置

    由于消息实时推送到前端需要用到WebSocket,不了解WebSocket的同学可以先去自行了解一下,这里就不过多介绍了,我们直接开始进行WebSocket的配置。

      /**
      * @Description: websocket配置
      * @Author: NoCortY
      * @Date: 2020/3/8
      */
      @Configuration
      @EnableWebSocket
      public class WebSSHWebSocketConfig implements WebSocketConfigurer{
          @Autowired
          WebSSHWebSocketHandler webSSHWebSocketHandler;
          @Override
          public void registerWebSocketHandlers(WebSocketHandlerRegistry webSocketHandlerRegistry) {
              //socket通道
              //指定处理器和路径,并设置跨域
              webSocketHandlerRegistry.addHandler(webSSHWebSocketHandler, "/webssh")
                      .addInterceptors(new WebSocketInterceptor())
                      .setAllowedOrigins("*");
          }
      }
    

    处理器(Handler)和拦截器(Interceptor)的实现

    刚才我们完成了WebSocket的配置,并指定了一个处理器和拦截器。所以接下来就是处理器和拦截器的实现。

    拦截器

      public class WebSocketInterceptor implements HandshakeInterceptor {
          /**
           * @Description: Handler处理前调用
           * @Param: [serverHttpRequest, serverHttpResponse, webSocketHandler, map]
           * @return: boolean
           * @Author: NoCortY
           * @Date: 2020/3/1
           */
          @Override
          public boolean beforeHandshake(ServerHttpRequest serverHttpRequest, ServerHttpResponse serverHttpResponse, WebSocketHandler webSocketHandler, Map<String, Object> map) throws Exception {
              if (serverHttpRequest instanceof ServletServerHttpRequest) {
                  ServletServerHttpRequest request = (ServletServerHttpRequest) serverHttpRequest;
                  //生成一个UUID,这里由于是独立的项目,没有用户模块,所以可以用随机的UUID
                  //但是如果要集成到自己的项目中,需要将其改为自己识别用户的标识
                  String uuid = UUID.randomUUID().toString().replace("-","");
                  //将uuid放到websocketsession中
                  map.put(ConstantPool.USER_UUID_KEY, uuid);
                  return true;
              } else {
                  return false;
              }
          }
    
          @Override
          public void afterHandshake(ServerHttpRequest serverHttpRequest, ServerHttpResponse serverHttpResponse, WebSocketHandler webSocketHandler, Exception e) {
    
          }
      }
    

    处理器

      /**
      * @Description: WebSSH的WebSocket处理器
      * @Author: NoCortY
      * @Date: 2020/3/8
      */
      @Component
      public class WebSSHWebSocketHandler implements WebSocketHandler{
          @Autowired
          private WebSSHService webSSHService;
          private Logger logger = LoggerFactory.getLogger(WebSSHWebSocketHandler.class);
    
          /**
           * @Description: 用户连接上WebSocket的回调
           * @Param: [webSocketSession]
           * @return: void
           * @Author: Object
           * @Date: 2020/3/8
           */
          @Override
          public void afterConnectionEstablished(WebSocketSession webSocketSession) throws Exception {
              logger.info("用户:{},连接WebSSH", webSocketSession.getAttributes().get(ConstantPool.USER_UUID_KEY));
              //调用初始化连接
              webSSHService.initConnection(webSocketSession);
          }
    
          /**
           * @Description: 收到消息的回调
           * @Param: [webSocketSession, webSocketMessage]
           * @return: void
           * @Author: NoCortY
           * @Date: 2020/3/8
           */
          @Override
          public void handleMessage(WebSocketSession webSocketSession, WebSocketMessage<?> webSocketMessage) throws Exception {
              if (webSocketMessage instanceof TextMessage) {
                  logger.info("用户:{},发送命令:{}", webSocketSession.getAttributes().get(ConstantPool.USER_UUID_KEY), webSocketMessage.toString());
                  //调用service接收消息
                  webSSHService.recvHandle(((TextMessage) webSocketMessage).getPayload(), webSocketSession);
              } else if (webSocketMessage instanceof BinaryMessage) {
    
              } else if (webSocketMessage instanceof PongMessage) {
    
              } else {
                  System.out.println("Unexpected WebSocket message type: " + webSocketMessage);
              }
          }
    
          /**
           * @Description: 出现错误的回调
           * @Param: [webSocketSession, throwable]
           * @return: void
           * @Author: Object
           * @Date: 2020/3/8
           */
          @Override
          public void handleTransportError(WebSocketSession webSocketSession, Throwable throwable) throws Exception {
              logger.error("数据传输错误");
          }
    
          /**
           * @Description: 连接关闭的回调
           * @Param: [webSocketSession, closeStatus]
           * @return: void
           * @Author: NoCortY
           * @Date: 2020/3/8
           */
          @Override
          public void afterConnectionClosed(WebSocketSession webSocketSession, CloseStatus closeStatus) throws Exception {
              logger.info("用户:{}断开webssh连接", String.valueOf(webSocketSession.getAttributes().get(ConstantPool.USER_UUID_KEY)));
              //调用service关闭连接
              webSSHService.close(webSocketSession);
          }
    
          @Override
          public boolean supportsPartialMessages() {
              return false;
          }
      }
    

    需要注意的是,我在拦截器中加入的用户标识是使用了随机的UUID,这是因为作为一个独立的websocket项目,没有用户模块,如果需要将这个项目集成到自己的项目中,需要修改这部分代码,将其改为自己项目中识别一个用户所用的用户标识。

    WebSSH的业务逻辑实现(核心)

    刚才我们实现了websocket的配置,都是一些死代码,实现了接口再根据自身需求即可实现,现在我们将进行后端主要业务逻辑的实现,在实现这个逻辑之前,我们先来想想,WebSSH,我们主要想要呈现一个什么效果。

    我这里做了一个总结:

    1.首先我们得先连接上终端(初始化连接)
    2.其次我们的服务端需要处理来自前端的消息(接收并处理前端消息)
    3.我们需要将终端返回的消息回写到前端(数据回写前端)
    4.关闭连接

    根据这四个需求,我们先定义一个接口,这样可以让需求明了起来。

      /**
       * @Description: WebSSH的业务逻辑
       * @Author: NoCortY
       * @Date: 2020/3/7
       */
      public interface WebSSHService {
          /**
           * @Description: 初始化ssh连接
           * @Param:
           * @return:
           * @Author: NoCortY
           * @Date: 2020/3/7
           */
          public void initConnection(WebSocketSession session);
    
          /**
           * @Description: 处理客户段发的数据
           * @Param:
           * @return:
           * @Author: NoCortY
           * @Date: 2020/3/7
           */
          public void recvHandle(String buffer, WebSocketSession session);
    
          /**
           * @Description: 数据写回前端 for websocket
           * @Param:
           * @return:
           * @Author: NoCortY
           * @Date: 2020/3/7
           */
          public void sendMessage(WebSocketSession session, byte[] buffer) throws IOException;
    
          /**
           * @Description: 关闭连接
           * @Param:
           * @return:
           * @Author: NoCortY
           * @Date: 2020/3/7
           */
          public void close(WebSocketSession session);
      }
    

    现在我们可以根据这个接口去实现我们定义的功能了。

    1.初始化连接

    由于我们的底层是依赖jsch实现的,所以这里是需要使用jsch去建立连接的。而所谓初始化连接,实际上就是将我们所需要的连接信息,保存在一个Map中,这里并不进行任何的真实连接操作。为什么这里不直接进行连接?因为这里前端只是连接上了WebSocket,但是我们还需要前端给我们发来linux终端的用户名和密码,没有这些信息,我们是无法进行连接的。

         public void initConnection(WebSocketSession session) {
                 JSch jSch = new JSch();
                 SSHConnectInfo sshConnectInfo = new SSHConnectInfo();
                 sshConnectInfo.setjSch(jSch);
                 sshConnectInfo.setWebSocketSession(session);
                 String uuid = String.valueOf(session.getAttributes().get(ConstantPool.USER_UUID_KEY));
                 //将这个ssh连接信息放入map中
                 sshMap.put(uuid, sshConnectInfo);
         }
    

    2.处理客户端发送的数据

    在这一步骤中,我们会分为两个分支。

    • 第一个分支:如果客户端发来的是终端的用户名和密码等信息,那么我们进行终端的连接。
    • 第二个分支:如果客户端发来的是操作终端的命令,那么我们就直接转发到终端并且获取终端的执行结果。

    具体代码实现:

         public void recvHandle(String buffer, WebSocketSession session) {
                 ObjectMapper objectMapper = new ObjectMapper();
                 WebSSHData webSSHData = null;
                 try {
                     //转换前端发送的JSON
                     webSSHData = objectMapper.readValue(buffer, WebSSHData.class);
                 } catch (IOException e) {
                     logger.error("Json转换异常");
                     logger.error("异常信息:{}", e.getMessage());
                     return;
                 }
             //获取刚才设置的随机的uuid
                 String userId = String.valueOf(session.getAttributes().get(ConstantPool.USER_UUID_KEY));
                 if (ConstantPool.WEBSSH_OPERATE_CONNECT.equals(webSSHData.getOperate())) {
                     //如果是连接请求
                     //找到刚才存储的ssh连接对象
                     SSHConnectInfo sshConnectInfo = (SSHConnectInfo) sshMap.get(userId);
                     //启动线程异步处理
                     WebSSHData finalWebSSHData = webSSHData;
                     executorService.execute(new Runnable() {
                         @Override
                         public void run() {
                             try {
                                 //连接到终端
                                 connectToSSH(sshConnectInfo, finalWebSSHData, session);
                             } catch (JSchException | IOException e) {
                                 logger.error("webssh连接异常");
                                 logger.error("异常信息:{}", e.getMessage());
                                 close(session);
                             }
                         }
                     });
                 } else if (ConstantPool.WEBSSH_OPERATE_COMMAND.equals(webSSHData.getOperate())) {
                     //如果是发送命令的请求
                     String command = webSSHData.getCommand();
                     SSHConnectInfo sshConnectInfo = (SSHConnectInfo) sshMap.get(userId);
                     if (sshConnectInfo != null) {
                         try {
                             //发送命令到终端
                             transToSSH(sshConnectInfo.getChannel(), command);
                         } catch (IOException e) {
                             logger.error("webssh连接异常");
                             logger.error("异常信息:{}", e.getMessage());
                             close(session);
                         }
                     }
                 } else {
                     logger.error("不支持的操作");
                     close(session);
                 }
         }
    

    3.数据通过websocket发送到前端

         public void sendMessage(WebSocketSession session, byte[] buffer) throws IOException {
                 session.sendMessage(new TextMessage(buffer));
         }
    

    4.关闭连接

         public void close(WebSocketSession session) {
             //获取随机生成的uuid
                 String userId = String.valueOf(session.getAttributes().get(ConstantPool.USER_UUID_KEY));
                 SSHConnectInfo sshConnectInfo = (SSHConnectInfo) sshMap.get(userId);
                 if (sshConnectInfo != null) {
                     //断开连接
                     if (sshConnectInfo.getChannel() != null) sshConnectInfo.getChannel().disconnect();
                     //map中移除该ssh连接信息
                     sshMap.remove(userId);
                 }
         }
    

    至此,我们的整个后端实现就结束了,由于篇幅有限,这里将一些操作封装成了方法,就不做过多展示了,重点讲逻辑实现的思路吧。接下来我们将进行前端的实现。

    前端实现

    前端工作主要分为这么几个步骤:

    1. 页面的实现
    2. 连接WebSocket并完成数据的接收并回写
    3. 数据的发送

    所以我们一步一步来实现它。

    页面实现

    页面的实现很简单,我们只不过需要在一整个屏幕上都显示终端那种大黑屏幕,所以我们并不用写什么样式,只需要创建一个div,之后将terminal实例通过xterm放到这个div中,就可以实现了。

      <!doctype html>
      <html>
      <head>
          <title>WebSSH</title>
          <link rel="stylesheet" href="../css/xterm.css" />
      </head>
      <body>
      <div id="terminal" style="width: 100%;height: 100%"></div>
    
      <script src="../lib/jquery-3.4.1/jquery-3.4.1.min.js"></script>
      <script src="../js/xterm.js" charset="utf-8"></script>
      <script src="../js/webssh.js" charset="utf-8"></script>
      <script src="../js/base64.js" charset="utf-8"></script>
      </body>
      </html>
    

    连接WebSocket并完成数据的发送、接收、回写

      openTerminal( {
          //这里的内容可以写死,但是要整合到项目中时,需要通过参数的方式传入,可以动态连接某个终端。
              operate:'connect',
              host: 'ip地址',
              port: '端口号',
              username: '用户名',
              password: '密码'
          });
          function openTerminal(options){
              var client = new WSSHClient();
              var term = new Terminal({
                  cols: 97,
                  rows: 37,
                  cursorBlink: true, // 光标闪烁
                  cursorStyle: "block", // 光标样式  null | 'block' | 'underline' | 'bar'
                  scrollback: 800, //回滚
                  tabStopWidth: 8, //制表宽度
                  screenKeys: true
              });
    
              term.on('data', function (data) {
                  //键盘输入时的回调函数
                  client.sendClientData(data);
              });
              term.open(document.getElementById('terminal'));
              //在页面上显示连接中...
              term.write('Connecting...');
              //执行连接操作
              client.connect({
                  onError: function (error) {
                      //连接失败回调
                      term.write('Error: ' + error + 'rn');
                  },
                  onConnect: function () {
                      //连接成功回调
                      client.sendInitData(options);
                  },
                  onClose: function () {
                      //连接关闭回调
                      term.write("rconnection closed");
                  },
                  onData: function (data) {
                      //收到数据时回调
                      term.write(data);
                  }
              });
          }
    

    效果展示

    连接

    4b17dd3137238750885f26a00473a3ec.png

    连接成功

    9ca263a533fcb1016c45ff34f6e8071b.png

    命令操作

    ls命令:

    400d5faf5fdfa1f316afb7944415d69f.png

    vim编辑器:

    5917aad8625dfddea0adf4a989944893.png

    top命令:

    80e30b7b91a4174af60d6d850faae0ca.png

    结语

    这样我们就完成了一个webssh项目的实现,没有依赖其它任何的组件,后端完全使用Java实现,由于用了SpringBoot,非常容易部署。

    但是,我们还可以对这个项目进行扩展,比如新增上传或下载文件,就像Xftp一样,可以很方便地拖拽式上传下载文件。

    这个项目之后我会持续更新,上述功能也会慢慢实现,Github:https://github.com/NoCortY/WebSSH

    喜欢可以给个Star哦~

    END

    Java面试题专栏

    【41期】盘点那些必问的数据结构算法题之链表

    【42期】盘点那些必问的数据结构算法题之二叉堆

    【43期】盘点那些必问的数据结构算法题之二叉树基础

    【44期】盘点那些必问的数据结构算法题之二分查找算法

    【45期】盘点那些必问的数据结构算法题之基础排序

    【46期】盘点那些必问的数据结构算法题之快速排序

    【47期】六大类二叉树面试题汇总解答

    【48期】盘点Netty面试常问考点:什么是 Netty 的零拷贝?

    【49期】面试官:SpringMVC的控制器是单例的吗?

    【50期】基础考察:ClassNotFoundException 和 NoClassDefFoundError 有什么区别

    展开全文
  • 就像是我们平常再用SecureCRT或者XShell连接服务器时一样。 下面是官网上的入门案例: 最终测试,页面就是下面这个样子: xterm入门 可以看到页面已经出现了类似与shell的样式,那就根据这个继续深入,实现一个web...

    前言

    最近由于项目需求,项目中需要实现一个WebSSH连接终端的功能,由于自己第一次做这类型功能,所以首先上了GitHub找了找有没有现成的轮子可以拿来直接用,当时看到了很多这方面的项目,例如:GateOne、webssh、shellinabox等,这些项目都可以很好地实现webssh的功能。

    但是最终并没有采用,原因是在于这些底层大都是python写的,需要依赖很多文件,自己用的时候可以使用这种方案,快捷省事,但是做到项目中供用户使用时,总不能要求用户做到服务器中必须包含这些底层依赖,这显然不太合理,所以我决定自己动手写一个WebSSH的功能,并且作为一个独立的项目开源出来。

    github项目开源地址:https://github.com/NoCortY/WebSSH

    技术选型

    由于webssh需要实时数据交互,所以会选用长连接的WebSocket,为了开发的方便,框架选用SpringBoot,另外还自己了解了Java用户连接ssh的jsch和实现前端shell页面的xterm.js.

    所以,最终的技术选型就是 SpringBoot+Websocket+jsch+xterm.js

    导入依赖

    <parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>2.1.7.RELEASE</version>
        <relativePath /> <!-- lookup parent from repository -->
    </parent>
    <dependencies>
        <!-- Web相关 -->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>
        <!-- jsch支持 -->
        <dependency>
            <groupId>com.jcraft</groupId>
            <artifactId>jsch</artifactId>
            <version>0.1.54</version>
        </dependency>
        <!-- WebSocket 支持 -->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-websocket</artifactId>
        </dependency>
        <!-- 文件上传解析器 -->
        <dependency>
            <groupId>commons-io</groupId>
            <artifactId>commons-io</artifactId>
            <version>1.4</version>
        </dependency>
        <dependency>
            <groupId>commons-fileupload</groupId>
            <artifactId>commons-fileupload</artifactId>
            <version>1.3.1</version>
        </dependency>
    </dependencies>
    

    一个简单的xterm案例

    由于xterm是一个冷门技术,所以很多同学并没有这方面的知识支撑,我也是为了实现这个功能所以临时学的,所以在这给大家介绍一下。

    xterm.js是一个基于WebSocket的容器,它可以帮助我们在前端实现命令行的样式。就像是我们平常再用SecureCRT或者XShell连接服务器时一样。

    下面是官网上的入门案例:

    <!doctype html>
     <html>
      <head>
        <link rel="stylesheet" href="node_modules/xterm/css/xterm.css" />
        <script src="node_modules/xterm/lib/xterm.js"></script>
      </head>
      <body>
        <div id="terminal"></div>
        <script>
          var term = new Terminal();
          term.open(document.getElementById('terminal'));
          term.write('Hello from \x1B[1;3;31mxterm.js\x1B[0m $ ')
        </script>
      </body>
     </html>
    

    最终测试,页面就是下面这个样子:

    xterm入门

    可以看到页面已经出现了类似与shell的样式,那就根据这个继续深入,实现一个webssh。

    后端实现

    由于xterm只要只是实现了前端的样式,并不能真正地实现与服务器交互,与服务器交互主要还是靠我们Java后端来进行控制的,所以我们从后端开始,使用jsch+websocket实现这部分内容。

    WebSocket配置

    由于消息实时推送到前端需要用到WebSocket,不了解WebSocket的同学可以先去自行了解一下,这里就不过多介绍了,我们直接开始进行WebSocket的配置。

      /**
      * @Description: websocket配置
      * @Author: NoCortY
      * @Date: 2020/3/8
      */
      @Configuration
      @EnableWebSocket
      public class WebSSHWebSocketConfig implements WebSocketConfigurer{
          @Autowired
          WebSSHWebSocketHandler webSSHWebSocketHandler;
          @Override
          public void registerWebSocketHandlers(WebSocketHandlerRegistry webSocketHandlerRegistry) {
              //socket通道
              //指定处理器和路径,并设置跨域
              webSocketHandlerRegistry.addHandler(webSSHWebSocketHandler, "/webssh")
                      .addInterceptors(new WebSocketInterceptor())
                      .setAllowedOrigins("*");
          }
      }
    

    处理器(Handler)和拦截器(Interceptor)的实现

    刚才我们完成了WebSocket的配置,并指定了一个处理器和拦截器。所以接下来就是处理器和拦截器的实现。

    拦截器

      public class WebSocketInterceptor implements HandshakeInterceptor {
          /**
           * @Description: Handler处理前调用
           * @Param: [serverHttpRequest, serverHttpResponse, webSocketHandler, map]
           * @return: boolean
           * @Author: NoCortY
           * @Date: 2020/3/1
           */
          @Override
          public boolean beforeHandshake(ServerHttpRequest serverHttpRequest, ServerHttpResponse serverHttpResponse, WebSocketHandler webSocketHandler, Map<String, Object> map) throws Exception {
              if (serverHttpRequest instanceof ServletServerHttpRequest) {
                  ServletServerHttpRequest request = (ServletServerHttpRequest) serverHttpRequest;
                  //生成一个UUID,这里由于是独立的项目,没有用户模块,所以可以用随机的UUID
                  //但是如果要集成到自己的项目中,需要将其改为自己识别用户的标识
                  String uuid = UUID.randomUUID().toString().replace("-","");
                  //将uuid放到websocketsession中
                  map.put(ConstantPool.USER_UUID_KEY, uuid);
                  return true;
              } else {
                  return false;
              }
          }
    
          @Override
          public void afterHandshake(ServerHttpRequest serverHttpRequest, ServerHttpResponse serverHttpResponse, WebSocketHandler webSocketHandler, Exception e) {
    
          }
      }
    

    处理器

      /**
      * @Description: WebSSH的WebSocket处理器
      * @Author: NoCortY
      * @Date: 2020/3/8
      */
      @Component
      public class WebSSHWebSocketHandler implements WebSocketHandler{
          @Autowired
          private WebSSHService webSSHService;
          private Logger logger = LoggerFactory.getLogger(WebSSHWebSocketHandler.class);
    
          /**
           * @Description: 用户连接上WebSocket的回调
           * @Param: [webSocketSession]
           * @return: void
           * @Author: Object
           * @Date: 2020/3/8
           */
          @Override
          public void afterConnectionEstablished(WebSocketSession webSocketSession) throws Exception {
              logger.info("用户:{},连接WebSSH", webSocketSession.getAttributes().get(ConstantPool.USER_UUID_KEY));
              //调用初始化连接
              webSSHService.initConnection(webSocketSession);
          }
    
          /**
           * @Description: 收到消息的回调
           * @Param: [webSocketSession, webSocketMessage]
           * @return: void
           * @Author: NoCortY
           * @Date: 2020/3/8
           */
          @Override
          public void handleMessage(WebSocketSession webSocketSession, WebSocketMessage<?> webSocketMessage) throws Exception {
              if (webSocketMessage instanceof TextMessage) {
                  logger.info("用户:{},发送命令:{}", webSocketSession.getAttributes().get(ConstantPool.USER_UUID_KEY), webSocketMessage.toString());
                  //调用service接收消息
                  webSSHService.recvHandle(((TextMessage) webSocketMessage).getPayload(), webSocketSession);
              } else if (webSocketMessage instanceof BinaryMessage) {
    
              } else if (webSocketMessage instanceof PongMessage) {
    
              } else {
                  System.out.println("Unexpected WebSocket message type: " + webSocketMessage);
              }
          }
    
          /**
           * @Description: 出现错误的回调
           * @Param: [webSocketSession, throwable]
           * @return: void
           * @Author: Object
           * @Date: 2020/3/8
           */
          @Override
          public void handleTransportError(WebSocketSession webSocketSession, Throwable throwable) throws Exception {
              logger.error("数据传输错误");
          }
    
          /**
           * @Description: 连接关闭的回调
           * @Param: [webSocketSession, closeStatus]
           * @return: void
           * @Author: NoCortY
           * @Date: 2020/3/8
           */
          @Override
          public void afterConnectionClosed(WebSocketSession webSocketSession, CloseStatus closeStatus) throws Exception {
              logger.info("用户:{}断开webssh连接", String.valueOf(webSocketSession.getAttributes().get(ConstantPool.USER_UUID_KEY)));
              //调用service关闭连接
              webSSHService.close(webSocketSession);
          }
    
          @Override
          public boolean supportsPartialMessages() {
              return false;
          }
      }
    

    需要注意的是,我在拦截器中加入的用户标识是使用了随机的UUID,这是因为作为一个独立的websocket项目,没有用户模块,如果需要将这个项目集成到自己的项目中,需要修改这部分代码,将其改为自己项目中识别一个用户所用的用户标识。

    WebSSH的业务逻辑实现(核心)

    刚才我们实现了websocket的配置,都是一些死代码,实现了接口再根据自身需求即可实现,现在我们将进行后端主要业务逻辑的实现,在实现这个逻辑之前,我们先来想想,WebSSH,我们主要想要呈现一个什么效果。

    我这里做了一个总结:

    1.首先我们得先连接上终端(初始化连接)

    2.其次我们的服务端需要处理来自前端的消息(接收并处理前端消息)

    3.我们需要将终端返回的消息回写到前端(数据回写前端)

    4.关闭连接

    根据这四个需求,我们先定义一个接口,这样可以让需求明了起来。

      /**
       * @Description: WebSSH的业务逻辑
       * @Author: NoCortY
       * @Date: 2020/3/7
       */
      public interface WebSSHService {
          /**
           * @Description: 初始化ssh连接
           * @Param:
           * @return:
           * @Author: NoCortY
           * @Date: 2020/3/7
           */
          public void initConnection(WebSocketSession session);
    
          /**
           * @Description: 处理客户段发的数据
           * @Param:
           * @return:
           * @Author: NoCortY
           * @Date: 2020/3/7
           */
          public void recvHandle(String buffer, WebSocketSession session);
    
          /**
           * @Description: 数据写回前端 for websocket
           * @Param:
           * @return:
           * @Author: NoCortY
           * @Date: 2020/3/7
           */
          public void sendMessage(WebSocketSession session, byte[] buffer) throws IOException;
    
          /**
           * @Description: 关闭连接
           * @Param:
           * @return:
           * @Author: NoCortY
           * @Date: 2020/3/7
           */
          public void close(WebSocketSession session);
      }
    

    现在我们可以根据这个接口去实现我们定义的功能了。

    1.初始化连接

    由于我们的底层是依赖jsch实现的,所以这里是需要使用jsch去建立连接的。而所谓初始化连接,实际上就是将我们所需要的连接信息,保存在一个Map中,这里并不进行任何的真实连接操作。为什么这里不直接进行连接?因为这里前端只是连接上了WebSocket,但是我们还需要前端给我们发来linux终端的用户名和密码,没有这些信息,我们是无法进行连接的。

         public void initConnection(WebSocketSession session) {
                 JSch jSch = new JSch();
                 SSHConnectInfo sshConnectInfo = new SSHConnectInfo();
                 sshConnectInfo.setjSch(jSch);
                 sshConnectInfo.setWebSocketSession(session);
                 String uuid = String.valueOf(session.getAttributes().get(ConstantPool.USER_UUID_KEY));
                 //将这个ssh连接信息放入map中
                 sshMap.put(uuid, sshConnectInfo);
         }
    

    2.处理客户端发送的数据

    在这一步骤中,我们会分为两个分支。

    • 第一个分支:如果客户端发来的是终端的用户名和密码等信息,那么我们进行终端的连接。

    • 第二个分支:如果客户端发来的是操作终端的命令,那么我们就直接转发到终端并且获取终端的执行结果。

    具体代码实现:

         public void recvHandle(String buffer, WebSocketSession session) {
                 ObjectMapper objectMapper = new ObjectMapper();
                 WebSSHData webSSHData = null;
                 try {
                     //转换前端发送的JSON
                     webSSHData = objectMapper.readValue(buffer, WebSSHData.class);
                 } catch (IOException e) {
                     logger.error("Json转换异常");
                     logger.error("异常信息:{}", e.getMessage());
                     return;
                 }
             //获取刚才设置的随机的uuid
                 String userId = String.valueOf(session.getAttributes().get(ConstantPool.USER_UUID_KEY));
                 if (ConstantPool.WEBSSH_OPERATE_CONNECT.equals(webSSHData.getOperate())) {
                     //如果是连接请求
                     //找到刚才存储的ssh连接对象
                     SSHConnectInfo sshConnectInfo = (SSHConnectInfo) sshMap.get(userId);
                     //启动线程异步处理
                     WebSSHData finalWebSSHData = webSSHData;
                     executorService.execute(new Runnable() {
                         @Override
                         public void run() {
                             try {
                                 //连接到终端
                                 connectToSSH(sshConnectInfo, finalWebSSHData, session);
                             } catch (JSchException | IOException e) {
                                 logger.error("webssh连接异常");
                                 logger.error("异常信息:{}", e.getMessage());
                                 close(session);
                             }
                         }
                     });
                 } else if (ConstantPool.WEBSSH_OPERATE_COMMAND.equals(webSSHData.getOperate())) {
                     //如果是发送命令的请求
                     String command = webSSHData.getCommand();
                     SSHConnectInfo sshConnectInfo = (SSHConnectInfo) sshMap.get(userId);
                     if (sshConnectInfo != null) {
                         try {
                             //发送命令到终端
                             transToSSH(sshConnectInfo.getChannel(), command);
                         } catch (IOException e) {
                             logger.error("webssh连接异常");
                             logger.error("异常信息:{}", e.getMessage());
                             close(session);
                         }
                     }
                 } else {
                     logger.error("不支持的操作");
                     close(session);
                 }
         }
    

    3.数据通过websocket发送到前端

         public void sendMessage(WebSocketSession session, byte[] buffer) throws IOException {
                 session.sendMessage(new TextMessage(buffer));
         }
    

    4.关闭连接

         public void close(WebSocketSession session) {
             //获取随机生成的uuid
                 String userId = String.valueOf(session.getAttributes().get(ConstantPool.USER_UUID_KEY));
                 SSHConnectInfo sshConnectInfo = (SSHConnectInfo) sshMap.get(userId);
                 if (sshConnectInfo != null) {
                     //断开连接
                     if (sshConnectInfo.getChannel() != null) sshConnectInfo.getChannel().disconnect();
                     //map中移除该ssh连接信息
                     sshMap.remove(userId);
                 }
         }
    

    至此,我们的整个后端实现就结束了,由于篇幅有限,这里将一些操作封装成了方法,就不做过多展示了,重点讲逻辑实现的思路吧。接下来我们将进行前端的实现。

    前端实现

    前端工作主要分为这么几个步骤:

    1. 页面的实现

    2. 连接WebSocket并完成数据的接收并回写

    3. 数据的发送

    所以我们一步一步来实现它。

    页面实现

    页面的实现很简单,我们只不过需要在一整个屏幕上都显示终端那种大黑屏幕,所以我们并不用写什么样式,只需要创建一个div,之后将terminal实例通过xterm放到这个div中,就可以实现了。

      <!doctype html>
      <html>
      <head>
          <title>WebSSH</title>
          <link rel="stylesheet" href="../css/xterm.css" />
      </head>
      <body>
      <div id="terminal" style="width: 100%;height: 100%"></div>
    
      <script src="../lib/jquery-3.4.1/jquery-3.4.1.min.js"></script>
      <script src="../js/xterm.js" charset="utf-8"></script>
      <script src="../js/webssh.js" charset="utf-8"></script>
      <script src="../js/base64.js" charset="utf-8"></script>
      </body>
      </html>
    

    连接WebSocket并完成数据的发送、接收、回写

      openTerminal( {
          //这里的内容可以写死,但是要整合到项目中时,需要通过参数的方式传入,可以动态连接某个终端。
              operate:'connect',
              host: 'ip地址',
              port: '端口号',
              username: '用户名',
              password: '密码'
          });
          function openTerminal(options){
              var client = new WSSHClient();
              var term = new Terminal({
                  cols: 97,
                  rows: 37,
                  cursorBlink: true, // 光标闪烁
                  cursorStyle: "block", // 光标样式  null | 'block' | 'underline' | 'bar'
                  scrollback: 800, //回滚
                  tabStopWidth: 8, //制表宽度
                  screenKeys: true
              });
    
              term.on('data', function (data) {
                  //键盘输入时的回调函数
                  client.sendClientData(data);
              });
              term.open(document.getElementById('terminal'));
              //在页面上显示连接中...
              term.write('Connecting...');
              //执行连接操作
              client.connect({
                  onError: function (error) {
                      //连接失败回调
                      term.write('Error: ' + error + '\r\n');
                  },
                  onConnect: function () {
                      //连接成功回调
                      client.sendInitData(options);
                  },
                  onClose: function () {
                      //连接关闭回调
                      term.write("\rconnection closed");
                  },
                  onData: function (data) {
                      //收到数据时回调
                      term.write(data);
                  }
              });
          }
    

    效果展示

    连接

    连接

    连接成功

    连接成功

    命令操作

    ls命令:

    ls命令

    vim编辑器:

    vim编辑器

    top命令:

    top命令

    结语

    这样我们就完成了一个webssh项目的实现,没有依赖其它任何的组件,后端完全使用Java实现,由于用了SpringBoot,非常容易部署。

    但是,我们还可以对这个项目进行扩展,比如新增上传或下载文件,就像Xftp一样,可以很方便地拖拽式上传下载文件。

    这个项目之后我会持续更新,上述功能也会慢慢实现,Github:https://github.com/NoCortY/WebSSH

    喜欢可以给个Star哦~

    展开全文
  • 就像是我们平常再用SecureCRT或者XShell连接服务器时一样。 下面是官网上的入门案例: html> var term = new Terminal(); term.open(document.getElementById('terminal')); term.write('Hello from x1B[1;3;...
  • 就像是我们平常再用SecureCRT或者XShell连接服务器时一样。 下面是官网上的入门案例: 最终测试,页面就是下面这个样子: xterm入门 可以看到页面已经出现了类似与shell的样式,那就根据这个继续深入,实现一个web...
  • 就像是我们平常再用SecureCRT或者XShell连接服务器时一样。 下面是官网上的入门案例: 最终测试,页面就是下面这个样子: xterm入门 可以看到页面已经出现了类似与shell的样式,那就根据这个继续深入,实现一个web...
  • 就像是我们平常再用SecureCRT或者XShell连接服务器时一样。 下面是官网上的入门案例: <html><head> rel="stylesheet" href="node_modules/xterm/css/xterm.css" /> src="node_modules/xterm/lib/xterm.js">...
  • 就像是我们平常再用SecureCRT或者XShell连接服务器时一样。 下面是官网上的入门案例: html>  <html> <head>  rel="stylesheet" href="node_modules/xterm/css/xterm.css" />  src="node_modules/xterm/lib/...
  • 就像是我们平常再用SecureCRT或者XShell连接服务器时一样。 下面是官网上的入门案例: html> 最终测试,页面就是下面这个样子: xterm入门 可以看到页面已经出现了类似与shell的样式,那就根据这个继续深入,实现一...
  • 拉到网页最底部,点击家庭/学校免费 填入信息,点击下载即可 进入邮箱,点击下载地址即可下载,等待下载成功即可 下载成功 双击 下一步 等待安装 完成 即可使用咯 开心 (#^.^#) ...
  • 就像是我们平常再用SecureCRT或者XShell连接服务器时一样。 下面是官网上的入门案例: <html><head> rel="stylesheet" href="node_modules/xterm/css/xterm.css" /> src="node_modules/xterm/lib/xterm.js">...
  • Xshell下载_官网 1、本人用谷歌浏览器,网页主动翻译成中文了。 首先选择把鼠标箭头移动到“所有下载”,选中“家庭/学校免费”点进去。 2、继第一步之后,把页面拉到下面,填写一下姓名(这个随便填)、邮箱(填写...
  • 阿里云的xshell连接,端口配置

    千次阅读 2018-11-18 14:38:58
    文章目录进入管理控制台修改远程连接的密码用xshell 远程连接mysql 的远程连接安全组的配置网页版的远程连接 进入管理控制台 选择你的一个服务器 点击后可看到该服务器的ip , 连接为公网ip 点击上图中的蓝色链接后...
  • 其实现在云服务器网页版控制台可以登录,但是这里推荐使用本地端工具进行远程登录,有时候告诉你太多东西,反而让你更加困惑。xshell远程登录登录的工具有很多,windows用户推荐使用xshell工具,至于如何获取,自己...
  • 金猪脚本(原飞猪脚本)以按键精灵教学为主,涉及UiBot,Python,Lua等脚本编程语言,教学包括全自动办公脚本,游戏辅助脚本,引流脚本,网页脚本,安卓脚本,IOS脚本,注册脚本,点赞脚本,阅读脚本以及网赚脚本等各个领域。...
  • 半年前就买了云服务器,今天想更新网页,发现完全忘了怎么上传文件到服务器,又因为中间重装了几次系统,也不记得用什么工具上传到服务器。还是记录一下吧~ 首先是下载Xshell。这一部比较简单,找到官网的下载界面...
  • 1.4.1 使用PuTTY远程连接Linux下载putty客户端,可以直接访问https://www.chiark.greenend.org.uk/~sgtatham/putty/latest.html这个链接进行下载选择网页的 Package files 下面的 MSI('Windows Installer') 根据...
  • webssh的安装与使用

    万次阅读 2019-06-14 11:09:02
    最近研究了一下在web端实现一个远程连接终端操作的类似网页版xshell的实现。在网上搜索了一下发现已经有类似的操作在这里主要介绍以下两种。 https://github.com/huashengdun/webssh ...
  • KODExplorer可道云是一款基于PHP开发的开源WEB网页版轻量级私有云网盘工具,是一款功能丰富的在线文件管理系统,非常适合搭建在私有的阿里云平台上,获得网盘能力。使用KODExplorer搭建的网盘配置和阿里云配置相当,...
  • @[TOC](通过root账户 和 ...谷歌提供了网页版的terminal来ssh到服务器。 先进入computer engine 目录下的VM instances 。 点击connect下的ssh,选择Open in browser windows。 然后服务器的页面就会以浏览器窗口...
  • Django+Nginx+uwgi 网页上线教程(真的是手把手教学) 使用内容的版本: Python 版本 python 3.7 Django 版本 1.11.8 服务器 腾讯云 ubuntu系统) 使用的软件 Xshell 用于和服务器建立起来连接 1. 打开...
  • 1.云服务器选购 阿里云服务器 ...Xshell下载个人喜欢也推荐用第三方软件进行连接 登陆后就是这个界面了,这样表示登陆成功 3.安装jdk和Tomcat 3.1 安装jdk 首先查找jdk版本 : yum search jdk 我安装...
  • 去年华为云服务器做活动,白嫖了一个弹性云服务器,一直没有用,今天着手来配置一下,不然要过期了。一边配置一边记录流程,亲测有效哦! 首先,需要安装一个远程登陆软件Xshell,可以去官网...打开Xshell,文件-...
  • 开一个服务器,然后用ssh连上,ssh可以用本地xshell或putty连接,也可以用网页版ssh连接 先进入管理员模式,免得后面一直sudo su 输入密码 下载frp wget ...
  • 1.在网页上登录搭建好的openstack虚机(名称为op1)的dashboard界面 2.远程SSH登录op1的命令行界面 Xshell输入 ssh 192.168.xx.xx ssh 后面是你的服务器域名(需要登录一个控制节点,一个计算节点,因为...
  • 精选(推荐阅读)教你用纯Java实现一个网页版Xshell(附源码)感觉Swagger功能不够强大?knife4j这款神器了解一下....Java项目构建基础:统一结果,统一异常,统...

空空如也

空空如也

1 2 3 4
收藏数 68
精华内容 27
关键字:

网页版xshell