001 /*
002 * Licensed to the Apache Software Foundation (ASF) under one or more
003 * contributor license agreements. See the NOTICE file distributed with
004 * this work for additional information regarding copyright ownership.
005 * The ASF licenses this file to You under the Apache license, Version 2.0
006 * (the "License"); you may not use this file except in compliance with
007 * the License. You may obtain a copy of the License at
008 *
009 * http://www.apache.org/licenses/LICENSE-2.0
010 *
011 * Unless required by applicable law or agreed to in writing, software
012 * distributed under the License is distributed on an "AS IS" BASIS,
013 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
014 * See the license for the specific language governing permissions and
015 * limitations under the license.
016 */
017 package org.apache.logging.log4j.util;
018
019 import java.io.IOException;
020 import java.lang.reflect.InvocationTargetException;
021 import java.net.URL;
022 import java.security.AccessController;
023 import java.security.PrivilegedAction;
024 import java.util.Collection;
025 import java.util.Enumeration;
026 import java.util.LinkedHashSet;
027
028 /**
029 * <em>Consider this class private.</em> Utility class for ClassLoaders.
030 * @see ClassLoader
031 * @see RuntimePermission
032 * @see Thread#getContextClassLoader()
033 * @see ClassLoader#getSystemClassLoader()
034 */
035 public final class LoaderUtil {
036 private LoaderUtil() {}
037
038 /**
039 * System property to set to ignore the thread context ClassLoader.
040 *
041 * @since 2.1
042 */
043 public static final String IGNORE_TCCL_PROPERTY = "log4j.ignoreTCL";
044
045 private static final SecurityManager SECURITY_MANAGER = System.getSecurityManager();
046
047 // this variable must be lazily loaded; otherwise, we get a nice circular class loading problem where LoaderUtil
048 // wants to use PropertiesUtil, but then PropertiesUtil wants to use LoaderUtil.
049 private static Boolean ignoreTCCL;
050
051 private static final boolean GET_CLASS_LOADER_DISABLED;
052
053 private static final PrivilegedAction<ClassLoader> TCCL_GETTER = new ThreadContextClassLoaderGetter();
054
055 static {
056 if (SECURITY_MANAGER != null) {
057 boolean getClassLoaderDisabled;
058 try {
059 SECURITY_MANAGER.checkPermission(new RuntimePermission("getClassLoader"));
060 getClassLoaderDisabled = false;
061 } catch (final SecurityException ignored) {
062 getClassLoaderDisabled = true;
063 }
064 GET_CLASS_LOADER_DISABLED = getClassLoaderDisabled;
065 } else {
066 GET_CLASS_LOADER_DISABLED = false;
067 }
068 }
069
070 /**
071 * Gets the current Thread ClassLoader. Returns the system ClassLoader if the TCCL is {@code null}. If the
072 * system ClassLoader is {@code null} as well, then the ClassLoader for this class is returned.
073 * If running with a {@link SecurityManager} that does not allow access to the Thread ClassLoader or system
074 * ClassLoader, then the ClassLoader for this class is returned.
075 *
076 * @return the current ThreadContextClassLoader.
077 */
078 public static ClassLoader getThreadContextClassLoader() {
079 if (GET_CLASS_LOADER_DISABLED) {
080 // we can at least get this class's ClassLoader regardless of security context
081 // however, if this is null, there's really no option left at this point
082 return LoaderUtil.class.getClassLoader();
083 }
084 return SECURITY_MANAGER == null
085 ? TCCL_GETTER.run()
086 : AccessController.doPrivileged(TCCL_GETTER);
087 }
088
089 private static class ThreadContextClassLoaderGetter implements PrivilegedAction<ClassLoader> {
090 @Override
091 public ClassLoader run() {
092 final ClassLoader cl = Thread.currentThread().getContextClassLoader();
093 if (cl != null) {
094 return cl;
095 }
096 final ClassLoader ccl = LoaderUtil.class.getClassLoader();
097 return ccl == null ? ClassLoader.getSystemClassLoader() : ccl;
098 }
099 }
100
101 /**
102 * Loads a class by name. This method respects the {@link #IGNORE_TCCL_PROPERTY} Log4j property. If this property
103 * is specified and set to anything besides {@code false}, then the default ClassLoader will be used.
104 *
105 * @param className The class name.
106 * @return the Class for the given name.
107 * @throws ClassNotFoundException if the specified class name could not be found
108 * @since 2.1
109 */
110 public static Class<?> loadClass(final String className) throws ClassNotFoundException {
111 if (isIgnoreTccl()) {
112 return Class.forName(className);
113 }
114 try {
115 return getThreadContextClassLoader().loadClass(className);
116 } catch (final Throwable ignored) {
117 return Class.forName(className);
118 }
119 }
120
121 /**
122 * Loads and instantiates a Class using the default constructor.
123 *
124 * @param className The class name.
125 * @return new instance of the class.
126 * @throws ClassNotFoundException if the class isn't available to the usual ClassLoaders
127 * @throws IllegalAccessException if the class can't be instantiated through a public constructor
128 * @throws InstantiationException if there was an exception whilst instantiating the class
129 * @throws NoSuchMethodException if there isn't a no-args constructor on the class
130 * @throws InvocationTargetException if there was an exception whilst constructing the class
131 * @since 2.1
132 */
133 public static Object newInstanceOf(final String className)
134 throws ClassNotFoundException, IllegalAccessException, InstantiationException, NoSuchMethodException,
135 InvocationTargetException {
136 final Class<?> clazz = loadClass(className);
137 try {
138 return clazz.getConstructor().newInstance();
139 } catch (final NoSuchMethodException ignored) {
140 // FIXME: looking at the code for Class.newInstance(), this seems to do the same thing as above
141 return clazz.newInstance();
142 }
143 }
144
145 /**
146 * Loads and instantiates a derived class using its default constructor.
147 *
148 * @param className The class name.
149 * @param clazz The class to cast it to.
150 * @param <T> The type of the class to check.
151 * @return new instance of the class cast to {@code T}
152 * @throws ClassNotFoundException if the class isn't available to the usual ClassLoaders
153 * @throws IllegalAccessException if the class can't be instantiated through a public constructor
154 * @throws InstantiationException if there was an exception whilst instantiating the class
155 * @throws NoSuchMethodException if there isn't a no-args constructor on the class
156 * @throws InvocationTargetException if there was an exception whilst constructing the class
157 * @throws ClassCastException if the constructed object isn't type compatible with {@code T}
158 * @since 2.1
159 */
160 public static <T> T newCheckedInstanceOf(final String className, final Class<T> clazz)
161 throws ClassNotFoundException, NoSuchMethodException, InvocationTargetException, InstantiationException,
162 IllegalAccessException {
163 return clazz.cast(newInstanceOf(className));
164 }
165
166 private static boolean isIgnoreTccl() {
167 // we need to lazily initialize this, but concurrent access is not an issue
168 if (ignoreTCCL == null) {
169 final String ignoreTccl = PropertiesUtil.getProperties().getStringProperty(IGNORE_TCCL_PROPERTY, null);
170 ignoreTCCL = ignoreTccl != null && !"false".equalsIgnoreCase(ignoreTccl.trim());
171 }
172 return ignoreTCCL;
173 }
174
175 /**
176 * Finds classpath {@linkplain URL resources}.
177 *
178 * @param resource the name of the resource to find.
179 * @return a Collection of URLs matching the resource name. If no resources could be found, then this will be empty.
180 * @since 2.1
181 */
182 public static Collection<URL> findResources(final String resource) {
183 final Collection<UrlResource> urlResources = findUrlResources(resource);
184 final Collection<URL> resources = new LinkedHashSet<URL>(urlResources.size());
185 for (final UrlResource urlResource : urlResources) {
186 resources.add(urlResource.getUrl());
187 }
188 return resources;
189 }
190
191 static Collection<UrlResource> findUrlResources(final String resource) {
192 final ClassLoader[] candidates = {
193 getThreadContextClassLoader(),
194 LoaderUtil.class.getClassLoader(),
195 ClassLoader.getSystemClassLoader()
196 };
197 final Collection<UrlResource> resources = new LinkedHashSet<UrlResource>();
198 for (final ClassLoader cl : candidates) {
199 if (cl != null) {
200 try {
201 final Enumeration<URL> resourceEnum = cl.getResources(resource);
202 while (resourceEnum.hasMoreElements()) {
203 resources.add(new UrlResource(cl, resourceEnum.nextElement()));
204 }
205 } catch (final IOException e) {
206 e.printStackTrace();
207 }
208 }
209 }
210 return resources;
211 }
212
213 /**
214 * {@link URL} and {@link ClassLoader} pair.
215 */
216 static class UrlResource {
217 private final ClassLoader classLoader;
218 private final URL url;
219
220 public UrlResource(final ClassLoader classLoader, final URL url) {
221 this.classLoader = classLoader;
222 this.url = url;
223 }
224
225 public ClassLoader getClassLoader() {
226 return classLoader;
227 }
228
229 public URL getUrl() {
230 return url;
231 }
232
233 @Override
234 public boolean equals(final Object o) {
235 if (this == o) {
236 return true;
237 }
238 if (o == null || getClass() != o.getClass()) {
239 return false;
240 }
241
242 final UrlResource that = (UrlResource) o;
243
244 if (classLoader != null ? !classLoader.equals(that.classLoader) : that.classLoader != null) {
245 return false;
246 }
247 if (url != null ? !url.equals(that.url) : that.url != null) {
248 return false;
249 }
250
251 return true;
252 }
253
254 @Override
255 public int hashCode() {
256 int result = classLoader != null ? classLoader.hashCode() : 0;
257 result = 31 * result + (url != null ? url.hashCode() : 0);
258 return result;
259 }
260 }
261 }