在运行时绑定到正确的构造函数-Java

今天我提出了一个解决方案，在解析文件后，使用Java中的API在运行时创建类

    while ((line = textReader.readLine()) != null)
    {
        Pattern p = Pattern
            .compile("([^:]+):([^:]+)::([\\d]+)::([^:]+)::(.+)");
        Matcher m = p.matcher(line);
        if (m.find())
        {
            String id = m.group(1);
            String className = m.group(2);
            int orderOfExecution = Integer.valueOf(m.group(3));
            String methodNameOrNew = m.group(4);
            Object[] arguments = m.group(5).split("::");
            if (methodNameOrNew.compareTo("new") == 0)
            {
                System.out.println("Loading class: " + className);
                if (className.contains("Competition"))
                {
                    continue;
                }
                else if (className.contains("$"))
                {
                    continue;
                }
                else
                {
                    Class<?> cl = Class.forName(className);
                    printMembers(cl.getConstructors(), "Constructor");
                    Constructor<?>[] cons = cl.getConstructors();
                    Object obj = cons[0].newInstance(arguments);
                    this.map.put(id, obj);
                }
            }
        }
    }

但是，我得到以下错误：

Loading class: org.powertac.common.TariffSpecification
Constructor:
  public org.powertac.common.TariffSpecification(org.powertac.common.Broker,org.powertac.common.enumerations.PowerType)

java.lang.IllegalArgumentException: argument type mismatch
    at sun.reflect.NativeConstructorAccessorImpl.newInstance0(Native Method)
    at sun.reflect.NativeConstructorAccessorImpl.newInstance(NativeConstructorAccessorImpl.java:57)
    at sun.reflect.DelegatingConstructorAccessorImpl.newInstance(DelegatingConstructorAccessorImpl.java:45)
    at java.lang.reflect.Constructor.newInstance(Constructor.java:525)
    at Parser.parse(Parser.java:64)
    at Parser.main(Parser.java:137)

参数[]

是：

1:CONSUMPTION

。如何创建正确的构造函数，并为其提供正确的参数（类型）？ 例如，在我使用的示例解析器中，我有：

2233:org.powertac.common.Tariff::6::new::6

然后我必须创建一个

org.powertac.common.tarriff

类型的

class

（

new

告诉我需要创建一个新对象，它以一个

double rate

作为参数，在本例中为

6

。但是，我不知道它需要一个

double

，只有参数是

String

（

6

）。如何创建/转换/转换为正确的类型，然后将其分配给构造函数？我的第一个想法是创建一个符号表，但我想知道一个更简单的解决方案…

您需要使用它来选择适合于希望传递给

构造函数的参数的构造函数。newInstance（对象…）

在您的示例中，我将假设

1:consumpion

的数组意味着您有一个相当于

Object[] arguments = new Object[]{Integer.valueOf(1), "CONSUMPTION"};

所以你称之为

Class clazz = ... //Whatever class reference you have
Constructor c = clazz.getConstructor(Integer.class, String.class);
Object obj = c.newInstance(arguments);

如果不知道参数的类型，则必须针对

Class.getConstructors（）返回的每个构造函数，根据
Constructor.getParameterTypes（）返回的类数组测试参数集
直到找到与参数数组匹配的构造函数。更具体地说，参数数组和类数组的长度相同，类数组中的每个类都传递
class。isAssignableFrom（class）
用于参数数组中相同位置的值的类

以上代码的实现

    public boolean canConstruct(Object[] args, Constructor<?> c){
        Class<?>[] paramTypes = c.getParameterTypes(); 
        if(args.length != paramTypes.length){
            return false;
        }

        int i = 0;
        for(Object arg: args){
            if(!paramTypes[i].isAssignableFrom(arg.getClass())){
                return false;
            }
                    i++;
        }

        return true;
    }

公共布尔canConstruct（对象[]参数，构造函数c）{
类[]paramTypes=c.getParameterTypes（）；
if（args.length！=paramTypes.length）{
返回false；
}
int i=0；
用于（对象arg:args）{
如果（！paramTypes[i].isAssignableFrom（arg.getClass（）））{
返回false；
}
i++；
}
返回true；
}

为了使用它，您必须将参数数组传递给构造函数。您可以尝试编辑输入，使其包含类型信息（这类似于java序列化的工作方式）因此，您可以使用自己的类型构造函数通过反射来构造构造函数参数数组的参数
您能给我提供更多详细信息吗？@philippe我在答案中添加了更多详细信息。如果您将值传递到
constructor.newInstance（Object…）
不可分配给由
构造函数返回的类数组表示的类。getParameterTypes（）
如果参数数量正确且顺序正确，那么您将在问题中看到上述参数类型不匹配异常。但是如果我不知道构造函数使用的每个参数的类型，那么在运行时如何确定/创建？我已经编辑了我的问题，因此现在更容易理解我的问题我在寻找…只是出于好奇，通常要解决什么问题？为什么不使用标准的Java序列化机制（序列化API、持久化xml/json等）@mudalov你能给我更多的细节吗？
    public boolean canConstruct(Object[] args, Constructor<?> c){
        Class<?>[] paramTypes = c.getParameterTypes(); 
        if(args.length != paramTypes.length){
            return false;
        }

        int i = 0;
        for(Object arg: args){
            if(!paramTypes[i].isAssignableFrom(arg.getClass())){
                return false;
            }
                    i++;
        }

        return true;
    }