使用varargs的Java反射调用方法

Question

我遇到反射问题，要计算用户传递的参数数量，并将参数长度与预期计数进行比较。如果满足此要求，则继续使用方法调用者的Object[] { incommingArguments }（varargs）参数执行该方法。

我的compute()课程中有一个名为LogicGates的方法。该方法需要2到3个参数。第一个参数是门，接下来的1或2是输入，具体取决于门的输入。

目前，该方法带有签名：

compute(gate:GATE,a:boolean,b:boolean):boolean

正确执行，但如果我使用

compute(gate:GATE,<VARARGS>:boolean):boolean

签名然后我的代码中断了。我正在使用我在这里找到的varargs逻辑：StackOverflow: Invoke method with an array parameter using reflection。

在我的问题的最后，两个方法都可以在LogicGates.java的底部找到。

输出

 A | B | AND     A | B | OR     A | B | NAND     A | B | NOR     A | B | XOR     A | B | XNOR     A | B | XNOR_NAND     A | B | XNOR_NOR     A | B | IF_THEN     A | B | THEN_IF    
---+---+-----   ---+---+----   ---+---+------   ---+---+-----   ---+---+-----   ---+---+------   ---+---+-----------   ---+---+----------   ---+---+---------   ---+---+---------   
 T | T | T       T | T | T      T | T | F        T | T | F       T | T | F       T | T | T        T | T | T             T | T | T            T | T | T           T | T | T          
 T | F | F       T | F | T      T | F | T        T | F | F       T | F | T       T | F | F        T | F | F             T | F | F            T | F | F           T | F | T          
 F | T | F       F | T | T      F | T | T        F | T | F       F | T | T       F | T | F        F | T | F             F | T | F            F | T | T           F | T | F          
 F | F | F       F | F | F      F | F | T        F | F | T       F | F | F       F | F | T        F | F | T             F | F | T            F | F | T           F | F | T          

GateTest.java

public class GateTest {
    public static void main(String[] args) {
        StringBuffer[] rows = newStringBufferArray(6, "");

        for (LogicGates.GATE g : LogicGates.GATE.values()) {
            if (g.operands == 2)
                rows = fillTable(g, rows, repeat(' ', 3));
        }

        for (StringBuffer row : rows) {
            System.out.println(row);
        }
    }

    private static final StringBuffer[] fillTable(final LogicGates.GATE gate,
            StringBuffer[] buffer, String delimiter) {
        int l = buffer.length - 1;
        String name = gate.name();
        String pad = repeat('-', name.length() + 1);

        buffer[0].append(String.format(" A | B | %s %s", name, delimiter));
        buffer[1].append(String.format("---+---+-%s%s", pad, delimiter));

        for (byte b = 3; b >= 0; --b)
            buffer[l - b].append(fillRow(gate, intToBool(b >> 1),
                    intToBool(b & 1), delimiter));

        return buffer;
    }

    private static final String fillRow(final LogicGates.GATE gate, boolean a,
            boolean b, String delimiter) {
        return String.format(" %c | %c | %c%s %s", boolToChar(a),
                boolToChar(b),
                boolToChar(LogicGates.compute(gate, a, b)),
                repeat(' ', gate.name().length() - 1), delimiter);
    }

    public static final StringBuffer[] newStringBufferArray(int size,
            String initialValue) {
        if (initialValue == null)
            initialValue = "";

        StringBuffer[] bufferArr = new StringBuffer[size];

        for (int i = 0; i < size; i++)
            bufferArr[i] = new StringBuffer(initialValue);

        return bufferArr;
    }

    private static final String repeat(char ch, int count) {
        StringBuilder sb = new StringBuilder();

        while (sb.length() < count)
            sb.append(ch);

        return sb.toString();
    }

    private static final char boolToChar(final boolean bool) {
        return bool ? 'T' : 'F';
    }

