com.dahuatech.hutool.core.util.ClassLoaderUtil Maven / Gradle / Ivy
Go to download
Show more of this group Show more artifacts with this name
Show all versions of java-sdk-common Show documentation
Show all versions of java-sdk-common Show documentation
Dahua ICC Open API SDK for Java
package com.dahuatech.hutool.core.util;
import com.dahuatech.hutool.core.convert.BasicType;
import com.dahuatech.hutool.core.exceptions.UtilException;
import com.dahuatech.hutool.core.lang.Assert;
import com.dahuatech.hutool.core.lang.JarClassLoader;
import com.dahuatech.hutool.core.lang.SimpleCache;
import java.io.File;
import java.lang.reflect.Array;
import java.util.ArrayList;
import java.util.List;
import java.util.Map;
import java.util.concurrent.ConcurrentHashMap;
/**
* {@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
clazz = tryLoadInnerClass(name, classLoader, isInitialized);
if (null == clazz) {
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;
}
/**
* 创建新的{@link JarClassLoader}，并使用此Classloader加载目录下的class文件和jar文件
*
* @param jarOrDir jar文件或者包含jar和class文件的目录
* @return {@link JarClassLoader}
* @since 4.4.2
*/
public static JarClassLoader getJarClassLoader(File jarOrDir) {
return JarClassLoader.load(jarOrDir);
}
/**
* 加载外部类
*
* @param jarOrDir jar文件或者包含jar和class文件的目录
* @param name 类名
* @return 类
* @since 4.4.2
*/
public static Class loadClass(File jarOrDir, String name) {
try {
return getJarClassLoader(jarOrDir).loadClass(name);
} catch (ClassNotFoundException e) {
throw new UtilException(e);
}
}
// ----------------------------------------------------------------------------------- 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;
}
}
// ----------------------------------------------------------------------------------- Private
// method start
/**
* 尝试转换并加载内部类，例如java.lang.Thread.State =》java.lang.Thread$State
*
* @param name 类名
* @param classLoader {@link ClassLoader}，{@code null} 则使用系统默认ClassLoader
* @param isInitialized 是否初始化类（调用static模块内容和初始化static属性）
* @return 类名对应的类
* @since 4.1.20
*/
private static Class tryLoadInnerClass(
String name, ClassLoader classLoader, boolean isInitialized) {
// 尝试获取内部类，例如java.lang.Thread.State =》java.lang.Thread$State
final 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 {
return Class.forName(innerClassName, isInitialized, classLoader);
} catch (ClassNotFoundException ex2) {
// 尝试获取内部类失败时，忽略之。
}
}
return null;
}
// ----------------------------------------------------------------------------------- Private
// method end
}