com.xiaoleilu.hutool.util.ClassLoaderUtil Maven / Gradle / Ivy

Go to download
package com.xiaoleilu.hutool.util;

import java.lang.reflect.Array;
import java.util.ArrayList;
import java.util.List;
import java.util.Map;
import java.util.concurrent.ConcurrentHashMap;

import com.xiaoleilu.hutool.convert.BasicType;
import com.xiaoleilu.hutool.exceptions.UtilException;
import com.xiaoleilu.hutool.lang.Assert;
import com.xiaoleilu.hutool.lang.SimpleCache;

/**
 * {@link ClassLoader}工具类
 * 
 * @author Looly
 * @since 3.0.9
 */
public class ClassLoaderUtil {

	/** 数组类的结尾符: "[]" */
	private static final String ARRAY_SUFFIX = "[]";
	/** 内部数组类名前缀: "[" */
	private static final String INTERNAL_ARRAY_PREFIX = "[";
	/** 内部非原始类型类名前缀: "[L" */
	private static final String NON_PRIMITIVE_ARRAY_PREFIX = "[L";
	/** 包名分界符: '.' */
	private static final char PACKAGE_SEPARATOR = StrUtil.C_DOT;
	/** 内部类分界符: '$' */
	private static final char INNER_CLASS_SEPARATOR = '$';

	/** 原始类型名和其class对应表，例如：int =》 int.class */
	private static final Map> primitiveTypeNameMap = new ConcurrentHashMap>(32);
	private static SimpleCache> classCache = new SimpleCache<>();

	static {
		List> primitiveTypes = new ArrayList>(32);
		// 加入原始类型
		primitiveTypes.addAll(BasicType.primitiveWrapperMap.keySet());
		// 加入原始类型数组类型
		primitiveTypes.add(boolean[].class);
		primitiveTypes.add(byte[].class);
		primitiveTypes.add(char[].class);
		primitiveTypes.add(double[].class);
		primitiveTypes.add(float[].class);
		primitiveTypes.add(int[].class);
		primitiveTypes.add(long[].class);
		primitiveTypes.add(short[].class);
		primitiveTypes.add(void.class);
		for (Class primitiveType : primitiveTypes) {
			primitiveTypeNameMap.put(primitiveType.getName(), primitiveType);
		}
	}

	/**
	 * 获取当前线程的{@link ClassLoader}
	 * 
	 * @return 当前线程的class loader
	 * @see Thread#getContextClassLoader()
	 */
	public static ClassLoader getContextClassLoader() {
		return Thread.currentThread().getContextClassLoader();
	}

	/**
	 * 获取{@link ClassLoader}

	 * 获取顺序如下：

	 * 
	 * 	 * 1、获取当前线程的ContextClassLoader
	 * 2、获取{@link ClassLoaderUtil}类对应的ClassLoader
	 * 3、获取系统ClassLoader（{@link ClassLoader#getSystemClassLoader()}）
	 * 
	 * 
	 * @return 类加载器
	 */
	public static ClassLoader getClassLoader() {
		ClassLoader classLoader = getContextClassLoader();
		if (classLoader == null) {
			classLoader = ClassLoaderUtil.class.getClassLoader();
			if (null == classLoader) {
				classLoader = ClassLoader.getSystemClassLoader();
			}
		}
		return classLoader;
	}

	// ----------------------------------------------------------------------------------- loadClass
	/**
	 * 加载类，通过传入类的字符串，返回其对应的类名，使用默认ClassLoader并初始化类（调用static模块内容和初始化static属性）

	 * 扩展{@link Class#forName(String, boolean, ClassLoader)}方法，支持以下几类类名的加载：
	 * 
	 * 	 * 1、原始类型，例如：int
	 * 2、数组类型，例如：int[]、Long[]、String[]
	 * 3、内部类，例如：java.lang.Thread.State会被转为java.lang.Thread$State加载
	 * 
	 * 
	 * @param name 类名
	 * @return 类名对应的类
	 * @throws UtilException 包装{@link ClassNotFoundException}，没有类名对应的类时抛出此异常
	 */
	public static Class loadClass(String name) throws UtilException {
		return loadClass(name, true);
	}

	/**
	 * 加载类，通过传入类的字符串，返回其对应的类名，使用默认ClassLoader

	 * 扩展{@link Class#forName(String, boolean, ClassLoader)}方法，支持以下几类类名的加载：
	 * 
	 * 	 * 1、原始类型，例如：int
	 * 2、数组类型，例如：int[]、Long[]、String[]
	 * 3、内部类，例如：java.lang.Thread.State会被转为java.lang.Thread$State加载
	 * 
	 * 
	 * @param name 类名
	 * @param isInitialized 是否初始化类（调用static模块内容和初始化static属性）
	 * @return 类名对应的类
	 * @throws UtilException 包装{@link ClassNotFoundException}，没有类名对应的类时抛出此异常
	 */
	public static Class loadClass(String name, boolean isInitialized) throws UtilException {
		return loadClass(name, null, isInitialized);
	}

