精华内容
下载资源
问答
  • java实现Telnet连接

    千次阅读 2019-07-23 10:13:55
    Telnet协议是TCP/IP协议族中的一员,是Internet远程登陆服务的标准协议和...远程登录是指用户使用Telnet命令,使自己的计算机暂时成为远程主机的一个仿真终端的过程。仿真终端等效于一个非智能的机器,它只负责...

    转载自:https://www.cnblogs.com/visoncheng/p/3665194.html

     

    Telnet协议是TCP/IP协议族中的一员,是Internet远程登陆服务的标准协议和主要方式。它为用户提供了在本地计算机上完成远程主机工作的能力。

    远程登录是指用户使用Telnet命令,使自己的计算机暂时成为远程主机的一个仿真终端的过程。仿真终端等效于一个非智能的机器,它只负责把用户输入的每个字符传递给主机,再将主机输出的每个信息回显在屏幕上。

     

    TelnetClient是commons-net-3.3.jar下的一个类,用于实现telnet连接。

    下面是用Java代码实现Telnet到windows Telnet Server,

    如何打开windows Telnet Server和设置账号详见:http://www.cnblogs.com/visoncheng/p/3665214.html

    Java 实现telnet连接代码实现(连接windows Telnet Server):

    package com.core;
    
    import java.io.IOException;
    import java.io.InputStream;
    import java.io.PrintStream;
    import java.net.SocketException;
    
    import org.apache.commons.net.telnet.TelnetClient;
    
    public class Main {
    
        public static void main(String[] args) {
            try {
                TelnetClient telnetClient = new TelnetClient("vt200");  //指明Telnet终端类型,否则会返回来的数据中文会乱码
                telnetClient.setDefaultTimeout(5000); //socket延迟时间:5000ms
                telnetClient.connect("127.0.0.1",23);  //建立一个连接,默认端口是23
                InputStream inputStream = telnetClient.getInputStream(); //读取命令的流
                PrintStream pStream = new PrintStream(telnetClient.getOutputStream());  //写命令的流
                byte[] b = new byte[1024];
                int size;
                StringBuffer sBuffer = new StringBuffer(300);
                while(true) {     //读取Server返回来的数据,直到读到登陆标识,这个时候认为可以输入用户名
                    size = inputStream.read(b);
                    if(-1 != size) {
                        sBuffer.append(new String(b,0,size));
                        if(sBuffer.toString().trim().endsWith("login:")) {
                            break;
                        }
                    }
                }
                System.out.println(sBuffer.toString());
                pStream.println("exit"); //写命令
                pStream.flush(); //将命令发送到telnet Server
                if(null != pStream) {
                    pStream.close();
                }
                telnetClient.disconnect();
            } catch (SocketException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            } catch (IOException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            }
        }
    }

     

     

    TelnetClient实际是通过socket实现的。

    通过InputStream读取服务器返回的数据,自己根据数据判断什么时候可以命令。

    通过OutputStream向服务器发送命令,由于每次写完命令后,需要写入一个换行符,所以使用printStream会省事点(println方法写入命令后自动加入换行符)。

     在不清楚命令返回结果时,可以使用windows telnet连接到设备,输入命令,观察结果,程序根据结果去修改就ok。

    TelnetClient实际上是模仿一个Telnet客户端,命令输入和获取和客户端输入命令返回结果是一样的。

    展开全文
  • Java源码下载 1个目标文件 摘要:Java源码,网络相关,HTTP   Java实现HTTP连接与浏览,Java源码下载,输入html文件地址或网址,显示页面和HTML源文件,一步步的实现过程请下载本实例的Java源码,代码中包括丰富的...
  • 远程登录是指用户使用Telnet命令,使自己的计算机暂时成为远程主机的一个仿真终端的过程。仿真终端等效于一个非智能的机器,它只负责把用户输入的每个字符传递给主机,再将主机输出的每个信息回显在屏幕上。 2 技术...

    1 概述

    数据流图
    在这里插入图片描述

    Telnet协议是TCP/IP协议族中的一员,是Internet远程登陆服务的标准协议和主要方式。它为用户提供了在本地计算机上完成远程主机工作的能力。远程登录是指用户使用Telnet命令,使自己的计算机暂时成为远程主机的一个仿真终端的过程。仿真终端等效于一个非智能的机器,它只负责把用户输入的每个字符传递给主机,再将主机输出的每个信息回显在屏幕上。

    2 技术实现

    采用Java语言,其中使用Apache Commons Net,TelnetClient是commons-net-3.6.jar(根据自己情况下载)下的一个类,用于实现telnet连接。所需的jar包下载地址:http://commons.apache.org/proper/commons-net/

    使用java连接telnet进行操作的注意

    • 1.telnet有VT100、 VT52、 VT220 、VTNT、 ANSI等协议。Demo中使用VT100。
    • 2.vt100控制码(ansi控制码)过滤的问题,可以过滤,也可以在服务设置不要。不过滤都是一些乱码。是以\033[***一个字母结尾的格式。
    • 3.中文乱码的问题。new String(old.getBytes(“ISO8859-1”),“GBK”)。
    • 4.如何判断读取到最后了。一demo中使用readUntil(),二有使用线程。
    • 5.选择telnet的java包问题,包有很多,比如appache(commons-net-3.6.jar), ganymed(ganymed-ssh2-build210.jar),javaexpect(smart-0.1-SNAPSHOT-jar-with-dependencies.jar)。Demo中使用Apache。
    • 6.Write要flush()才发送。

    Demo实现流程图
    在这里插入图片描述

    3 技术总结

    TelnetClient实际是通过socket实现的。
    通过InputStream读取服务器返回的数据,自己根据数据判断什么时候可以命令。
    通过OutputStream向服务器发送命令,由于每次写完命令后,需要写入一个换行符,所以使用printStream会省事点(println方法写入命令后自动加入换行符)。
    在不清楚命令返回结果时,可以使用windows telnet连接到设备,输入命令,观察结果,程序根据结果去修改就ok。
    TelnetClient实际上是模仿一个Telnet客户端,命令输入和获取和客户端输入命令返回结果是一样的。

    源码实现

    package com.internet;
    
    /**
     * .Description:TODO
     * .@Author:
     * .@Date: 2020/1/9 17:11
     */
    import java.io.IOException;
    import java.io.InputStream;
    import java.io.PrintStream;
    import java.io.UnsupportedEncodingException;
    import java.net.SocketException;
    import org.apache.commons.net.telnet.TelnetClient;
    
    /**
     *
     * 使用java连接telnet进行操作的注意
     1.telnet有VT100 VT52 VT220 VTNT ANSI等协议。
     我用vt100。
     2.vt100控制码(ansi控制码)过滤的问题,可以过滤,也可以在服务设置不要。
     不过滤都是一些乱码。是以\033[***一个字母结尾的格式。
     3.中文乱码的问题。
     new String(old.getBytes("ISO8859-1"),"GBK")。
     4.如何判断读取到最后了。
     一有readUntil(),二有使用线程。
     5.选择telnet的java包问题,包有很多,比如appache(commons-net-3.1.jar), ganymed(ganymed-ssh2-build210.jar),javaexpect(smart-0.1-SNAPSHOT-jar-with-dependencies.jar)
     我使用appache。javaexpect有带的vt100控制码过滤,我没有仔细研究。
     6.write要flush()才发送。
     *
     *
     * telnet操作类。使用appache的net.Telnet包,对vt100控制代码(即ansi控制码)进行简单过滤。
     *
     * @author chruan
     * @version 1.0
     */
    public class Telnet {
        Object lock = new Object();
        TelnetClient telnet = null;
        String hostname;
        int hostport = 23;
        String user;
        String password;
        private InputStream in;
        private PrintStream out;
        private static final String ORIG_CODEC = "ISO8859-1";
        private static final String TRANSLATE_CODEC = "GBK";
    
        public Telnet(String hostname, int hostport, String user, String password) throws SocketException, IOException {
            super();
            this.hostname = hostname;
            this.hostport = hostport;
            this.user = user;
            this.password = password;
            // VT100 VT52 VT220 VTNT ANSI
            telnet = new TelnetClient("VT100");
            telnet.connect(hostname, hostport);
            in = telnet.getInputStream();
            out = new PrintStream(telnet.getOutputStream());
    
            readUntil("Username:");
            write(user);
            write("\n");
            readUntil("Password:");
            write(password);
            write("\n");
        }
    
        public void readToEnd() {
            ReadThread readThread = new ReadThread();
            readThread.start();
            try {
                readThread.join();
            } catch (Exception e) {
            }
            readThread = null;
        }
    
        public void readUntil(String str) {
            char last = str.charAt(str.length() - 1);
            String[] ss;
            try {
                StringBuffer sb = new StringBuffer();
                char c;
                int code = -1;
                boolean ansiControl = false;
                boolean start = true;
                while ((code = (in.read())) != -1) {
                    c = (char) code;
                    //vt100控制码都是以\033开头的。
                    if (c == '\033') {
                        ansiControl = true;
                        int code2 = in.read();
                        char cc = (char) code2;
                        if (cc == '[' || cc == '(') {
                        }
                    }
                    if (!ansiControl) {
                        if (c == '\r') {
                            //这里是命令行中的每一句反馈
                            String olds = new String(sb.toString().getBytes(
                                    ORIG_CODEC), TRANSLATE_CODEC);
                            System.out.println(olds);
                            if (sb.lastIndexOf(str) != -1) {
                                break;
                            }
                            sb.delete(0, sb.length());
                        } else if (c == '\n'){
    
                        } else{
                            sb.append(c);
                        }
                        if (sb.lastIndexOf(str) != -1) {
                            break;
                        }
                    }
    
                    if (ansiControl) {
                        if (('a' <= c && c <= 'z') || ('A' <= c && c <= 'Z')
                                || c == '"') {
                            ansiControl = false;
                        }
                    }
                }
                System.out.println(new String(sb.toString().getBytes(ORIG_CODEC), TRANSLATE_CODEC));
            } catch (Exception e) {
                e.printStackTrace();
            }
        }
    
        /**
         * 读取分析结果
         *
         * @param pattern
         * @return
         */
        public String read(String pattern) {
            try {
                char lastChar = pattern.charAt(pattern.length() - 1);
                StringBuffer sb = new StringBuffer();
                char ch = (char) in.read();
                while (true) {
                    sb.append(ch);
                    if (ch == lastChar) {
                        if (sb.toString().endsWith(pattern)) {
                            return sb.toString().substring(sb.toString().indexOf("D"),sb.toString().length());
                        }
                    }
                    ch = (char) in.read();
                    //System.out.print(ch);
                }
            } catch (Exception e) {
                e.printStackTrace();
            }
            return null;
        }
    
    
        public void write(String s) {
            try {
                out.write(s.getBytes());
                out.flush();
                //System.out.println(s);
            } catch (Exception e) {
            }
        }
    
        /**
         * 完成之后必须关闭
         */
        public void close() {
            if (out != null) {
                out.close();
            }
            if (in != null) {
                try {
                    in.close();
                } catch (IOException e1) {
                }
            }
            if (telnet != null) {
                try {
                    telnet.disconnect();
                } catch (IOException e) {
                }
            }
        }
    
        public void doJob() {
            // restartTerminal();
            counter();
        }
        private void counter() {
            //演示在一台机器上远程登录另一台计算机
            try {
                //readUntil("Switch#");
                write("Information");
                write("\n");
                write("show others");
                write("\n");
                System.out.println("**************");
                String s = read("way");
                System.out.println("s为:\n"+s);
                System.out.println("**************");
                //write("show state");
                readToEnd();
            } catch (Exception e) {
                e.printStackTrace();
            } finally {
    
            }
        }
    
    
        public static void main(String[] args) {
            String hostname = "10.10.0.101";
            int hostport = 23;
            String user = "admin";
            String password = "admin";
            Telnet helper = null;
            try {
                helper = new Telnet(hostname, hostport, user, password);
                helper.doJob();
    
            } catch (Exception e) {
                e.printStackTrace();
            } finally {
                if (helper != null) {
                    helper.close();
                }
            }
        }
    
        /**
         * 读取主线程,负责管理子线程。防止读取时不动了,这时就抛弃读取子线程
         *
         */
        class ReadThread extends Thread {
            @Override
            public void run() {
                //只能一个读取
                synchronized (lock) {
                    SubReadThread sub = new SubReadThread();
                    sub.start();
                    int last = sub.count;
                    while (true) {
                        try {
                            Thread.sleep(100);
                        } catch (InterruptedException e) {
                        }
                        if (last == sub.count) {
                            sub.stop();
                            break;
                        } else {
                            last = sub.count;
                        }
                    }
                    String s = sub.sb.toString();
                    try {
                        System.out.println(new String(s.getBytes(ORIG_CODEC),
                                TRANSLATE_CODEC));
                    } catch (UnsupportedEncodingException e) {
                        System.out.println(s);
                    }
                    sub = null;
                }
             System.out.println("===========ReadThread end=============");
            }
        }
    
        /**
         * 读取子线程,完成实际读取
         *
         */
        class SubReadThread extends Thread {
            int count = 0;
            StringBuffer sb = new StringBuffer();
    
            public void read() {
                try {
                    char c;
                    int code = -1;
                    boolean ansiControl = false;
                    boolean start = true;
                    while ((code = (in.read())) != -1) {
                        count++;
                        c = (char) code;
                        if (c == '\033') {
                            ansiControl = true;
                            int code2 = in.read();
                            char cc = (char) code2;
                            count++;
                            if (cc == '[' || cc == '(') {
                            }
                        }
                        if (!ansiControl) {
                            if (c == '\r') {
                                String olds = new String(sb.toString().getBytes(
                                        ORIG_CODEC), TRANSLATE_CODEC);
                                System.out.println(olds);
                                sb.delete(0, sb.length());
                            } else if (c == '\n') {
                                ;
                            }else {
                                sb.append(c);
                            }
                        }
    
                        if (ansiControl) {
                            if (('a' <= c && c <= 'z') || ('A' <= c && c <= 'Z')
                                    || c == '"') {
                                ansiControl = false;
                            }
                        }
                    }
                } catch (Exception e) {
                }
            }
            @Override
            public void run() {
                read();
            }
        }
    }
    
    
    展开全文
  • 浏览器是无法和远程机器进行通信的,我们就得借助后端来帮助实现这样的一个功能需求,具体的实现逻辑是: 用户————>控制浏览器命令行界面————>发送命令到后端服务器————>后端服务器连接socket...

     

    前言

    叮当 wap.guxs.net

    这几天研究了一下如何在web页面上通过telnet 连接一个远程的机器,通过命令行进行控制,让然,B/S架构的项目,如果直接通过

    浏览器是无法和远程机器进行通信的,我们就得借助后端来帮助实现这样的一个功能需求,具体的实现逻辑是:

    用户————>控制浏览器命令行界面————>发送命令到后端服务器————>后端服务器连接socket————>推送用户的命令

    telnet Server ————>后端服务器输入流接受返回字符——————>websocket 推送到前端完成交互

     

    telnet 

    可能很多人都知道ssh,估计很少会了解到关于telnet的东西,但是又结合起来说,其实两个都是一种协议,可以远程操控,

    但是telnet 在传输过程中存在着不安全的因素,因为传输都未经过加密,而都是明文,这就在远程连接中,很容易就会被抓包,出现问题,

    但SSH 就好比是加强版的telnet ,在传输过程中的数据进行加密,进而减少了被盗取的风险。并且所有的SSH都是经过压缩的,在网络上的

    传输速率也很优秀,这样多方面优秀的情况下,自然而然的就会代替掉telnet 

     

    并不是这样说telnet 就没什么用了,也不是这样子的,我们通过搭建这样一个demo 学习的是这样的搭建过程中去了解建立连接的过程以及交互的过程

    同样的,就算改编成SSH 其实也是这样的一个过程,学习就是一个不断探索的过程

     

     

    开始

    后端的话,从Springboot 入手,快速的搭建一个web工程,我们主要用这个web工程来接受前端发送过来的命令请求。

    包括:连接、断开、发送命令等等。

    最主要的,就是采用commons-net包下面的TelnetClient

            <dependency>
                <groupId>commons-net</groupId>
                <artifactId>commons-net</artifactId>
                <version>3.6</version>
            </dependency>

    就好比我们的交换机作为一个Telnet的服务端,而我们的本机就作为一个Telnet的客户端,客户端发起请求,服务端相应,与B/S其实一样的

    这里我就摘一些关键的部分来进行讲解,其他的请clone 项目进行查看

     

    创建一个telnet 客户端

    其实创建一个telnet 客户端是很简单的,就只需要new一个对象,而后填写ip地址和端口,端口默认是23,可以不写,就打开了一个telnet的Connection

            telnetClient = new TelnetClient();
            telnetClient.connect(ip,port);
    
            inputStream = telnetClient.getInputStream();
            outputStream = telnetClient.getOutputStream();

    从客户端得到两个流,一个输入流,一个输出流,这里就会涉及到JAVA关于IO相关的知识,当然网络上一般通行都是采用字节流

    inputStream 输入流 outputStread 输出流

    对于输入流和输出流相对于模糊的小伙伴,这里给大家加深一下理解,从字面意思上理解

    输入流:就是输进来的

    输出流:就是丢出去的

    其实这样理解的话,丢失了一个基于的对象。那就是,到底是基于客户端还是服务端呢,我这里简单的画个图

    就好比你的程序要读取一个文件,这个时候就需要用到输入流,输入流提供一个read的方法

    我得把日志信息写入到日志文件里,这个时候就需要用到输出流,输出流提供一个write() 方法

    输出流有一个flush() 强制刷新的方法 强制清空和写入

    一个好的习惯,流用完之后要进行关闭!!!!!

     

    在当前的环境里面,输入流就好比是客户端给我们返回的数据,而输出流才是我们推送命令的

     

    输入命令

    切记在命令后加入一个换行符,这就好比我们在telnet 客户端上面操作的时候,写完一句就需要敲一个回车,一样的道理。

    通过输出流的write 方法写入到输出流里面,flush将输出流清空和强制写入命令。

        public String sendCommand(String send) throws IOException {
    
            //加入换行符
             send = send + "\n";
    
            if (null == telnetClient) {
                return "连接已关闭";
            }
            outputStream.write(send.getBytes());
            outputStream.flush();
    
            return "发送成功";
        }

     

    读取服务端的返回

    上面已经反复叙述过了,服务端的返回我们需要采用输入流进行接收,同样的,需要从流里面读取出我们需要的字节,并将其转换为字符

    通过webSocket 推送到前台进行展示

    这时候就需要起一个线程来操作了,因为你不知道什么时候回接收到推送的消息,所以这个线程还不能停掉,得设置为后台线程,让它在开启连接后一直

    在后台保持活动状态,这里就需要了解一下:守护线程

     

    守护线程 、后台线程

    通过给一个线程设置setDaemon(true) 的形式标记这个线程为守护线程,也就是后台线程,线程启动前必须启动这个线程

    对于停止这个线程的方法嘛 那就是执行中断,在这个线程的逻辑代码中判断是否中断,中断则跳出这个线程,线程执行完毕

    这个线程也就停掉了呗!

     

     

     通过new 一个线程类,主要看一下这个类的实现方法

    outputThread = new InputPrintThread(inputStream);
    
            //守护线程
            outputThread.setDaemon(true);
            outputThread.start();

    通过一个while 循环的方式时刻执行是否中断的方法和 对输入流进行读取,因为读取在读取不到字节的时候会发生阻塞,所以这样是很有必要的

    因为在读取不到的时候,会阻塞这个线程,若读取流在文件末尾,则会返回-1 我们只需要判断不是-1继续读取就好了

     

    注意:这里说的是:读取出一些字节,并不是所有的字节,一次返回过来的字节它可能会读取多次,所以不能只循环一次就判断这个就完了

    @Override
        public void run() {
    
            int num = 0;
            //字节缓冲
            char[] bytes = new char[1024];
            InputStreamReader inputStreamReader = new InputStreamReader(inputStream);
            try {
                //这里会发生阻塞,通过websocket推送进行
                while (!interrupted() && (num = inputStreamReader.read(bytes)) != -1) {
    
                    for (int i = 0; i < num; i++) {
                        char ab = bytes[i];
                        WebSocketServer.sendInfo(ab + "", SocketIdEnum.TELNET.getValue());
                    }
                }
            } catch (IOException e) {
                e.printStackTrace();
            }
        }

     

    webSocket 推送

    这一部分对于Springboot 来说整合WebSocket 简直是太简单了,一个POM依赖以及简单的几行配置即可开启

            <dependency>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-starter-websocket</artifactId>
            </dependency>

    这里我就不细说了:我的内容也是参考这一篇文章:请参阅

    https://blog.csdn.net/moshowgame/article/details/80275084

     

    telnet 客户端的配置

    在windows 里面开启telnet 基本步骤:搜索windows功能

     

     

    找到并开始这一项即可,即可在命令行里面通过telnet + ip 进行远程访问,

     

    telnet 测试服务端

    很多小伙伴在昨晚后,不知如何去测试telnet的连通性以及代码的测试,缺少一个测试的环境

    手头又没有其他闲置的电脑或者是交换机,可以参考手头建立一个虚拟机的方式,这样也行,或者就

    采用华为的ENSP 创建一个虚拟的交换机后,通过自己电脑的虚拟网卡接入到虚拟交换机,这样其实也是可以通过telnet

    进行访问的,ENSP的安装这里略过,这里给一个链接:https://share.weiyun.com/5kmSEYr

     

    而后新建一个交换机通过虚拟网卡的映射进行连接后,通过本机PING 这台交换机的IP 若ping通则证明连接正常

     

     

    若不清楚配置交换机的telnet 可以参阅:https://www.cnblogs.com/pipci/p/8075686.html

    划分vlan 这些基础我就不细说了,自行参考

     

    测试效果

    对与一个写后台的人来说:前台这样子其实已经很不错了 

    哈哈 只能简单的写个窗口,然后将后台推送的内容push到页面上 

    因为是一个小的测试demo 有兴趣的可以进行改造升级更好的CSS美化

    小结

    关于研究这个web版本的telnet 其实还是涉及到很多东西,比如又再一次的学习到了流的概念以及

    之前从未知道这个输入流还会存在阻塞的问题 以及如何优雅的关闭流以及flush 强制刷新写入等诸多的问题

    虽然SSH已经是远程当中的主流,telnet 也未必没得用,总结一下总是好的。

     

    参考

    交换机telnet配置 https://www.cnblogs.com/pipci/p/8075686.html

    springboot 配置websocket https://www.cnblogs.com/pipci/p/8075686.html

     

    代码开源

    https://gitee.com/mrc1999/web-telnet

    展开全文
  • java调用Telnet

    千次阅读 2016-04-04 23:42:58
    //老师要求用java模拟手动的Telnet过程。 具体要求: 在Linux下搭建Telnet-server。在客户端Telnet连接成功后,服务器会有输出,客户端读取以后,发送用户名和口令,然后会登录到Linux服务器上。 环境:用CentOS ...

    //老师要求用java模拟手动的Telnet过程。

    具体要求:

    在Linux下搭建Telnet-server。在客户端Telnet连接成功后,服务器会有输出,客户端读取以后,发送用户名和口令,然后会登录到Linux服务器上。

    环境:用CentOS 7 64位机器搭建的Telnet,在Win10 64位机器上搭建的Telnet-client。

    实现思路:

    用apache提供的commons-net-3.4.jar,对Telnet实现java调用。实例化Telnet类后,向目标IP发起请求,请求成功后进入Telnet界面,由于客户端是搭建在Win10上,因此DOS命令下时以>这个符号作为每次命令执行结束的标识符号,而由于服务端在Centos7上,其shell命令是$作为结束符号,因此用$作为命令执行完成后的结束符号,若是Ubuntu则是#。在Telnet登录界面,服务器端返回的字符含Login:,读取该字符串后,写入用户名,然后再读取Password:,再写入密码,此时的写入条件看Telnet服务器成功后返回的登录字符串是怎样一种形式。若登录成功,则进入CentOS,此时应注意将命令执行结束的标记符号修改为$,然后即可向服务端发起需要的命令。若登录失败,则服务端会返回login incorrect,以返回的字符串作为条件判断登录失败。

    大概的思路就是如此。获得Telnet对象,向服务器发请求,获得服务器返回的字符串,从字符串解析需要的目标字符串是否存在。

    多想想机器是怎么工作的,模拟的过程。

    //第一次编辑 20min

    展开全文
  • 前言:前一篇博客已经介绍了如何利用Java提供ServerSocket类搭建本地服务器并实现简单的消息首发。现在呢主要来考虑一下登陆注册以及实现私聊这些功能,上一篇博客我们已经实现允许多个人同时登陆服务器来,由于笔者...
  • 利用TelnetClient后台登陆远程计算机,发送相关指令让远程计算机执行。
  • JAVA上百实例源码以及开源项目

    千次下载 热门讨论 2016-01-03 17:37:40
     Java实现HTTP连接与浏览,Java源码下载,输入html文件地址或网址,显示页面和HTML源文件,一步步的实现过程请下载本实例的Java源码,代码中包括丰富的注释,对学习有帮助。 Java实现的FTP连接与数据浏览程序 1个...
  • TelnetJava实现

    万次阅读 热门讨论 2014-08-11 21:10:52
    1.1 Telnet交互过程 1)本地与远程主机建立连接。该过程实际上是建立一个TCP连接,用户必须知道远程主机的IP或者域名; 2)将本地连接上输入的用户名和口令及以后输入的任何命令或字符以NVT(Net Virtual Terminal...
  • 花了几天时间赶了个软件,功能是Telnet登录到一台Linux主机上,然后执行命令,将返回的信息解析后插入到Oracle数据库中(多... 首先说JavaTelnet实现。先提Apache基金会(http://projects.apache.org/index.html...
  • java telnet ssh 实现

    2014-03-05 09:43:25
    java telnet ssh 实现 2011-05-1113:17 911人阅读 评论(1) 收藏 举报  先看看telnet 和ssh的定义:  Telnet协议是TCP/IP协议中的一员,是Internet远程登陆服务的标准协议和主要方式。它为用户提供...
  • JAVA中的Ping和Telnet

    2009-11-30 22:56:00
    JAVA里的PING是在JDK 1.5后用了新的函数isreachable去实现,具体介绍如下:InetAddress对象的常用方法 InetAddress类有很多get方法,用来获取主机名,主机地址等信息。主要有:byte[] getAddress() 返回次InetAddress...
  • java telnet ssh 实现 2011-05-11 13:17 911人阅读 评论(1) 收藏 举报    先看看telnet 和ssh的定义:    Telnet协议是TCP/IP协议中的一员,是Internet远程登陆服务的标准协议和主要方式。它为用户提供了...
  • #java 聊天室(一)—— 实现一个简单Telnet多人群聊聊天室   学习本文需要先准备的知识点:队列(或数组)、类与对象、线程、InputStream和OutputStream的使用。 1.前期准备(新知识点讲解) (1)、认识...
  • FTP在传输控制命令时使用Telnet协议,因此命令会以纯字符的形式进行发送,下面我们以列表方式对命令内容进行描述: 命令码 命令 描述 USER 用户名 在建立连接时发生用户名 PASS ...
  • java源码包---java 源码 大量 实例

    千次下载 热门讨论 2013-04-18 23:15:26
     Java实现HTTP连接与浏览,Java源码下载,输入html文件地址或网址,显示页面和HTML源文件,一步步的实现过程请下载本实例的Java源码,代码中包括丰富的注释,对学习有帮助。 Java实现的FTP连接与数据浏览程序 1个...
  • JAVA实现SMTP邮件发送

    万次阅读 2018-02-11 20:27:27
    该博客主要是JAVA实现SMTP发送邮件,主要做到以下几点 1、打开talent客户端 2、掌握在cmd下邮件的发送 3、发送者邮箱开启客户端授权码 4、掌握Base64编码 5、当然还有你会敲代码的双手^_^ 一、...
  • MySQL 面试题

    万次阅读 多人点赞 2019-09-02 16:03:33
    如果使用 Java 语言时,需要使用 BigDecimal 进行对应。 ? 一张表,里面有 ID 自增主键,当 insert 了 17 条记录之后,删除了第 15,16,17 条记录,再把 MySQL 重启,再 insert 一条记录,这条记录的 ID 是 18 ...
  • Linux总结

    千次阅读 多人点赞 2020-01-14 20:36:45
    11.1、write 11.2、wall 11.3、ping 11.4、ifconfig 11.5、mail 11.6、nslookup 11.7、netstat 11.8、wget 11.9、service network restart 11.9.1、telnet 11.9.2、mount 12、关机重启命令 12.1、shutdown 12.2、...
  • SpringBoot

    万次阅读 多人点赞 2019-08-07 23:42:15
    1.5: 准生产的应用监控(基于: ssh , http , telnet 对服务器运行的项目进行监控.). 1.6: springboot无需做出xml配置,也不是通过代码生成来实现(通过条件注解.). 使用优点: 1.快速搭建项目, 2,与主流框架集成无需...
  • Java线程池原理及实现(详解)

    万次阅读 2018-08-21 17:21:55
    线程池是一种多线程处理形式,处理过程中将任务加入到队列,然后在创建线程后自己主动启动这些任务。线程池线程都是后台线程。每一个线程都使用默认的堆栈大小,以默认的优先级执行。并处于多线程单元中。 假设某个...
  • Java实现单点登录

    千次阅读 2017-02-26 21:56:42
    摘要:单点登录(SSO)的技术被越来越广泛地运用到各个领域的...从技术本身的角度分析了单点登录技术的内部机制和实现手段,并且给出Web-SSO和桌面SSO的实现、源代码和详细讲解;还从安全和性能的角度对现有的实现
  • Java网络:使用telnet

    2021-05-18 15:46:08
    打在前面:部分内容摘自《java核心技术 卷||》第11版 page181 to page221 telnet的使用 telnet是一种用于网络编程的非常强大的调试工具。 1、windows环境下启用telnet 2.telnet的简单使用 shell下输入 telnet ...
  • 3、实现客户端与服务器的通信 (1)、控制台版 先看代码: (注意:此代码可以直接复制粘贴但是需要将包名换成自己写的。) 编写服务器Socket: package test08; import java.io.DataInputStream; import ...
  • java实现ping功能的几种方法

    千次阅读 2018-01-29 11:50:51
    import java.io.BufferedReader; import java.io.IOException; import java.io.InputStreamReader; import java.net.InetAddress; import java.net.InetSocketAddress; import java.net.Socket; import java.net.Unk

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 19,827
精华内容 7,930
关键字:

java实现telnet过程

java 订阅