//-------------------------------------

//类ArgumentHolder

//用于调用参数的封装，实现变长参数及

//不同类型参数的统一形式地传递

//成员变量:

// Class[] cl 参数类型数组

// Object[] args 参数对象数组

//方法:

// getArgumentClasses()返回参数类型数组

// getArguments() 返回参数对象数组

// setArgument() 在参数列表中增加项目

//

//---------------------------------------

public class ArgumentHolder {

protected Class[] cl;

protected Object[] args;

protected int argc;

ArgumentHolder() {

argc = 0;

cl = new Class[0];

args = new Object[0];

}

ArgumentHolder(int argc) {

this.argc = argc;

cl = new Class[argc];

args = new Object[argc];

}

public Class[] getArgumentClasses() {

return cl;

}

public Object[] getArguments() {

return args;

}

//以下16个setArgument

//函数实现简单数据类型boolean,byte,

// char,int,short,long,float,double的封装。

//为支持Invoker

//类dynaCall方法中getClass的调用，

//此处将简单数据类型

//转换为对应的对象，如boolean转换为Boolean

public int setArgument(boolean b) {

return this.setArgument(argc, new Boolean(b),

Boolean.TYPE);

}

public int setArgument(int argnum, boolean b) {

return this.setArgument(argnum, new Boolean(b),Boolean.TYPE);

}

public int setArgument(byte b) {

return this.setArgument(argc, new Byte(b),Byte.TYPE);

}

public int setArgument(int argnum, byte b) {

return this.setArgument(argnum, new Byte(b),Byte.TYPE);

}

public int setArgument(char c) {

return this.setArgument(argc, new Character(c),Character.TYPE);

}

public int setArgument(int argnum, char c) {

return this.setArgument(argnum, new Character(c),Character.TYPE);

}

public int setArgument(int i) {

return this.setArgument(argc, new Integer(i),Integer.TYPE);

}

public int setArgument(int argnum, int i) {

return this.setArgument(argnum, new Integer(i), Integer.TYPE);

}

public int setArgument(short s) {

return this.setArgument(argc, new Short(s),Short.TYPE);

}

public int setArgument(int argnum, short s) {

return this.setArgument(argnum, new Short(s),Short.TYPE);

}

public int setArgument(long l) {

return this.setArgument(argc, new Long(l),Long.TYPE);

}

public int setArgument(int argnum, long l) {

return this.setArgument(argnum, new Long(l),Long.TYPE);

}

public int setArgument(float f) {

return this.setArgument(argc, new Float(f),Float.TYPE);

}

public int setArgument(int argnum, float f) {

return this.setArgument(argnum, new Float(f),

Float.TYPE);

}

public int setArgument(double d) {

return this.setArgument(argc, new Double(d),Double.TYPE);

}

public int setArgument(int argnum, double d) {

return this.setArgument(argnum, new Double(d),Double.TYPE);

}

//以下2个setArgument函数实现对象的封装，

public int setArgument(Object obj) {

return this.setArgument(argc, obj,

obj.getClass());

}

public int setArgument(int argnum, Object obj) {

return this.setArgument(argnum, obj,

obj.getClass());

}

//以下setArgument函数具体实现以对象形式

//提供的参数封装。

//具体操作为：增加计数器argc的值、

//在cl和args中增加相应内容

public int setArgument(int argnum,Object obj, Class c) {

if (argnum >= args.length) {

argc = argnum + 1;

Class[] clExpanded = new Class[argc];

Object[] argsExpanded = new Object[argc];

System.arraycopy(cl, 0, clExpanded,

0, cl.length);

System.arraycopy(args, 0, argsExpanded,

0, args.length);

cl = clExpanded;

args = argsExpanded;

}

args[argnum] = obj;

cl[argnum] = c;

return argnum;

}

}

//

//---- 以 下 给 出 一 个 类Invoker 和ArgumentHolder 的 应 用 实 例。

//类DynaCallTest 应 用 类Invoker 和ArgumentHolder 实 现 以 下 功 能： 根 据 用 户 在 命 令 行 中 输 入 的 内 容， 动 态 地 确 定 所 调 用 方 法。 程 序 可 以 接 受 的 合 法 输 入 为：

//

//add 参数为两个整数，显示两个整数之和

//concat 参数为两个字符串，显示两个字符串连接之后的值

//help 无参数，显示可以接受的命令列表

//minmax 参数为三个整数，显示三个参数的最大之和最小值

//quit 无参数，结束运行

//rand 无参数，显示一个随机值

//

//程序清单如下：

import java.io.BufferedReader;

import java.io.IOException;

import java.io.InputStreamReader;

import java.lang.reflect.InvocationTargetException;

import java.util.Random;

import java.util.StringTokenizer;