    private static final boolean intToBool(final int input) {
        return intToBool((byte) input);
    }

    private static final boolean intToBool(final byte input) {
        if (input < 0 || input > 1)
            throw new IllegalArgumentException("Input must be 0 or 1");

        return input == 1;
    }
}

LogicGates.java

import java.lang.reflect.Method;
import java.util.Arrays;

@SuppressWarnings("unused")
public final class LogicGates {
    public static enum GATE {
        NOT("not", "Negation", 1), // .
        AND("and", "Logical conjunction", 2), // .
        OR("or", "Logical disjunction", 2), // .
        NAND("nand", "Logical NAND", 2), // .
        NOR("nor", "Logical NOR", 2), // .
        XOR("xor", "Exclusive disjunction", 2), // .
        XNOR("xnor", "Logical biconditional", 2), // .
        XNOR_NAND("xnorNand", "XNOR using only NAND gates.", 2), // .
        XNOR_NOR("xnorNor", "XNOR using only NOR gates.", 2), // .
        IF_THEN("ifThen", "Material implication.", 2), // .
        THEN_IF("thenIf", "Converse implication.", 2); // .

        private String methodName, description;
        int operands;

        private GATE(String methodName, String description, int operands) {
            this.methodName = methodName;
            this.description = description;
            this.operands = operands;
        }

        protected String methodName() {
            return methodName;
        }

        protected int operands() {
            return operands;
        }
    }

    private LogicGates() {
        throw new AssertionError();
    }

    private static final boolean not(boolean a) {
        return !a;
    }

    private static final boolean and(final boolean a, final boolean b) {
        return a && b;
    }

    private static final boolean or(final boolean a, final boolean b) {
        return a || b;
    }

    private static final boolean nand(final boolean a, final boolean b) {
        return not(and(a, b));
    }

    private static final boolean nor(final boolean a, final boolean b) {
        return not(or(a, b));
    }

    private static final boolean xor(final boolean a, final boolean b) {
        return or(and(a, not(b)), and(not(a), b));
    }

    private static final boolean xnor(final boolean a, final boolean b) {
        return or(and(a, b), nor(a, b));
    }

    private static final boolean xnorNand(final boolean a, final boolean b) {
        return nand(nand(nand(a, nand(a, b)), nand(b, nand(a, b))),
                nand(nand(a, nand(a, b)), nand(b, nand(a, b))));
    }

    private static final boolean xnorNor(final boolean a, final boolean b) {
        return nor(nor(a, nor(a, b)), nor(b, nor(a, b)));
    }

    private static final boolean ifThen(final boolean a, final boolean b) {
        return or(and(a, b), not(a));
    }

    private static final boolean thenIf(final boolean a, final boolean b) {
        return or(a, nor(a, b));
    }

    public static final boolean compute(GATE gate, boolean... values) {
        boolean result = false;

        if (values.length != gate.operands())
            throw new IllegalArgumentException(String.format(
                    "%s gate requires %d inputs.", gate.name(), gate.operands));

        try {
            Class<?> c = Class.forName(LogicGates.class.getName());
            Method method = null;

            if (gate.operands() == 2)
                method = c.getDeclaredMethod(gate.methodName(), boolean.class,
                        boolean.class);
            else if (gate.operands() == 1) {
                method = c.getDeclaredMethod(gate.methodName(), boolean.class);
            } else {
                method = null;
            }

            boolean[] args = Arrays.copyOfRange(values, 0, values.length);
            result = (boolean) method.invoke(c, new Object[] { args });
        } catch (Exception e) {
            System.out.println(e.getMessage() + " " + e.getCause());
        }

        return result;
    }

