现在服务器远程控制一般都是web方式实现的，这种方式体现的最明显的是J2EE应用服务器；当然为了操作方便，有些服务器也提供GUI客户端，
不过笔者比较喜欢字符终端，我想有很多人同笔者一样，在这里，向大家介绍一个Java实现的命令行程序，这是笔者当时阅读OBE(一个Workflow Engine)
的源代码时的收获，把代码调整了一下，版权就不属于Adrian.Price的了，哈哈！
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
import java.util.HashMap;
import java.util.Map;
public class CommandClient {
//返回菜单
protected static final Object[] BACK = {"Q", "Back to previous menu", null};
protected static final String UNDERLINE = "-----------------------------------------------------------------------------";
//设置菜单
private static final Object[][] SET_MENU = {
// mnemonic, description, method
{"1", "Load Default value", "loadDefault"},
{"2", "Set Remote Host and Port(example,localhost:8191)", "setHost"},
{"3", "Set Welcome message", "setMessage"},
BACK
};
//主菜单
private static final Object[][] MAIN_MENU = {
// mnemonic, description, method
{"1", "Set", SET_MENU},
{"2", "Check Server Status", "checkServerStatus"},
{"3", "Shutdown Server", "shutdownServer"},
{"Q", "Quit", "quit"}
};
protected BufferedReader _stdin;
protected FormattingPrintWriter _stdout;
protected String title = null;
public void setHost()
throws IOException
{
System.out.println("please enter connection string:");
BufferedReader stdin = new BufferedReader(new InputStreamReader(System.in));
System.out.println("The host you set is " + stdin.readLine());
}
public void shutdownServer()
{
System.out.println("server has been shut down");
}
public void checkServerStatus()
{
System.out.println("server is OK");
}
public CommandClient()
{
_stdin = new BufferedReader(new InputStreamReader(System.in));
_stdout = new FormattingPrintWriter(System.out, true);
title = "Command Client";
_stdout.println("\n--- "+title+" ---");
}
protected void quit() {
System.exit(0);
}
private Method findMethod(String name) {
Class cl = getClass();
Method method = null;
while (method == null) {
try {
method = cl.getDeclaredMethod(name, null);
} catch (NoSuchMethodException e) {
System.out.println("no method define");
cl = cl.getSuperclass();
if (cl == null) {
e.printStackTrace();
System.exit(1);
}
/*
try
{
return cl.getDeclaredMethod("done", null);
}
catch (NoSuchMethodException ex) {ex.printStackTrace();}
*/
}
}
return method;
}
protected String getChoice(String choices)
throws IOException {
while (true) {
_stdout.print("> ");
_stdout.flush();
String line = _stdin.readLine().trim();
if (line.length() == 1) {
int choice = Character.toUpperCase(line.charAt(0));
int index = choices.indexOf(choice);
if (index != -1)
return choices.substring(index, index + 1);
}
_stdout.println("\007*** Choice must be one of: " + choices);
}
}
//选择菜单选项，动态调用某个方法
public void doMenu(Object[][] menu, boolean main)
{
this.doMenu(this.title,menu,main);
}
public void doMenu(String pTitle,Object[][] menu, boolean main)
{
synchronized (System.in) {
Map actions = new HashMap();
StringBuffer sb = new StringBuffer(menu.length);
for (int i = 0; i < menu.length; i++) {
Object mnemonic = menu[i][0];
sb.append(mnemonic);
Object action = menu[i][2];
if (action instanceof String)
action = findMethod((String)action);
actions.put(mnemonic, action);
}
String choices = sb.toString();
while (true) {/////////////////////////////////////////////////////////////
try {
String mnemonic;
_stdout.clearTabs();
_stdout.println("\n--- " + pTitle + " ---");
_stdout.println("\nEnter choice:");
for (int i = 0; i < menu.length; i++)
_stdout.println(menu[i][0] + ") " + menu[i][1]);
// Get the user's selection.
mnemonic = getChoice(choices);
//System.out.println("mnemonic="+mnemonic);
for (int i = 0; i < menu.length; i++) {
Object[] entry = menu[i];
if (entry[0].equals(mnemonic)) {
Object action = actions.get(mnemonic);
if (action == null) {
return;
} else if (action instanceof Method) {
//System.out.println("selected,will do");
// Cast required to suppress JDK1.5 varargs compiler warning.
((Method)action).invoke(this, (Object[])null);
} else {
doMenu((String)entry[1], (Object[][])action,
false);
}
}
}
} catch (Exception e) {
Throwable t = e;
if (e instanceof InvocationTargetException)
t = ((InvocationTargetException)e).getTargetException();
_stdout.println("\007*** Caught exception: " + t);
}
}////////////////////////////////////////////////////////////////////////////
}
}
/**
* @param args
*/
public static void main(String[] args)
{
new CommandClient().doMenu(MAIN_MENU,true);
}
public void setMessage()
throws IOException
{
System.out.println("please enter welcome message:");
BufferedReader stdin = new BufferedReader(new InputStreamReader(System.in));
System.out.println("welcome message is " + stdin.readLine());
}
public void loadDefault()
{
System.out.println("default setting is loaded");
}
}
附另外一个类（javaeye的blog有点令我失望，加个附件也很痛苦）
import java.io.BufferedReader;
import java.io.File;
import java.io.InputStreamReader;
import java.io.OutputStream;
import java.io.PrintWriter;
import java.io.Writer;
import java.util.Stack;
/**
* A PrintWriter class that supports tab stops and programmable indentation.
* The writer interprets tab characters in the usual way, by emitting spaces to
* align the following characters at the next tab stop to the right of the
* current print position. The default tab stops are at every 8 characters,
* that is, in columns 9, 17, 25, ... 81. The {@link #setTabs} method allows
* custom tab stops to be specified. Indentation can be controlled via the
* {@link #pushIndent()}, {@link #pushIndent(int)} and {@link #popIndent()}
* methods.
* <p/>
* The writer scans all arguments for newline characters, and achieves the
* desired indentation level by inserting a corresponding number of spaces into
* the output before continuing with the characters following the newline.
* Indentation settings are held internally on a stack so that cancelling the
* current setting automatically restores the previous one.
*
* @author Adrian Price
*/
public class FormattingPrintWriter extends PrintWriter {
private static final String NEWLINE =
System.getProperty("line.separator", "\r\n");
// Standard tab settings
private static final int[] STD_TABS =
{9, 17, 25, 33, 41, 49, 57, 65, 73, 81};
private boolean _autoFlush;
private int[] _tabs = STD_TABS;
private Stack _stack = new Stack();
private int _indent;
private int _pos;
/**
* Returns a string consisting of the specified number of spaces.
*
* @return The requested whitespace string.
*/
private static String spaces(int n) {
char[] ca = new char[n];
for (int i = 0; i < n; i++)
ca[i] = ' ';
return new String(ca, 0, ca.length);
}
/**
* Constructs a new FormattingPrintWriter, without automatic line flushing.
*
* @param out A character-output stream.
*/
public FormattingPrintWriter(Writer out) {
super(out);
}
/**
* Constructs a new FormattingPrintWriter.
*
* @param out A character-output stream.
* @param autoFlush If <code>true</code>, the println() methods will flush
* the output buffer.
*/
public FormattingPrintWriter(Writer out, boolean autoFlush) {
super(out, autoFlush);
_autoFlush = autoFlush;
}
/**
* Constructs a new PrintWriter, without automatic line flushing, from an
* existing OutputStream. This convenience constructor creates the necessary
* intermediate OutputStreamWriter, which will convert characters into bytes
* using the default character encoding.
*
* @param out An output stream.
*/
public FormattingPrintWriter(OutputStream out) {
super(out);
}
/**
* Constructs a new PrintWriter from an existing OutputStream. This
* convenience constructor creates the necessary intermediate
* OutputStreamWriter, which will convert characters into bytes using the
* default character encoding.
*
* @param out An output stream.
* @param autoFlush if <code>true</code>, the println() methods will flush
* the output buffer.
*/
public FormattingPrintWriter(OutputStream out, boolean autoFlush) {
super(out, autoFlush);
_autoFlush = autoFlush;
}
/**
* Restores the default tab stops.
*/
public void clearTabs() {
setTabs(null);
}
/**
* Sets custom tab stops. At output positions past the rightmost tab stop,
* tab characters are converted into single spaces.
*
* @param tabs Unity-based tab stop positions, as an ascending sequence of
* positive integers.
*/
public void setTabs(int[] tabs) {
synchronized (lock) {
if (tabs == null) {
_tabs = STD_TABS;
} else {
for (int i = 0, n = tabs.length - 1; i < n; i++) {
if (tabs[i] <= 0 || tabs[i] >= tabs[i + 1])
throw new IllegalArgumentException(
"Tab stops must be an ascending sequence of positive integers.");
}
_tabs = new int[tabs.length];
System.arraycopy(tabs, 0, _tabs, 0, tabs.length);
}
if (_pos != 0)
println();
}
}
/**
* Returns unity-based tab stop positions, as an ascending sequence of
* positive integers.
*
* @return Current tab stops.
*/
public int[] getTabs() {
return (int[])_tabs.clone();
}
/**
* Increases the indentation level by the specified amount.
*
* @param i Number of columns by which to increase indentation.
*/
public void pushIndent(int i) {
if (i <= 0) {
throw new IllegalArgumentException(
"Indentation must be a positive integer");
}
synchronized (lock) {
_stack.push(new Integer(i));
_indent += i;
}
}
/**
* Increases the indentation level to the next tab stop past the current
* output position.
*/
public void pushIndent() {
// Indent to the nearest tab stop to the right of the current
// indentation level, if such a tab stop exists.
for (int i = 0, n = _tabs.length; i < n; i++)
if (_tabs[i] > _indent) {
pushIndent(_tabs[i] - _indent);
return;
}
// Past the rightmost tab stop, indentation is one space.
pushIndent(1);
}
/**
* Restores the previous indentation level.
*
* @throws IllegalStateException if the current indentation level is 0.
*/
public void popIndent() {
if (_stack.empty())
throw new IllegalStateException();
_indent -= ((Integer)_stack.pop()).intValue();
}
/**
* Returns the current indentation level.
*
* @return Indentation level as a character count.
*/
public int getIndent() {
return _indent;
}
/**
* Returns the current output position (zero-based).
*
* @return The output position.
*/
public int getPosition() {
return _pos;
}
/**
* Expands a tab character by setting the output position to the next tab
* stop past the current output position.
*
* @return Space-filled string.
*/
private String expandTab() {
// If pos is after the last tab stop, translate tab characters to spaces.
String s = " ";
int curpos = _indent + _pos;
for (int i = 0; i < _tabs.length; i++) {
// Tab stops use 1-based column numbers,
if (_tabs[i] - 1 > curpos) {
// curpos is a 0-based column index.
s = spaces(_tabs[i] - curpos - 1);
break;
}
}
_pos += s.length();
return s;
}
/**
* Expands embedded tab and newline escape sequences, adjusting the output
* position accordingly. The method recognizes 'C'/Java-style '\t', '\r' and
* '\n' escape sequences.
*
* @param ch Character to expand.
* @return String containing (expanded) input character.
*/
private String expandEscapes(char ch) {
StringBuffer result = new StringBuffer();
switch (ch) {
case '\t':
if (_pos == 0 && _indent > 0)
result.append(spaces(_indent));
result.append(expandTab());
break;
case '\n':
_pos = 0;
case '\r':
result.append(ch);
break;
default:
if (_pos == 0 && _indent > 0)
result.append(spaces(_indent));
result.append(ch);
_pos++;
}
return result.toString();
}
/**
* Expands embedded tab and newline escape sequences, adjusting the output
* position accordingly. The method recognizes 'C'/Java-style '\t', '\r' and
* '\n' escape sequences.
*
* @param s Source string.
* @param off Offset at which to start copying.
* @param len Number of source characters to process.
* @return Copy of the source string where all escape sequences have been
* replaced by their equivalent characters.
*/
private String expandEscapes(String s, int off, int len) {
StringBuffer result = new StringBuffer(len);
for (int i = off, end = off + len; i < end; i++) {
char ch = s.charAt(i);
switch (ch) {
case '\t':
if (_pos == 0 && _indent > 0)
result.append(spaces(_indent));
result.append(expandTab());
break;
case '\n':
_pos = 0;
case '\r':
result.append(ch);
break;
default:
if (_pos == 0 && _indent > 0)
result.append(spaces(_indent));
result.append(ch);
_pos++;
}
}
return result.toString();
}
/**
* Writes a character, which may be a tab or newline.
*
* @param c Character to write.
*/
private void _writeEx(int c) {
String s = expandEscapes((char)c);
super.write(s, 0, s.length());
}
/**
* Writes a string which may contain tab or newline characters.
*
* @param s Source string.
* @param off Offset at which to start writing.
* @param len Number of source characters to process.
*/
private void _writeEx(String s, int off, int len) {
s = expandEscapes(s, off, len);
super.write(s, 0, s.length());
}
/**
* Writes a string that does not contain embedded tabs or newlines.
*
* @param s Source string.
* @param off Offset at which to start writing.
* @param len Number of source characters to process.
*/
private void _write(String s, int off, int len) {
_pos += len;
super.write(s, off, len);
}
public void print(boolean b) {
String s = String.valueOf(b);
_write(s, 0, s.length());
}
public void print(char c) {
_writeEx(c);
}
public void print(int i) {
String s = String.valueOf(i);
_write(s, 0, s.length());
}
public void print(long l) {
String s = String.valueOf(l);
_write(s, 0, s.length());
}
public void print(float f) {
String s = String.valueOf(f);
_write(s, 0, s.length());
}
public void print(double d) {
String s = String.valueOf(d);
_write(s, 0, s.length());
}
public void print(char[] ca) {
_writeEx(new String(ca), 0, ca.length);
}
public void print(String s) {
_writeEx(s, 0, s.length());
}
public void print(Object obj) {
String s = String.valueOf(obj);
_writeEx(s, 0, s.length());
}
private void newLine() {
_write(NEWLINE, 0, NEWLINE.length());
_pos = 0;
if (_autoFlush)
flush();
}
public void println() {
synchronized (lock) {
newLine();
}
}
public void println(boolean b) {
synchronized (lock) {
print(b);
newLine();
}
}
public void println(char c) {
synchronized (lock) {
print(c);
newLine();
}
}
public void println(int i) {
synchronized (lock) {
print(i);
newLine();
}
}
public void println(long l) {
synchronized (lock) {
print(l);
newLine();
}
}
public void println(float f) {
synchronized (lock) {
print(f);
newLine();
}
}
public void println(double d) {
synchronized (lock) {
print(d);
newLine();
}
}
public void println(char[] c) {
synchronized (lock) {
print(c);
newLine();
}
}
public void println(String s) {
synchronized (lock) {
print(s);
newLine();
}
}
public void println(Object obj) {
synchronized (lock) {
print(obj);
newLine();
}
}
public void write(int c) {
_writeEx(c);
}
public void write(char[] buf, int off, int len) {
_writeEx(new String(buf, off, len), 0, len);
}
public void write(char[] buf) {
_writeEx(new String(buf), 0, buf.length);
}
public void write(String s, int off, int len) {
_writeEx(s, off, len);
}
public void write(String s) {
_writeEx(s, 0, s.length());
}
public static void main(String[] args)
throws Exception
{
System.out.println("please enter file path");
BufferedReader stdin = new BufferedReader(new InputStreamReader(System.in));
String line = null;
while ((line = stdin.readLine()) != null)
{
File dir = new File(line.trim());
if (dir.exists())
{
System.out.println(dir.getAbsolutePath());
break;
}
else
{
System.out.println("dir does not exist,please re-enter:");
}
}
}
}
