static AccessClassLoader get (Class type) { ClassLoader parent = getParentClassLoader(type); // 1. fast-path: if (selfContextParentClassLoader.equals(parent)) { if (selfContextAccessClassLoader == null) { synchronized (accessClassLoaders) { // DCL with volatile semantics if (selfContextAccessClassLoader == null) selfContextAccessClassLoader = new AccessClassLoader(selfContextParentClassLoader); } } return selfContextAccessClassLoader; } // 2. normal search: synchronized (accessClassLoaders) { WeakReference<AccessClassLoader> ref = accessClassLoaders.get(parent); if (ref != null) { AccessClassLoader accessClassLoader = ref.get(); if (accessClassLoader != null) return accessClassLoader; else accessClassLoaders.remove(parent); // the value has been GC-reclaimed, but still not the key (defensive sanity) } AccessClassLoader accessClassLoader = new AccessClassLoader(parent); accessClassLoaders.put(parent, new WeakReference<AccessClassLoader>(accessClassLoader)); return accessClassLoader; } }
Class<?> defineClass (String name, byte[] bytes) throws ClassFormatError { try { // Attempt to load the access class in the same loader, which makes protected and default access members accessible. return (Class<?>)getDefineClassMethod().invoke(getParent(), new Object[] {name, bytes, Integer.valueOf(0), Integer.valueOf(bytes.length), getClass().getProtectionDomain()}); } catch (Exception ignored) { // continue with the definition in the current loader (won't have access to protected and package-protected members) } return defineClass(name, bytes, 0, bytes.length, getClass().getProtectionDomain()); }
/** Returns null if the access class has not yet been defined. */ Class loadAccessClass (String name) { // No need to check the parent class loader if the access class hasn't been defined yet. if (localClassNames.contains(name)) { try { return loadClass(name, false); } catch (ClassNotFoundException ex) { throw new RuntimeException(ex); // Should not happen, since we know the class has been defined. } } return null; }
AccessClassLoader loader = AccessClassLoader.get(type); synchronized (loader) { accessClass = loader.loadAccessClass(accessClassName); if (accessClass == null) { String accessClassNameInternal = accessClassName.replace('.', '/'); accessClass = loader.defineAccessClass(accessClassName, cw.toByteArray()); throw new RuntimeException("Exception constructing constructor access class: " + accessClassName, t); if (!(access instanceof PublicConstructorAccess) && !AccessClassLoader.areInSameRuntimeClassLoader(type, accessClass)) {
Class accessClass = null; AccessClassLoader loader = AccessClassLoader.get(type); synchronized (loader) { try { accessClass = loader.loadClass(accessClassName); } catch (ClassNotFoundException ignored) { String accessClassNameInternal = accessClassName.replace('.', '/'); accessClass = loader.defineClass(accessClassName, cw.toByteArray());
static public FieldAccess get (Class type) { AccessClassLoader loader = new AccessClassLoader(type.getClassLoader()); Class accessClass = null; try { accessClass = loader.loadClass(accessClassName); } catch (ClassNotFoundException ignored) { accessClass = loader.defineClass(accessClassName, data);
Class<?> defineClass (String name, byte[] bytes) throws ClassFormatError { try { // Attempt to load the access class in the same loader, which makes protected and default access members accessible. Method method = ClassLoader.class.getDeclaredMethod("defineClass", new Class[] {String.class, byte[].class, int.class, int.class}); method.setAccessible(true); return (Class)method.invoke(getParent(), new Object[] {name, bytes, new Integer(0), new Integer(bytes.length)}); } catch (Exception ignored) { } return defineClass(name, bytes, 0, bytes.length); } }
AccessClassLoader loader = AccessClassLoader.get(type); synchronized (loader) { accessClass = loader.loadAccessClass(accessClassName); if (accessClass == null) { String accessClassNameInternal = accessClassName.replace('.', '/'); insertGetString(cw, classNameInternal, fields); cw.visitEnd(); accessClass = loader.defineAccessClass(accessClassName, cw.toByteArray());
Class accessClass; AccessClassLoader loader = AccessClassLoader.get(type); try { accessClass = loader.loadClassLocal(accessClassName); } catch (ClassNotFoundException ignored) { synchronized (loader) { try { accessClass = loader.loadClassLocal(accessClassName); } catch (ClassNotFoundException ignored2) { String accessClassNameInternal = accessClassName.replace('.', '/'); accessClass = loader.defineClassLocal(accessClassName, cw.toByteArray()); throw new RuntimeException("Exception constructing constructor access class: " + accessClassName, t); if (!(access instanceof PublicConstructorAccess) && !AccessClassLoader.areInSameRuntimeClassLoader(type, accessClass)) {
Class accessClass; AccessClassLoader loader = AccessClassLoader.get(type); try { accessClass = loader.loadClassLocal(accessClassName); } catch (ClassNotFoundException ignored) { synchronized (loader) { try { accessClass = loader.loadClassLocal(accessClassName); } catch (ClassNotFoundException ignored2) { String accessClassNameInternal = accessClassName.replace('.', '/'); accessClass = loader.defineClassLocal(accessClassName, data);
Class defineAccessClass (String name, byte[] bytes) throws ClassFormatError { localClassNames.add(name); return defineClass(name, bytes); }
Class accessClass; AccessClassLoader loader = AccessClassLoader.get(type); synchronized (loader) { try { accessClass = loader.loadClass(accessClassName); } catch (ClassNotFoundException ignored) { String accessClassNameInternal = accessClassName.replace('.', '/'); accessClass = loader.defineClass(accessClassName, data);
static public MethodAccess get (Class type) { AccessClassLoader loader = new AccessClassLoader(type.getClassLoader()); Class accessClass = null; try { accessClass = loader.loadClass(accessClassName); } catch (ClassNotFoundException ignored) { accessClass = loader.defineClass(accessClassName, data);
Class<?> defineClass (String name, byte[] bytes) throws ClassFormatError { try { // Attempt to load the access class in the same loader, which makes protected and default access members accessible. Method method = ClassLoader.class.getDeclaredMethod("defineClass", new Class[] {String.class, byte[].class, int.class, int.class, ProtectionDomain.class}); if (!method.isAccessible()) method.setAccessible(true); return (Class)method.invoke(getParent(), new Object[] {name, bytes, Integer.valueOf(0), Integer.valueOf(bytes.length), getClass().getProtectionDomain()}); } catch (Exception ignored) { } return defineClass(name, bytes, 0, bytes.length, getClass().getProtectionDomain()); }
AccessClassLoader loader = AccessClassLoader.get(type); synchronized (loader) { accessClass = loader.loadAccessClass(accessClassName); if (accessClass == null) { String accessClassNameInternal = accessClassName.replace('.', '/'); accessClass = loader.defineAccessClass(accessClassName, data);
AccessClassLoader loader = AccessClassLoader.get(type); synchronized (loader) { accessClass = loader.loadAccessClass(accessClassName); if (accessClass == null) { String accessClassNameInternal = accessClassName.replace('.', '/'); accessClass = loader.defineAccessClass(accessClassName, cw.toByteArray()); throw new RuntimeException("Exception constructing constructor access class: " + accessClassName, t); if (!(access instanceof PublicConstructorAccess) && !AccessClassLoader.areInSameRuntimeClassLoader(type, accessClass)) {
Class accessClass = null; AccessClassLoader loader = AccessClassLoader.get(type); try { accessClass = loader.loadClassLocal(accessClassName); } catch (ClassNotFoundException ignored) { synchronized (loader) { try { accessClass = loader.loadClassLocal(accessClassName); } catch (ClassNotFoundException ignored2) { String accessClassNameInternal = accessClassName.replace('.', '/'); insertGetString(cw, classNameInternal, fields); cw.visitEnd(); accessClass = loader.defineClassLocal(accessClassName, cw.toByteArray());
Class defineAccessClass (String name, byte[] bytes) throws ClassFormatError { localClassNames.add(name); return defineClass(name, bytes); }
Class accessClass = null; AccessClassLoader loader = AccessClassLoader.get(type); synchronized (loader) { try { accessClass = loader.loadClass(accessClassName); } catch (ClassNotFoundException ignored) { String accessClassNameInternal = accessClassName.replace('.', '/'); insertGetString(cw, classNameInternal, fields); cw.visitEnd(); accessClass = loader.defineClass(accessClassName, cw.toByteArray());
Class<?> defineClass (String name, byte[] bytes) throws ClassFormatError { try { // Attempt to load the access class in the same loader, which makes protected and default access members accessible. return (Class<?>)getDefineClassMethod().invoke(getParent(), new Object[] {name, bytes, Integer.valueOf(0), Integer.valueOf(bytes.length), getClass().getProtectionDomain()}); } catch (Exception ignored) { // continue with the definition in the current loader (won't have access to protected and package-protected members) } return defineClass(name, bytes, 0, bytes.length, getClass().getProtectionDomain()); }