    public static final boolean compute(GATE gate, boolean a, boolean b) {
        boolean result = false;

        try {
            Class<?> c = Class.forName(LogicGates.class.getName());
            Method method = null;

            if (gate.operands() == 2)
                method = c.getDeclaredMethod(gate.methodName(), boolean.class,
                        boolean.class);
            else if (gate.operands() == 1) {
                method = c.getDeclaredMethod(gate.methodName(), boolean.class);
            } else {
                method = null;
            }

            result = (boolean) method.invoke(c, a, b);
        } catch (Exception e) {
            System.out.println(e.getMessage() + " " + e.getCause());
        }

        return result;
    }
}

Answer 1

在Java 7中，使用invokeWithArguments方法。

编辑：当然，这意味着使用Java 7 MethodHandle类代替旧的Java 1.1 Method类。

Answer 2

好吧，在我坐下来思考一下之后，我想出了一个解决方案：

<强>输出

>> Invoking SimpleGate.not(false)
>> Invoking SimpleGate.and(true,true)
>> Invoking SimpleGate.or(true,false)
>> Invoking SimpleGate$AdvancedGate.xor(true,false)
PASS

<强> ReflectTest.java

public class ReflectTest {
    private enum Gate {
        NOT(SimpleGate.class),
        AND(SimpleGate.class),
        OR(SimpleGate.class),
        XOR(SimpleGate.AdvancedGate.class);

        private Class<?> clazz;

        private Gate(Class<?> clazz) { this.clazz = clazz; }

        public Class<?> clazz() { return clazz; }
    }

    public static boolean compute(Gate gate, Boolean... input) {
        return (Boolean) Reflect.call(gate.clazz(),
                gate.name().toLowerCase(), (Object[]) input);
    }

    public static void main(String[] args) {
        Boolean not = compute(Gate.NOT, false);
        Boolean and = compute(Gate.AND, true, true);
        Boolean or = compute(Gate.OR, true, false);
        Boolean xor = compute(Gate.XOR, true, false);

        if (not && and && or && xor)
            System.out.println("PASS");
        else
            System.out.println("FAIL");
    }
}

<强> Reflect.java

import java.lang.reflect.Constructor;
import java.lang.reflect.Method;
import java.lang.reflect.Modifier;

public abstract class Reflect {
    public static final Object call(Class<?> clazz, String methodName, Object... varArgs) {
        try {
            Object invokee = null;
            String className = clazz.getName();
            int argc = varArgs.length;
            Class<?>[] classList = new Class[argc];
            StringBuffer varArgsStr = new StringBuffer();

            for (int i = 0; i < argc; i++) {
                Object argv = varArgs[i];
                classList[i] = argv.getClass();
                varArgsStr.append(argv.toString());

                if (i < argc - 1) varArgsStr.append(',');
            }
            System.out.printf(">> Invoking %s.%s(%s)\n", className,methodName, varArgsStr);

            Class<?> target = Class.forName(className);
            Method method = target.getDeclaredMethod(methodName, classList);
            int childIndex = className.indexOf('$');

            if (childIndex > -1) {
                String wrappingClassName = className.substring(0, childIndex);
                Class<?> wrapper = Class.forName(wrappingClassName);
                Object wrapperInstance = wrapper.newInstance();
                Constructor<?> con = target.getDeclaredConstructor(wrapper);

                invokee = con.newInstance(wrapperInstance);
            } else {
                boolean isStatic = Modifier.isStatic(method.getModifiers());

                invokee = isStatic ? target : target.newInstance();
            }

            return method.invoke(invokee, varArgs);

        } catch(Exception e) {
            e.printStackTrace();
        }

        return null;
    }
}

SimpleGate.java＆amp; SimpleGate $ AdvancedGate.java

public class SimpleGate {
    public Boolean not(Boolean a) { return !a; }

    public static Boolean and(Boolean a, Boolean b) { return a && b; }

    public static Boolean or(Boolean a, Boolean b) { return a || b; }

    public class AdvancedGate {
        public Boolean xor(Boolean a, Boolean b) {
            return or(and(not(a),b),and(a,not(b)));
        }
    }
}