--- old/src/java.base/share/classes/jdk/internal/reflect/ReflectionFactory.java 2019-07-19 09:06:01.000000000 -0700 +++ new/src/java.base/share/classes/jdk/internal/reflect/ReflectionFactory.java 2019-07-19 09:06:00.000000000 -0700 @@ -43,6 +43,8 @@ import java.util.Objects; import java.util.Properties; +import jdk.internal.access.JavaLangReflectAccess; +import jdk.internal.access.SharedSecrets; import jdk.internal.misc.VM; import sun.reflect.misc.ReflectUtil; import sun.security.action.GetPropertyAction; @@ -64,8 +66,7 @@ private static boolean initted = false; private static final ReflectionFactory soleInstance = new ReflectionFactory(); - // Provides access to package-private mechanisms in java.lang.reflect - private static volatile LangReflectAccess langReflectAccess; + /* Method for static class initializer , or null */ private static volatile Method hasStaticInitializerMethod; @@ -90,7 +91,9 @@ // true if deserialization constructor checking is disabled private static boolean disableSerialConstructorChecks = false; + private final JavaLangReflectAccess langReflectAccess; private ReflectionFactory() { + this.langReflectAccess = SharedSecrets.getJavaLangReflectAccess(); } /** @@ -160,12 +163,7 @@ // // - /** Called only by java.lang.reflect.Modifier's static initializer */ - public void setLangReflectAccess(LangReflectAccess access) { - langReflectAccess = access; - } - - /** + /* * Note: this routine can cause the declaring class for the field * be initialized and therefore must not be called until the * first get/set of this field. @@ -175,7 +173,7 @@ public FieldAccessor newFieldAccessor(Field field, boolean override) { checkInitted(); - Field root = langReflectAccess().getRoot(field); + Field root = langReflectAccess.getRoot(field); if (root != null) { // FieldAccessor will use the root unless the modifiers have // been overrridden @@ -197,7 +195,7 @@ } // use the root Method that will not cache caller class - Method root = langReflectAccess().getRoot(method); + Method root = langReflectAccess.getRoot(method); if (root != null) { method = root; } @@ -233,7 +231,7 @@ } // use the root Constructor that will not cache caller class - Constructor root = langReflectAccess().getRoot(c); + Constructor root = langReflectAccess.getRoot(c); if (root != null) { c = root; } @@ -268,52 +266,6 @@ // // - /** Creates a new java.lang.reflect.Field. Access checks as per - java.lang.reflect.AccessibleObject are not overridden. */ - public Field newField(Class declaringClass, - String name, - Class type, - int modifiers, - int slot, - String signature, - byte[] annotations) - { - return langReflectAccess().newField(declaringClass, - name, - type, - modifiers, - slot, - signature, - annotations); - } - - /** Creates a new java.lang.reflect.Method. Access checks as per - java.lang.reflect.AccessibleObject are not overridden. */ - public Method newMethod(Class declaringClass, - String name, - Class[] parameterTypes, - Class returnType, - Class[] checkedExceptions, - int modifiers, - int slot, - String signature, - byte[] annotations, - byte[] parameterAnnotations, - byte[] annotationDefault) - { - return langReflectAccess().newMethod(declaringClass, - name, - parameterTypes, - returnType, - checkedExceptions, - modifiers, - slot, - signature, - annotations, - parameterAnnotations, - annotationDefault); - } - /** Creates a new java.lang.reflect.Constructor. Access checks as per java.lang.reflect.AccessibleObject are not overridden. */ public Constructor newConstructor(Class declaringClass, @@ -325,30 +277,20 @@ byte[] annotations, byte[] parameterAnnotations) { - return langReflectAccess().newConstructor(declaringClass, - parameterTypes, - checkedExceptions, - modifiers, - slot, - signature, - annotations, - parameterAnnotations); - } - - /** Gets the MethodAccessor object for a java.lang.reflect.Method */ - public MethodAccessor getMethodAccessor(Method m) { - return langReflectAccess().getMethodAccessor(m); - } - - /** Sets the MethodAccessor object for a java.lang.reflect.Method */ - public void setMethodAccessor(Method m, MethodAccessor accessor) { - langReflectAccess().setMethodAccessor(m, accessor); + return langReflectAccess.newConstructor(declaringClass, + parameterTypes, + checkedExceptions, + modifiers, + slot, + signature, + annotations, + parameterAnnotations); } /** Gets the ConstructorAccessor object for a java.lang.reflect.Constructor */ public ConstructorAccessor getConstructorAccessor(Constructor c) { - return langReflectAccess().getConstructorAccessor(c); + return langReflectAccess.getConstructorAccessor(c); } /** Sets the ConstructorAccessor object for a @@ -356,21 +298,21 @@ public void setConstructorAccessor(Constructor c, ConstructorAccessor accessor) { - langReflectAccess().setConstructorAccessor(c, accessor); + langReflectAccess.setConstructorAccessor(c, accessor); } /** Makes a copy of the passed method. The returned method is a "child" of the passed one; see the comments in Method.java for details. */ public Method copyMethod(Method arg) { - return langReflectAccess().copyMethod(arg); + return langReflectAccess.copyMethod(arg); } /** Makes a copy of the passed method. The returned method is NOT * a "child" but a "sibling" of the Method in arg. Should only be * used on non-root methods. */ public Method leafCopyMethod(Method arg) { - return langReflectAccess().leafCopyMethod(arg); + return langReflectAccess.leafCopyMethod(arg); } @@ -378,30 +320,30 @@ "child" of the passed one; see the comments in Field.java for details. */ public Field copyField(Field arg) { - return langReflectAccess().copyField(arg); + return langReflectAccess.copyField(arg); } /** Makes a copy of the passed constructor. The returned constructor is a "child" of the passed one; see the comments in Constructor.java for details. */ public Constructor copyConstructor(Constructor arg) { - return langReflectAccess().copyConstructor(arg); + return langReflectAccess.copyConstructor(arg); } /** Gets the byte[] that encodes TypeAnnotations on an executable. */ public byte[] getExecutableTypeAnnotationBytes(Executable ex) { - return langReflectAccess().getExecutableTypeAnnotationBytes(ex); + return langReflectAccess.getExecutableTypeAnnotationBytes(ex); } public Class[] getExecutableSharedParameterTypes(Executable ex) { - return langReflectAccess().getExecutableSharedParameterTypes(ex); + return langReflectAccess.getExecutableSharedParameterTypes(ex); } public T newInstance(Constructor ctor, Object[] args, Class caller) throws IllegalAccessException, InstantiationException, InvocationTargetException { - return langReflectAccess().newInstance(ctor, args, caller); + return langReflectAccess.newInstance(ctor, args, caller); } //-------------------------------------------------------------------------- @@ -526,13 +468,13 @@ constructorToCall.getParameterTypes(), constructorToCall.getExceptionTypes(), constructorToCall.getModifiers(), - langReflectAccess(). + langReflectAccess. getConstructorSlot(constructorToCall), - langReflectAccess(). + langReflectAccess. getConstructorSignature(constructorToCall), - langReflectAccess(). + langReflectAccess. getConstructorAnnotations(constructorToCall), - langReflectAccess(). + langReflectAccess. getConstructorParameterAnnotations(constructorToCall)); setConstructorAccessor(c, acc); c.setAccessible(true); @@ -725,17 +667,6 @@ initted = true; } - private static LangReflectAccess langReflectAccess() { - if (langReflectAccess == null) { - // Call a static method to get class java.lang.reflect.Modifier - // initialized. Its static initializer will cause - // setLangReflectAccess() to be called from the context of the - // java.lang.reflect package. - Modifier.isPublic(Modifier.PUBLIC); - } - return langReflectAccess; - } - /** * Returns true if classes are defined in the classloader and same package, false * otherwise.