Hutool
  • 指南
  • 核心(hutool-core)
  • 类加载器(classloader)
Hutool
2026-01-03
目录

资源类加载器-ResourceClassLoader

# 📚 介绍

ResourceClassLoader 是 Hutool 核心模块中的资源类加载器，继承自 Java 原生的 SecureClassLoader，专门用于加载任意类型资源中的类。它支持从各种资源中加载类，包括文件、流或者字符串，为 Java 开发者提供了灵活的类加载解决方案。

# 设计理念

  • 资源无关：支持从任意类型的资源中加载类
  • 安全可靠：继承自 SecureClassLoader，保证加载安全
  • 缓存机制：内置类缓存，提高加载效率
  • 灵活扩展：支持动态添加资源
  • 便捷 API：提供简单易用的构造方法和实例方法

# 🔧 核心方法详解

# 1. 构造方法

# ResourceClassLoader(ClassLoader parentClassLoader, Map<String, T> resourceMap)

功能：创建资源类加载器

参数：

  • parentClassLoader：父类加载器，null 表示默认当前上下文加载器
  • resourceMap：资源映射，键为类名，值为资源对象

示例：

// 创建空的资源映射
Map<String, FileResource> resourceMap = new HashMap<>();

// 创建资源类加载器，使用默认父类加载器
ResourceClassLoader<FileResource> loader1 = new ResourceClassLoader<>(null, resourceMap);

// 创建自定义父类加载器
ClassLoader customLoader = new URLClassLoader(new URL[]{});

// 创建资源类加载器，使用自定义父类加载器
ResourceClassLoader<FileResource> loader2 = new ResourceClassLoader<>(customLoader, resourceMap);

# 2. 实例方法

# addResource(T resource)

功能：增加需要加载的类资源

参数：

  • resource：资源对象，可以是文件、流或者字符串

返回值：当前 ResourceClassLoader 实例，支持链式调用

示例：

// 创建资源类加载器
ResourceClassLoader<FileResource> loader = new ResourceClassLoader<>(null, null);

// 添加文件资源
FileResource fileResource = new FileResource("/path/to/MyClass.class");
loader.addResource(fileResource);

// 链式添加多个资源
loader.addResource(new FileResource("/path/to/Class1.class"))
      .addResource(new FileResource("/path/to/Class2.class"))
      .addResource(new FileResource("/path/to/Class3.class"));

# findClass(String name)

功能：查找并加载指定名称的类，重写了父类的方法

参数：

  • name：类名

返回值：加载的类

抛出异常：

  • ClassNotFoundException：找不到指定名称的类

说明：

  • 首先从缓存中查找类，如果找到直接返回
  • 如果缓存中没有，尝试从资源映射中加载
  • 如果资源映射中没有，调用父类的 findClass 方法

# 🚀 综合示例

# 示例1：从文件资源加载类

public void loadFromFileResourceTest() {
    // 创建资源映射
    Map<String, FileResource> resourceMap = new HashMap<>();

    // 添加文件资源
    resourceMap.put("com.example.MyClass", new FileResource("/path/to/MyClass.class"));

    // 创建资源类加载器
    ResourceClassLoader<FileResource> loader = new ResourceClassLoader<>(null, resourceMap);

    try {
        // 加载类
        Class<?> myClass = loader.loadClass("com.example.MyClass");

        // 验证类加载成功
        Console.log("成功加载类：" + myClass.getName());

        // 使用反射创建实例并调用方法
        Object instance = myClass.getDeclaredConstructor().newInstance();
        Method method = myClass.getMethod("sayHello");
        String result = (String) method.invoke(instance);

        Console.log("调用方法结果：" + result);
    } catch (Exception e) {
        e.printStackTrace();
    }
}

# 示例2：动态添加资源

public void dynamicAddResourceTest() {
    // 创建空的资源类加载器
    ResourceClassLoader<FileResource> loader = new ResourceClassLoader<>(null, null);

    // 动态添加资源
    loader.addResource(new FileResource("/path/to/Class1.class"))
          .addResource(new FileResource("/path/to/Class2.class"));

    try {
        // 加载第一个类
        Class<?> class1 = loader.loadClass("com.example.Class1");
        Console.log("成功加载类1：" + class1.getName());

        // 加载第二个类
        Class<?> class2 = loader.loadClass("com.example.Class2");
        Console.log("成功加载类2：" + class2.getName());

        // 再次添加资源
        loader.addResource(new FileResource("/path/to/Class3.class"));

        // 加载第三个类
        Class<?> class3 = loader.loadClass("com.example.Class3");
        Console.log("成功加载类3：" + class3.getName());
    } catch (Exception e) {
        e.printStackTrace();
    }
}

# 示例3：使用不同类型的资源

