org.apache.wss4j.common.util.Loader Maven / Gradle / Ivy
The newest version!
/**
* 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.wss4j.common.util;
import java.io.IOException;
import java.io.InputStream;
import java.lang.reflect.InvocationTargetException;
import java.net.MalformedURLException;
import java.net.URL;
import java.nio.file.Files;
import java.nio.file.Paths;
import java.security.AccessController;
import java.security.PrivilegedAction;
import org.apache.wss4j.common.ext.WSSecurityException;
/**
* Load resources (or images) from various sources.
*
*/
public final class Loader {
private static final org.slf4j.Logger LOG =
org.slf4j.LoggerFactory.getLogger(Loader.class);
private Loader() {
// complete
}
public static InputStream loadInputStream(ClassLoader loader, String resource)
throws WSSecurityException, IOException {
InputStream is = null;
if (resource != null) {
URL url = null;
// First see if it's a URL
try {
url = new URL(resource);
} catch (MalformedURLException ex) { //NOPMD
// skip
}
// If not a URL, then try to load the resource
if (url == null) {
url = Loader.getResource(loader, resource);
}
if (url != null) {
is = url.openStream();
}
//
// If we don't find it, then look on the file system.
//
if (is == null) {
try {
is = Files.newInputStream(Paths.get(resource));
} catch (Exception e) {
LOG.debug(e.getMessage(), e);
throw new WSSecurityException(
WSSecurityException.ErrorCode.FAILURE, e, "resourceNotFound", new Object[] {resource}
);
}
}
}
return is;
}
/**
* This method will search for resource in different
* places. The search order is as follows:
*
* - Search for
resource using the thread context
* class loader under Java2.
* - Try one last time with
*
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.
*
*
*
* @param resource
* @return the url to the resource or null if not found
*/
public static URL getResource(String resource) {
URL url = null;
try {
ClassLoader classLoader = getTCL();
if (classLoader != null) {
if (LOG.isDebugEnabled()) {
LOG.debug("Trying to find [" + resource + "] using " + classLoader + " class loader.");
}
url = classLoader.getResource(resource);
if (url == null && resource.startsWith("/")) {
//certain classloaders need it without the leading /
url = classLoader.getResource(resource.substring(1));
}
if (url != null) {
return url;
}
}
} catch (Exception e) {
LOG.warn("Caught Exception while in Loader.getResource. This may be innocuous.", e);
}
ClassLoader cluClassloader = Loader.class.getClassLoader();
if (cluClassloader == null) {
cluClassloader = ClassLoader.getSystemClassLoader();
}
url = cluClassloader.getResource(resource);
if (url == null && resource.startsWith("/")) {
//certain classloaders need it without the leading /
url = cluClassloader.getResource(resource.substring(1));
}
if (url != null) {
return url;
}
// 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.
LOG.debug("Trying to find [{}] using ClassLoader.getSystemResource().", resource);
return ClassLoader.getSystemResource(resource);
}
/**
* This method will search for resource in different
* places. The search order is as follows:
*
* - Search for
resource using the supplied class loader.
* If that fails, search for resource using the thread context
* class loader.
* - Try one last time with
*
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.
*
*
*
* @param resource
* @return the url to the resource or null if not found
*/
public static URL getResource(ClassLoader loader, String resource) {
URL url = null;
try {
if (loader != null) {
if (LOG.isDebugEnabled()) {
LOG.debug("Trying to find [" + resource + "] using " + loader + " class loader.");
}
url = loader.getResource(resource);
if (url == null && resource.startsWith("/")) {
//certain classloaders need it without the leading /
url = loader.getResource(resource.substring(1));
}
if (url != null) {
return url;
}
}
} catch (Exception e) {
LOG.warn("Caught Exception while in Loader.getResource. This may be innocuous.", e);
}
return getResource(resource);
}
/**
* This is a convenience method to load a resource as a stream. The
* algorithm used to find the resource is given in getResource()
*
* @param resourceName The name of the resource to load
*/
public static InputStream getResourceAsStream(String resourceName) {
URL url = getResource(resourceName);
try {
return (url != null) ? url.openStream() : null;
} catch (IOException e) {
LOG.debug(e.getMessage(), e);
return null;
}
}
/**
* Get the Thread context class loader.
*
*
* @return the Thread context class loader
* @throws IllegalAccessException
* @throws InvocationTargetException
*/
public static ClassLoader getTCL() throws IllegalAccessException, InvocationTargetException {
return AccessController.doPrivileged(new PrivilegedAction() {
public ClassLoader run() {
return Thread.currentThread().getContextClassLoader();
}
});
}
/**
* Get the class loader of the class argument
*
*
* @return the class loader of the argument
*/
public static ClassLoader getClassLoader(final Class clazz) {
return AccessController.doPrivileged(new PrivilegedAction() {
public ClassLoader run() {
return clazz.getClassLoader();
}
});
}
/**
* Try the specified classloader and then fall back to the loadClass
*
*
* @param loader
* @param clazz
* @return Class
* @throws ClassNotFoundException
*/
public static Class loadClass(ClassLoader loader, String clazz) throws ClassNotFoundException {
try {
if (loader != null) {
Class c = loader.loadClass(clazz);
if (c != null) {
return c;
}
}
} catch (Exception e) {
LOG.warn(e.getMessage(), e);
}
return loadClass(clazz, true);
}
/**
* Try the specified classloader and then fall back to the loadClass
*
*
* @param loader
* @param clazz
* @param type
* @return Class
* @throws ClassNotFoundException
*/
public static Class loadClass(ClassLoader loader,
String clazz,
Class type) throws ClassNotFoundException {
try {
if (loader != null) {
Class c = loader.loadClass(clazz);
if (c != null) {
return c.asSubclass(type);
}
}
} catch (Exception e) {
LOG.warn(e.getMessage(), e);
}
return loadClass(clazz, true, type);
}
/**
* If running under JDK 1.2 load the specified class using the
* Thread contextClassLoader if that
* fails try Class.forname.
*
*
* @param clazz
* @return the class
* @throws ClassNotFoundException
*/
public static Class loadClass(String clazz) throws ClassNotFoundException {
return loadClass(clazz, true);
}
/**
* If running under JDK 1.2 load the specified class using the
* Thread contextClassLoader if that
* fails try Class.forname.
*
*
* @param clazz
* @param type Type to cast it to
* @return the class
* @throws ClassNotFoundException
*/
public static Class loadClass(String clazz, Class type)
throws ClassNotFoundException {
return loadClass(clazz, true, type);
}
public static Class loadClass(String clazz,
boolean warn,
Class type) throws ClassNotFoundException {
return loadClass(clazz, warn).asSubclass(type);
}
public static Class loadClass(String clazz, boolean warn) throws ClassNotFoundException {
try {
ClassLoader tcl = getTCL();
if (tcl != null) {
Class c = tcl.loadClass(clazz);
if (c != null) {
return c;
}
}
} catch (Exception e) {
if (warn) {
LOG.warn(e.getMessage(), e);
} else {
LOG.debug(e.getMessage(), e);
}
}
return loadClass2(clazz, null);
}
private static Class loadClass2(String className, Class callingClass)
throws ClassNotFoundException {
try {
return Class.forName(className);
} catch (ClassNotFoundException ex) {
try {
if (Loader.class.getClassLoader() != null) {
return Loader.class.getClassLoader().loadClass(className);
}
} catch (ClassNotFoundException exc) {
if (callingClass != null && callingClass.getClassLoader() != null) {
return callingClass.getClassLoader().loadClass(className);
}
}
throw ex;
}
}
}