Java tutorial
/******************************************************************************* * Copyright (c) 2011-2014 Fernando Petrola * * This file is part of Dragome SDK. * * All rights reserved. This program and the accompanying materials * are made available under the terms of the GNU Public License v3.0 * which accompanies this distribution, and is available at * http://www.gnu.org/licenses/gpl.html ******************************************************************************/ /* * Licensed to the Apache Software Foundation (ASF) under one or more * contributor license agreements. See the NOTICE file distributed with * this work for additional information regarding copyright ownership. * The ASF licenses this file to You under the Apache License, Version 2.0 * (the "License"); you may not use this file except in compliance with * the License. You may obtain a copy of the License at * * http://www.apache.org/licenses/LICENSE-2.0 * * Unless required by applicable law or agreed to in writing, software * distributed under the License is distributed on an "AS IS" BASIS, * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. * See the License for the specific language governing permissions and * limitations under the License. */ package com.dragome.callbackevictor.serverside; import java.io.ByteArrayOutputStream; import java.io.IOException; import java.io.InputStream; import java.net.URL; import java.net.URLClassLoader; import java.security.AccessControlContext; import java.security.AccessController; import java.security.PrivilegedAction; import java.security.ProtectionDomain; import java.util.ArrayList; import java.util.HashMap; import java.util.HashSet; import java.util.Iterator; import java.util.List; import java.util.Map; import java.util.Set; import org.apache.commons.logging.Log; import org.apache.commons.logging.LogFactory; import com.dragome.callbackevictor.serverside.bytecode.transformation.ResourceTransformer; import com.dragome.callbackevictor.serverside.bytecode.transformation.asm.AsmClassTransformer; import com.dragome.commons.compiler.BytecodeTransformer; /** * {@link URLClassLoader} with bytecode instrumentation for javaflow. * * <p> * This class loader is useful where the application can set up multiple * class loaders (such as in a container environment, * <a href="http://classworlds.codehaus.org/">ClassWorlds</a>, or * <a href="http://forehead.werken.com/">Forehead</a>) and when you can * isolate the continuation-enabled portion of your application into a separate * jar file. */ public final class DragomeContinuationClassLoader extends URLClassLoader { private final static Log log = LogFactory.getLog(DragomeContinuationClassLoader.class); private final ResourceTransformer transformer; /** * Indicates whether the parent class loader should be * consulted before trying to load with this class loader. */ private boolean parentFirst = true; /** * These are the package roots that are to be loaded by the parent class * loader regardless of whether the parent class loader is being searched * first or not. */ private List systemPackages = new ArrayList(); /** * These are the package roots that are to be loaded by this class loader * regardless of whether the parent class loader is being searched first * or not. */ private List loaderPackages = new ArrayList(); /** * Whether or not this classloader will ignore the base * classloader if it can't find a class. * * @see #setIsolated(boolean) */ private boolean ignoreBase = false; /* The context to be used when loading classes and resources */ private final AccessControlContext acc; private static final int BUFFER_SIZE = 4096; protected Set<String> loadFromParent = new HashSet<String>(); private Map<String, byte[]> bytecodes = new HashMap<String, byte[]>(); private List<String> loadingClass = new ArrayList<String>(); private ClassLoader last; private BytecodeTransformer bytecodeTransformer; /** * 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 transformer * This transformer is used to perform the byte-code enhancement. * May not be null. */ public DragomeContinuationClassLoader(URL[] urls, ClassLoader parent, ResourceTransformer transformer) { super(urls, fixNullParent(parent)); if (transformer == null) throw new IllegalArgumentException(); this.transformer = transformer; acc = AccessController.getContext(); } public DragomeContinuationClassLoader(URL[] urls, ClassLoader parent, ClassLoader last, BytecodeTransformer bytecodeTransformer, Set<String> loadFromParentList) { this(urls, parent, new AsmClassTransformer()); this.loadFromParent = loadFromParentList; this.last = last; this.bytecodeTransformer = bytecodeTransformer; } private static ClassLoader fixNullParent(ClassLoader classLoader) { if (classLoader != null) { return classLoader; } else { return getSystemClassLoader(); } } /** * Control whether class lookup is delegated to the parent loader first * or after this loader. Use with extreme caution. Setting this to * false violates the class loader hierarchy and can lead to Linkage errors * * @param parentFirst if true, delegate initial class search to the parent * classloader. */ public void setParentFirst(boolean parentFirst) { this.parentFirst = parentFirst; } /** * Sets whether this classloader should run in isolated mode. In * isolated mode, classes not found on the given classpath will * not be referred to the parent class loader but will cause a * ClassNotFoundException. * * @param isolated Whether or not this classloader should run in * isolated mode. */ public void setIsolated(boolean isolated) { ignoreBase = isolated; } /** * Adds a package root to the list of packages which must be loaded on the * parent loader. * * All subpackages are also included. * * @param packageRoot The root of all packages to be included. * Should not be <code>null</code>. */ public synchronized void addSystemPackageRoot(String packageRoot) { systemPackages.add(appendDot(packageRoot)); } /** * Adds a package root to the list of packages which must be loaded using * this loader. * * All subpackages are also included. * * @param packageRoot The root of all packages to be included. * Should not be <code>null</code>. */ public synchronized void addLoaderPackageRoot(String packageRoot) { loaderPackages.add(/*appendDot(*/packageRoot/*)*/); } public synchronized void addLoadFromParent(String packageRoot) { loadFromParent.add(packageRoot); } private String appendDot(String str) { if (str.endsWith(".")) str += '.'; return str; } /** * Loads a class through this class loader even if that class is available * on the parent classpath. * * This ensures that any classes which are loaded by the returned class * will use this classloader. * * @param classname The name of the class to be loaded. * Must not be <code>null</code>. * * @return the required Class object * * @exception ClassNotFoundException if the requested class does not exist * on this loader's classpath. */ public Class forceLoadClass(String classname) throws ClassNotFoundException { log.debug("force loading " + classname); Class theClass = findLoadedClass(classname); if (theClass == null) { theClass = findClass(classname); } return theClass; } /** * Tests whether or not the parent classloader should be checked for * a resource before this one. If the resource matches both the * "use parent classloader first" and the "use this classloader first" * lists, the latter takes priority. * * @param resourceName The name of the resource to check. * Must not be <code>null</code>. * * @return whether or not the parent classloader should be checked for a * resource before this one is. */ private synchronized boolean isParentFirst(String resourceName) { // default to the global setting and then see // if this class belongs to a package which has been // designated to use a specific loader first // (this one or the parent one) // XXX - shouldn't this always return false in isolated mode? boolean useParentFirst = parentFirst; for (Iterator itr = systemPackages.iterator(); itr.hasNext();) { String packageName = (String) itr.next(); if (resourceName.startsWith(packageName)) { useParentFirst = true; break; } } for (Iterator itr = loaderPackages.iterator(); itr.hasNext();) { String packageName = (String) itr.next(); if (resourceName.startsWith(packageName)) { useParentFirst = false; break; } } return useParentFirst; } /** * Loads a class with this class loader. * * This class attempts to load the class in an order determined by whether * or not the class matches the system/loader package lists, with the * loader package list taking priority. If the classloader is in isolated * mode, failure to load the class in this loader will result in a * ClassNotFoundException. * * @param classname The name of the class to be loaded. * Must not be <code>null</code>. * @param resolve <code>true</code> if all classes upon which this class * depends are to be loaded. * * @return the required Class object * * @exception ClassNotFoundException if the requested class does not exist * on the system classpath (when not in isolated mode) or this loader's * classpath. */ protected synchronized Class loadClass(String classname, boolean resolve) throws ClassNotFoundException { try { // 'sync' is needed - otherwise 2 threads can load the same class // twice, resulting in LinkageError: duplicated class definition. // findLoadedClass avoids that, but without sync it won't work. Class theClass = findLoadedClass(classname); byte[] bs = bytecodes.get(classname); if (bs != null) theClass = defineClassFromData(bs, classname); if (theClass != null) { return theClass; } if (classNeedsLoadingFromParent(classname)) { try { theClass = getParent().loadClass(classname); log.debug("Class " + classname + " loaded from parent loader " + "(parentFirst)"); } catch (ClassNotFoundException cnfe) { theClass = findClass(classname); log.debug("Class " + classname + " loaded from ant loader " + "(parentFirst)"); } } else { try { theClass = findClass(classname); log.debug("Class " + classname + " loaded from ant loader"); } catch (ClassNotFoundException cnfe) { if (ignoreBase) { throw cnfe; } theClass = getParent().loadClass(classname); log.debug("Class " + classname + " loaded from parent loader"); } } if (resolve) { resolveClass(theClass); } return theClass; } finally { loadingClass.remove(classname); } } private boolean classNeedsLoadingFromParent(String classname) { for (String packageName : loadFromParent) { if (classname.startsWith((String) packageName)) return true; } return classname.startsWith("javassist.") || classname.startsWith("junit.") || classname.startsWith("sun.") || classname.startsWith("java.") || classname.startsWith("javax.") || classname.startsWith("org.w3c") || classname.startsWith("org.xml") || loadFromParent.contains(classname) || classname.startsWith("org.apache") /* && isParentFirst(classname) */; } // // private boolean classNeedsTransformation(String classname) // { // for (Object packageName : loaderPackages) // { // if (classname.startsWith((String) packageName)) // return true; // } // // return false; // } /** * Define a class given its bytes * * @param classData the bytecode data for the class * @param classname the name of the class * * @return the Class instance created from the given data */ public Class defineClassFromData(final byte[] classData, final String classname) { return (Class) AccessController.doPrivileged(new PrivilegedAction() { public Object run() { // define a package if necessary. int i = classname.lastIndexOf('.'); if (i > 0) { String packageName = classname.substring(0, i); Package pkg = getPackage(packageName); if (pkg == null) { definePackage(packageName, null, null, null, null, null, null, null); } } byte[] newData; if (!bytecodeTransformer.requiresTransformation(classname) || loadingClass.contains(classname)) newData = classData; else { loadingClass.add(classname); Thread.currentThread().setContextClassLoader(last); newData = transformer.transform(classData); Thread.currentThread().setContextClassLoader(DragomeContinuationClassLoader.this); } ProtectionDomain domain = this.getClass().getProtectionDomain(); return defineClass(classname, newData, 0, newData.length, domain); } }, acc); } /** * Reads a class definition from a stream. * * @param stream The stream from which the class is to be read. * Must not be <code>null</code>. * @param classname The name of the class in the stream. * Must not be <code>null</code>. * * @return the Class object read from the stream. * * @exception IOException if there is a problem reading the class from the * stream. * @exception SecurityException if there is a security problem while * reading the class from the stream. */ private Class getClassFromStream(InputStream stream, String classname) throws IOException, SecurityException { ByteArrayOutputStream baos = new ByteArrayOutputStream(); int bytesRead; byte[] buffer = new byte[BUFFER_SIZE]; while ((bytesRead = stream.read(buffer, 0, BUFFER_SIZE)) != -1) { baos.write(buffer, 0, bytesRead); } byte[] classData = baos.toByteArray(); return defineClassFromData(classData, classname); } /** * Searches for and load a class on the classpath of this class loader. * * @param name The name of the class to be loaded. Must not be * <code>null</code>. * * @return the required Class object * * @exception ClassNotFoundException if the requested class does not exist * on this loader's classpath. */ public Class findClass(final String name) throws ClassNotFoundException { log.debug("Finding class " + name); // locate the class file String classFileName = name.replace('.', '/') + ".class"; InputStream stream = getResourceAsStream(classFileName); if (stream == null) throw new ClassNotFoundException(name); try { return getClassFromStream(stream, name); } catch (IOException e) { throw new ClassNotFoundException(name, e); } finally { try { stream.close(); } catch (IOException e) { // ignore } } } /** * Finds the resource with the given name. A resource is * some data (images, audio, text, etc) that can be accessed by class * code in a way that is independent of the location of the code. * * @param name The name of the resource for which a stream is required. * Must not be <code>null</code>. * @return a URL for reading the resource, or <code>null</code> if the * resource could not be found or the caller doesn't have * adequate privileges to get the resource. */ public synchronized URL getResource(String name) { // we need to search the components of the path to see if // we can find the class we want. if (isParentFirst(name)) { return super.getResource(name); } // try this class loader first, then parent URL url = findResource(name); if (url == null) { url = getParent().getResource(name); } return url; } public void addLoaderPackagesRoot(String[] packagesroot) { for (String packageroot : packagesroot) addLoaderPackageRoot(packageroot); } public void addClassBytecode(byte[] bytecode, String aName) { bytecodes.put(aName, bytecode); } }