Coverage Report

 /*
  * 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.shiro.util;
 
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
 
 import java.io.InputStream;
 import java.lang.reflect.Constructor;
 
 
 /**
  * Utility method library used to conveniently interact with <code>Class</code>es, such as acquiring them from the
  * application <code>ClassLoader</code>s and instantiating Objects from them.
  *
  * @since 0.1
  */
 public class ClassUtils {
 
     //TODO - complete JavaDoc
 
     /**
      * Private internal log instance.
      */
     private static final Logger log = LoggerFactory.getLogger(ClassUtils.class);
 
     /**
      * @since 1.0
      */
     private static final ClassLoaderAccessor THREAD_CL_ACCESSOR = new ExceptionIgnoringAccessor() {
         @Override
         protected ClassLoader doGetClassLoader() throws Throwable {
             return Thread.currentThread().getContextClassLoader();
         }
     };
 
     /**
      * @since 1.0
      */
     private static final ClassLoaderAccessor CLASS_CL_ACCESSOR = new ExceptionIgnoringAccessor() {
         @Override
         protected ClassLoader doGetClassLoader() throws Throwable {
             return ClassUtils.class.getClassLoader();
         }
     };
 
     /**
      * @since 1.0
      */
     private static final ClassLoaderAccessor SYSTEM_CL_ACCESSOR = new ExceptionIgnoringAccessor() {
         @Override
         protected ClassLoader doGetClassLoader() throws Throwable {
             return ClassLoader.getSystemClassLoader();
         }
     };
 
     /**
      * Returns the specified resource by checking the current thread's
      * {@link Thread#getContextClassLoader() context class loader}, then the
      * current ClassLoader (<code>ClassUtils.class.getClassLoader()</code>), then the system/application
      * ClassLoader (<code>ClassLoader.getSystemClassLoader()</code>, in that order, using
      * {@link ClassLoader#getResourceAsStream(String) getResourceAsStream(name)}.
      *
      * @param name the name of the resource to acquire from the classloader(s).
      * @return the InputStream of the resource found, or <code>null</code> if the resource cannot be found from any
      *         of the three mentioned ClassLoaders.
      * @since 0.9
      */
     public static InputStream getResourceAsStream(String name) {
 
         InputStream is = THREAD_CL_ACCESSOR.getResourceStream(name);
 
         if (is == null) {
             if (log.isTraceEnabled()) {
                 log.trace("Resource [" + name + "] was not found via the thread context ClassLoader.  Trying the " +
                         "current ClassLoader...");
             }
             is = CLASS_CL_ACCESSOR.getResourceStream(name);
         }
 
         if (is == null) {
             if (log.isTraceEnabled()) {
                 log.trace("Resource [" + name + "] was not found via the current class loader.  Trying the " +
                         "system/application ClassLoader...");
             }
             is = SYSTEM_CL_ACCESSOR.getResourceStream(name);
         }
 
         if (is == null && log.isTraceEnabled()) {
             log.trace("Resource [" + name + "] was not found via the thread context, current, or " +
                     "system/application ClassLoaders.  All heuristics have been exhausted.  Returning null.");
         }
 
         return is;
     }
 
     /**
      * Attempts to load the specified class name from the current thread's
      * {@link Thread#getContextClassLoader() context class loader}, then the
      * current ClassLoader (<code>ClassUtils.class.getClassLoader()</code>), then the system/application
      * ClassLoader (<code>ClassLoader.getSystemClassLoader()</code>, in that order.  If any of them cannot locate
      * the specified class, an <code>UnknownClassException</code> is thrown (our RuntimeException equivalent of
      * the JRE's <code>ClassNotFoundException</code>.
      *
      * @param fqcn the fully qualified class name to load
      * @return the located class
      * @throws UnknownClassException if the class cannot be found.
      */
     public static Class forName(String fqcn) throws UnknownClassException {
 
         Class clazz = THREAD_CL_ACCESSOR.loadClass(fqcn);
 
         if (clazz == null) {
             if (log.isTraceEnabled()) {
                 log.trace("Unable to load class named [" + fqcn +
                         "] from the thread context ClassLoader.  Trying the current ClassLoader...");
             }
             clazz = CLASS_CL_ACCESSOR.loadClass(fqcn);
         }
 
         if (clazz == null) {
             if (log.isTraceEnabled()) {
                 log.trace("Unable to load class named [" + fqcn + "] from the current ClassLoader.  " +
                         "Trying the system/application ClassLoader...");
             }
             clazz = SYSTEM_CL_ACCESSOR.loadClass(fqcn);
         }
 
         if (clazz == null) {
             String msg = "Unable to load class named [" + fqcn + "] from the thread context, current, or " +
                     "system/application ClassLoaders.  All heuristics have been exhausted.  Class could not be found.";
             throw new UnknownClassException(msg);
         }
 
         return clazz;
     }
 
     public static boolean isAvailable(String fullyQualifiedClassName) {
         try {
             forName(fullyQualifiedClassName);
             return true;
         } catch (UnknownClassException e) {
             return false;
         }
     }
 
     public static Object newInstance(String fqcn) {
         return newInstance(forName(fqcn));
     }
 
     public static Object newInstance(String fqcn, Object... args) {
         return newInstance(forName(fqcn), args);
     }
 
     public static Object newInstance(Class clazz) {
         if (clazz == null) {
             String msg = "Class method parameter cannot be null.";
             throw new IllegalArgumentException(msg);
         }
         try {
             return clazz.newInstance();
         } catch (Exception e) {
             throw new InstantiationException("Unable to instantiate class [" + clazz.getName() + "]", e);
         }
     }
 
     public static Object newInstance(Class clazz, Object... args) {
         Class[] argTypes = new Class[args.length];
         for (int i = 0; i < args.length; i++) {
             argTypes[i] = args[i].getClass();
         }
         Constructor ctor = getConstructor(clazz, argTypes);
         return instantiate(ctor, args);
     }
 
     public static Constructor getConstructor(Class clazz, Class... argTypes) {
         try {
             return clazz.getConstructor(argTypes);
         } catch (NoSuchMethodException e) {
             throw new IllegalStateException(e);
         }
 
     }
 
     public static Object instantiate(Constructor ctor, Object... args) {
         try {
             return ctor.newInstance(args);
         } catch (Exception e) {
             String msg = "Unable to instantiate Permission instance with constructor [" + ctor + "]";
             throw new InstantiationException(msg, e);
         }
     }
 
     /**
      * @since 1.0
      */
     private static interface ClassLoaderAccessor {
         Class loadClass(String fqcn);
         InputStream getResourceStream(String name);
     }
 
     /**
      * @since 1.0
      */
     private static abstract class ExceptionIgnoringAccessor implements ClassLoaderAccessor {
 
         public Class loadClass(String fqcn) {
             Class clazz = null;
             ClassLoader cl = getClassLoader();
             if (cl != null) {
                 try {
                     clazz = cl.loadClass(fqcn);
                 } catch (ClassNotFoundException e) {
                     if (log.isTraceEnabled()) {
                         log.trace("Unable to load clazz named [" + fqcn + "] from class loader [" + cl + "]");
                     }
                 }
             }
             return clazz;
         }
 
         public InputStream getResourceStream(String name) {
             InputStream is = null;
             ClassLoader cl = getClassLoader();
             if (cl != null) {
                 is = cl.getResourceAsStream(name);
             }
             return is;
         }
 
         protected final ClassLoader getClassLoader() {
             try {
                 return doGetClassLoader();
             } catch (Throwable t) {
                 if (log.isDebugEnabled()) {
                     log.debug("Unable to acquire ClassLoader.", t);
                 }
             }
             return null;
         }
 
         protected abstract ClassLoader doGetClassLoader() throws Throwable;
     }
 }

1		/*
2		* Licensed to the Apache Software Foundation (ASF) under one
3		* or more contributor license agreements. See the NOTICE file
4		* distributed with this work for additional information
5		* regarding copyright ownership. The ASF licenses this file
6		* to you under the Apache License, Version 2.0 (the
7		* "License"); you may not use this file except in compliance
8		* with the License. You may obtain a copy of the License at
9		*
10		* http://www.apache.org/licenses/LICENSE-2.0
11		*
12		* Unless required by applicable law or agreed to in writing,
13		* software distributed under the License is distributed on an
14		* "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
15		* KIND, either express or implied. See the License for the
16		* specific language governing permissions and limitations
17		* under the License.
18		*/
19		package org.apache.shiro.util;
20
21		import org.slf4j.Logger;
22		import org.slf4j.LoggerFactory;
23
24		import java.io.InputStream;
25		import java.lang.reflect.Constructor;
26
27
28		/**
29		* Utility method library used to conveniently interact with <code>Class</code>es, such as acquiring them from the
30		* application <code>ClassLoader</code>s and instantiating Objects from them.
31		*
32		* @since 0.1
33		*/
34	102	public class ClassUtils {
35
36		//TODO - complete JavaDoc
37
38		/**
39		* Private internal log instance.
40		*/
41	1	private static final Logger log = LoggerFactory.getLogger(ClassUtils.class);
42
43		/**
44		* @since 1.0
45		*/
46	1	private static final ClassLoaderAccessor THREAD_CL_ACCESSOR = new ExceptionIgnoringAccessor() {
47		@Override
48		protected ClassLoader doGetClassLoader() throws Throwable {
49	94	return Thread.currentThread().getContextClassLoader();
50		}
51		};
52
53		/**
54		* @since 1.0
55		*/
56	1	private static final ClassLoaderAccessor CLASS_CL_ACCESSOR = new ExceptionIgnoringAccessor() {
57		@Override
58		protected ClassLoader doGetClassLoader() throws Throwable {
59	19	return ClassUtils.class.getClassLoader();
60		}
61		};
62
63		/**
64		* @since 1.0
65		*/
66	1	private static final ClassLoaderAccessor SYSTEM_CL_ACCESSOR = new ExceptionIgnoringAccessor() {
67		@Override
68		protected ClassLoader doGetClassLoader() throws Throwable {
69	19	return ClassLoader.getSystemClassLoader();
70		}
71		};
72
73		/**
74		* Returns the specified resource by checking the current thread's
75		* {@link Thread#getContextClassLoader() context class loader}, then the
76		* current ClassLoader (<code>ClassUtils.class.getClassLoader()</code>), then the system/application
77		* ClassLoader (<code>ClassLoader.getSystemClassLoader()</code>, in that order, using
78		* {@link ClassLoader#getResourceAsStream(String) getResourceAsStream(name)}.
79		*
80		* @param name the name of the resource to acquire from the classloader(s).
81		* @return the InputStream of the resource found, or <code>null</code> if the resource cannot be found from any
82		* of the three mentioned ClassLoaders.
83		* @since 0.9
84		*/
85		public static InputStream getResourceAsStream(String name) {
86
87	7	InputStream is = THREAD_CL_ACCESSOR.getResourceStream(name);
88
89	7	if (is == null) {
90	2	if (log.isTraceEnabled()) {
91	2	log.trace("Resource [" + name + "] was not found via the thread context ClassLoader. Trying the " +
92		"current ClassLoader...");
93		}
94	2	is = CLASS_CL_ACCESSOR.getResourceStream(name);
95		}
96
97	7	if (is == null) {
98	2	if (log.isTraceEnabled()) {
99	2	log.trace("Resource [" + name + "] was not found via the current class loader. Trying the " +
100		"system/application ClassLoader...");
101		}
102	2	is = SYSTEM_CL_ACCESSOR.getResourceStream(name);
103		}
104
105	7	if (is == null && log.isTraceEnabled()) {
106	2	log.trace("Resource [" + name + "] was not found via the thread context, current, or " +
107		"system/application ClassLoaders. All heuristics have been exhausted. Returning null.");
108		}
109
110	7	return is;
111		}
112
113		/**
114		* Attempts to load the specified class name from the current thread's
115		* {@link Thread#getContextClassLoader() context class loader}, then the
116		* current ClassLoader (<code>ClassUtils.class.getClassLoader()</code>), then the system/application
117		* ClassLoader (<code>ClassLoader.getSystemClassLoader()</code>, in that order. If any of them cannot locate
118		* the specified class, an <code>UnknownClassException</code> is thrown (our RuntimeException equivalent of
119		* the JRE's <code>ClassNotFoundException</code>.
120		*
121		* @param fqcn the fully qualified class name to load
122		* @return the located class
123		* @throws UnknownClassException if the class cannot be found.
124		*/
125		public static Class forName(String fqcn) throws UnknownClassException {
126
127	87	Class clazz = THREAD_CL_ACCESSOR.loadClass(fqcn);
128
129	87	if (clazz == null) {
130	17	if (log.isTraceEnabled()) {
131	17	log.trace("Unable to load class named [" + fqcn +
132		"] from the thread context ClassLoader. Trying the current ClassLoader...");
133		}
134	17	clazz = CLASS_CL_ACCESSOR.loadClass(fqcn);
135		}
136
137	87	if (clazz == null) {
138	17	if (log.isTraceEnabled()) {
139	17	log.trace("Unable to load class named [" + fqcn + "] from the current ClassLoader. " +
140		"Trying the system/application ClassLoader...");
141		}
142	17	clazz = SYSTEM_CL_ACCESSOR.loadClass(fqcn);
143		}
144
145	87	if (clazz == null) {
146	17	String msg = "Unable to load class named [" + fqcn + "] from the thread context, current, or " +
147		"system/application ClassLoaders. All heuristics have been exhausted. Class could not be found.";
148	17	throw new UnknownClassException(msg);
149		}
150
151	70	return clazz;
152		}
153
154		public static boolean isAvailable(String fullyQualifiedClassName) {
155		try {
156	0	forName(fullyQualifiedClassName);
157	0	return true;
158	0	} catch (UnknownClassException e) {
159	0	return false;
160		}
161		}
162
163		public static Object newInstance(String fqcn) {
164	66	return newInstance(forName(fqcn));
165		}
166
167		public static Object newInstance(String fqcn, Object... args) {
168	0	return newInstance(forName(fqcn), args);
169		}
170
171		public static Object newInstance(Class clazz) {
172	92	if (clazz == null) {
173	0	String msg = "Class method parameter cannot be null.";
174	0	throw new IllegalArgumentException(msg);
175		}
176		try {
177	92	return clazz.newInstance();
178	0	} catch (Exception e) {
179	0	throw new InstantiationException("Unable to instantiate class [" + clazz.getName() + "]", e);
180		}
181		}
182
183		public static Object newInstance(Class clazz, Object... args) {
184	33	Class[] argTypes = new Class[args.length];
185	77	for (int i = 0; i < args.length; i++) {
186	44	argTypes[i] = args[i].getClass();
187		}
188	33	Constructor ctor = getConstructor(clazz, argTypes);
189	33	return instantiate(ctor, args);
190		}
191
192		public static Constructor getConstructor(Class clazz, Class... argTypes) {
193		try {
194	33	return clazz.getConstructor(argTypes);
195	0	} catch (NoSuchMethodException e) {
196	0	throw new IllegalStateException(e);
197		}
198
199		}
200
201		public static Object instantiate(Constructor ctor, Object... args) {
202		try {
203	33	return ctor.newInstance(args);
204	0	} catch (Exception e) {
205	0	String msg = "Unable to instantiate Permission instance with constructor [" + ctor + "]";
206	0	throw new InstantiationException(msg, e);
207		}
208		}
209
210		/**
211		* @since 1.0
212		*/
213		private static interface ClassLoaderAccessor {
214		Class loadClass(String fqcn);
215		InputStream getResourceStream(String name);
216		}
217
218		/**
219		* @since 1.0
220		*/
221	6	private static abstract class ExceptionIgnoringAccessor implements ClassLoaderAccessor {
222
223		public Class loadClass(String fqcn) {
224	121	Class clazz = null;
225	121	ClassLoader cl = getClassLoader();
226	121	if (cl != null) {
227		try {
228	121	clazz = cl.loadClass(fqcn);
229	51	} catch (ClassNotFoundException e) {
230	51	if (log.isTraceEnabled()) {
231	51	log.trace("Unable to load clazz named [" + fqcn + "] from class loader [" + cl + "]");
232		}
233	70	}
234		}
235	121	return clazz;
236		}
237
238		public InputStream getResourceStream(String name) {
239	11	InputStream is = null;
240	11	ClassLoader cl = getClassLoader();
241	11	if (cl != null) {
242	11	is = cl.getResourceAsStream(name);
243		}
244	11	return is;
245		}
246
247		protected final ClassLoader getClassLoader() {
248		try {
249	132	return doGetClassLoader();
250	0	} catch (Throwable t) {
251	0	if (log.isDebugEnabled()) {
252	0	log.debug("Unable to acquire ClassLoader.", t);
253		}
254		}
255	0	return null;
256		}
257
258		protected abstract ClassLoader doGetClassLoader() throws Throwable;
259		}
260		}