http://git-wip-us.apache.org/repos/asf/incubator-tamaya/blob/a55d1c97/core/src/main/java/org/apache/tamaya/core/internal/resources/io/ClassUtils.java ---------------------------------------------------------------------- diff --git a/core/src/main/java/org/apache/tamaya/core/internal/resources/io/ClassUtils.java b/core/src/main/java/org/apache/tamaya/core/internal/resources/io/ClassUtils.java new file mode 100644 index 0000000..6041cae --- /dev/null +++ b/core/src/main/java/org/apache/tamaya/core/internal/resources/io/ClassUtils.java @@ -0,0 +1,1232 @@ +/* +* Copyright 2002-2014 the original author or authors. +* +* Licensed 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.tamaya.core.internal.resources.io; + +import java.beans.Introspector; +import java.lang.reflect.Array; +import java.lang.reflect.Constructor; +import java.lang.reflect.Method; +import java.lang.reflect.Modifier; +import java.lang.reflect.Proxy; +import java.util.*; + +/** +* Miscellaneous class utility methods. +* Mainly for internal use within the framework. +* +* @author Juergen Hoeller +* @author Keith Donald +* @author Rob Harrop +* @author Sam Brannen +* @since 1.1 +*/ +public class ClassUtils { + + /** Suffix for array class names: "[]" */ + public static final String ARRAY_SUFFIX = "[]"; + + /** Prefix for internal array class names: "[" */ + private static final String INTERNAL_ARRAY_PREFIX = "["; + + /** Prefix for internal non-primitive array class names: "[L" */ + private static final String NON_PRIMITIVE_ARRAY_PREFIX = "[L"; + + /** The package separator character '.' */ + private static final char PACKAGE_SEPARATOR = '.'; + + /** The path separator character '/' */ + private static final char PATH_SEPARATOR = '/'; + + /** The inner class separator character '$' */ + private static final char INNER_CLASS_SEPARATOR = '$'; +// +// /** The CGLIB class separator character "$$" */ +// public static final String CGLIB_CLASS_SEPARATOR = "$$"; +// +// /** The ".class" file suffix */ +// public static final String CLASS_FILE_SUFFIX = ".class"; +// + + /** + * Map with primitive wrapper type as key and corresponding primitive + * type as value, for example: Integer.class -> int.class. + */ + private static final Map<Class<?>, Class<?>> primitiveWrapperTypeMap = new HashMap<Class<?>, Class<?>>(8); + + /** + * Map with primitive type as key and corresponding wrapper + * type as value, for example: int.class -> Integer.class. + */ + private static final Map<Class<?>, Class<?>> primitiveTypeToWrapperMap = new HashMap<Class<?>, Class<?>>(8); + + /** + * Map with primitive type name as key and corresponding primitive + * type as value, for example: "int" -> "int.class". + */ + private static final Map<String, Class<?>> primitiveTypeNameMap = new HashMap<String, Class<?>>(32); +// +// /** +// * Map with common "java.lang" class name as key and corresponding Class as value. +// * Primarily for efficient deserialization of remote invocations. +// */ +// private static final Map<String, Class<?>> commonClassCache = new HashMap<String, Class<?>>(32); +// +// + static { + primitiveWrapperTypeMap.put(Boolean.class, boolean.class); + primitiveWrapperTypeMap.put(Byte.class, byte.class); + primitiveWrapperTypeMap.put(Character.class, char.class); + primitiveWrapperTypeMap.put(Double.class, double.class); + primitiveWrapperTypeMap.put(Float.class, float.class); + primitiveWrapperTypeMap.put(Integer.class, int.class); + primitiveWrapperTypeMap.put(Long.class, long.class); + primitiveWrapperTypeMap.put(Short.class, short.class); + + for (Map.Entry<Class<?>, Class<?>> entry : primitiveWrapperTypeMap.entrySet()) { + primitiveTypeToWrapperMap.put(entry.getValue(), entry.getKey()); +// registerCommonClasses(entry.getKey()); + } + + Set<Class<?>> primitiveTypes = new HashSet<Class<?>>(32); + primitiveTypes.addAll(primitiveWrapperTypeMap.values()); + primitiveTypes.addAll(Arrays.asList(new Class<?>[] { + boolean[].class, byte[].class, char[].class, double[].class, + float[].class, int[].class, long[].class, short[].class})); + primitiveTypes.add(void.class); + for (Class<?> primitiveType : primitiveTypes) { + primitiveTypeNameMap.put(primitiveType.getName(), primitiveType); + } + +// registerCommonClasses(Boolean[].class, Byte[].class, Character[].class, Double[].class, +// Float[].class, Integer[].class, Long[].class, Short[].class); +// registerCommonClasses(Number.class, Number[].class, String.class, String[].class, +// Object.class, Object[].class, Class.class, Class[].class); +// registerCommonClasses(Throwable.class, Exception.class, RuntimeException.class, +// Error.class, StackTraceElement.class, StackTraceElement[].class); + } +// +// private ClassUtils(){} +// +// /** +// * Register the given common classes with the ClassUtils cache. +// */ +// private static void registerCommonClasses(Class<?>... commonClasses) { +// for (Class<?> clazz : commonClasses) { +// commonClassCache.put(clazz.getName(), clazz); +// } +// } +// + /** + * Return the default ClassLoader to use: typically the thread context + * ClassLoader, if available; the ClassLoader that loaded the ClassUtils + * class will be used as fallback. + * <p>Call this method if you intend to use the thread context ClassLoader + * in a scenario where you clearly prefer a non-null ClassLoader reference: + * for example, for class path resource loading (but not necessarily for + * {@code Class.forName}, which accepts a {@code null} ClassLoader + * reference as well). + * @return the default ClassLoader (only {@code null} if even the system + * ClassLoader isn't accessible) + * @see Thread#getContextClassLoader() + * @see ClassLoader#getSystemClassLoader() + */ + public static ClassLoader getDefaultClassLoader() { + ClassLoader cl = null; + try { + cl = Thread.currentThread().getContextClassLoader(); + } + catch (Throwable ex) { + // Cannot access thread context ClassLoader - falling back... + } + if (cl == null) { + // No thread context class loader -> use class loader of this class. + cl = ClassUtils.class.getClassLoader(); + if (cl == null) { + // getClassLoader() returning null indicates the bootstrap ClassLoader + try { + cl = ClassLoader.getSystemClassLoader(); + } + catch (Throwable ex) { + // Cannot access system ClassLoader - oh well, maybe the caller can live with null... + } + } + } + return cl; + } + +// /** +// * Override the thread context ClassLoader with the environment's bean ClassLoader +// * if necessary, i.e. if the bean ClassLoader is not equivalent to the thread +// * context ClassLoader already. +// * @param classLoaderToUse the actual ClassLoader to use for the thread context +// * @return the original thread context ClassLoader, or {@code null} if not overridden +// */ +// public static ClassLoader overrideThreadContextClassLoader(ClassLoader classLoaderToUse) { +// Thread currentThread = Thread.currentThread(); +// ClassLoader threadContextClassLoader = currentThread.getContextClassLoader(); +// if (classLoaderToUse != null && !classLoaderToUse.equals(threadContextClassLoader)) { +// currentThread.setContextClassLoader(classLoaderToUse); +// return threadContextClassLoader; +// } +// else { +// return null; +// } +// } + + /** + * Replacement for {@code Class.forName()} that also returns Class instances + * for primitives (e.g. "int") and array class names (e.g. "String[]"). + * Furthermore, it is also capable of resolving inner class names in Java source + * style (e.g. "java.lang.Thread.State" instead of "java.lang.Thread$State"). + * @param name the name of the Class + * @param classLoader the class loader to use + * (may be {@code null}, which indicates the default class loader) + * @return Class instance for the supplied name + * @throws ClassNotFoundException if the class was not found + * @throws LinkageError if the class file could not be loaded + * @see Class#forName(String, boolean, ClassLoader) + */ + public static Class<?> forName(String name, ClassLoader classLoader) throws ClassNotFoundException, LinkageError { + Objects.requireNonNull(name, "Name must not be null"); + + Class<?> clazz = resolvePrimitiveClassName(name); +// if (clazz == null) { +// clazz = commonClassCache.get(name); +// } + if (clazz != null) { + return clazz; + } + + // "java.lang.String[]" style arrays + if (name.endsWith(ARRAY_SUFFIX)) { + String elementClassName = name.substring(0, name.length() - ARRAY_SUFFIX.length()); + Class<?> elementClass = forName(elementClassName, classLoader); + return Array.newInstance(elementClass, 0).getClass(); + } + + // "[Ljava.lang.String;" style arrays + if (name.startsWith(NON_PRIMITIVE_ARRAY_PREFIX) && name.endsWith(";")) { + String elementName = name.substring(NON_PRIMITIVE_ARRAY_PREFIX.length(), name.length() - 1); + Class<?> elementClass = forName(elementName, classLoader); + return Array.newInstance(elementClass, 0).getClass(); + } + + // "[[I" or "[[Ljava.lang.String;" style arrays + if (name.startsWith(INTERNAL_ARRAY_PREFIX)) { + String elementName = name.substring(INTERNAL_ARRAY_PREFIX.length()); + Class<?> elementClass = forName(elementName, classLoader); + return Array.newInstance(elementClass, 0).getClass(); + } + + ClassLoader clToUse = classLoader; + if (clToUse == null) { + clToUse = getDefaultClassLoader(); + } + try { + return (clToUse != null ? clToUse.loadClass(name) : Class.forName(name)); + } + catch (ClassNotFoundException ex) { + int lastDotIndex = name.lastIndexOf(PACKAGE_SEPARATOR); + if (lastDotIndex != -1) { + String innerClassName = + name.substring(0, lastDotIndex) + INNER_CLASS_SEPARATOR + name.substring(lastDotIndex + 1); + try { + return (clToUse != null ? clToUse.loadClass(innerClassName) : Class.forName(innerClassName)); + } + catch (ClassNotFoundException ex2) { + // Swallow - let original exception get through + } + } + throw ex; + } + } + +// /** +// * Resolve the given class name into a Class instance. Supports +// * primitives (like "int") and array class names (like "String[]"). +// * <p>This is effectively equivalent to the {@code forName} +// * method with the same arguments, with the only difference being +// * the exceptions thrown in case of class loading failure. +// * @param className the name of the Class +// * @param classLoader the class loader to use +// * (may be {@code null}, which indicates the default class loader) +// * @return Class instance for the supplied name +// * @throws IllegalArgumentException if the class name was not resolvable +// * (that is, the class could not be found or the class file could not be loaded) +// * @see #forName(String, ClassLoader) +// */ +// public static Class<?> resolveClassName(String className, ClassLoader classLoader) throws IllegalArgumentException { +// try { +// return forName(className, classLoader); +// } +// catch (ClassNotFoundException ex) { +// throw new IllegalArgumentException("Cannot find class [" + className + "]", ex); +// } +// catch (LinkageError ex) { +// throw new IllegalArgumentException( +// "Error loading class [" + className + "]: problem with class file or dependent class.", ex); +// } +// } + + /** + * Resolve the given class name as primitive class, if appropriate, + * according to the JVM's naming rules for primitive classes. + * <p>Also supports the JVM's internal class names for primitive arrays. + * Does <i>not</i> support the "[]" suffix notation for primitive arrays; + * this is only supported by {@link #forName(String, ClassLoader)}. + * @param name the name of the potentially primitive class + * @return the primitive class, or {@code null} if the name does not denote + * a primitive class or primitive array class + */ + public static Class<?> resolvePrimitiveClassName(String name) { + Class<?> result = null; + // Most class names will be quite long, considering that they + // SHOULD sit in a package, so a length check is worthwhile. + if (name != null && name.length() <= 8) { + // Could be a primitive - likely. + result = primitiveTypeNameMap.get(name); + } + return result; + } + +// /** +// * Determine whether the {@link Class} identified by the supplied name is present +// * and can be loaded. Will return {@code false} if either the class or +// * one of its dependencies is not present or cannot be loaded. +// * @param className the name of the class to check +// * @param classLoader the class loader to use +// * (may be {@code null}, which indicates the default class loader) +// * @return whether the specified class is present +// */ +// public static boolean isPresent(String className, ClassLoader classLoader) { +// try { +// forName(className, classLoader); +// return true; +// } +// catch (Throwable ex) { +// // Class or one of its dependencies is not present... +// return false; +// } +// } +// +// /** +// * Return the user-defined class for the given instance: usually simply +// * the class of the given instance, but the original class in case of a +// * CGLIB-generated subclass. +// * @param instance the instance to check +// * @return the user-defined class +// */ +// public static Class<?> getUserClass(Object instance) { +// Objects.requireNonNull(instance, "Instance must not be null"); +// return getUserClass(instance.getClass()); +// } +// +// /** +// * Return the user-defined class for the given class: usually simply the given +// * class, but the original class in case of a CGLIB-generated subclass. +// * @param clazz the class to check +// * @return the user-defined class +// */ +// public static Class<?> getUserClass(Class<?> clazz) { +// if (clazz != null && clazz.getName().contains(CGLIB_CLASS_SEPARATOR)) { +// Class<?> superClass = clazz.getSuperclass(); +// if (superClass != null && !Object.class.equals(superClass)) { +// return superClass; +// } +// } +// return clazz; +// } +// +// /** +// * Check whether the given class is cache-safe in the given context, +// * i.e. whether it is loaded by the given ClassLoader or a parent of it. +// * @param clazz the class to analyze +// * @param classLoader the ClassLoader to potentially cache metadata in +// */ +// public static boolean isCacheSafe(Class<?> clazz, ClassLoader classLoader) { +// Objects.requireNonNull(clazz, "Class must not be null"); +// try { +// ClassLoader target = clazz.getClassLoader(); +// if (target == null) { +// return true; +// } +// ClassLoader cur = classLoader; +// if (cur == target) { +// return true; +// } +// while (cur != null) { +// cur = cur.getParent(); +// if (cur == target) { +// return true; +// } +// } +// return false; +// } +// catch (SecurityException ex) { +// // Probably from the system ClassLoader - let's consider it safe. +// return true; +// } +// } +// +// +// /** +// * Get the class name without the qualified package name. +// * @param className the className to get the short name for +// * @return the class name of the class without the package name +// * @throws IllegalArgumentException if the className is empty +// */ +// public static String getShortName(String className) { +// Objects.requireNonNull(className, "Class name must not be empty"); +// int lastDotIndex = className.lastIndexOf(PACKAGE_SEPARATOR); +// int nameEndIndex = className.indexOf(CGLIB_CLASS_SEPARATOR); +// if (nameEndIndex == -1) { +// nameEndIndex = className.length(); +// } +// String shortName = className.substring(lastDotIndex + 1, nameEndIndex); +// shortName = shortName.replace(INNER_CLASS_SEPARATOR, PACKAGE_SEPARATOR); +// return shortName; +// } +// +// /** +// * Get the class name without the qualified package name. +// * @param clazz the class to get the short name for +// * @return the class name of the class without the package name +// */ +// public static String getShortName(Class<?> clazz) { +// return getShortName(getQualifiedName(clazz)); +// } +// +// /** +// * Return the short string name of a Java class in uncapitalized JavaBeans +// * property format. Strips the outer class name in case of an inner class. +// * @param clazz the class +// * @return the short name rendered in a standard JavaBeans property format +// * @see java.beans.Introspector#decapitalize(String) +// */ +// public static String getShortNameAsProperty(Class<?> clazz) { +// String shortName = ClassUtils.getShortName(clazz); +// int dotIndex = shortName.lastIndexOf(PACKAGE_SEPARATOR); +// shortName = (dotIndex != -1 ? shortName.substring(dotIndex + 1) : shortName); +// return Introspector.decapitalize(shortName); +// } +// +// /** +// * Determine the name of the class file, relative to the containing +// * package: e.g. "String.class" +// * @param clazz the class +// * @return the file name of the ".class" file +// */ +// public static String getClassFileName(Class<?> clazz) { +// Objects.requireNonNull(clazz, "Class must not be null"); +// String className = clazz.getName(); +// int lastDotIndex = className.lastIndexOf(PACKAGE_SEPARATOR); +// return className.substring(lastDotIndex + 1) + CLASS_FILE_SUFFIX; +// } +// +// /** +// * Determine the name of the package of the given class, +// * e.g. "java.lang" for the {@code java.lang.String} class. +// * @param clazz the class +// * @return the package name, or the empty String if the class +// * is defined in the default package +// */ +// public static String getPackageName(Class<?> clazz) { +// Objects.requireNonNull(clazz, "Class must not be null"); +// return getPackageName(clazz.getName()); +// } +// +// /** +// * Determine the name of the package of the given fully-qualified class name, +// * e.g. "java.lang" for the {@code java.lang.String} class name. +// * @param fqClassName the fully-qualified class name +// * @return the package name, or the empty String if the class +// * is defined in the dObjects.requireNonNullefault package +// */ +// public static String getPackageName(String fqClassName) { +// Objects.requireNonNull(fqClassName, "Class name must not be null"); +// int lastDotIndex = fqClassName.lastIndexOf(PACKAGE_SEPARATOR); +// return (lastDotIndex != -1 ? fqClassName.substring(0, lastDotIndex) : ""); +// } +// +// /** +// * Return the qualified name of the given class: usually simply +// * the class name, but component type class name + "[]" for arrays. +// * @param clazz the class +// * @return the qualified name of the class +// */ +// public static String getQualifiedName(Class<?> clazz) { +// Objects.requireNonNull(clazz, "Class must not be null"); +// if (clazz.isArray()) { +// return getQualifiedNameForArray(clazz); +// } +// else { +// return clazz.getName(); +// } +// } +// +// /** +// * Build a nice qualified name for an array: +// * component type class name + "[]". +// * @param clazz the array class +// * @return a qualified name for the array class +// */ +// private static String getQualifiedNameForArray(Class<?> clazz) { +// StringBuilder result = new StringBuilder(); +// while (clazz.isArray()) { +// clazz = clazz.getComponentType(); +// result.append(ClassUtils.ARRAY_SUFFIX); +// } +// result.insert(0, clazz.getName()); +// return result.toString(); +// } +// +// /** +// * Return the qualified name of the given method, consisting of +// * fully qualified interface/class name + "." + method name. +// * @param method the method +// * @return the qualified name of the method +// */ +// public static String getQualifiedMethodName(Method method) { +// Objects.requireNonNull(method, "Method must not be null"); +// return method.getDeclaringClass().getName() + "." + method.getName(); +// } +// +// /** +// * Return a descriptive name for the given object's type: usually simply +// * the class name, but component type class name + "[]" for arrays, +// * and an appended list of implemented interfaces for JDK proxies. +// * @param value the value to introspect +// * @return the qualified name of the class +// */ +// public static String getDescriptiveType(Object value) { +// if (value == null) { +// return null; +// } +// Class<?> clazz = value.getClass(); +// if (Proxy.isProxyClass(clazz)) { +// StringBuilder result = new StringBuilder(clazz.getName()); +// result.append(" implementing "); +// Class<?>[] ifcs = clazz.getInterfaces(); +// for (int i = 0; i < ifcs.length; i++) { +// result.append(ifcs[i].getName()); +// if (i < ifcs.length - 1) { +// result.append(','); +// } +// } +// return result.toString(); +// } +// else if (clazz.isArray()) { +// return getQualifiedNameForArray(clazz); +// } +// else { +// return clazz.getName(); +// } +// } +// +// /** +// * Check whether the given class matches the user-specified type name. +// * @param clazz the class to check +// * @param typeName the type name to match +// */ +// public static boolean matchesTypeName(Class<?> clazz, String typeName) { +// return (typeName != null && +// (typeName.equals(clazz.getName()) || typeName.equals(clazz.getSimpleName()) || +// (clazz.isArray() && typeName.equals(getQualifiedNameForArray(clazz))))); +// } +// +// +// /** +// * Determine whether the given class has a public constructor with the given signature. +// * <p>Essentially translates {@code NoSuchMethodException} to "false". +// * @param clazz the clazz to analyze +// * @param paramTypes the parameter types of the method +// * @return whether the class has a corresponding constructor +// * @see Class#getMethod +// */ +// public static boolean hasConstructor(Class<?> clazz, Class<?>... paramTypes) { +// return (getConstructorIfAvailable(clazz, paramTypes) != null); +// } +// +// /** +// * Determine whether the given class has a public constructor with the given signature, +// * and return it if available (else return {@code null}). +// * <p>Essentially translates {@code NoSuchMethodException} to {@code null}. +// * @param clazz the clazz to analyze +// * @param paramTypes the parameter types of the method +// * @return the constructor, or {@code null} if not found +// * @see Class#getConstructor +// */ +// public static <T> Constructor<T> getConstructorIfAvailable(Class<T> clazz, Class<?>... paramTypes) { +// Objects.requireNonNull(clazz, "Class must not be null"); +// try { +// return clazz.getConstructor(paramTypes); +// } +// catch (NoSuchMethodException ex) { +// return null; +// } +// } +// +// /** +// * Determine whether the given class has a public method with the given signature. +// * <p>Essentially translates {@code NoSuchMethodException} to "false". +// * @param clazz the clazz to analyze +// * @param methodName the name of the method +// * @param paramTypes the parameter types of the method +// * @return whether the class has a corresponding method +// * @see Class#getMethod +// */ +// public static boolean hasMethod(Class<?> clazz, String methodName, Class<?>... paramTypes) { +// return (getMethodIfAvailable(clazz, methodName, paramTypes) != null); +// } +// +// /** +// * Determine whether the given class has a public method with the given signature, +// * and return it if available (else throws an {@code IllegalStateException}). +// * <p>In case of any signature specified, only returns the method if there is a +// * unique candidate, i.e. a single public method with the specified name. +// * <p>Essentially translates {@code NoSuchMethodException} to {@code IllegalStateException}. +// * @param clazz the clazz to analyze +// * @param methodName the name of the method +// * @param paramTypes the parameter types of the method +// * (may be {@code null} to indicate any signature) +// * @return the method (never {@code null}) +// * @throws IllegalStateException if the method has not been found +// * @see Class#getMethod +// */ +// public static Method getMethod(Class<?> clazz, String methodName, Class<?>... paramTypes) { +// Objects.requireNonNull(clazz, "Class must not be null"); +// Objects.requireNonNull(methodName, "Method name must not be null"); +// if (paramTypes != null) { +// try { +// return clazz.getMethod(methodName, paramTypes); +// } +// catch (NoSuchMethodException ex) { +// throw new IllegalStateException("Expected method not found: " + ex); +// } +// } +// else { +// Set<Method> candidates = new HashSet<Method>(1); +// Method[] methods = clazz.getMethods(); +// for (Method method : methods) { +// if (methodName.equals(method.getName())) { +// candidates.add(method); +// } +// } +// if (candidates.size() == 1) { +// return candidates.iterator().next(); +// } +// else if (candidates.isEmpty()) { +// throw new IllegalStateException("Expected method not found: " + clazz + "." + methodName); +// } +// else { +// throw new IllegalStateException("No unique method found: " + clazz + "." + methodName); +// } +// } +// } +// +// /** +// * Determine whether the given class has a public method with the given signature, +// * and return it if available (else return {@code null}). +// * <p>In case of any signature specified, only returns the method if there is a +// * unique candidate, i.e. a single public method with the specified name. +// * <p>Essentially translates {@code NoSuchMethodException} to {@code null}. +// * @param clazz the clazz to analyze +// * @param methodName the name of the method +// * @param paramTypes the parameter types of the method +// * (may be {@code null} to indicate any signature) +// * @return the method, or {@code null} if not found +// * @see Class#getMethod +// */ +// public static Method getMethodIfAvailable(Class<?> clazz, String methodName, Class<?>... paramTypes) { +// Objects.requireNonNull(clazz, "Class must not be null"); +// Objects.requireNonNull(methodName, "Method name must not be null"); +// if (paramTypes != null) { +// try { +// return clazz.getMethod(methodName, paramTypes); +// } +// catch (NoSuchMethodException ex) { +// return null; +// } +// } +// else { +// Set<Method> candidates = new HashSet<Method>(1); +// Method[] methods = clazz.getMethods(); +// for (Method method : methods) { +// if (methodName.equals(method.getName())) { +// candidates.add(method); +// } +// } +// if (candidates.size() == 1) { +// return candidates.iterator().next(); +// } +// return null; +// } +// } +// +// /** +// * Return the number of methods with a given name (with any argument types), +// * for the given class and/or its superclasses. Includes non-public methods. +// * @param clazz the clazz to check +// * @param methodName the name of the method +// * @return the number of methods with the given name +// */ +// public static int getMethodCountForName(Class<?> clazz, String methodName) { +// Objects.requireNonNull(clazz, "Class must not be null"); +// Objects.requireNonNull(methodName, "Method name must not be null"); +// int count = 0; +// Method[] declaredMethods = clazz.getDeclaredMethods(); +// for (Method method : declaredMethods) { +// if (methodName.equals(method.getName())) { +// count++; +// } +// } +// Class<?>[] ifcs = clazz.getInterfaces(); +// for (Class<?> ifc : ifcs) { +// count += getMethodCountForName(ifc, methodName); +// } +// if (clazz.getSuperclass() != null) { +// count += getMethodCountForName(clazz.getSuperclass(), methodName); +// } +// return count; +// } +// +// /** +// * Does the given class or one of its superclasses at least have one or more +// * methods with the supplied name (with any argument types)? +// * Includes non-public methods. +// * @param clazz the clazz to check +// * @param methodName the name of the method +// * @return whether there is at least one method with the given name +// */ +// public static boolean hasAtLeastOneMethodWithName(Class<?> clazz, String methodName) { +// Objects.requireNonNull(clazz, "Class must not be null"); +// Objects.requireNonNull(methodName, "Method name must not be null"); +// Method[] declaredMethods = clazz.getDeclaredMethods(); +// for (Method method : declaredMethods) { +// if (method.getName().equals(methodName)) { +// return true; +// } +// } +// Class<?>[] ifcs = clazz.getInterfaces(); +// for (Class<?> ifc : ifcs) { +// if (hasAtLeastOneMethodWithName(ifc, methodName)) { +// return true; +// } +// } +// return (clazz.getSuperclass() != null && hasAtLeastOneMethodWithName(clazz.getSuperclass(), methodName)); +// } +// +// /** +// * Given a method, which may come from an interface, and a target class used +// * in the current reflective invocation, find the corresponding target method +// * if there is one. E.g. the method may be {@code IFoo.bar()} and the +// * target class may be {@code DefaultFoo}. In this case, the method may be +// * {@code DefaultFoo.bar()}. This enables attributes on that method to be found. +// * <p><b>NOTE:</b> In contrast to {@code org.springframework.aop.support.AopUtils#getMostSpecificMethod}, +// * this method does <i>not</i> resolve Java 5 bridge methods automatically. +// * Call {@code org.springframework.core.BridgeMethodResolver#findBridgedMethod} +// * if bridge method resolution is desirable (e.g. for obtaining metadata from +// * the original method definition). +// * <p><b>NOTE:</b> Since Spring 3.1.1, if Java security settings disallow reflective +// * access (e.g. calls to {@code Class#getDeclaredMethods} etc, this implementation +// * will fall back to returning the originally provided method. +// * @param method the method to be invoked, which may come from an interface +// * @param targetClass the target class for the current invocation. +// * May be {@code null} or may not even implement the method. +// * @return the specific target method, or the original method if the +// * {@code targetClass} doesn't implement it or is {@code null} +// */ +// public static Method getMostSpecificMethod(Method method, Class<?> targetClass) { +// if (method != null && isOverridable(method, targetClass) && +// targetClass != null && !targetClass.equals(method.getDeclaringClass())) { +// try { +// if (Modifier.isPublic(method.getModifiers())) { +// try { +// return targetClass.getMethod(method.getName(), method.getParameterTypes()); +// } +// catch (NoSuchMethodException ex) { +// return method; +// } +// } +// else { +// Method specificMethod = +// ReflectionUtils.findMethod(targetClass, method.getName(), method.getParameterTypes()); +// return (specificMethod != null ? specificMethod : method); +// } +// } +// catch (SecurityException ex) { +// // Security settings are disallowing reflective access; fall back to 'method' below. +// } +// } +// return method; +// } +// +// /** +// * Determine whether the given method is declared by the user or at least pointing to +// * a user-declared method. +// * <p>Checks {@link Method#isSynthetic()} (for implementation methods) as well as the +// * {@code GroovyObject} interface (for interface methods; on an implementation class, +// * implementations of the {@code GroovyObject} methods will be marked as synthetic anyway). +// * Note that, despite being synthetic, bridge methods ({@link Method#isBridge()}) are considered +// * as user-level methods since they are eventually pointing to a user-declared generic method. +// * @param method the method to check +// * @return {@code true} if the method can be considered as user-declared; [@code false} otherwise +// */ +// public static boolean isUserLevelMethod(Method method) { +// Objects.requireNonNull(method, "Method must not be null"); +// return (method.isBridge() || (!method.isSynthetic() && !isGroovyObjectMethod(method))); +// } +// +// private static boolean isGroovyObjectMethod(Method method) { +// return method.getDeclaringClass().getName().equals("groovy.lang.GroovyObject"); +// } +// +// /** +// * Determine whether the given method is overridable in the given target class. +// * @param method the method to check +// * @param targetClass the target class to check against +// */ +// private static boolean isOverridable(Method method, Class<?> targetClass) { +// if (Modifier.isPrivate(method.getModifiers())) { +// return false; +// } +// if (Modifier.isPublic(method.getModifiers()) || Modifier.isProtected(method.getModifiers())) { +// return true; +// } +// return getPackageName(method.getDeclaringClass()).equals(getPackageName(targetClass)); +// } +// +// /** +// * Return a public static method of a class. +// * @param methodName the static method name +// * @param clazz the class which defines the method +// * @param args the parameter types to the method +// * @return the static method, or {@code null} if no static method was found +// * @throws IllegalArgumentException if the method name is blank or the clazz is null +// */ +// public static Method getStaticMethod(Class<?> clazz, String methodName, Class<?>... args) { +// Objects.requireNonNull(clazz, "Class must not be null"); +// Objects.requireNonNull(methodName, "Method name must not be null"); +// try { +// Method method = clazz.getMethod(methodName, args); +// return Modifier.isStatic(method.getModifiers()) ? method : null; +// } +// catch (NoSuchMethodException ex) { +// return null; +// } +// } +// +// +// /** +// * Check if the given class represents a primitive wrapper, +// * i.e. Boolean, Byte, Character, Short, Integer, Long, Float, or Double. +// * @param clazz the class to check +// * @return whether the given class is a primitive wrapper class +// */ +// public static boolean isPrimitiveWrapper(Class<?> clazz) { +// Objects.requireNonNull(clazz, "Class must not be null"); +// return primitiveWrapperTypeMap.containsKey(clazz); +// } +// +// /** +// * Check if the given class represents a primitive (i.e. boolean, byte, +// * char, short, int, long, float, or double) or a primitive wrapper +// * (i.e. Boolean, Byte, Character, Short, Integer, Long, Float, or Double). +// * @param clazz the class to check +// * @return whether the given class is a primitive or primitive wrapper class +// */ +// public static boolean isPrimitiveOrWrapper(Class<?> clazz) { +// Objects.requireNonNull(clazz, "Class must not be null"); +// return (clazz.isPrimitive() || isPrimitiveWrapper(clazz)); +// } +// +// /** +// * Check if the given class represents an array of primitives, +// * i.e. boolean, byte, char, short, int, long, float, or double. +// * @param clazz the class to check +// * @return whether the given class is a primitive array class +// */ +// public static boolean isPrimitiveArray(Class<?> clazz) { +// Objects.requireNonNull(clazz, "Class must not be null"); +// return (clazz.isArray() && clazz.getComponentType().isPrimitive()); +// } +// +// /** +// * Check if the given class represents an array of primitive wrappers, +// * i.e. Boolean, Byte, Character, Short, Integer, Long, Float, or Double. +// * @param clazz the class to check +// * @return whether the given class is a primitive wrapper array class +// */ +// public static boolean isPrimitiveWrapperArray(Class<?> clazz) { +// Objects.requireNonNull(clazz, "Class must not be null"); +// return (clazz.isArray() && isPrimitiveWrapper(clazz.getComponentType())); +// } +// +// /** +// * Resolve the given class if it is a primitive class, +// * returning the corresponding primitive wrapper type instead. +// * @param clazz the class to check +// * @return the original class, or a primitive wrapper for the original primitive type +// */ +// public static Class<?> resolvePrimitiveIfNecessary(Class<?> clazz) { +// Objects.requireNonNull(clazz, "Class must not be null"); +// return (clazz.isPrimitive() && clazz != void.class? primitiveTypeToWrapperMap.get(clazz) : clazz); +// } +// +// /** +// * Check if the right-hand side type may be assigned to the left-hand side +// * type, assuming setting by reflection. Considers primitive wrapper +// * classes as assignable to the corresponding primitive types. +// * @param lhsType the target type +// * @param rhsType the value type that should be assigned to the target type +// * @return if the target type is assignable from the value type +// */ +// public static boolean isAssignable(Class<?> lhsType, Class<?> rhsType) { +// Objects.requireNonNull(lhsType, "Left-hand side type must not be null"); +// Objects.requireNonNull(rhsType, "Right-hand side type must not be null"); +// if (lhsType.isAssignableFrom(rhsType)) { +// return true; +// } +// if (lhsType.isPrimitive()) { +// Class<?> resolvedPrimitive = primitiveWrapperTypeMap.get(rhsType); +// if (resolvedPrimitive != null && lhsType.equals(resolvedPrimitive)) { +// return true; +// } +// } +// else { +// Class<?> resolvedWrapper = primitiveTypeToWrapperMap.get(rhsType); +// if (resolvedWrapper != null && lhsType.isAssignableFrom(resolvedWrapper)) { +// return true; +// } +// } +// return false; +// } +// +// /** +// * Determine if the given type is assignable from the given value, +// * assuming setting by reflection. Considers primitive wrapper classes +// * as assignable to the corresponding primitive types. +// * @param type the target type +// * @param value the value that should be assigned to the type +// * @return if the type is assignable from the value +// */ +// public static boolean isAssignableValue(Class<?> type, Object value) { +// Objects.requireNonNull(type, "Type must not be null"); +// return (value != null ? isAssignable(type, value.getClass()) : !type.isPrimitive()); +// } +// +// +// /** +// * Convert a "/"-based resource path to a "."-based fully qualified class name. +// * @param resourcePath the resource path pointing to a class +// * @return the corresponding fully qualified class name +// */ +// public static String convertResourcePathToClassName(String resourcePath) { +// Objects.requireNonNull(resourcePath, "Resource path must not be null"); +// return resourcePath.replace(PATH_SEPARATOR, PACKAGE_SEPARATOR); +// } +// +// /** +// * Convert a "."-based fully qualified class name to a "/"-based resource path. +// * @param className the fully qualified class name +// * @return the corresponding resource path, pointing to the class +// */ +// public static String convertClassNameToResourcePath(String className) { +// Objects.requireNonNull(className, "Class name must not be null"); +// return className.replace(PACKAGE_SEPARATOR, PATH_SEPARATOR); +// } +// +// /** +// * Return a path suitable for use with {@code ClassLoader.getResource} +// * (also suitable for use with {@code Class.getResource} by prepending a +// * slash ('/') to the return value). Built by taking the package of the specified +// * class file, converting all dots ('.') to slashes ('/'), adding a trailing slash +// * if necessary, and concatenating the specified resource name to this. +// * <br/>As such, this function may be used to build a path suitable for +// * loading a resource file that is in the same package as a class file, +// * although {@code org.springframework.core.io.ClassPathResource} is usually +// * even more convenient. +// * @param clazz the Class whose package will be used as the base +// * @param resourceName the resource name to append. A leading slash is optional. +// * @return the built-up resource path +// * @see ClassLoader#getResource +// * @see Class#getResource +// */ +// public static String addResourcePathToPackagePath(Class<?> clazz, String resourceName) { +// Objects.requireNonNull(resourceName, "Resource name must not be null"); +// if (!resourceName.startsWith("/")) { +// return classPackageAsResourcePath(clazz) + "/" + resourceName; +// } +// return classPackageAsResourcePath(clazz) + resourceName; +// } + + /** + * Given an input class object, return a string which consists of the + * class's package name as a pathname, i.e., all dots ('.') are replaced by + * slashes ('/'). Neither a leading nor trailing slash is added. The result + * could be concatenated with a slash and the name of a resource and fed + * directly to {@code ClassLoader.getResource()}. For it to be fed to + * {@code Class.getResource} instead, a leading slash would also have + * to be prepended to the returned value. + * @param clazz the input class. A {@code null} value or the default + * (empty) package will result in an empty string ("") being returned. + * @return a path which represents the package name + * @see ClassLoader#getResource + * @see Class#getResource + */ + public static String classPackageAsResourcePath(Class<?> clazz) { + if (clazz == null) { + return ""; + } + String className = clazz.getName(); + int packageEndIndex = className.lastIndexOf(PACKAGE_SEPARATOR); + if (packageEndIndex == -1) { + return ""; + } + String packageName = className.substring(0, packageEndIndex); + return packageName.replace(PACKAGE_SEPARATOR, PATH_SEPARATOR); + } + +// /** +// * Build a String that consists of the names of the classes/interfaces +// * in the given array. +// * <p>Basically like {@code AbstractCollection.toString()}, but stripping +// * the "class "/"interface " prefix before every class name. +// * @param classes a Collection of Class objects (may be {@code null}) +// * @return a String of form "[com.foo.Bar, com.foo.Baz]" +// * @see java.util.AbstractCollection#toString() +// */ +// public static String classNamesToString(Class<?>... classes) { +// return classNamesToString(Arrays.asList(classes)); +// } +// +// /** +// * Build a String that consists of the names of the classes/interfaces +// * in the given collection. +// * <p>Basically like {@code AbstractCollection.toString()}, but stripping +// * the "class "/"interface " prefix before every class name. +// * @param classes a Collection of Class objects (may be {@code null}) +// * @return a String of form "[com.foo.Bar, com.foo.Baz]" +// * @see java.util.AbstractCollection#toString() +// */ +// public static String classNamesToString(Collection<Class<?>> classes) { +// if (classes.isEmpty()) { +// return "[]"; +// } +// StringBuilder sb = new StringBuilder("["); +// for (Iterator<Class<?>> it = classes.iterator(); it.hasNext(); ) { +// Class<?> clazz = it.next(); +// sb.append(clazz.getName()); +// if (it.hasNext()) { +// sb.append(", "); +// } +// } +// sb.append("]"); +// return sb.toString(); +// } +// +// /** +// * Copy the given Collection into a Class array. +// * The Collection must contain Class elements only. +// * @param collection the Collection to copy +// * @return the Class array ({@code null} if the passed-in +// * Collection was {@code null}) +// */ +// public static Class<?>[] toClassArray(Collection<Class<?>> collection) { +// if (collection == null) { +// return null; +// } +// return collection.toArray(new Class<?>[collection.size()]); +// } +// +// /** +// * Return all interfaces that the given instance implements as array, +// * including ones implemented by superclasses. +// * @param instance the instance to analyze for interfaces +// * @return all interfaces that the given instance implements as array +// */ +// public static Class<?>[] getAllInterfaces(Object instance) { +// Objects.requireNonNull(instance, "Instance must not be null"); +// return getAllInterfacesForClass(instance.getClass()); +// } +// +// /** +// * Return all interfaces that the given class implements as array, +// * including ones implemented by superclasses. +// * <p>If the class itself is an interface, it gets returned as sole interface. +// * @param clazz the class to analyze for interfaces +// * @return all interfaces that the given object implements as array +// */ +// public static Class<?>[] getAllInterfacesForClass(Class<?> clazz) { +// return getAllInterfacesForClass(clazz, null); +// } +// +// /** +// * Return all interfaces that the given class implements as array, +// * including ones implemented by superclasses. +// * <p>If the class itself is an interface, it gets returned as sole interface. +// * @param clazz the class to analyze for interfaces +// * @param classLoader the ClassLoader that the interfaces need to be visible in +// * (may be {@code null} when accepting all declared interfaces) +// * @return all interfaces that the given object implements as array +// */ +// public static Class<?>[] getAllInterfacesForClass(Class<?> clazz, ClassLoader classLoader) { +// Set<Class<?>> ifcs = getAllInterfacesForClassAsSet(clazz, classLoader); +// return ifcs.toArray(new Class<?>[ifcs.size()]); +// } +// +// /** +// * Return all interfaces that the given instance implements as Set, +// * including ones implemented by superclasses. +// * @param instance the instance to analyze for interfaces +// * @return all interfaces that the given instance implements as Set +// */ +// public static Set<Class<?>> getAllInterfacesAsSet(Object instance) { +// Objects.requireNonNull(instance, "Instance must not be null"); +// return getAllInterfacesForClassAsSet(instance.getClass()); +// } +// +// /** +// * Return all interfaces that the given class implements as Set, +// * including ones implemented by superclasses. +// * <p>If the class itself is an interface, it gets returned as sole interface. +// * @param clazz the class to analyze for interfaces +// * @return all interfaces that the given object implements as Set +// */ +// public static Set<Class<?>> getAllInterfacesForClassAsSet(Class<?> clazz) { +// return getAllInterfacesForClassAsSet(clazz, null); +// } +// +// /** +// * Return all interfaces that the given class implements as Set, +// * including ones implemented by superclasses. +// * <p>If the class itself is an interface, it gets returned as sole interface. +// * @param clazz the class to analyze for interfaces +// * @param classLoader the ClassLoader that the interfaces need to be visible in +// * (may be {@code null} when accepting all declared interfaces) +// * @return all interfaces that the given object implements as Set +// */ +// public static Set<Class<?>> getAllInterfacesForClassAsSet(Class<?> clazz, ClassLoader classLoader) { +// Objects.requireNonNull(clazz, "Class must not be null"); +// if (clazz.isInterface() && isVisible(clazz, classLoader)) { +// return Collections.<Class<?>>singleton(clazz); +// } +// Set<Class<?>> interfaces = new LinkedHashSet<Class<?>>(); +// while (clazz != null) { +// Class<?>[] ifcs = clazz.getInterfaces(); +// for (Class<?> ifc : ifcs) { +// interfaces.addAll(getAllInterfacesForClassAsSet(ifc, classLoader)); +// } +// clazz = clazz.getSuperclass(); +// } +// return interfaces; +// } +// +// /** +// * Create a composite interface Class for the given interfaces, +// * implementing the given interfaces in one single Class. +// * <p>This implementation builds a JDK proxy class for the given interfaces. +// * @param interfaces the interfaces to merge +// * @param classLoader the ClassLoader to create the composite Class in +// * @return the merged interface as Class +// * @see java.lang.reflect.Proxy#getProxyClass +// */ +// public static Class<?> createCompositeInterface(Class<?>[] interfaces, ClassLoader classLoader) { +// if(interfaces.length==0) throw new IllegalArgumentException("Interfaces must not be empty"); +// Objects.requireNonNull(classLoader, "ClassLoader must not be null"); +// return Proxy.getProxyClass(classLoader, interfaces); +// } +// +// /** +// * Determine the common ancestor of the given classes, if any. +// * @param clazz1 the class to introspect +// * @param clazz2 the other class to introspect +// * @return the common ancestor (i.e. common superclass, one interface +// * extending the other), or {@code null} if none found. If any of the +// * given classes is {@code null}, the other class will be returned. +// * @since 3.2.6 +// */ +// public static Class<?> determineCommonAncestor(Class<?> clazz1, Class<?> clazz2) { +// if (clazz1 == null) { +// return clazz2; +// } +// if (clazz2 == null) { +// return clazz1; +// } +// if (clazz1.isAssignableFrom(clazz2)) { +// return clazz1; +// } +// if (clazz2.isAssignableFrom(clazz1)) { +// return clazz2; +// } +// Class<?> ancestor = clazz1; +// do { +// ancestor = ancestor.getSuperclass(); +// if (ancestor == null || Object.class.equals(ancestor)) { +// return null; +// } +// } +// while (!ancestor.isAssignableFrom(clazz2)); +// return ancestor; +// } +// +// /** +// * Check whether the given class is visible in the given ClassLoader. +// * @param clazz the class to check (typically an interface) +// * @param classLoader the ClassLoader to check against (may be {@code null}, +// * in which case this method will always return {@code true}) +// */ +// public static boolean isVisible(Class<?> clazz, ClassLoader classLoader) { +// if (classLoader == null) { +// return true; +// } +// try { +// Class<?> actualClass = classLoader.loadClass(clazz.getName()); +// return (clazz == actualClass); +// // Else: different interface class found... +// } +// catch (ClassNotFoundException ex) { +// // No interface class found... +// return false; +// } +// } +// +// /** +// * Check whether the given object is a CGLIB proxy. +// * @param object the object to check +// */ +// public static boolean isCglibProxy(Object object) { +// return ClassUtils.isCglibProxyClass(object.getClass()); +// } +// +// /** +// * Check whether the specified class is a CGLIB-generated class. +// * @param clazz the class to check +// */ +// public static boolean isCglibProxyClass(Class<?> clazz) { +// return (clazz != null && isCglibProxyClassName(clazz.getName())); +// } +// +// /** +// * Check whether the specified class name is a CGLIB-generated class. +// * @param className the class name to check +// */ +// public static boolean isCglibProxyClassName(String className) { +// return (className != null && className.contains(CGLIB_CLASS_SEPARATOR)); +// } + +}
http://git-wip-us.apache.org/repos/asf/incubator-tamaya/blob/a55d1c97/core/src/main/java/org/apache/tamaya/core/internal/resources/io/DefaultResourceLoader.java ---------------------------------------------------------------------- diff --git a/core/src/main/java/org/apache/tamaya/core/internal/resources/io/DefaultResourceLoader.java b/core/src/main/java/org/apache/tamaya/core/internal/resources/io/DefaultResourceLoader.java new file mode 100644 index 0000000..442a12d --- /dev/null +++ b/core/src/main/java/org/apache/tamaya/core/internal/resources/io/DefaultResourceLoader.java @@ -0,0 +1,136 @@ +/* + * Copyright 2002-2014 the original author or authors. + * + * Licensed 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.tamaya.core.internal.resources.io; + +import java.net.MalformedURLException; +import java.net.URL; +import java.util.Objects; + +/** + * <p>Will return a {@code UrlResource} if the location value is a URL, + * and a {@code ClassPathResource} if it is a non-URL path or a + * "classpath:" pseudo-URL. + * + * @author Juergen Hoeller + * @since 10.03.2004 + */ +class DefaultResourceLoader { + + /** Pseudo URL prefix for loading from the class path: "classpath:" */ + public static final String CLASSPATH_URL_PREFIX = "classpath:"; + + private ClassLoader classLoader; + + + /** + * Create a new DefaultResourceLoader. + * <p>ClassLoader access will happen using the thread context class loader + * at the time of this ResourceLoader's initialization. + * @see java.lang.Thread#getContextClassLoader() + */ + public DefaultResourceLoader() { + this.classLoader = ClassUtils.getDefaultClassLoader(); + } + + /** + * Create a new DefaultResourceLoader. + * @param classLoader the ClassLoader to load class path resources with, or {@code null} + * for using the thread context class loader at the time of actual resource access + */ + public DefaultResourceLoader(ClassLoader classLoader) { + this.classLoader = classLoader; + } + + + /** + * Specify the ClassLoader to load class path resources with, or {@code null} + * for using the thread context class loader at the time of actual resource access. + * <p>The default is that ClassLoader access will happen using the thread context + * class loader at the time of this ResourceLoader's initialization. + */ + void setClassLoader(ClassLoader classLoader) { + this.classLoader = classLoader; + } + + /** + * Return the ClassLoader to load class path resources with. + * <p>Will get passed to ClassPathResource's constructor for all + * ClassPathResource objects created by this resource loader. + * @see ClassPathResource + */ + public ClassLoader getClassLoader() { + return (this.classLoader != null ? this.classLoader : ClassUtils.getDefaultClassLoader()); + } + + + public Resource getResource(String location) { + Objects.requireNonNull(location, "Location must not be null"); + if (location.startsWith("/")) { + return getResourceByPath(location); + } + else if (location.startsWith(CLASSPATH_URL_PREFIX)) { + return new ClassPathResource(location.substring(CLASSPATH_URL_PREFIX.length()), getClassLoader()); + } + else { + try { + // Try to parse the location as a URL... + URL url = new URL(location); + return new UrlResource(url); + } + catch (MalformedURLException ex) { + // No URL -> resolve as resource path. + return getResourceByPath(location); + } + } + } + + /** + * Return a Resource handle for the resource at the given path. + * <p>The default implementation supports class path locations. This should + * be appropriate for standalone implementations but can be overridden, + * e.g. for implementations targeted at a Servlet container. + * @param path the path to the resource + * @return the corresponding Resource handle + * @see ClassPathResource + */ + protected Resource getResourceByPath(String path) { + return new ClassPathContextResource(path, getClassLoader()); + } + + + /** + * ClassPathResource that explicitly expresses a context-relative path + * through implementing the ContextResource interface. + */ + protected static class ClassPathContextResource extends ClassPathResource { + + public ClassPathContextResource(String path, ClassLoader classLoader) { + super(path, classLoader); + } + + public String getPathWithinContext() { + return getPath(); + } + + @Override + public Resource createRelative(String relativePath) { + String pathToUse = StringUtils.applyRelativePath(getPath(), relativePath); + return new ClassPathContextResource(pathToUse, getClassLoader()); + } + } + +} http://git-wip-us.apache.org/repos/asf/incubator-tamaya/blob/a55d1c97/core/src/main/java/org/apache/tamaya/core/internal/resources/io/FileSystemResource.java ---------------------------------------------------------------------- diff --git a/core/src/main/java/org/apache/tamaya/core/internal/resources/io/FileSystemResource.java b/core/src/main/java/org/apache/tamaya/core/internal/resources/io/FileSystemResource.java new file mode 100644 index 0000000..93d6ec5 --- /dev/null +++ b/core/src/main/java/org/apache/tamaya/core/internal/resources/io/FileSystemResource.java @@ -0,0 +1,218 @@ +/* + * Copyright 2002-2014 the original author or authors. + * + * Licensed 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.tamaya.core.internal.resources.io; + +import java.io.File; +import java.io.FileInputStream; +import java.io.FileOutputStream; +import java.io.IOException; +import java.io.InputStream; +import java.io.OutputStream; +import java.net.URI; +import java.net.URL; +import java.util.Objects; + +/** + * {@link Resource} implementation for {@code java.io.File} handles. + * Obviously supports resolution as File, and also as URL. + * + * @author Juergen Hoeller + * @since 28.12.2003 + * @see java.io.File + */ +public class FileSystemResource extends AbstractResource { + + private final File file; + + private final String path; + + + /** + * Create a new {@code FileSystemResource} from a {@link File} handle. + * <p>Note: When building relative resources via {@link #createRelative}, + * the relative path will apply <i>at the same directory level</i>: + * e.g. new File("C:/dir1"), relative path "dir2" -> "C:/dir2"! + * If you prefer to have relative paths built underneath the given root + * directory, use the {@link #FileSystemResource(String) constructor with a file path} + * to append a trailing slash to the root path: "C:/dir1/", which + * indicates this directory as root for all relative paths. + * @param file a File handle + */ + public FileSystemResource(File file) { + Objects.requireNonNull(file, "File must not be null"); + this.file = file; + this.path = StringUtils.cleanPath(file.getPath()); + } + + /** + * Create a new {@code FileSystemResource} from a file path. + * <p>Note: When building relative resources via {@link #createRelative}, + * it makes a difference whether the specified resource base path here + * ends with a slash or not. In the case of "C:/dir1/", relative paths + * will be built underneath that root: e.g. relative path "dir2" -> + * "C:/dir1/dir2". In the case of "C:/dir1", relative paths will apply + * at the same directory level: relative path "dir2" -> "C:/dir2". + * @param path a file path + */ + public FileSystemResource(String path) { + Objects.requireNonNull(path, "Path must not be null"); + this.file = new File(path); + this.path = StringUtils.cleanPath(path); + } + + + /** + * Return the file path for this resource. + */ + public final String getPath() { + return this.path; + } + + + /** + * This implementation returns whether the underlying file exists. + * @see java.io.File#exists() + */ + @Override + public boolean exists() { + return this.file.exists(); + } + + /** + * This implementation checks whether the underlying file is marked as readable + * (and corresponds to an actual file with content, not to a directory). + * @see java.io.File#canRead() + * @see java.io.File#isDirectory() + */ + @Override + public boolean isReadable() { + return (this.file.canRead() && !this.file.isDirectory()); + } + + /** + * This implementation opens a FileInputStream for the underlying file. + * @see java.io.FileInputStream + */ + @Override + public InputStream getInputStream() throws IOException { + return new FileInputStream(this.file); + } + + /** + * This implementation returns a URL for the underlying file. + * @see java.io.File#toURI() + */ + @Override + public URL getURL() throws IOException { + return this.file.toURI().toURL(); + } + + /** + * This implementation returns a URI for the underlying file. + * @see java.io.File#toURI() + */ + @Override + public URI getURI() throws IOException { + return this.file.toURI(); + } + + /** + * This implementation returns the underlying File reference. + */ + @Override + public File getFile() { + return this.file; + } + + /** + * This implementation returns the underlying File's length. + */ + @Override + public long contentLength() throws IOException { + return this.file.length(); + } + + /** + * This implementation creates a FileSystemResource, applying the given path + * relative to the path of the underlying file of this resource descriptor. + * @see StringUtils#applyRelativePath(String, String) + */ + @Override + public Resource createRelative(String relativePath) { + String pathToUse = StringUtils.applyRelativePath(this.path, relativePath); + return new FileSystemResource(pathToUse); + } + + /** + * This implementation returns the name of the file. + * @see java.io.File#getName() + */ + @Override + public String getFilename() { + return this.file.getName(); + } + + /** + * This implementation returns a description that includes the absolute + * path of the file. + * @see java.io.File#getAbsolutePath() + */ + @Override + public String getDescription() { + return "file [" + this.file.getAbsolutePath() + "]"; + } + + + // implementation of WritableResource + + /** + * This implementation checks whether the underlying file is marked as writable + * (and corresponds to an actual file with content, not to a directory). + * @see java.io.File#canWrite() + * @see java.io.File#isDirectory() + */ + public boolean isWritable() { + return (this.file.canWrite() && !this.file.isDirectory()); + } + + /** + * This implementation opens a FileOutputStream for the underlying file. + * @see java.io.FileOutputStream + */ + public OutputStream getOutputStream() throws IOException { + return new FileOutputStream(this.file); + } + + + /** + * This implementation compares the underlying File references. + */ + @Override + public boolean equals(Object obj) { + return (obj == this || + (obj instanceof FileSystemResource && this.path.equals(((FileSystemResource) obj).path))); + } + + /** + * This implementation returns the hash code of the underlying File reference. + */ + @Override + public int hashCode() { + return this.path.hashCode(); + } + +} http://git-wip-us.apache.org/repos/asf/incubator-tamaya/blob/a55d1c97/core/src/main/java/org/apache/tamaya/core/internal/resources/io/InputStreamResource.java ---------------------------------------------------------------------- diff --git a/core/src/main/java/org/apache/tamaya/core/internal/resources/io/InputStreamResource.java b/core/src/main/java/org/apache/tamaya/core/internal/resources/io/InputStreamResource.java new file mode 100644 index 0000000..3480f7c --- /dev/null +++ b/core/src/main/java/org/apache/tamaya/core/internal/resources/io/InputStreamResource.java @@ -0,0 +1,123 @@ +/* + * Copyright 2002-2012 the original author or authors. + * + * Licensed 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.tamaya.core.internal.resources.io; + +import java.io.IOException; +import java.io.InputStream; + +/** + * {@link Resource} implementation for a given InputStream. Should only + * be used if no specific Resource implementation is applicable. + * In particular, prefer {@code ByteArrayResource} or any of the + * file-based Resource implementations where possible. + * + * <p>In contrast to other Resource implementations, this is a descriptor + * for an <i>already opened</i> resource - therefore returning "true" from + * {@code isOpen()}. Do not use it if you need to keep the resource + * descriptor somewhere, or if you need to read a stream multiple times. + * + * @author Juergen Hoeller + * @since 28.12.2003 + */ +public class InputStreamResource extends AbstractResource { + + private final InputStream inputStream; + + private final String description; + + private boolean read = false; + + + /** + * Create a new InputStreamResource. + * @param inputStream the InputStream to use + */ + public InputStreamResource(InputStream inputStream) { + this(inputStream, "resource loaded through InputStream"); + } + + /** + * Create a new InputStreamResource. + * @param inputStream the InputStream to use + * @param description where the InputStream comes from + */ + public InputStreamResource(InputStream inputStream, String description) { + if (inputStream == null) { + throw new IllegalArgumentException("InputStream must not be null"); + } + this.inputStream = inputStream; + this.description = (description != null ? description : ""); + } + + + /** + * This implementation always returns {@code true}. + */ + @Override + public boolean exists() { + return true; + } + + /** + * This implementation always returns {@code true}. + */ + @Override + public boolean isOpen() { + return true; + } + + /** + * This implementation throws IllegalStateException if attempting to + * read the underlying stream multiple times. + */ + @Override + public InputStream getInputStream() throws IOException { + if (this.read) { + throw new IllegalStateException("InputStream has already been read - " + + "do not use InputStreamResource if a stream needs to be read multiple times"); + } + this.read = true; + return this.inputStream; + } + + /** + * This implementation returns the passed-in description, if any. + */ + @Override + public String getDescription() { + return this.description; + } + + + /** + * This implementation compares the underlying InputStream. + */ + @Override + public boolean equals(Object obj) { + return (obj == this || + (obj instanceof InputStreamResource && ((InputStreamResource) obj).inputStream.equals(this.inputStream))); + } + + /** + * This implementation returns the hash code of the underlying InputStream. + */ + @Override + public int hashCode() { + return this.inputStream.hashCode(); + } + +} http://git-wip-us.apache.org/repos/asf/incubator-tamaya/blob/a55d1c97/core/src/main/java/org/apache/tamaya/core/internal/resources/io/InputStreamSource.java ---------------------------------------------------------------------- diff --git a/core/src/main/java/org/apache/tamaya/core/internal/resources/io/InputStreamSource.java b/core/src/main/java/org/apache/tamaya/core/internal/resources/io/InputStreamSource.java new file mode 100644 index 0000000..c84199a --- /dev/null +++ b/core/src/main/java/org/apache/tamaya/core/internal/resources/io/InputStreamSource.java @@ -0,0 +1,55 @@ +/* + * Copyright 2002-2012 the original author or authors. + * + * Licensed 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.tamaya.core.internal.resources.io; + +import java.io.IOException; +import java.io.InputStream; + +/** + * Simple interface for objects that are sources for an {@link InputStream}. + * + * <p>This is the base interface for Spring's more extensive {@link Resource} interface. + * + * <p>For single-use streams, {@link InputStreamResource} can be used for any + * given {@code InputStream}. Spring's {@code ByteArrayResource} or any + * file-based {@code Resource} implementation can be used as a concrete + * instance, allowing one to read the underlying content stream multiple times. + * This makes this interface useful as an abstract content source for mail + * attachments, for example. + * + * @author Juergen Hoeller + * @since 20.01.2004 + * @see java.io.InputStream + * @see Resource + * @see InputStreamResource + */ +@FunctionalInterface +public interface InputStreamSource { + + /** + * Return an {@link InputStream}. + * <p>It is expected that each call creates a <i>fresh</i> stream. + * <p>This requirement is particularly important when you consider an API such + * as JavaMail, which needs to be able to read the stream multiple times when + * creating mail attachments. For such a use case, it is <i>required</i> + * that each {@code getInputStream()} call returns a fresh stream. + * @return the input stream for the underlying resource (must not be {@code null}) + * @throws IOException if the stream could not be opened + */ + InputStream getInputStream() throws IOException; + +} \ No newline at end of file