public void differentResourceTypesTest() {
    // 创建资源映射，支持不同类型的资源
    Map<String, Resource> resourceMap = new HashMap<>();

    // 添加文件资源
    resourceMap.put("com.example.FileClass", new FileResource("/path/to/FileClass.class"));

    // 添加字符串资源（假设已经有类的字节数组）
    byte[] classBytes = getClassBytes(); // 自定义方法，获取类的字节数组
    resourceMap.put("com.example.StringClass", new StringResource("StringClass", classBytes));

    // 添加URL资源
    resourceMap.put("com.example.UrlClass", new UrlResource("https://example.com/UrlClass.class"));

    // 创建资源类加载器
    ResourceClassLoader<Resource> loader = new ResourceClassLoader<>(null, resourceMap);

    try {
        // 加载不同类型的资源
        Class<?> fileClass = loader.loadClass("com.example.FileClass");
        Class<?> stringClass = loader.loadClass("com.example.StringClass");
        Class<?> urlClass = loader.loadClass("com.example.UrlClass");

        Console.log("成功加载文件资源类：" + fileClass.getName());
        Console.log("成功加载字符串资源类：" + stringClass.getName());
        Console.log("成功加载URL资源类：" + urlClass.getName());
    } catch (Exception e) {
        e.printStackTrace();
    }
}

# 示例4：结合其他类加载器使用

public void combineWithOtherLoadersTest() {
    // 创建外部Jar加载器
    JarClassLoader jarLoader = JarClassLoader.load(new File("/path/to/external.jar"));

    // 创建资源映射
    Map<String, FileResource> resourceMap = new HashMap<>();
    resourceMap.put("com.example.DynamicClass", new FileResource("/path/to/DynamicClass.class"));

    // 使用JarClassLoader作为父类加载器
    ResourceClassLoader<FileResource> resourceLoader = new ResourceClassLoader<>(jarLoader, resourceMap);

    try {
        // 加载外部Jar中的类（通过父类加载器）
        Class<?> externalClass = resourceLoader.loadClass("com.external.ExternalClass");
        Console.log("成功加载外部Jar类：" + externalClass.getName());

        // 加载资源中的类
        Class<?> dynamicClass = resourceLoader.loadClass("com.example.DynamicClass");
        Console.log("成功加载动态资源类：" + dynamicClass.getName());
    } catch (Exception e) {
        e.printStackTrace();
    }
}

# 🎯 最佳实践

# 1. 资源管理

  • 合理组织：将相关的资源组织在一起，便于管理
  • 及时释放：不再使用的资源类加载器应该被及时释放，避免内存泄漏
  • 资源验证：在加载资源之前，验证资源的完整性和合法性

# 2. 性能优化

  • 缓存复用：对频繁使用的资源类加载器进行缓存，避免重复创建
  • 按需加载：只加载必要的资源，避免不必要的性能开销
  • 批量添加：一次性添加多个资源，减少方法调用次数

# 3. 安全考虑

  • 验证来源：只加载来自可信来源的资源
  • 权限控制：根据需要设置适当的安全策略
  • 异常处理：妥善处理类加载过程中可能出现的异常

# 4. 灵活扩展

  • 自定义资源类型：根据需要实现自定义的资源类型
  • 扩展加载逻辑：可以继承 ResourceClassLoader，重写相关方法以扩展加载逻辑
  • 结合其他类加载器：与其他类加载器结合使用，实现更复杂的加载策略

# 📌 注意事项

  1. 类名格式：资源映射中的键必须是完整的类名，包括包名
  2. 资源类型：资源对象必须正确实现了 Resource 接口
  3. 缓存机制：一旦类被加载，就会被缓存起来，后续加载会直接返回缓存中的类
  4. 父类加载器：资源类加载器遵循双亲委派模型，优先从父类加载器加载类
  5. 线程安全：ResourceClassLoader 是线程安全的，可以在多线程环境下使用
  6. 内存使用：每个类加载器实例都会占用一定的内存，注意资源使用

# 🚀 总结

ResourceClassLoader 是一个功能强大、使用便捷的资源类加载器，为 Java 开发者提供了灵活的类加载解决方案。它支持从各种资源中加载类，包括文件、流或者字符串，内置类缓存，提高加载效率。

无论是加载单个资源中的类，还是加载多个资源中的类，ResourceClassLoader 都能轻松应对。通过合理使用 ResourceClassLoader，可以实现动态加载类、插件化开发等高级应用场景。

ResourceClassLoader 是 Hutool 类加载器模块中的重要组成部分，与 ClassLoaderUtil 和 JarClassLoader 一起，构成了完整的类加载解决方案，为 Java 开发者提供了丰富的类加载工具。

外部Jar加载器-JarClassLoader
简介

← 简介→

Theme by Vdoing | Copyright © 2025-2026 Hutool | Apache-2.0