Categories:
Audio (13)
Biotech (29)
Bytecode (36)
Database (77)
Framework (7)
Game (7)
General (507)
Graphics (53)
I/O (35)
IDE (2)
JAR Tools (101)
JavaBeans (21)
JDBC (121)
JDK (426)
JSP (20)
Logging (108)
Mail (58)
Messaging (8)
Network (84)
PDF (97)
Report (7)
Scripting (84)
Security (32)
Server (121)
Servlet (26)
SOAP (24)
Testing (54)
Web (15)
XML (309)
Collections:
Other Resources:
JDK 11 java.base.jmod - Base Module
JDK 11 java.base.jmod is the JMOD file for JDK 11 Base module.
JDK 11 Base module compiled class files are stored in \fyicenter\jdk-11.0.1\jmods\java.base.jmod.
JDK 11 Base module compiled class files are also linked and stored in the \fyicenter\jdk-11.0.1\lib\modules JImage file.
JDK 11 Base module source code files are stored in \fyicenter\jdk-11.0.1\lib\src.zip\java.base.
You can click and view the content of each source code file in the list below.
✍: FYIcenter
⏎ jdk/internal/reflect/Reflection.java
/* * Copyright (c) 2001, 2018, Oracle and/or its affiliates. All rights reserved. * ORACLE PROPRIETARY/CONFIDENTIAL. Use is subject to license terms. * * * * * * * * * * * * * * * * * * * * */ package jdk.internal.reflect; import java.lang.reflect.*; import java.util.HashMap; import java.util.Map; import java.util.Objects; import jdk.internal.HotSpotIntrinsicCandidate; import jdk.internal.loader.ClassLoaders; import jdk.internal.misc.VM; /** Common utility routines used by both java.lang and java.lang.reflect */ public class Reflection { /** Used to filter out fields and methods from certain classes from public view, where they are sensitive or they may contain VM-internal objects. These Maps are updated very rarely. Rather than synchronize on each access, we use copy-on-write */ private static volatile Map<Class<?>,String[]> fieldFilterMap; private static volatile Map<Class<?>,String[]> methodFilterMap; static { Map<Class<?>,String[]> map = new HashMap<Class<?>,String[]>(); map.put(Reflection.class, new String[] {"fieldFilterMap", "methodFilterMap"}); map.put(System.class, new String[] {"security"}); map.put(Class.class, new String[] {"classLoader"}); fieldFilterMap = map; methodFilterMap = new HashMap<>(); } /** Returns the class of the caller of the method calling this method, ignoring frames associated with java.lang.reflect.Method.invoke() and its implementation. */ @CallerSensitive @HotSpotIntrinsicCandidate public static native Class<?> getCallerClass(); /** Retrieves the access flags written to the class file. For inner classes these flags may differ from those returned by Class.getModifiers(), which searches the InnerClasses attribute to find the source-level access flags. This is used instead of Class.getModifiers() for run-time access checks due to compatibility reasons; see 4471811. Only the values of the low 13 bits (i.e., a mask of 0x1FFF) are guaranteed to be valid. */ @HotSpotIntrinsicCandidate public static native int getClassAccessFlags(Class<?> c); /** * Ensures that access to a member is granted and throws * IllegalAccessException if not. * * @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 * @throws IllegalAccessException if access to member is denied */ public static void ensureMemberAccess(Class<?> currentClass, Class<?> memberClass, Class<?> targetClass, int modifiers) throws IllegalAccessException { if (!verifyMemberAccess(currentClass, memberClass, targetClass, modifiers)) { throw newIllegalAccessException(currentClass, memberClass, targetClass, modifiers); } } /** * 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) { if (currentClass == memberClass) { // Always succeeds return true; } 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; } } // At this point we know that currentClass can access memberClass. if (Modifier.isPublic(modifiers)) { return true; } // Check for nestmate access if member is private if (Modifier.isPrivate(modifiers)) { // Note: targetClass may be outside the nest, but that is okay // as long as memberClass is in the nest. if (areNestMates(currentClass, memberClass)) { return true; } } boolean successSoFar = false; if (Modifier.isProtected(modifiers)) { // See if currentClass is a subclass of memberClass if (isSubclassOf(currentClass, memberClass)) { successSoFar = true; } } if (!successSoFar && !Modifier.isPrivate(modifiers)) { if (!gotIsSameClassPackage) { isSameClassPackage = isSameClassPackage(currentClass, memberClass); gotIsSameClassPackage = true; } if (isSameClassPackage) { successSoFar = true; } } if (!successSoFar) { return false; } // Additional test for protected instance members // and protected constructors: JLS 6.6.2 if (targetClass != null && Modifier.isProtected(modifiers) && targetClass != currentClass) { if (!gotIsSameClassPackage) { isSameClassPackage = isSameClassPackage(currentClass, memberClass); gotIsSameClassPackage = true; } if (!isSameClassPackage) { if (!isSubclassOf(targetClass, currentClass)) { return false; } } } return true; } /** * Returns {@code true} if memberClass's module exports memberClass's * package to currentModule. */ public static boolean verifyModuleAccess(Module currentModule, Class<?> memberClass) { Module memberModule = memberClass.getModule(); 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(); return memberModule.isExported(pkg, currentModule); } } /** * Returns true if two classes in the same package. */ private static boolean isSameClassPackage(Class<?> c1, Class<?> c2) { if (c1.getClassLoader() != c2.getClassLoader()) return false; return Objects.equals(c1.getPackageName(), c2.getPackageName()); } static boolean isSubclassOf(Class<?> queryClass, Class<?> ofClass) { while (queryClass != null) { if (queryClass == ofClass) { return true; } queryClass = queryClass.getSuperclass(); } return false; } // fieldNames must contain only interned Strings public static synchronized void registerFieldsToFilter(Class<?> containingClass, String ... fieldNames) { fieldFilterMap = registerFilter(fieldFilterMap, containingClass, fieldNames); } // methodNames must contain only interned Strings public static synchronized void registerMethodsToFilter(Class<?> containingClass, String ... methodNames) { methodFilterMap = registerFilter(methodFilterMap, containingClass, methodNames); } private static Map<Class<?>,String[]> registerFilter(Map<Class<?>,String[]> map, Class<?> containingClass, String ... names) { if (map.get(containingClass) != null) { throw new IllegalArgumentException ("Filter already registered: " + containingClass); } map = new HashMap<Class<?>,String[]>(map); map.put(containingClass, names); return map; } public static Field[] filterFields(Class<?> containingClass, Field[] fields) { if (fieldFilterMap == null) { // Bootstrapping return fields; } return (Field[])filter(fields, fieldFilterMap.get(containingClass)); } public static Method[] filterMethods(Class<?> containingClass, Method[] methods) { if (methodFilterMap == null) { // Bootstrapping return methods; } return (Method[])filter(methods, methodFilterMap.get(containingClass)); } private static Member[] filter(Member[] members, String[] filteredNames) { if ((filteredNames == null) || (members.length == 0)) { return members; } int numNewMembers = 0; for (Member member : members) { boolean shouldSkip = false; for (String filteredName : filteredNames) { if (member.getName() == filteredName) { shouldSkip = true; break; } } if (!shouldSkip) { ++numNewMembers; } } Member[] newMembers = (Member[])Array.newInstance(members[0].getClass(), numNewMembers); int destIdx = 0; for (Member member : members) { boolean shouldSkip = false; for (String filteredName : filteredNames) { if (member.getName() == filteredName) { shouldSkip = true; break; } } if (!shouldSkip) { newMembers[destIdx++] = member; } } return newMembers; } /** * Tests if the given method is caller-sensitive and the declaring class * is defined by either the bootstrap class loader or platform class loader. */ public static boolean isCallerSensitive(Method m) { final ClassLoader loader = m.getDeclaringClass().getClassLoader(); if (VM.isSystemDomainLoader(loader)) { return m.isAnnotationPresent(CallerSensitive.class); } return false; } /** * Returns an IllegalAccessException with an exception message based on * the access that is denied. */ public static IllegalAccessException newIllegalAccessException(Class<?> currentClass, Class<?> memberClass, Class<?> targetClass, int modifiers) throws IllegalAccessException { String currentSuffix = ""; String memberSuffix = ""; Module m1 = currentClass.getModule(); if (m1.isNamed()) currentSuffix = " (in " + m1 + ")"; Module m2 = memberClass.getModule(); if (m2.isNamed()) memberSuffix = " (in " + m2 + ")"; String memberPackageName = memberClass.getPackageName(); String msg = currentClass + currentSuffix + " cannot access "; if (m2.isExported(memberPackageName, m1)) { // module access okay so include the modifiers in the message msg += "a member of " + memberClass + memberSuffix + " with modifiers \"" + Modifier.toString(modifiers) + "\""; } else { // module access failed msg += memberClass + memberSuffix+ " because " + m2 + " does not export " + memberPackageName; if (m2.isNamed()) msg += " to " + m1; } return new IllegalAccessException(msg); } /** * Returns true if {@code currentClass} and {@code memberClass} * are nestmates - that is, if they have the same nesthost as * determined by the VM. */ public static native boolean areNestMates(Class<?> currentClass, Class<?> memberClass); }
⏎ jdk/internal/reflect/Reflection.java
Or download all of them as a single archive file:
File name: java.base-11.0.1-src.zip File size: 8740354 bytes Release date: 2018-11-04 Download
2020-05-29, 206326👍, 0💬
Popular Posts:
What Is XMLBeans xbean.jar 2.6.0? XMLBeans xbean.jar 2.6.0 is the JAR file for Apache XMLBeans 2.6.0...
Java Advanced Imaging (JAI) is a Java platform extension API that provides a set of object-oriented ...
JDK 7 tools.jar is the JAR file for JDK 7 tools. It contains Java classes to support different JDK t...
Smack is an Open Source XMPP (Jabber) client library for instant messaging and presence. A pure Java...
commons-net-1.4.1.jar is the JAR file for Apache Commons Net 1.4.1, which implements the client side...