[Java] Wrapper, der die private Methode eines Objekts von außerhalb der Klasse ausführt

Beim Schreiben von Tests greife ich manchmal auf die privaten Methoden des Objekts zu. Ich habe eine einfache Wrapper-Funktion erstellt, weil ich dies nicht tun kann, indem ich jedes Mal direkt auf die Reflexion treffe.

class Main {

    /**
     *Führen Sie die private Objektmethode aus
     *
     * @param target Instanz des Zielobjekts
     * @Parametername Methodenname
     * @param <T>Zielobjekttyp
     * @löst beim Ausführen der Methode eine Ausnahme aus
     */
    public static <T> void invokeMethod(T target, String name) throws Exception {
        final Method method = target.getClass().getDeclaredMethod(name);
        method.setAccessible(true);
        method.invoke(target);
    }

    /**
     *Führen Sie die private Objektmethode aus
     *
     * @param target Instanz des Zielobjekts
     * @Parametername Methodenname
     * @param parameterValues Liste der Argumente
     * @param <T>Zielobjekttyp
     * @löst beim Ausführen der Methode eine Ausnahme aus
     */
    public static <T> void invokeMethod(T target, String name, List<?> parameterValues) throws Exception {
        //Holen Sie sich ein Array von Argumenttypen
        final Class<?>[] parameterTypes = new Class[parameterValues.size()];
        parameterValues.stream().map(Object::getClass).collect(Collectors.toList()).toArray(parameterTypes);

        final Method method = target.getClass().getDeclaredMethod(name, parameterTypes);
        method.setAccessible(true);
        method.invoke(target, parameterValues.toArray());
    }

    /**
     *Führen Sie die private Objektmethode aus
     *
     * @param target Instanz des Zielobjekts
     * @Parametername Methodenname
     * @param parameterValues Liste der Argumente
     * @param resultType Klasseninstanz des Ergebnisobjekts
     * @param <T>Zielobjekttyp
     * @param <U>Rückgabetyp
     * @Rückgabewert der Rückgabemethode
     * @löst beim Ausführen der Methode eine Ausnahme aus
     */
    public static <T, U> U invokeMethod(T target, String name, List<?> parameterValues, Class<U> resultType) throws Exception {
        //Holen Sie sich ein Array von Argumenttypen
        final Class<?>[] parameterTypes = new Class[parameterValues.size()];
        parameterValues.stream().map(Object::getClass).collect(Collectors.toList()).toArray(parameterTypes);

        final Method method = target.getClass().getDeclaredMethod(name, parameterTypes);
        method.setAccessible(true);
        return resultType.cast(method.invoke(target, parameterValues.toArray()));
    }

    static class PrivateMethodTest {
        private void sayHelloWorld() {
            System.out.println(makeHelloMessage("world!"));
        }
        private void sayHello(String message) {
            System.out.println(makeHelloMessage(message));
        }
        private String makeHelloMessage(String message) {
            return "Hello, " + message;
        }
    }

    public static void main(String[] args) throws Exception {
        final PrivateMethodTest target = new PrivateMethodTest();

        invokeMethod(target, "sayHelloWorld");

        final List<Object> params = new ArrayList<>();
        params.add("world!");

        invokeMethod(target, "sayHello", params);

        final String message = invokeMethod(target, "makeHelloMessage", params, String.class);
        System.out.println(message);
    }
}