public class DynaCallTest {

Random rand;

BufferedReader consoleIn;

//建构函数，初始化

DynaCallTest() {

consoleIn = new BufferedReader

(new InputStreamReader(System.in));

rand = new Random();

}

//读取用户输入行

String getCommandLine() throws IOException {

System.out.print(">");

System.out.flush();

String commandLine = consoleIn.readLine();

if (commandLine == null)

return "Quit";

if (commandLine.length() == 0)

return "Quit";

else

return commandLine;

}

//从用户输入行中提取命令，

//格式化为：首字符大写，其余字符小写

//返回格式化后的命令

String extractCommand(String commandLine) {

StringTokenizer t = new StringTokenizer(commandLine);

String cmd = t.nextToken().toLowerCase();

return cmd.substring(0,1).toUpperCase()

+ cmd.substring(1);

}

//从用户输入行中提取参数，

//创建ArgumentHolder类型的对象a以封装所有参数

//错误格式的整数被视为字符串

//返回ArgumentHolder类型的对象，即封装后的参数

ArgumentHolder extractArguments(String cmd) {

StringTokenizer t = new StringTokenizer(cmd);

int tokenCount = t.countTokens();

ArgumentHolder a = new ArgumentHolder();

String token = t.nextToken();

while(t.hasMoreTokens()) {

token = t.nextToken();

try {

int i = Integer.parseInt(token);

a.setArgument(i);

}

catch (NumberFormatException e) {

a.setArgument(token);

}

}

return a;

}

//以下6个以meth开头的函数实现本测试程序

//接受的合法命令的具体处理过程。

//函数的命名规则为：meth+格式化后的用户命令

public String methAdd(int i1, int i2) {

return Integer.toString(i1) + " + " +

Integer.toString(i2) + " = " + Integer.toString(i1 + i2);

}

public String methConcat(String s1, String s2) {

return "the concatenated string is " + s1 + s2;

}

public String methHelp() {

final String[] helpMessages =

{"DynaCallTest Version 1.0",

"valid commands are:",

"add int1 int2",

"concat string1 string 2",

"help",

"minmax int1 int2 int3",

"quit",

"rand"

};

for (int i = 0; i < helpMessages.length; ++i)

System.out.println(helpMessages[i]);

return "";

}

public String methMinmax(int i1, int i2, int i3) {

return ("min = " +

Integer.toString(java.lang.Math.min

(java.lang.Math.min(

i1,i2),i3)) + ", max = " + Integer.toString(

java.lang.Math.max(java.lang.Math.max(i1,i2),i3)));

}

public String methQuit() {

return "quitting";

}

public String methRand() {

return "the random number is "

+ Integer.toString(rand.nextInt());

}

//处理用户在命令行中的输入

//调用extractCommand以生成对应于用户输入的方法名

//调用extractArguments以封装用户输入参数

//调用Invoker.dynaCall以实现命令处理

String processCommand(String cmd) {

try {

String meth = "meth" + extractCommand(cmd);

ArgumentHolder a = extractArguments(cmd);

return (String)(Invoker.dynaCall(this, meth,a));

}

catch (NoSuchMethodException e) {

return "no method to process command " + cmd;

}

catch (InvocationTargetException e) {

System.out.println("trace:");

e.printStackTrace();

return "InvocationTargetException processing command" + cmd;

}

catch (IllegalAccessException e) {

System.out.println("trace:");

e.printStackTrace();

return "IllegalAccessException processing command" + cmd;

}

}

//主函数，调用processCommand以实现程序功能

public static void main(String args[]) {

boolean allOK = true;

String line;

DynaCallTest myClient = new DynaCallTest();

System.out.println("DynaCallTest Version 1.0");

System.out.println("Enter command at the prompt");

System.out.println("Type help for help");

while(allOK) {

try {

line = myClient.getCommandLine();

if (line == null)

allOK = false;

else {

System.out.println(myClient.processCommand(line));

if (line.substring(0,1).toUpperCase().equals("Q"))

allOK = false;

}

}

catch (IOException e) {

e.printStackTrace();

allOK = false;

}

}

System.exit(0);

}

}

//--------------------------------------

//类Invoker

//实现函数的动态调用

//方法：

// dynaCall

// 参数 Object c希望调用函数(方法)所在对象

// String m希望调用的方法名称

// ArgumentHolder a传递给被调用方法的参数

//-----------------------------------------

import java.lang.reflect.InvocationTargetException;

import java.lang.reflect.Method;

public class Invoker {

static Object dynaCall(Object c,String m,

ArgumentHolder a) throws NoSuchMethodException,InvocationTargetException,IllegalAccessException {

//由于java支持方法名称的重载

//(同一类中出现多于一个的同名函数)，

//所以getMethod方法使用两个参数：

//字符串形式的方法名称和数组形式

//的调用参数类列表。返回值为类Method的一个对象，

//该对象和将要被

//调用的方法相关联

Method meth = c.getClass().getMethod(m, a.getArgumentClasses());

//通过类Method对象的invoke方法动态调用希望调用的方法

return (meth.invoke(c, a.getArguments()));

}

}