167

我有一个使用 XML 和反射将Objects 返回到另一个类的类。

通常这些对象是外部对象的子字段，但偶尔它是我想动态生成的。我尝试过这样的事情，但无济于事。我相信这是因为 Java 不允许您访问private反射方法。

Element node = outerNode.item(0);
String methodName = node.getAttribute("method");
String objectName = node.getAttribute("object");

if ("SomeObject".equals(objectName))
    object = someObject;
else
    object = this;

method = object.getClass().getMethod(methodName, (Class[]) null);

如果提供的方法是private，则失败并显示NoSuchMethodException. 我可以通过制作方法来解决它public，或者制作另一个类来派生它。

长话短说，我只是想知道是否有办法private通过反射访问方法。

4

7 回答 7

326

您可以使用反射调用私有方法。修改发布代码的最后一位：

Method method = object.getClass().getDeclaredMethod(methodName);
method.setAccessible(true);
Object r = method.invoke(object);

有几点需要注意。首先，getDeclaredMethod只会找到在 current 中声明的方法Class，而不是从超类型继承的。因此，如有必要，向上遍历具体的类层次结构。二是一种SecurityManager可以防止使用的setAccessible方法。因此，它可能需要作为PrivilegedAction（使用AccessController或Subject）运行。

于 2009-05-19T00:13:28.317 回答
35

用于getDeclaredMethod()获取私有 Method 对象，然后用于method.setAccessible()允许实际调用它。

于 2009-05-19T00:06:13.260 回答
30

如果该方法接受非原始数据类型，则可以使用以下方法调用任何类的私有方法：

public static Object genericInvokeMethod(Object obj, String methodName,
            Object... params) {
        int paramCount = params.length;
        Method method;
        Object requiredObj = null;
        Class<?>[] classArray = new Class<?>[paramCount];
        for (int i = 0; i < paramCount; i++) {
            classArray[i] = params[i].getClass();
        }
        try {
            method = obj.getClass().getDeclaredMethod(methodName, classArray);
            method.setAccessible(true);
            requiredObj = method.invoke(obj, params);
        } catch (NoSuchMethodException e) {
            e.printStackTrace();
        } catch (IllegalArgumentException e) {
            e.printStackTrace();
        } catch (IllegalAccessException e) {
            e.printStackTrace();
        } catch (InvocationTargetException e) {
            e.printStackTrace();
        }

        return requiredObj;
    }

接受的参数是 obj、methodName 和参数。例如

public class Test {
private String concatString(String a, String b) {
    return (a+b);
}
}

方法 concatString 可以调用为

Test t = new Test();
    String str = (String) genericInvokeMethod(t, "concatString", "Hello", "Mr.x");
于 2013-09-20T06:10:38.903 回答
11

您可以使用 Spring 的 ReflectionTestUtils ( org.springframework.test.util.ReflectionTestUtils )来做到这一点

ReflectionTestUtils.invokeMethod(instantiatedObject,"methodName",argument);

示例：如果您有一个带有私有方法的类square(int x)

Calculator calculator = new Calculator();
ReflectionTestUtils.invokeMethod(calculator,"square",10);
于 2018-05-14T12:48:14.683 回答
3

让我通过反射为执行受保护的方法提供完整的代码。它支持任何类型的参数，包括泛型、自动装箱参数和空值

@SuppressWarnings("unchecked")
public static <T> T executeSuperMethod(Object instance, String methodName, Object... params) throws Exception {
    return executeMethod(instance.getClass().getSuperclass(), instance, methodName, params);
}

public static <T> T executeMethod(Object instance, String methodName, Object... params) throws Exception {
    return executeMethod(instance.getClass(), instance, methodName, params);
}

@SuppressWarnings("unchecked")
public static <T> T executeMethod(Class clazz, Object instance, String methodName, Object... params) throws Exception {

    Method[] allMethods = clazz.getDeclaredMethods();

    if (allMethods != null && allMethods.length > 0) {

        Class[] paramClasses = Arrays.stream(params).map(p -> p != null ? p.getClass() : null).toArray(Class[]::new);

        for (Method method : allMethods) {
            String currentMethodName = method.getName();
            if (!currentMethodName.equals(methodName)) {
                continue;
            }
            Type[] pTypes = method.getParameterTypes();
            if (pTypes.length == paramClasses.length) {
                boolean goodMethod = true;
                int i = 0;
                for (Type pType : pTypes) {
                    if (!ClassUtils.isAssignable(paramClasses[i++], (Class<?>) pType)) {
                        goodMethod = false;
                        break;
                    }
                }
                if (goodMethod) {
                    method.setAccessible(true);
                    return (T) method.invoke(instance, params);
                }
            }
        }

        throw new MethodNotFoundException("There are no methods found with name " + methodName + " and params " +
            Arrays.toString(paramClasses));
    }

    throw new MethodNotFoundException("There are no methods found with name " + methodName);
}

方法使用 apache ClassUtils 检查自动装箱参数的兼容性

于 2018-04-05T10:20:33.837 回答
1

另一种变体是使用非常强大的 JOOR 库https://github.com/jOOQ/jOOR

MyObject myObject = new MyObject()
on(myObject).get("privateField");

它允许修改任何字段，如最终静态常量并调用 yne 受保护的方法，而无需在继承层次结构中指定具体类

<!-- https://mvnrepository.com/artifact/org.jooq/joor-java-8 -->
<dependency>
     <groupId>org.jooq</groupId>
     <artifactId>joor-java-8</artifactId>
     <version>0.9.7</version>
</dependency>
于 2018-04-05T15:51:14.827 回答
0

您可以使用Manifold 的 @Jailbreak进行直接的、类型安全的 Java 反射：

@Jailbreak Foo foo = new Foo();
foo.callMe();

public class Foo {
    private void callMe();
}

@Jailbreak解锁foo编译器中的局部变量，以便直接访问Foo的层次结构中的所有成员。

同样，您可以将jailbreak()扩展方法用于一次性使用：

foo.jailbreak().callMe();

通过该jailbreak()方法，您可以访问Foo层次结构中的任何成员。

在这两种情况下，编译器都会以类型安全的方式为您解析方法调用，就像一个公共方法一样，而 Manifold 会在后台为您生成高效的反射代码。

或者，如果类型不是静态已知的，您可以使用结构类型来定义一个类型可以满足的接口，而无需声明其实现。此策略维护类型安全并避免与反射和代理代码相关的性能和身份问题。

了解有关歧管的更多信息。

于 2018-12-09T04:41:41.167 回答