Question

以下是什么功能

Class c = Class.forName(handler);
Class partypes[] = new Class[1];
partypes[0] = new String().getClass();
Constructor ct = c.getConstructor(partypes);
Object arglist1[] = new Object[1];
arglist1[0] = address;
Method meth[] = c.getMethods();
Object arglist[] = new Object[7]; 
arglist[0] = new Integer(transid);
arglist[1] = transobj;            
arglist[2] = data_vec;            
arglist[3] = company_name;        
arglist[4] = new Boolean(flag_final_level_approval); 
flag_final_level_approval=true else false
arglist[5] = con;                
arglist[6] = scon;              
boolean found = false;
for(int i=0;i<meth.length;i++) {
    Method m = meth[i];
    if(m.getName().equals(functionName)) {
        result_vec = (Vector)m.invoke(ct.newInstance(arglist1),arglist);
    }
}

Answer 1

这看起来像是滥用反射来掩盖无法为我创建两个交互式Java组件的正确接口。如果您为代码段中的变量提供具体值，则可以进一步猜测......

Answer 2

Class c = Class.forName(handler);       // get class object for class with name <handler>
Class partypes[] = new Class[1];    
partypes[0] = new String().getClass();      // get class object for string
Constructor ct = c.getConstructor(partypes);    // get constructor of <handler> with signature <handler>(String)
Object arglist1[] = new Object[1]; 
arglist1[0] = address; 
Method meth[] = c.getMethods();         // get method objects from <handler>
Object arglist[] = new Object[7];       // collect a few params
arglist[0] = new Integer(transid);      // collect a few params
arglist[1] = transobj;              // collect a few params
arglist[2] = data_vec;              // collect a few params
arglist[3] = company_name;          // collect a few params
arglist[4] = new Boolean(flag_final_level_approval); // collect a few params
flag_final_level_approval=true else false   // this won't compile
arglist[5] = con;               // collect a few params
arglist[6] = scon;              // collect a few params
boolean found = false; 
for(int i=0;i<meth.length;i++) {
    Method m = meth[i];
    if(m.getName().equals(functionName)) {  // if method with name <functionName> found
        result_vec = (Vector)m.invoke(ct.newInstance(arglist1),arglist);  // invokes method on ct.NewInstance with arglist as param 
    }

有人试图通过名称获取类对象，创建此类的实例并使用arglist中的参数调用某些方法。

Answer 3

创建名为handler的类中的对象表示：

Class c = Class.forName(handler);

然后，我们使用一个String参数搜索其构造函数：

Class partypes[] = new Class[1];
partypes[0] = new String().getClass();
Constructor ct = c.getConstructor(partypes);

用于for循环。

最后，迭代方法寻找一个名为functionName的方法，该方法在新创建的实例上调用：

result_vec = (Vector)m.invoke(ct.newInstance(arglist1),arglist);

所有这些都等同于写作（使用诸如groovy之类的语言）

target = new ${handler}
target.${functionName} ( ${transid}, ${transobj}, ${data_vec}, ${company_name}, ${lag_final_level_approval}, ${con}, ${scon});

就像我的所有同行所说的那样，它显然是对内省的滥用，因为通过迭代方法，可能会遇到多个具有正确名称的方法，并尝试调用所有这些方法，收集各种执行异常和奇怪的结果。

Answer 4

基本上，它会查看类中的所有方法，并且只要找到匹配项，它就会创建一个新实例（即ct.newInstance(arglist1)位），然后调用该方法（即m.invoke(..., arglist) }位）。

您可能会发现它更容易理解为：

Object instance = ct.newInstance(arglist1);
result_vec = (Vector) m.invoke(instance, arglist);

（总的来说，虽然代码很丑陋......）

Answer 5

有人使用一些令人发指的反射来调用handler类的方法。

我很想知道为什么所有的参数都被如此费力地放入那个参数数组中，因此无法传递给处理程序实例并简单地调用。

看起来有人决定采用复杂的实现来满足（真实的或想象的）最终灵活性的要求。

作为实例方法调用

5 个答案: