java - 通过反射计算方法调用传递的参数

Question

我有一组实现通用接口(interface)的类，例如:

public inteface CustomGenerator {  
   Object generate(Reader r);  
} 

这些类可以相应地处理参数并生成预期类型的​​响应。
我有一个需要填充的基类。为了填充类，我使用这些客户生成器类和反射。

public static void copy(CustomClass target, String tag, Reader reader) {  
   Object input = CustomGenerators.get(tag).generate(reader); 
   String setter = setterNames.get(tag);   
   Method m = target.getClass().getMethod(setter, input.getClass());  
   m.invoke(target, input);   
}  

}

为了清楚起见，省略了异常处理。这可行，但我想要以下地址:
问题:
传入的一些 type 没有自定义生成器来解析它们，因为它们本质上是基元，并且 1) 我不想创建许多小类只是为了做一些琐碎的事情，比如 Integer.valueOf(reader.nextString());
另一方面，当我调用 target.getClass().getMethod 时，我需要参数类型，并且需要处理原始值的情况。
所以我需要以某种方式在这里弄清楚:
target.getClass().getMethod(setter, input.getClass()); 我需要传递的第二个参数是什么。

如何彻底解决这个问题？

Answer 1

像这样怎么样？

import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
import java.lang.reflect.Modifier;
import java.util.HashMap;
import java.util.Map;

public class Main {
    static final Map<String, CustomGenerator> generators = new HashMap<String, CustomGenerator>();
    static final Map<String, String> setterNames = new HashMap<String, String>();
    static final Map<Class<?>, Class<?>> wrappers = new HashMap<Class<?>, Class<?>>();

    public static void main(String[] args) throws NoSuchMethodException, InvocationTargetException, IllegalAccessException {
        wrappers.put(int.class, Integer.class);
        wrappers.put(double.class, Double.class);
        wrappers.put(boolean.class, Boolean.class);
        //...

        generators.put("int", new PrimitiveCustomGenerator(int.class));
        generators.put("double", new PrimitiveCustomGenerator(double.class));
        generators.put("boolean", new PrimitiveCustomGenerator(boolean.class));
        //...

        setterNames.put("int", "setInt");
        //...

        CustomClass holder = new CustomClass();
        System.out.println(holder.intValue);

        copy(holder, "int", new Reader());
        System.out.println(holder.intValue);
    }

    static void assertThat(boolean condition) {
        if (!condition) {
            throw new IllegalStateException();
        }
    }

    public static class CustomClass {
        private int intValue;

        public void setInt(int intValue) {
            this.intValue = intValue;
        }
    }

    public static void copy(CustomClass target, String tag, Reader reader) throws InvocationTargetException, IllegalAccessException, NoSuchMethodException {
        CustomGenerator generator = generators.get(tag);
        Object input = generator.generate(reader);

        String setter = setterNames.get(tag);
        Method m = target.getClass().getMethod(setter, generator.getTargetClass());
        m.invoke(target, input);
    }

    public static class Reader {
        public String nextString() {
            return "22";
        }
    }

    public interface CustomGenerator {
        Class getTargetClass();
        Object generate(Reader r) throws InvocationTargetException, IllegalAccessException;
    }

    public abstract static class AbstractCustomGenerator implements CustomGenerator {
        protected Class<?> targetClass;

        AbstractCustomGenerator(Class<?> targetClass) {
            this.targetClass = targetClass;
        }

        public Class<?> getTargetClass() {
            return targetClass;
        }
    }

    public static class PrimitiveCustomGenerator extends AbstractCustomGenerator {

        private final Method valueOfMethod;
        private final Class<?> wrapperClass;

        PrimitiveCustomGenerator(Class<?> targetClass) throws NoSuchMethodException {
            super(targetClass);
            assertThat(targetClass.isPrimitive());

            // use google-guava lib
            // Class wrapperClass = com/google/common/primitives/Primitives.wrap(targetClass);
            wrapperClass = wrappers.get(targetClass);

            valueOfMethod = wrapperClass.getMethod("valueOf", String.class);
            assertThat(Modifier.isStatic(valueOfMethod.getModifiers()));
        }

        public Object generate(Reader r) throws InvocationTargetException, IllegalAccessException {
            return valueOfMethod.invoke(wrapperClass, r.nextString());
        }
    }
}