vladium/util/ClassLoaderResolver.java

/* Copyright (C) 2003 Vladimir Roubtsov. All rights reserved.
 *
 * This program and the accompanying materials are made available under
 * the terms of the Common Public License v1.0 which accompanies this distribution,
 * and is available at http://www.eclipse.org/legal/cpl-v10.html
 *
 * $Id: ClassLoaderResolver.java,v 1.1.1.1.2.2 2004/07/10 03:34:53 vlad_r Exp $
 */
package com.vladium.util;

// ----------------------------------------------------------------------------
/**
 * This non-instantiable non-subclassable class acts as the global point for
 * choosing a ClassLoader for dynamic class/resource loading at any point
 * in an application.
 *
 * @see ResourceLoader
 * @see IClassLoadStrategy
 * @see DefaultClassLoadStrategy
 *
 * @author Vlad Roubtsov, (C) 2003
 */
public
abstract class ClassLoaderResolver
{
    // public: ................................................................

    // NOTE: don't use Logger in this class to avoid infinite recursion

    /**
     * This method selects the "best" classloader instance to be used for
     * class/resource loading by whoever calls this method. The decision
     * typically involves choosing between the caller's current, thread context,
     * system, and other classloaders in the JVM and is made by the {@link IClassLoadStrategy}
     * instance established by the last call to {@link #setStrategy}.<P>
     *
     * This method does not throw.
     *
     * @param caller [null input eliminates the caller's current classloader
     * from consideration]
     *
     * @return classloader to be used by the caller ['null' indicates the
     * primordial loader]
     */
    public static synchronized ClassLoader getClassLoader (final Class caller)
    {
        final ClassLoadContext ctx = new ClassLoadContext (caller);

        return s_strategy.getClassLoader (ctx);
    }

    /**
     * This method selects the "best" classloader instance to be used for
     * class/resource loading by whoever calls this method. The decision
     * typically involves choosing between the caller's current, thread context,
     * system, and other classloaders in the JVM and is made by the {@link IClassLoadStrategy}
     * instance established by the last call to {@link #setStrategy}.<P>
     *
     * This method uses its own caller to set the call context. To be able to
     * override this decision explicitly, use {@link #getClassLoader(Class)}.<P>
     *
     * This method does not throw.
     *
     * @return classloader to be used by the caller ['null' indicates the
     * primordial loader]
     */
    public static synchronized ClassLoader getClassLoader ()
    {
        final Class caller = getCallerClass (1); // 'caller' can be set to null
        final ClassLoadContext ctx = new ClassLoadContext (caller);

        return s_strategy.getClassLoader (ctx);
    }

    /*
     * Indexes into the current method call context with a given offset. Offset 0
     * corresponds to the immediate caller, offset 1 corresponds to its caller,
     * etc.<P>
     *
     * Invariant: getCallerClass(0) == class containing code that performs this call
     */
    public static Class getCallerClass (final int callerOffset)
    {
        if (CALLER_RESOLVER == null) return null; // only happens if <clinit> failed

        return CALLER_RESOLVER.getClassContext () [CALL_CONTEXT_OFFSET + callerOffset];
    }

    /**
     * Returns 'true' if 'loader2' is a delegation child of 'loader1' [or if
     * 'loader1'=='loader2']. Of course, this works only for classloaders that
     * set their parent pointers correctly. 'null' is interpreted as the
     * primordial loader [i.e., everybody's parent].
     */
    public static boolean isChild (final ClassLoader loader1, ClassLoader loader2)
    {
        if (loader1 == loader2) return true;
        if (loader2 == null) return false;
        if (loader1 == null) return true;

        for ( ; loader2 != null; loader2 = loader2.getParent ())
        {
            if (loader2 == loader1) return true;
        }

        return false;
    }

    /**
     * Gets the current classloader selection strategy setting.
     */
    public static synchronized IClassLoadStrategy getStrategy ()
    {
        return s_strategy;
    }

    /**
     * Sets the classloader selection strategy to be used by subsequent calls
     * to {@link #getClassLoader()}. An instance of {@link ClassLoaderResolver.DefaultClassLoadStrategy}
     * is in effect if this method is never called.
     *
     * @param strategy new strategy [may not be null]
     * @return previous setting
     */
    public static synchronized IClassLoadStrategy setStrategy (final IClassLoadStrategy strategy)
    {
        if (strategy == null) throw new IllegalArgumentException ("null input: strategy");

        final IClassLoadStrategy old = s_strategy;
        s_strategy = strategy;

        return old;
    }

    // protected: .............................................................

    // package: ...............................................................

    // private: ...............................................................


    private static final class DefaultClassLoadStrategy implements IClassLoadStrategy
    {
        public ClassLoader getClassLoader (final ClassLoadContext ctx)
        {
            if (ctx == null) throw new IllegalArgumentException ("null input: ctx");

            final Class caller = ctx.getCallerClass ();
            final ClassLoader contextLoader = Thread.currentThread ().getContextClassLoader ();

            ClassLoader result;

            if (caller == null)
                result = contextLoader;
            else
            {
                final ClassLoader callerLoader = caller.getClassLoader ();

                // if 'callerLoader' and 'contextLoader' are in a parent-child
                // relationship, always choose the child:

                // SF BUG 975080: change the sibling case to use 'callerLoader'
                // to work around ANT 1.6.x incorrect classloading model:

                if (isChild (callerLoader, contextLoader))
                    result = contextLoader;
                else
                    result = callerLoader;
            }

            final ClassLoader systemLoader = ClassLoader.getSystemClassLoader ();

            // precaution for when deployed as a bootstrap or extension class:
            if (isChild (result, systemLoader))
                result = systemLoader;

            return result;
        }

    } // end of nested class


    /**
     * A helper class to get the call context. It subclasses SecurityManager
     * to make getClassContext() accessible. An instance of CallerResolver
     * only needs to be created, not installed as an actual security
     * manager.
     */
    private static final class CallerResolver extends SecurityManager
    {
        protected Class [] getClassContext ()
        {
            return super.getClassContext ();
        }

    } // end of nested class


    private ClassLoaderResolver () {} // prevent subclassing


    private static IClassLoadStrategy s_strategy; // initialized in <clinit>

    private static final int CALL_CONTEXT_OFFSET = 2; // may need to change if this class is redesigned
    private static final CallerResolver CALLER_RESOLVER; // set in <clinit>
    //private static Throwable CLINIT_FAILURE;

    static
    {
        CallerResolver temp = null;
        try
        {
            // this can fail if the current SecurityManager does not allow
            // RuntimePermission ("createSecurityManager"):

            temp = new CallerResolver ();
        }
        catch (Throwable t)
        {
            //CLINIT_FAILURE = t;
        }
        CALLER_RESOLVER = temp;

        s_strategy = new DefaultClassLoadStrategy ();
    }

} // end of class
// ----------------------------------------------------------------------------