Java Telnet库

我真的不清楚如何解释这个需求，但我需要的基本上是一个JSP页面，它连接到Unix服务器，获取文件的字数并显示在JSP页面上。我在这里看了各种各样的问题，但没有任何帮助。一个示例代码将非常有用。谢谢

为什么不使用开源telnet客户端呢。肯定有好几个可供选择。谷歌列出了很多

卡文，我想你现在一定找到了别的解决办法或者继续前进。然而，我刚刚遇到了一个要求，这让我进入了这个页面

我浏览了本页和其他许多页面上有点自以为是的回复，但根本找不到一个简单易用的Telnet客户端

我花了一点时间，在Commons Net的解决方案之上编写了一个简单的客户端。请原谅代码中的System.out和System.err，我让它几乎无法工作

public static void main(String[] args) throws Exception {
    SimpleTelnetClient client = new SimpleTelnetClient("localhost", 2323);
    client.connect();

    String result = client.waitFor("login:");
    System.out.println("Got " + result);
    client.send("username");
    result = client.waitFor("Password:");
    System.out.println("Got " + result);
    client.send("password");
    client.waitFor("#");
    client.send("ls -al");
    result = client.waitFor("#");
    System.out.println("Got " + result);
    client.send("exit");
}

不确定它是否会对你有帮助，但也许它可以成为其他人的起点

import java.io.InputStream;
import java.io.PrintStream;
import java.util.concurrent.BlockingQueue;
import java.util.concurrent.CountDownLatch;
import java.util.concurrent.LinkedBlockingQueue;

import org.apache.commons.net.telnet.EchoOptionHandler;
import org.apache.commons.net.telnet.InvalidTelnetOptionException;
import org.apache.commons.net.telnet.SuppressGAOptionHandler;
import org.apache.commons.net.telnet.TelnetClient;
import org.apache.commons.net.telnet.TerminalTypeOptionHandler;

public class SimpleTelnetClient {
    static class Responder extends Thread {
        private StringBuilder builder = new StringBuilder();
        private final SimpleTelnetClient checker;
        private CountDownLatch latch;
        private String waitFor = null;
        private boolean isKeepRunning = true;

        Responder(SimpleTelnetClient checker) {
            this.checker = checker;
        }

        boolean foundWaitFor(String waitFor) {
            return builder.toString().contains(waitFor);
        }

        public synchronized String getAndClearBuffer() {
            String result = builder.toString();
            builder = new StringBuilder();
            return result;
        }

        @Override
        public void run() {
            while (isKeepRunning) {
                String s;

                try {
                    s = checker.messageQueue.take();
                } catch (InterruptedException e) {
                    break;
                }

                synchronized (Responder.class) {
                    builder.append(s);
                }

                if (waitFor != null && latch != null && foundWaitFor(waitFor)) {
                    latch.countDown();
                }
            }
        }

        public String waitFor(String waitFor) {
            synchronized (Responder.class) {
                if (foundWaitFor(waitFor)) {
                    return getAndClearBuffer();
                }
            }

            this.waitFor = waitFor;
            latch = new CountDownLatch(1);
            try {
                latch.await();
            } catch (InterruptedException e) {
                e.printStackTrace();
                return null;
            }

            String result = null;
            synchronized (Responder.class) {
                result = builder.toString();
                builder = new StringBuilder();
            }

            return result;
        }
    }

    static class TelnetReader extends Thread {
        private final SimpleTelnetClient checker;
        private final TelnetClient tc;

        TelnetReader(SimpleTelnetClient checker, TelnetClient tc) {
            this.checker = checker;
            this.tc = tc;
        }

        @Override
        public void run() {
            InputStream instr = tc.getInputStream();

            try {
                byte[] buff = new byte[1024];
                int ret_read = 0;

                do {
                    ret_read = instr.read(buff);
                    if (ret_read > 0) {
                        checker.sendForResponse(new String(buff, 0, ret_read));
                    }
                } while (ret_read >= 0);
            } catch (Exception e) {
                System.err.println("Exception while reading socket:" + e.getMessage());
            }

            try {
                tc.disconnect();
                checker.stop();
                System.out.println("Disconnected.");
            } catch (Exception e) {
                System.err.println("Exception while closing telnet:" + e.getMessage());
            }
        }
    }

    private String host;
    private BlockingQueue<String> messageQueue = new LinkedBlockingQueue<String>();
    private int port;
    private TelnetReader reader;
    private Responder responder;
    private TelnetClient tc;

    public SimpleTelnetClient(String host, int port) {
        this.host = host;
        this.port = port;
    }

    protected void stop() {
        responder.isKeepRunning = false;
        responder.interrupt();
    }

    public void send(String command) {
        PrintStream ps = new PrintStream(tc.getOutputStream());
        ps.println(command);
        ps.flush();
    }

    public void sendForResponse(String s) {
        messageQueue.add(s);
    }

