Question

让我们假设我创建了一个名为Foo的Java库，我在该库中有一个名为Bar的类。让我们进一步假设在Bar类中我有一个名为fooBar的私有方法。

public class Bar {
    //...
    private Object fooBar() {
        //Do something
    }
    //...
}

可以使用类中编写的代码毫无困难地运行此方法，如下所示：

public static Object runMethod(Object object, String methodName) {
    Method method = object.getClass().getDeclaredMethod(methodName);
    method.setAccessible(true);
    return method.invoke(object);
}

但是，我们假设我们打算劝阻fooBar这个习惯。我们怎么能这样做呢？我们应该从某处获取堆栈跟踪并检查它的调用位置吗？或者我们应该做些什么呢？

Answer 1

您需要一名安全经理......

https://docs.oracle.com/javase/tutorial/essential/environment/security.html

安全管理器是一个定义安全策略的对象应用。此策略指定不安全的操作或敏感。安全策略不允许的任何操作都会导致抛出SecurityException。应用程序也可以查询它安全经理发现允许哪些操作。

它支持禁止setAccessible()通过反射使私有和受保护的方法可被调用。

Answer 2

我认为如果你想成为极端，你可以得到这样的堆栈跟踪：

public class Bar {
    //...
    private Object fooBar() {
        try {
            throw new CheckIfCalledFromMethodException(); 
        } catch(CheckIfCalledFromMethodException e) {
            //here you have access to stack trace in your exception
        }

        //Do something
    }
    //...
}

我整理了一个简单的场景，它检查调用该类的second实例是否是同一个对象或其他内容。

public class StackTraceTest {
    private void execute() {
        try {
            throw new Exception();
        } catch (Exception e) {
            /*for(int i = 0; i < e.getStackTrace().length; i++) {
                StackTraceElement stackTraceElement = e.getStackTrace()[i];
                System.out.println(stackTraceElement.getFileName());
            }
            System.out.println("");
            e.printStackTrace();*/
            if(!e.getStackTrace()[1].getFileName().equals(StackTraceTest.class.getSimpleName() + ".java")) {
                throw new IllegalAccessError("Illegal Access.");
            }
        }
    }

    public void executeExternal() {
        this.execute();
    }
}

和

public class AccsessorTest {
    public static void main(String[] args) throws NoSuchMethodException, InvocationTargetException, IllegalAccessException {
        StackTraceTest stackTraceTest = new StackTraceTest();
        stackTraceTest.executeExternal();
        System.out.println("Accessed from within other method in class.");
        System.out.println("");
        Class<?> clazz = StackTraceTest.class;
        Method method = clazz.getDeclaredMethod("execute");
        method.setAccessible(true);
        System.out.println("Accessing through reflection...");
        method.invoke(stackTraceTest);
    }
}

然后我得到

Accessed from within other method in class.

Reflection test start.
Accessing through reflection...
Exception in thread "main" java.lang.reflect.InvocationTargetException
    at sun.reflect.NativeMethodAccessorImpl.invoke0(Native Method)
    at sun.reflect.NativeMethodAccessorImpl.invoke(NativeMethodAccessorImpl.java:62)
    at sun.reflect.DelegatingMethodAccessorImpl.invoke(DelegatingMethodAccessorImpl.java:43)
    at java.lang.reflect.Method.invoke(Method.java:483)
    at stacktracetest.another.AccsessorTest.main(AccsessorTest.java:22)
    at sun.reflect.NativeMethodAccessorImpl.invoke0(Native Method)
    at sun.reflect.NativeMethodAccessorImpl.invoke(NativeMethodAccessorImpl.java:62)
    at sun.reflect.DelegatingMethodAccessorImpl.invoke(DelegatingMethodAccessorImpl.java:43)
    at java.lang.reflect.Method.invoke(Method.java:483)
    at com.intellij.rt.execution.application.AppMain.main(AppMain.java:134)
Caused by: java.lang.IllegalAccessError: Illegal Access.
    at stacktracetest.StackTraceTest.execute(StackTraceTest.java:18)
    ... 10 more

所以我猜我可以用堆栈跟踪元素魔法进行检查，但是你应该检查一下它是否真的有效，这是非常粗糙的，我只是在一秒钟之前把它放在一起。

Java阻止在类外调用私有或受保护的方法

2 个答案: