Java中的函数动态调用

//------------------------------------- 
//类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()));
 }
}

 

 

文章来源：http://www.cn-java.com/www1/?action-viewnews-itemid-2317