	/**
	 * 加载类，通过传入类的字符串，返回其对应的类名

	 * 此方法支持缓存，第一次被加载的类之后会读取缓存中的类

	 * 加载失败的原因可能是此类不存在或其关联引用类不存在

	 * 扩展{@link Class#forName(String, boolean, ClassLoader)}方法，支持以下几类类名的加载：
	 * 
	 * 	 * 1、原始类型，例如：int
	 * 2、数组类型，例如：int[]、Long[]、String[]
	 * 3、内部类，例如：java.lang.Thread.State会被转为java.lang.Thread$State加载
	 * 
	 * 
	 * @param name 类名
	 * @param classLoader {@link ClassLoader}，{@code null} 则使用系统默认ClassLoader
	 * @param isInitialized 是否初始化类（调用static模块内容和初始化static属性）
	 * @return 类名对应的类
	 * @throws UtilException 包装{@link ClassNotFoundException}，没有类名对应的类时抛出此异常
	 */
	public static Class loadClass(String name, ClassLoader classLoader, boolean isInitialized) throws UtilException {
		Assert.notNull(name, "Name must not be null");

		// 加载原始类型和缓存中的类
		Class clazz = loadPrimitiveClass(name);
		if (clazz == null) {
			clazz = classCache.get(name);
		}
		if (clazz != null) {
			return clazz;
		}

		if (name.endsWith(ARRAY_SUFFIX)) {
			// 对象数组"java.lang.String[]"风格
			final String elementClassName = name.substring(0, name.length() - ARRAY_SUFFIX.length());
			final Class elementClass = loadClass(elementClassName, classLoader, isInitialized);
			clazz = Array.newInstance(elementClass, 0).getClass();
		} else if (name.startsWith(NON_PRIMITIVE_ARRAY_PREFIX) && name.endsWith(";")) {
			// "[Ljava.lang.String;" 风格
			final String elementName = name.substring(NON_PRIMITIVE_ARRAY_PREFIX.length(), name.length() - 1);
			final Class elementClass = loadClass(elementName, classLoader, isInitialized);
			clazz = Array.newInstance(elementClass, 0).getClass();
		} else if (name.startsWith(INTERNAL_ARRAY_PREFIX)) {
			// "[[I" 或 "[[Ljava.lang.String;" 风格
			final String elementName = name.substring(INTERNAL_ARRAY_PREFIX.length());
			final Class elementClass = loadClass(elementName, classLoader, isInitialized);
			clazz = Array.newInstance(elementClass, 0).getClass();
		} else {
			// 加载普通类
			if (null == classLoader) {
				classLoader = getClassLoader();
			}
			try {
				clazz = Class.forName(name, isInitialized, classLoader);
			} catch (ClassNotFoundException ex) {
				// 尝试获取内部类，例如java.lang.Thread.State =》java.lang.Thread$State
				int lastDotIndex = name.lastIndexOf(PACKAGE_SEPARATOR);
				if (lastDotIndex > 0) {// 类与内部类的分隔符不能在第一位，因此>0
					final String innerClassName = name.substring(0, lastDotIndex) + INNER_CLASS_SEPARATOR + name.substring(lastDotIndex + 1);
					try {
						clazz = Class.forName(innerClassName, isInitialized, classLoader);
					} catch (ClassNotFoundException ex2) {
						// 尝试获取内部类失败时，忽略之。
					}
				}
				throw new UtilException(ex);
			}
		}

		// 加入缓存并返回
		return classCache.put(name, clazz);
	}

	/**
	 * 加载原始类型的类。包括原始类型、原始类型数组和void
	 * 
	 * @param name 原始类型名，比如 int
	 * @return 原始类型类
	 */
	public static Class loadPrimitiveClass(String name) {
		Class result = null;
		if (StrUtil.isNotBlank(name)) {
			name = name.trim();
			if (name.length() <= 8) {
				result = primitiveTypeNameMap.get(name);
			}
		}
		return result;
	}

	// ----------------------------------------------------------------------------------- isPresent
	/**
	 * 指定类是否被提供，使用默认ClassLoader

	 * 通过调用{@link #loadClass(String, ClassLoader, boolean)}方法尝试加载指定类名的类，如果加载失败返回false

	 * 加载失败的原因可能是此类不存在或其关联引用类不存在
	 * 
	 * @param className 类名
	 * @return 是否被提供
	 */
	public static boolean isPresent(String className) {
		return isPresent(className, null);
	}

	/**
	 * 指定类是否被提供

	 * 通过调用{@link #loadClass(String, ClassLoader, boolean)}方法尝试加载指定类名的类，如果加载失败返回false

	 * 加载失败的原因可能是此类不存在或其关联引用类不存在
	 * 
	 * @param className 类名
	 * @param classLoader {@link ClassLoader}
	 * @return 是否被提供
	 */
	public static boolean isPresent(String className, ClassLoader classLoader) {
		try {
			loadClass(className, classLoader, false);
			return true;
		} catch (Throwable ex) {
			return false;
		}
	}
}