public static ResourceTransformer createTransformer(URL[] extraURL, ResourceTransformationFactory factory) { URLClassLoader classLoader = new URLClassLoader(extraURL, safeParentClassLoader()); final ResourceTransformer transformerDelegate = factory.createTransformer( factory.createResolver(new ClasspathResourceLoader(classLoader)) ); return new ResourceTransformer() { public byte[] transform(byte[] original) { byte[] transformed = transformerDelegate.transform(original); return null != transformed ? transformed : original; } }; }
protected ContinuableClassInfoResolver getCachedResolver(final ClassLoader classLoader) { synchronized (classLoader2resolver) { final ContinuableClassInfoResolver cachedResolver = classLoader2resolver.get(classLoader); if (null == cachedResolver) { final ContinuableClassInfoResolver newResolver = resourceTransformationFactory.createResolver(new ExtendedClasspathResourceLoader(classLoader)); classLoader2resolver.put(classLoader, newResolver); return newResolver; } else { return cachedResolver; } } }
public byte[] call() { resolver.forget(currentTarget.className); final ResourceTransformer transformer = resourceTransformationFactory.createTransformer(resolver); return transformer.transform(classfileBuffer); } },
protected ContinuableClassInfoResolver getCachedResolver(ClassLoader classLoader) { synchronized (classLoader2resolver) { ContinuableClassInfoResolver cachedResolver = classLoader2resolver.get(classLoader); if (null == cachedResolver) { ContinuableClassInfoResolver newResolver = resourceTransformationFactory .createResolver(new ExtendedClasspathResourceLoader(classLoader)); classLoader2resolver.put(classLoader, newResolver); return newResolver; } else { return cachedResolver; } } }
public Class<?> run() { // define a package if necessary. int i = classname.lastIndexOf('.'); if (i > 0) { final String packageName = classname.substring(0,i); final Package pkg = getPackage(packageName); if (pkg == null) { definePackage(packageName, null, null, null, null, null, null, null); } } final ResourceTransformer transformer = transforationFactory.createTransformer(cciResolver); byte[] transfomred; CurrentClass prevClass = CURRENT_CLASS.get(); CURRENT_CLASS.set(new CurrentClass(classname, classData)); try { transfomred = transformer.transform(classData); } finally { CURRENT_CLASS.set(prevClass); } if (null == transfomred) transfomred = classData; final ProtectionDomain domain = this.getClass().getProtectionDomain(); return defineClass(null, transfomred, 0, transfomred.length, domain); } }, acc);
public static ResourceTransformer createTransformer(final URL[] extraURL, final ResourceTransformationFactory factory) { final URLClassLoader classLoader = new URLClassLoader( extraURL, safeParentClassLoader() ); final ResourceTransformer transformerDelegate = factory.createTransformer( factory.createResolver(new ClasspathResourceLoader(classLoader)) ); return new ResourceTransformer() { public byte[] transform(final byte[] original) { final byte[] transformed = transformerDelegate.transform(original); return null != transformed ? transformed : original; } }; }
/** * Creates a classloader by using the classpath given. * * @param urls * The URLs from which to load classes and resources * @param parent * The parent classloader to which unsatisfied loading * attempts are delegated. May be <code>null</code>, * in which case the {@link ClassLoader#getSystemClassLoader() system classloader} * is used as the parent. * @param transformationFactory * This factory is used to create necessary resolver/transformer to perform the byte-code enhancement. * May not be null. */ public ContinuationClassLoader(URL[] urls, ClassLoader parent, ResourceTransformationFactory transformationFactory) { super(urls,fixNullParent(parent)); if(transformationFactory==null) throw new IllegalArgumentException(); this.transforationFactory = transformationFactory; this.cciResolver = transformationFactory.createResolver( new ExtendedResourceLoader(new ClasspathResourceLoader(this)) ); acc = AccessController.getContext(); }