< prev index next >
src/java.base/share/classes/jdk/internal/reflect/Reflection.java
Print this page
@@ -29,13 +29,11 @@
import java.lang.reflect.*;
import java.util.HashMap;
import java.util.Map;
import java.util.Objects;
import jdk.internal.HotSpotIntrinsicCandidate;
-import jdk.internal.misc.SharedSecrets;
import jdk.internal.misc.VM;
-import sun.security.action.GetPropertyAction;
/** Common utility routines used by both java.lang and
java.lang.reflect */
public class Reflection {
@@ -102,43 +100,44 @@
Class<?> memberClass,
Class<?> targetClass,
int modifiers)
throws IllegalAccessException
{
- if (currentClass == null || memberClass == null) {
- throw new InternalError();
- }
-
if (!verifyMemberAccess(currentClass, memberClass, targetClass, modifiers)) {
- throwIllegalAccessException(currentClass, memberClass, targetClass, modifiers);
+ throw newIllegalAccessException(currentClass, memberClass, targetClass, modifiers);
}
}
/**
- * Verify access to a member, returning {@code false} if no access
+ * Verify access to a member and return {@code true} if it is granted.
+ *
+ * @param currentClass the class performing the access
+ * @param memberClass the declaring class of the member being accessed
+ * @param targetClass the class of target object if accessing instance
+ * field or method;
+ * or the declaring class if accessing constructor;
+ * or null if accessing static field or method
+ * @param modifiers the member's access modifiers
+ * @return {@code true} if access to member is granted
*/
public static boolean verifyMemberAccess(Class<?> currentClass,
Class<?> memberClass,
Class<?> targetClass,
int modifiers)
{
- // Verify that currentClass can access a field, method, or
- // constructor of memberClass, where that member's access bits are
- // "modifiers".
-
- boolean gotIsSameClassPackage = false;
- boolean isSameClassPackage = false;
-
if (currentClass == memberClass) {
// Always succeeds
return true;
}
- if (!verifyModuleAccess(currentClass, memberClass)) {
+ if (!verifyModuleAccess(currentClass.getModule(), memberClass)) {
return false;
}
+ boolean gotIsSameClassPackage = false;
+ boolean isSameClassPackage = false;
+
if (!Modifier.isPublic(getClassAccessFlags(memberClass))) {
isSameClassPackage = isSameClassPackage(currentClass, memberClass);
gotIsSameClassPackage = true;
if (!isSameClassPackage) {
return false;
@@ -194,35 +193,24 @@
return true;
}
/**
- * Returns {@code true} if memberClass's's module exports memberClass's
- * package to currentClass's module.
+ * Returns {@code true} if memberClass's module exports memberClass's
+ * package to currentModule.
*/
- public static boolean verifyModuleAccess(Class<?> currentClass,
- Class<?> memberClass) {
- return verifyModuleAccess(currentClass.getModule(), memberClass);
- }
-
public static boolean verifyModuleAccess(Module currentModule, Class<?> memberClass) {
Module memberModule = memberClass.getModule();
-
- // module may be null during startup (initLevel 0)
- if (currentModule == memberModule)
- return true; // same module (named or unnamed)
-
+ if (currentModule == memberModule) {
+ // same module (named or unnamed) or both null if called
+ // before module system is initialized, which means we are
+ // dealing with java.base only.
+ return true;
+ } else {
String pkg = memberClass.getPackageName();
- boolean allowed = memberModule.isExported(pkg, currentModule);
- if (allowed && memberModule.isNamed() && printStackTraceWhenAccessSucceeds()) {
- if (!SharedSecrets.getJavaLangReflectModuleAccess()
- .isStaticallyExported(memberModule, pkg, currentModule)) {
- String msg = currentModule + " allowed access to member of " + memberClass;
- new Exception(msg).printStackTrace(System.err);
- }
+ return memberModule.isExported(pkg, currentModule);
}
- return allowed;
}
/**
* Returns true if two classes in the same package.
*/
@@ -342,49 +330,17 @@
cl = cl.getParent();
}
return false;
}
-
- // true to print a stack trace when access fails
- private static volatile boolean printStackWhenAccessFails;
-
- // true to print a stack trace when access succeeds
- private static volatile boolean printStackWhenAccessSucceeds;
-
- // true if printStack* values are initialized
- private static volatile boolean printStackPropertiesSet;
-
- private static void ensurePrintStackPropertiesSet() {
- if (!printStackPropertiesSet && VM.initLevel() >= 1) {
- String s = GetPropertyAction.privilegedGetProperty(
- "sun.reflect.debugModuleAccessChecks");
- if (s != null) {
- printStackWhenAccessFails = !s.equalsIgnoreCase("false");
- printStackWhenAccessSucceeds = s.equalsIgnoreCase("access");
- }
- printStackPropertiesSet = true;
- }
- }
-
- public static boolean printStackTraceWhenAccessFails() {
- ensurePrintStackPropertiesSet();
- return printStackWhenAccessFails;
- }
-
- public static boolean printStackTraceWhenAccessSucceeds() {
- ensurePrintStackPropertiesSet();
- return printStackWhenAccessSucceeds;
- }
-
/**
- * Throws IllegalAccessException with the an exception message based on
+ * Returns an IllegalAccessException with an exception message based on
* the access that is denied.
*/
- private static void throwIllegalAccessException(Class<?> currentClass,
+ public static IllegalAccessException newIllegalAccessException(Class<?> currentClass,
Class<?> memberClass,
- Object target,
+ Class<?> targetClass,
int modifiers)
throws IllegalAccessException
{
String currentSuffix = "";
String memberSuffix = "";
@@ -409,22 +365,8 @@
msg += memberClass + memberSuffix+ " because "
+ m2 + " does not export " + memberPackageName;
if (m2.isNamed()) msg += " to " + m1;
}
- throwIllegalAccessException(msg);
- }
-
- /**
- * Throws IllegalAccessException with the given exception message.
- */
- public static void throwIllegalAccessException(String msg)
- throws IllegalAccessException
- {
- IllegalAccessException e = new IllegalAccessException(msg);
- ensurePrintStackPropertiesSet();
- if (printStackWhenAccessFails) {
- e.printStackTrace(System.err);
- }
- throw e;
+ return new IllegalAccessException(msg);
}
}
< prev index next >