log4j-core/src/main/java/org/apache/logging/log4j/core/util/Loader.java - logging-log4j2 - Git at Google

 /*
  * 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 org.apache.logging.log4j.core.util;

 import java.io.InputStream;
 import java.lang.reflect.InvocationTargetException;
 import java.net.URL;

 import org.apache.logging.log4j.Logger;
 import org.apache.logging.log4j.status.StatusLogger;
 import org.apache.logging.log4j.util.LoaderUtil;
 import org.apache.logging.log4j.util.PropertiesUtil;

 /**
  * Load resources (or images) from various sources.
  */
 public final class Loader {

     private static final Logger LOGGER = StatusLogger.getLogger();

     private static final String TSTR = "Caught Exception while in Loader.getResource. This may be innocuous.";

     final static Boolean ignoreTccl =
         Boolean.valueOf(PropertiesUtil.getProperties().getStringProperty(LoaderUtil.IGNORE_TCCL_PROPERTY, null));

     private Loader() {
     }

     /**
      * Returns the ClassLoader to use.
      * @return the ClassLoader.
      */
     public static ClassLoader getClassLoader() {
         return Loader.getClassLoader(Loader.class, null);
     }

     // TODO: this method could use some explanation
     public static ClassLoader getClassLoader(final Class<?> class1, final Class<?> class2) {
         return LoaderUtil.getClassLoader(class1, class2);
     }

     /**
      * Returns the ClassLoader of current thread if possible, or falls back to the system ClassLoader if none is
      * available.
      *
      * @return the TCCL.
      * @see org.apache.logging.log4j.util.LoaderUtil#getThreadContextClassLoader()
      */
     public static ClassLoader getThreadContextClassLoader() {
         return LoaderUtil.getThreadContextClassLoader();
     }

     /**
      * This method will search for {@code resource} in different
      * places. The search order is as follows:
      *
      * <ol>
      *
      * <li>Search for {@code resource} using the thread context
      * class loader under Java2. If that fails, search for
      * {@code resource} using the class loader that loaded this
      * class ({@code Loader}). Under JDK 1.1, only the the class
      * loader that loaded this class ({@code Loader}) is used.</li>
      * <li>Try one last time with
      * {@code ClassLoader.getSystemResource(resource)}, that is is
      * using the system class loader in JDK 1.2 and virtual machine's
      * built-in class loader in JDK 1.1.</li>
      * </ol>
      * @param resource The resource to load.
      * @param defaultLoader The default ClassLoader.
      * @return A URL to the resource.
      */
     public static URL getResource(final String resource, final ClassLoader defaultLoader) {
         try {
             ClassLoader classLoader = getThreadContextClassLoader();
             if (classLoader != null) {
                 LOGGER.trace("Trying to find [{}] using context class loader {}.", resource, classLoader);
                 final URL url = classLoader.getResource(resource);
                 if (url != null) {
                     return url;
                 }
             }

             // We could not find resource. Let us now try with the classloader that loaded this class.
             classLoader = Loader.class.getClassLoader();
             if (classLoader != null) {
                 LOGGER.trace("Trying to find [{}] using {} class loader.", resource, classLoader);
                 final URL url = classLoader.getResource(resource);
                 if (url != null) {
                     return url;
                 }
             }
             // We could not find resource. Finally try with the default ClassLoader.
             if (defaultLoader != null) {
                 LOGGER.trace("Trying to find [{}] using {} class loader.", resource, defaultLoader);
                 final URL url = defaultLoader.getResource(resource);
                 if (url != null) {
                     return url;
                 }
             }
         } catch (final Throwable t) {
             //
             //  can't be InterruptedException or InterruptedIOException
             //    since not declared, must be error or RuntimeError.
             LOGGER.warn(TSTR, t);
         }

         // Last ditch attempt: get the resource from the class path. It
         // may be the case that clazz was loaded by the Extension class
         // loader which the parent of the system class loader. Hence the
         // code below.
         LOGGER.trace("Trying to find [{}] using ClassLoader.getSystemResource().", resource);
         return ClassLoader.getSystemResource(resource);
     }

     /**
      * This method will search for {@code resource} in different
      * places. The search order is as follows:
      *
      * <ol>
      * <li>Search for {@code resource} using the thread context
      * class loader under Java2. If that fails, search for
      * {@code resource} using the class loader that loaded this
      * class ({@code Loader}). Under JDK 1.1, only the the class
      * loader that loaded this class ({@code Loader}) is used.</li>
      * <li>Try one last time with
      * {@code ClassLoader.getSystemResource(resource)}, that is is
      * using the system class loader in JDK 1.2 and virtual machine's
      * built-in class loader in JDK 1.1.</li>
      * </ol>
      * @param resource The resource to load.
      * @param defaultLoader The default ClassLoader.
      * @return An InputStream to read the resouce.
      */
     public static InputStream getResourceAsStream(final String resource, final ClassLoader defaultLoader) {
         try {
             ClassLoader classLoader = getThreadContextClassLoader();
             InputStream is;
             if (classLoader != null) {
                 LOGGER.trace("Trying to find [{}] using context class loader {}.", resource, classLoader);
                 is = classLoader.getResourceAsStream(resource);
                 if (is != null) {
                     return is;
                 }
             }

             // We could not find resource. Let us now try with the classloader that loaded this class.
             classLoader = Loader.class.getClassLoader();
             if (classLoader != null) {
                 LOGGER.trace("Trying to find [{}] using {} class loader.", resource, classLoader);
                 is = classLoader.getResourceAsStream(resource);
                 if (is != null) {
                     return is;
                 }
             }

             // We could not find resource. Finally try with the default ClassLoader.
             if (defaultLoader != null) {
                 LOGGER.trace("Trying to find [{}] using {} class loader.", resource, defaultLoader);
                 is = defaultLoader.getResourceAsStream(resource);
                 if (is != null) {
                     return is;
                 }
             }
         } catch (final Throwable t) {
             //
             //  can't be InterruptedException or InterruptedIOException
             //    since not declared, must be error or RuntimeError.
             LOGGER.warn(TSTR, t);
         }

         // Last ditch attempt: get the resource from the class path. It
         // may be the case that clazz was loaded by the Extension class
         // loader which the parent of the system class loader. Hence the
         // code below.
         LOGGER.trace("Trying to find [{}] using ClassLoader.getSystemResource().", resource);
         return ClassLoader.getSystemResourceAsStream(resource);
     }

     /**
      * Loads and initializes a named Class using a given ClassLoader.
      *
      * @param className The class name.
      * @param loader The class loader.
      * @return The class.
      * @throws ClassNotFoundException if the class could not be found.
      */
     public static Class<?> initializeClass(final String className, final ClassLoader loader)
             throws ClassNotFoundException {
         return Class.forName(className, true, loader);
     }

     /**
      * Loads a named Class using a given ClassLoader.
      *
      * @param className The class name.
      * @param loader The class loader.
      * @return The class, or null if loader is null.
      * @throws ClassNotFoundException if the class could not be found.
      */
     public static Class<?> loadClass(final String className, final ClassLoader loader)
             throws ClassNotFoundException {
         return loader != null ? loader.loadClass(className) : null;
     }

     /**
      * Load a Class in the {@code java.*} namespace by name. Useful for peculiar scenarios typically involving
      * Google App Engine.
      *
      * @param className The class name.
      * @return The Class.
      * @throws ClassNotFoundException if the Class could not be found.
      */
     public static Class<?> loadSystemClass(final String className) throws ClassNotFoundException {
         try {
             return Class.forName(className, true, ClassLoader.getSystemClassLoader());
         } catch (final Throwable t) {
             LOGGER.trace("Couldn't use SystemClassLoader. Trying Class.forName({}).", className, t);
             return Class.forName(className);
         }
     }

     /**
      * Loads and instantiates a Class using the default constructor.
      *
      * @param className The class name.
      * @return new instance of the class.
      * @throws ClassNotFoundException if the class isn't available to the usual ClassLoaders
      * @throws IllegalAccessException if the class can't be instantiated through a public constructor
      * @throws InstantiationException if there was an exception whilst instantiating the class
      * @throws InvocationTargetException if there was an exception whilst constructing the class
      * @since 2.1
      */
     @SuppressWarnings("unchecked")
     public static <T> T newInstanceOf(final String className)
             throws ClassNotFoundException, IllegalAccessException, InstantiationException, InvocationTargetException {
         return newInstanceOf((Class<T>) loadClass(className));
     }

     /**
      * Loads, instantiates, and casts a Class using the default constructor.
      *
      * @param className The class name.
      * @param clazz The class to cast it to.
      * @param <T> The type to cast it to.
      * @return new instance of the class cast to {@code T}
      * @throws ClassNotFoundException if the class isn't available to the usual ClassLoaders
      * @throws IllegalAccessException if the class can't be instantiated through a public constructor
      * @throws InstantiationException if there was an exception whilst instantiating the class
      * @throws InvocationTargetException if there was an exception whilst constructing the class
      * @throws ClassCastException if the constructed object isn't type compatible with {@code T}
      */
     public static <T> T newCheckedInstanceOf(final String className, final Class<T> clazz)
             throws ClassNotFoundException, IllegalAccessException, InvocationTargetException, InstantiationException {
         return newInstanceOf(loadClass(className).asSubclass(clazz));
     }

     /**
      * Loads and instantiates a class given by a property name.
      *
      * @param propertyName The property name to look up a class name for.
      * @param clazz        The class to cast it to.
      * @param <T>          The type to cast it to.
      * @return new instance of the class given in the property or {@code null} if the property was unset.
      * @throws ClassNotFoundException    if the class isn't available to the usual ClassLoaders
      * @throws IllegalAccessException    if the class can't be instantiated through a public constructor
      * @throws InstantiationException    if there was an exception whilst instantiating the class
      * @throws NoSuchMethodException     if there isn't a no-args constructor on the class
      * @throws InvocationTargetException if there was an exception whilst constructing the class
      * @throws ClassCastException        if the constructed object isn't type compatible with {@code T}
      */
     public static <T> T newCheckedInstanceOfProperty(final String propertyName, final Class<T> clazz)
         throws ClassNotFoundException, NoSuchMethodException, InvocationTargetException, InstantiationException,
         IllegalAccessException {
         final String className = PropertiesUtil.getProperties().getStringProperty(propertyName);
         ClassLoader contextClassLoader = Thread.currentThread().getContextClassLoader();
         try {
             Thread.currentThread().setContextClassLoader(getClassLoader());
             return LoaderUtil.newCheckedInstanceOfProperty(propertyName, clazz);
         } finally {
             Thread.currentThread().setContextClassLoader(contextClassLoader);
         }
     }

     /**
      * Loads and instantiates a Class using the default constructor.
      *
      * @param clazz The class.
      * @return new instance of the class.
      * @throws IllegalAccessException if the class can't be instantiated through a public constructor
      * @throws InstantiationException if there was an exception whilst instantiating the class
      * @throws InvocationTargetException if there was an exception whilst constructing the class
      * @since 2.7
      */
     public static <T> T newInstanceOf(final Class<T> clazz)
             throws InstantiationException, IllegalAccessException, InvocationTargetException {
         try {
             return clazz.getConstructor().newInstance();
         } catch (final NoSuchMethodException ignored) {
             // FIXME: looking at the code for Class.newInstance(), this seems to do the same thing as above
             return clazz.newInstance();
         }
     }

     /**
      * Determines if a named Class can be loaded or not.
      *
      * @param className The class name.
      * @return {@code true} if the class could be found or {@code false} otherwise.
      */
     public static boolean isClassAvailable(final String className) {
         ClassLoader contextClassLoader = Thread.currentThread().getContextClassLoader();
         try {
             Thread.currentThread().setContextClassLoader(getClassLoader());
             return LoaderUtil.isClassAvailable(className);
         } finally {
             Thread.currentThread().setContextClassLoader(contextClassLoader);
         }
     }

     public static boolean isJansiAvailable() {
         return isClassAvailable("org.fusesource.jansi.AnsiRenderer");
     }

     /**
      * Loads a class by name. This method respects the {@link #IGNORE_TCCL_PROPERTY} Log4j property. If this property is
      * specified and set to anything besides {@code false}, then the default ClassLoader will be used.
      *
      * @param className The class name.
      * @return the Class for the given name.
      * @throws ClassNotFoundException if the specified class name could not be found
      */
     public static Class<?> loadClass(final String className) throws ClassNotFoundException {
         if (ignoreTccl) {
             return Class.forName(className);
         }
         try {
             return getClassLoader().loadClass(className);
         } catch (final Throwable ignored) {
             return Class.forName(className);
         }
     }
 }
	/*
	* 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 org.apache.logging.log4j.core.util;

	import java.io.InputStream;
	import java.lang.reflect.InvocationTargetException;
	import java.net.URL;

	import org.apache.logging.log4j.Logger;
	import org.apache.logging.log4j.status.StatusLogger;
	import org.apache.logging.log4j.util.LoaderUtil;
	import org.apache.logging.log4j.util.PropertiesUtil;

	/**
	* Load resources (or images) from various sources.
	*/
	public final class Loader {

	private static final Logger LOGGER = StatusLogger.getLogger();

	private static final String TSTR = "Caught Exception while in Loader.getResource. This may be innocuous.";

	final static Boolean ignoreTccl =
	Boolean.valueOf(PropertiesUtil.getProperties().getStringProperty(LoaderUtil.IGNORE_TCCL_PROPERTY, null));

	private Loader() {
	}

	/**
	* Returns the ClassLoader to use.
	* @return the ClassLoader.
	*/
	public static ClassLoader getClassLoader() {
	return Loader.getClassLoader(Loader.class, null);
	}

	// TODO: this method could use some explanation
	public static ClassLoader getClassLoader(final Class<?> class1, final Class<?> class2) {
	return LoaderUtil.getClassLoader(class1, class2);
	}

	/**
	* Returns the ClassLoader of current thread if possible, or falls back to the system ClassLoader if none is
	* available.
	*
	* @return the TCCL.
	* @see org.apache.logging.log4j.util.LoaderUtil#getThreadContextClassLoader()
	*/
	public static ClassLoader getThreadContextClassLoader() {
	return LoaderUtil.getThreadContextClassLoader();
	}

	/**
	* This method will search for {@code resource} in different
	* places. The search order is as follows:
	*
	* <ol>
	*
	* <li>Search for {@code resource} using the thread context
	* class loader under Java2. If that fails, search for
	* {@code resource} using the class loader that loaded this
	* class ({@code Loader}). Under JDK 1.1, only the the class
	* loader that loaded this class ({@code Loader}) is used.</li>
	* <li>Try one last time with
	* {@code ClassLoader.getSystemResource(resource)}, that is is
	* using the system class loader in JDK 1.2 and virtual machine's
	* built-in class loader in JDK 1.1.</li>
	* </ol>
	* @param resource The resource to load.
	* @param defaultLoader The default ClassLoader.
	* @return A URL to the resource.
	*/
	public static URL getResource(final String resource, final ClassLoader defaultLoader) {
	try {
	ClassLoader classLoader = getThreadContextClassLoader();
	if (classLoader != null) {
	LOGGER.trace("Trying to find [{}] using context class loader {}.", resource, classLoader);
	final URL url = classLoader.getResource(resource);
	if (url != null) {
	return url;
	}
	}

	// We could not find resource. Let us now try with the classloader that loaded this class.
	classLoader = Loader.class.getClassLoader();
	if (classLoader != null) {
	LOGGER.trace("Trying to find [{}] using {} class loader.", resource, classLoader);
	final URL url = classLoader.getResource(resource);
	if (url != null) {
	return url;
	}
	}
	// We could not find resource. Finally try with the default ClassLoader.
	if (defaultLoader != null) {
	LOGGER.trace("Trying to find [{}] using {} class loader.", resource, defaultLoader);
	final URL url = defaultLoader.getResource(resource);
	if (url != null) {
	return url;
	}
	}
	} catch (final Throwable t) {
	//
	// can't be InterruptedException or InterruptedIOException
	// since not declared, must be error or RuntimeError.
	LOGGER.warn(TSTR, t);
	}

	// Last ditch attempt: get the resource from the class path. It
	// may be the case that clazz was loaded by the Extension class
	// loader which the parent of the system class loader. Hence the
	// code below.
	LOGGER.trace("Trying to find [{}] using ClassLoader.getSystemResource().", resource);
	return ClassLoader.getSystemResource(resource);
	}

	/**
	* This method will search for {@code resource} in different
	* places. The search order is as follows:
	*
	* <ol>
	* <li>Search for {@code resource} using the thread context
	* class loader under Java2. If that fails, search for
	* {@code resource} using the class loader that loaded this
	* class ({@code Loader}). Under JDK 1.1, only the the class
	* loader that loaded this class ({@code Loader}) is used.</li>
	* <li>Try one last time with
	* {@code ClassLoader.getSystemResource(resource)}, that is is
	* using the system class loader in JDK 1.2 and virtual machine's
	* built-in class loader in JDK 1.1.</li>
	* </ol>
	* @param resource The resource to load.
	* @param defaultLoader The default ClassLoader.
	* @return An InputStream to read the resouce.
	*/
	public static InputStream getResourceAsStream(final String resource, final ClassLoader defaultLoader) {
	try {
	ClassLoader classLoader = getThreadContextClassLoader();
	InputStream is;
	if (classLoader != null) {
	LOGGER.trace("Trying to find [{}] using context class loader {}.", resource, classLoader);
	is = classLoader.getResourceAsStream(resource);
	if (is != null) {
	return is;
	}
	}

	// We could not find resource. Let us now try with the classloader that loaded this class.
	classLoader = Loader.class.getClassLoader();
	if (classLoader != null) {
	LOGGER.trace("Trying to find [{}] using {} class loader.", resource, classLoader);
	is = classLoader.getResourceAsStream(resource);
	if (is != null) {
	return is;
	}
	}

	// We could not find resource. Finally try with the default ClassLoader.
	if (defaultLoader != null) {
	LOGGER.trace("Trying to find [{}] using {} class loader.", resource, defaultLoader);
	is = defaultLoader.getResourceAsStream(resource);
	if (is != null) {
	return is;
	}
	}
	} catch (final Throwable t) {
	//
	// can't be InterruptedException or InterruptedIOException
	// since not declared, must be error or RuntimeError.
	LOGGER.warn(TSTR, t);
	}

	// Last ditch attempt: get the resource from the class path. It
	// may be the case that clazz was loaded by the Extension class
	// loader which the parent of the system class loader. Hence the
	// code below.
	LOGGER.trace("Trying to find [{}] using ClassLoader.getSystemResource().", resource);
	return ClassLoader.getSystemResourceAsStream(resource);
	}

	/**
	* Loads and initializes a named Class using a given ClassLoader.
	*
	* @param className The class name.
	* @param loader The class loader.
	* @return The class.
	* @throws ClassNotFoundException if the class could not be found.
	*/
	public static Class<?> initializeClass(final String className, final ClassLoader loader)
	throws ClassNotFoundException {
	return Class.forName(className, true, loader);
	}

	/**
	* Loads a named Class using a given ClassLoader.
	*
	* @param className The class name.
	* @param loader The class loader.
	* @return The class, or null if loader is null.
	* @throws ClassNotFoundException if the class could not be found.
	*/
	public static Class<?> loadClass(final String className, final ClassLoader loader)
	throws ClassNotFoundException {
	return loader != null ? loader.loadClass(className) : null;
	}

	/**
	* Load a Class in the {@code java.*} namespace by name. Useful for peculiar scenarios typically involving
	* Google App Engine.
	*
	* @param className The class name.
	* @return The Class.
	* @throws ClassNotFoundException if the Class could not be found.
	*/
	public static Class<?> loadSystemClass(final String className) throws ClassNotFoundException {
	try {
	return Class.forName(className, true, ClassLoader.getSystemClassLoader());
	} catch (final Throwable t) {
	LOGGER.trace("Couldn't use SystemClassLoader. Trying Class.forName({}).", className, t);
	return Class.forName(className);
	}
	}

	/**
	* Loads and instantiates a Class using the default constructor.
	*
	* @param className The class name.
	* @return new instance of the class.
	* @throws ClassNotFoundException if the class isn't available to the usual ClassLoaders
	* @throws IllegalAccessException if the class can't be instantiated through a public constructor
	* @throws InstantiationException if there was an exception whilst instantiating the class
	* @throws InvocationTargetException if there was an exception whilst constructing the class
	* @since 2.1
	*/
	@SuppressWarnings("unchecked")
	public static <T> T newInstanceOf(final String className)
	throws ClassNotFoundException, IllegalAccessException, InstantiationException, InvocationTargetException {
	return newInstanceOf((Class<T>) loadClass(className));
	}

	/**
	* Loads, instantiates, and casts a Class using the default constructor.
	*
	* @param className The class name.
	* @param clazz The class to cast it to.
	* @param <T> The type to cast it to.
	* @return new instance of the class cast to {@code T}
	* @throws ClassNotFoundException if the class isn't available to the usual ClassLoaders
	* @throws IllegalAccessException if the class can't be instantiated through a public constructor
	* @throws InstantiationException if there was an exception whilst instantiating the class
	* @throws InvocationTargetException if there was an exception whilst constructing the class
	* @throws ClassCastException if the constructed object isn't type compatible with {@code T}
	*/
	public static <T> T newCheckedInstanceOf(final String className, final Class<T> clazz)
	throws ClassNotFoundException, IllegalAccessException, InvocationTargetException, InstantiationException {
	return newInstanceOf(loadClass(className).asSubclass(clazz));
	}

	/**
	* Loads and instantiates a class given by a property name.
	*
	* @param propertyName The property name to look up a class name for.
	* @param clazz The class to cast it to.
	* @param <T> The type to cast it to.
	* @return new instance of the class given in the property or {@code null} if the property was unset.
	* @throws ClassNotFoundException if the class isn't available to the usual ClassLoaders
	* @throws IllegalAccessException if the class can't be instantiated through a public constructor
	* @throws InstantiationException if there was an exception whilst instantiating the class
	* @throws NoSuchMethodException if there isn't a no-args constructor on the class
	* @throws InvocationTargetException if there was an exception whilst constructing the class
	* @throws ClassCastException if the constructed object isn't type compatible with {@code T}
	*/
	public static <T> T newCheckedInstanceOfProperty(final String propertyName, final Class<T> clazz)
	throws ClassNotFoundException, NoSuchMethodException, InvocationTargetException, InstantiationException,
	IllegalAccessException {
	final String className = PropertiesUtil.getProperties().getStringProperty(propertyName);
	ClassLoader contextClassLoader = Thread.currentThread().getContextClassLoader();
	try {
	Thread.currentThread().setContextClassLoader(getClassLoader());
	return LoaderUtil.newCheckedInstanceOfProperty(propertyName, clazz);
	} finally {
	Thread.currentThread().setContextClassLoader(contextClassLoader);
	}
	}

	/**
	* Loads and instantiates a Class using the default constructor.
	*
	* @param clazz The class.
	* @return new instance of the class.
	* @throws IllegalAccessException if the class can't be instantiated through a public constructor
	* @throws InstantiationException if there was an exception whilst instantiating the class
	* @throws InvocationTargetException if there was an exception whilst constructing the class
	* @since 2.7
	*/
	public static <T> T newInstanceOf(final Class<T> clazz)
	throws InstantiationException, IllegalAccessException, InvocationTargetException {
	try {
	return clazz.getConstructor().newInstance();
	} catch (final NoSuchMethodException ignored) {
	// FIXME: looking at the code for Class.newInstance(), this seems to do the same thing as above
	return clazz.newInstance();
	}
	}

	/**
	* Determines if a named Class can be loaded or not.
	*
	* @param className The class name.
	* @return {@code true} if the class could be found or {@code false} otherwise.
	*/
	public static boolean isClassAvailable(final String className) {
	ClassLoader contextClassLoader = Thread.currentThread().getContextClassLoader();
	try {
	Thread.currentThread().setContextClassLoader(getClassLoader());
	return LoaderUtil.isClassAvailable(className);
	} finally {
	Thread.currentThread().setContextClassLoader(contextClassLoader);
	}
	}

	public static boolean isJansiAvailable() {
	return isClassAvailable("org.fusesource.jansi.AnsiRenderer");
	}

	/**
	* Loads a class by name. This method respects the {@link #IGNORE_TCCL_PROPERTY} Log4j property. If this property is
	* specified and set to anything besides {@code false}, then the default ClassLoader will be used.
	*
	* @param className The class name.
	* @return the Class for the given name.
	* @throws ClassNotFoundException if the specified class name could not be found
	*/
	public static Class<?> loadClass(final String className) throws ClassNotFoundException {
	if (ignoreTccl) {
	return Class.forName(className);
	}
	try {
	return getClassLoader().loadClass(className);
	} catch (final Throwable ignored) {
	return Class.forName(className);
	}
	}
	}