    public void connect() throws Exception {
        tc = new TelnetClient();

        TerminalTypeOptionHandler ttopt = new TerminalTypeOptionHandler("VT100", false, false, true, false);
        EchoOptionHandler echoopt = new EchoOptionHandler(true, false, true, false);
        SuppressGAOptionHandler gaopt = new SuppressGAOptionHandler(true, true, true, true);

        try {
            tc.addOptionHandler(ttopt);
            tc.addOptionHandler(echoopt);
            tc.addOptionHandler(gaopt);
        } catch (InvalidTelnetOptionException e) {
            System.err.println("Error registering option handlers: " + e.getMessage());
        }

        tc.connect(host, port);
        reader = new TelnetReader(this, tc);
        reader.start();

        responder = new Responder(this);
        responder.start();
    }

    public String waitFor(String s) {
        return responder.waitFor(s);
    }
}

import java.io.InputStream；
导入java.io.PrintStream；
导入java.util.concurrent.BlockingQueue；
导入java.util.concurrent.CountDownLatch；
导入java.util.concurrent.LinkedBlockingQueue；
导入org.apache.commons.net.telnet.EchoOptionHandler；
导入org.apache.commons.net.telnet.InvalidTelnetOptionException；
导入org.apache.commons.net.telnet.SuppressGAOptionHandler；
导入org.apache.commons.net.telnet.TelnetClient；
导入org.apache.commons.net.telnet.TerminalTypeOptionHandler；
公共类SimpleTelnetClient{
静态类响应程序扩展线程{
私有StringBuilder=新StringBuilder（）；
专用最终SimpleTelnet客户端检查器；
私人倒计时闩锁；
私有字符串waitFor=null；
私有布尔值isKeepRunning=true；
响应程序（SimpleTelnetClient检查器）{
this.checker=checker；
}
布尔值foundWaitFor（字符串waitFor）{
返回builder.toString（）.contains（waitFor）；
}
公共同步字符串getAndClearBuffer（）{
字符串结果=builder.toString（）；
生成器=新的StringBuilder（）；
返回结果；
}
@凌驾
公开募捐{
while（正在修剪）{
字符串s；
试一试{
s=checker.messageQueue.take（）；
}捕捉（中断异常e）{
打破
}
已同步（Responder.class）{
建造商。附加；
}
if（waitFor！=null&&latch！=null&&foundWaitFor（waitFor））{
倒计时（）；
}
}
}
公共字符串waitFor（字符串waitFor）{
已同步（Responder.class）{
如果（查找等待（等待））{
返回getAndClearBuffer（）；
}
}
this.waitFor=waitFor；
闩锁=新的倒计时闩锁（1）；
试一试{
satch.wait（）；
}捕捉（中断异常e）{
e、 printStackTrace（）；
返回null；
}
字符串结果=null；
已同步（Responder.class）{
结果=builder.toString（）；
生成器=新的StringBuilder（）；
}
返回结果；
}
}
静态类TelnetReader扩展线程{
专用最终SimpleTelnet客户端检查器；
私有最终TelnetClient tc；
TelnetReader（SimpleTelnetClient检查器，TelnetClient tc）{
this.checker=checker；
this.tc=tc；
}
@凌驾
公开募捐{
InputStream instr=tc.getInputStream（）；
试一试{
字节[]buff=新字节[1024]；
int ret_read=0；
做{
ret_read=仪表读数（buff）；
如果（重新读取>0）{
checker.sendForResponse（新字符串（buff，0，ret_read））；
}
}while（ret_read>=0）；
}捕获（例外e）{
System.err.println（“读取套接字时异常：+e.getMessage（））；
}
试一试{
tc.disconnect（）；
checker.stop（）；
System.out.println（“断开连接”）；
}捕获（例外e）{
System.err.println（“关闭telnet时出现异常：+e.getMessage（））；
}
}
}
私有字符串主机；
private BlockingQueue messageQueue=新建LinkedBlockingQueue（）；
专用int端口；
私人电话网络阅读器；
私人应答器；
私有电信客户端；
公共SimpleTelnetClient（字符串主机，int端口）{
this.host=host；
this.port=端口；
}
受保护的无效停止（）{
responder.isKeepRunning=false；
响应程序中断（）；
}
公共无效发送（字符串命令）{
PrintStream ps=新的PrintStream（tc.getOutputStream（））；
ps.println（命令）；
ps.flush（）；
}
公共void sendForResponse（字符串s）{
messageQueue.add（s）；
}
public void connect（）引发异常{
tc=新的TelnetClient（）；
TerminalTypeOptionHandler ttopt=新的TerminalTypeOptionHandler（“VT100”，false，false，true，false）；
EchoOptionHandler echoopt=新EchoOptionHandler（真、假、真、假）；
SuppressGAOptionHandler gaopt=新的SuppressGAOptionHandler（真、真、真、真）；
试一试{
tc.addOptionHandler（ttopt）；
tc.addOptionHandler（echoopt）；
tc.addOptionHandler（gaopt）；
}捕获（无效TelnetOptionException e）{
System.err.println（“注册选项处理程序时出错：+e.getMessage（））；
}
tc.connect（主机、端口）；
reader=新的TelnetReader