这是一个远程连接工具，使用的是Apache commons-net.3.3，下面的代码是自己做的封装
maven配置如下：
<dependency>
<groupId>commons-net</groupId>
<artifactId>commons-net</artifactId>
<version>3.3</version>
</dependency>
<!--这里是引用了本地的一个jar包，主要服务于WeatherTelnet类-->
<dependency>
<groupId>commons-net</groupId>
<artifactId>examples</artifactId>
<version>3.3</version>
<scope>system</scope>
<systemPath>H:\Apache\commons-net\commons-net-examples-3.3.jar</systemPath>
</dependency>
封装的Telnet类
package com.special.utils.telnet;
import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;
import org.apache.commons.net.telnet.TelnetClient;
import java.io.*;
/**
* file TelnetUtil
* 使用Apache的commons-net 3.3 作为底层，封装的一个远程连接工具包
* TODO：如果字符串的截取未按理想状态进行，那么程序将挂起，所以最好将byte数组设为一屏的字节
* @author ds
* @version 1.0 2015
* date 15-3-18
*/
public class TelnetUtil {
Log log = LogFactory.getLog(TelnetUtil.class);
/**
* 终端类型，格式由前缀T_加终端类型构成
*/
public enum TerminalType {
T_513, T_715, T_4410, T_4425, T_VT220, T_NTT, T_W2KTT, T_SUNT;
/**
* 获取终端类型的类型名称
*
* @return 实际类型名称
*/
public String getTypeName() {
String name = this.name();
return name.substring(2, name.length());
}
}
/**
* 连接失败后，尝试重连的次数 _rCnt作为常量标识
*/
final Integer _rCnt = 1;
Integer reCntCount = _rCnt;
/**
* 终端输入用户名的提示信息
*/
final String _logPrompt = "login: ";
/**
* 终端输入密码的提示信息
*/
final String _pwdPrompt = "Password: ";
/**
* 终端选择终端类型的提示信息
*/
final String _terPrompt = "[513]";
/**
* 终端输入命令的提示信息
*/
final String _cmdPrompt = "Command: ";
/**
* 客户端
*/
TelnetClient client;
/**
* 终端类型
*/
String _terName = "W2KTT";
/**
* 远程输入流；该处使用过Reader，本来意欲每次读取一行，
* 但是实验结果表示使用reader导致输出停滞
*/
InputStream remoteInput;
/**
* 远程输出流 ，使用该流主要是使用它的println()功能;
* 他不需要手动加入回车换行，相当于每输入一次，自动加确认机制
*/
PrintStream remoteOut;
/**
* 构造方法
*
* @param host 远程主机域名或者IP
* @param port 主机的端口号
* @param terType 终端类型
*/
public TelnetUtil(String host, Integer port, TerminalType terType) {
//开启客户端连接
_terName = terType.getTypeName();
client = new TelnetClient(_terName);
//远程连接
if (getConnect(host, port)) {
//设置输入输出流
remoteInput = client.getInputStream();
remoteOut = new PrintStream(client.getOutputStream());
} else { //如果连接失败需要初始化流
remoteInput = new ByteArrayInputStream("connect failure!".getBytes());
remoteOut = new PrintStream(new ByteArrayOutputStream());
}
}
/**
* 获取远程连接
*
* @param host 主机域名或者IP
* @param port 主机端口
* @return boolean true 连接成功 false 连接失败
*/
private boolean getConnect(String host, Integer port) {
boolean flag = false;
try {
client.connect(host, port);
flag = true;
} catch (IOException e) {
//尝试重复连接，此处可以不使用同步，因为getConnect为私有非静态，并且连接次数也是非静态
if (!client.isConnected() && reCntCount > 0) {
reCntCount--;
if (getConnect(host, port)) {
reCntCount = _rCnt;
flag = true;
}
} else {
reCntCount = _rCnt;
}
e.printStackTrace();
}
return flag;
}
/**
* 输入用户名、密码登录终端
*
* @param name 用户名
* @param pwd 用户密码
*/
public void login(String name, String pwd) {
//输入用户名
read(_logPrompt);
write(name);
//输入密码
read(_pwdPrompt);
write(pwd);
//输入终端信息
read(_terPrompt);
write(_terName);
//读取可以输入命令
read(_cmdPrompt);
}
public StringBuffer execCommand(String command,String endBy){
write(command);
return readEndBy(endBy);
}
/**
* 读取流中的数据
*
* @param flagWords 流中是否含有该标志
* @return String 错误则返回error，否则返回读取的字符串
*/
public String read(String flagWords) {
String tmp = null;
int read ;
byte[] buff = new byte[2048];
flagWords = flagWords==null?"":flagWords;
try {
while ((read = remoteInput.read(buff))>0) {
tmp = new String(buff,0,read);
log.info("#" + tmp + "#");
/*此处就是潜在的BUG，如果截取的字符串非理想化，那么这里程序将挂起，
可以通过调整byte数组大小来解决，即确认截取一屏的字节数*/
if (tmp.startsWith(flagWords) || tmp.indexOf(flagWords) > 0) {
return tmp;
}else if(tmp.indexOf("successfully completed")>0){
return tmp;
}
}
} catch (IOException e) {
tmp = "error";
e.printStackTrace();
}
return tmp;
}
/**
* 读取流中的数据
*
* @param end 流中是否含有该标志
* @return StringBuffer 错误则返回error，否则返回读取的字符串
*/
public StringBuffer readEndBy(String end) {
String tmp ;
StringBuffer buffer = new StringBuffer();
int read;
byte[] bytes = new byte[2048];
end = end==null?"":end;
try {
while (0 < (read = remoteInput.read(bytes))) {
//替换特殊字符
tmp = new String(bytes,0,read).replaceAll("\\u001B","");
buffer.append(tmp);
log.info("#" + tmp + "#");
//此处仅适用endsWith是为了防止相同结束符存在造成的获取误差
if (tmp.endsWith(end)) {
return buffer;
}
}
} catch (IOException e) {
buffer = new StringBuffer();
buffer.append("error");
e.printStackTrace();
}
return buffer;
}
/**
* 关闭连接
*/
public void close() {
//关闭流
if (null != remoteInput) {
try {
remoteInput.close();
} catch (IOException e) {
e.printStackTrace();
}
}
if (null != remoteOut) {
remoteOut.close();
}
//关闭连接
try {
client.disconnect();
} catch (IOException e) {
e.printStackTrace();
}
}
/**
* 往流里写入数据
*
* @param msg 需要写入流的数据
*/
public void write(String msg) {
remoteOut.println(msg);
remoteOut.flush();
}
public static void main(String[] args) throws IOException, InterruptedException {
TelnetUtil util = new TelnetUtil("10.11.9.*",5023,TerminalType.T_W2KTT);
util.login("szct****", "sz****");
StringBuffer tmp = util.execCommand("status socket-usage","[0m");
System.out.println(tmp.toString());
util.close();
}
}
net中自带的实例工具类，可以参考下
/*
* Licensed to the Apache Software Foundation (ASF) under one or more
* contributor license agreements. See the NOTICE file distributed with
* this work for additional information regarding copyright ownership.
* The ASF licenses this file to You under the Apache License, Version 2.0
* (the "License"); you may not use this file except in compliance with
* the License. You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package com.special.utils.telnet;
import java.io.IOException;
import org.apache.commons.net.telnet.TelnetClient;
import examples.util.IOUtil;
/***
* This is an example of a trivial use of the TelnetClient class.
* It connects to the weather server at the University of Michigan,
* um-weather.sprl.umich.edu port 3000, and allows the user to interact
* with the server via standard input. You could use this example to
* connect to any telnet server, but it is obviously not general purpose
* because it reads from standard input a line at a time, making it
* inconvenient for use with a remote interactive shell. The TelnetClient
* class used by itself is mostly intended for automating access to telnet
* resources rather than interactive use.
* <p>
***/
// This class requires the IOUtil support class!
public final class WeatherTelnet
{
public final static void main(String[] args)
{
TelnetClient telnet;
telnet = new TelnetClient();
try
{
// telnet.connect("rainmaker.wunderground.com", 3000);
telnet.connect("10.11.9.5",5023);
}
catch (IOException e)
{
e.printStackTrace();
System.exit(1);
}
IOUtil.readWrite(telnet.getInputStream(), telnet.getOutputStream(),
System.in, System.out);
try
{
telnet.disconnect();
}
catch (IOException e)
{
e.printStackTrace();
System.exit(1);
}
System.exit(0);
}
}