| /*
|
| * Copyright 1999-2011 Alibaba Group.
|
| *
|
| * 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 com.alibaba.dubbo.common.utils; |
| |
| import java.lang.reflect.Array; |
| import java.util.Arrays; |
| import java.util.HashMap; |
| import java.util.HashSet; |
| import java.util.Iterator; |
| import java.util.Map; |
| import java.util.Set; |
| |
| public class ClassHelper { |
| |
| /** |
| * get class loader |
| * |
| * @param cls |
| * @return class loader |
| */ |
| public static ClassLoader getClassLoader(Class<?> cls) { |
| ClassLoader cl = null; |
| try { |
| cl = Thread.currentThread().getContextClassLoader(); |
| } catch (Throwable ex) { |
| // Cannot access thread context ClassLoader - falling back to system class loader... |
| } |
| if (cl == null) { |
| // No thread context class loader -> use class loader of this class. |
| cl = cls.getClassLoader(); |
| } |
| return cl; |
| } |
| |
| /** |
| * 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 absolutely need a non-null ClassLoader reference: for |
| * example, for class path resource loading (but not necessarily for |
| * <code>Class.forName</code>, which accepts a <code>null</code> ClassLoader |
| * reference as well). |
| * |
| * @return the default ClassLoader (never <code>null</code>) |
| * @see java.lang.Thread#getContextClassLoader() |
| */ |
| public static ClassLoader getClassLoader() { |
| return getClassLoader(ClassHelper.class); |
| } |
| |
| /** |
| * Same as <code>Class.forName()</code>, except that it works for primitive |
| * types. |
| */ |
| public static Class<?> forName(String name) throws ClassNotFoundException { |
| return forName(name, getClassLoader()); |
| } |
| |
| /** |
| * Replacement for <code>Class.forName()</code> that also returns Class |
| * instances for primitives (like "int") and array class names (like |
| * "String[]"). |
| * |
| * @param name the name of the Class |
| * @param classLoader the class loader to use (may be <code>null</code>, |
| * 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 { |
| |
| Class<?> clazz = resolvePrimitiveClassName(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 |
| int internalArrayMarker = name.indexOf(INTERNAL_ARRAY_PREFIX); |
| if (internalArrayMarker != -1 && name.endsWith(";")) { |
| String elementClassName = null; |
| if (internalArrayMarker == 0) { |
| elementClassName = name |
| .substring(INTERNAL_ARRAY_PREFIX.length(), name.length() - 1); |
| } else if (name.startsWith("[")) { |
| elementClassName = name.substring(1); |
| } |
| Class<?> elementClass = forName(elementClassName, classLoader); |
| return Array.newInstance(elementClass, 0).getClass(); |
| } |
| |
| ClassLoader classLoaderToUse = classLoader; |
| if (classLoaderToUse == null) { |
| classLoaderToUse = getClassLoader(); |
| } |
| return classLoaderToUse.loadClass(name); |
| } |
| |
| /** |
| * 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}. |
| * |
| * @param name the name of the potentially primitive class |
| * @return the primitive class, or <code>null</code> 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 = (Class<?>) primitiveTypeNameMap.get(name); |
| } |
| return result; |
| } |
| |
| /** Suffix for array class names: "[]" */ |
| public static final String ARRAY_SUFFIX = "[]"; |
| /** Prefix for internal array class names: "[L" */ |
| private static final String INTERNAL_ARRAY_PREFIX = "[L"; |
| |
| /** |
| * 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<?>>(16); |
| |
| /** |
| * 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); |
| |
| 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); |
| |
| Set<Class<?>> primitiveTypeNames = new HashSet<Class<?>>(16); |
| primitiveTypeNames.addAll(primitiveWrapperTypeMap.values()); |
| primitiveTypeNames.addAll(Arrays |
| .asList(new Class<?>[] { boolean[].class, byte[].class, char[].class, double[].class, |
| float[].class, int[].class, long[].class, short[].class })); |
| for (Iterator<Class<?>> it = primitiveTypeNames.iterator(); it.hasNext();) { |
| Class<?> primitiveClass = (Class<?>) it.next(); |
| primitiveTypeNameMap.put(primitiveClass.getName(), primitiveClass); |
| } |
| } |
| |
| public static String toShortString(Object obj){ |
| if(obj == null){ |
| return "null"; |
| } |
| return obj.getClass().getSimpleName() + "@" + System.identityHashCode(obj); |
| |
| } |
| } |