Java基础- 自定义类加载器
自定义类加载器
在 Java 中实现自定义类加载器通常涉及继承 ClassLoader 类并重写其 findClass 方法。自定义类加载器允许我们从非标准来源（如网络、加密文件或其他媒体）加载类。下面是实现自定义类加载器的基本步骤：
1. 继承 ClassLoader 类
创建一个新的类并继承 ClassLoader 类。例如：
public class MyClassLoader extends ClassLoader {
// 类的实现
}
2. 重写 findClass 方法
在自定义类加载器中重写 findClass 方法。这是类加载的核心，我们需要在这里实现查找类字节码并定义类的逻辑。
@Override
protected Class<?> findClass(String name) throws ClassNotFoundException {
// 实现加载类的逻辑
// 比如从文件系统、网络或其他源读取类的字节码
}
3. 读取类数据
在 findClass 方法中，需要实现读取类的字节码数据的逻辑。这可能涉及读取文件、网络资源等。
4. 调用 defineClass 方法
一旦获得了类的字节码，使用 defineClass 方法来将这些字节码转换为 Class 对象。defineClass 是 ClassLoader 类的一个受保护方法，可以将一个字节数组转换为 Class 类的实例。
byte[] bytes = ... // 从文件或其他地方获取的类字节码
Class<?> c = defineClass(name, bytes, 0, bytes.length);
5. 返回类对象
在 findClass 方法的末尾，返回通过 defineClass 方法创建的类对象。
完整示例
以下是一个简单的自定义类加载器示例，它从文件系统加载类：
public class MyClassLoader extends ClassLoader {
private String classPath;
public MyClassLoader(String classPath) {
this.classPath = classPath;
}
@Override
protected Class<?> findClass(String name) throws ClassNotFoundException {
try {
byte[] data = loadClassData(name);
return defineClass(name, data, 0, data.length);
} catch (IOException e) {
throw new ClassNotFoundException("Could not load class " + name, e);
}
}
private byte[] loadClassData(String name) throws IOException {
String path = classPath + name.replace('.', '/') + ".class";
InputStream is = new FileInputStream(path);
ByteArrayOutputStream byteStream = new ByteArrayOutputStream();
int nextValue = 0;
while ((nextValue = is.read()) != -1) {
byteStream.write(nextValue);
}
return byteStream.toByteArray();
}
}
在这个示例中，MyClassLoader 从指定的文件路径读取类文件，将文件内容转换为字节数组，然后使用 defineClass 方法来创建 Class 对象。
注意事项
- 安全考虑：自定义类加载器在处理类字节码时应确保数据的来源是安全的。
- 性能考虑：合理管理资源，如关闭打开的文件流。
- 遵循双亲委派模型：默认情况下，类加载器会先尝试让其父类加载器加载类，以保证 Java 核心库的类不会被覆盖。如果需要打破这一模型，需谨慎操作并充分理解可能的后果。
自定义类加载器使得 Java 程序能够以灵活和动态的方式加载类，但同时需要确保代码的安全和有效性。
findClass方法
在 Java 中，findClass 方法是 ClassLoader 类的一部分，用于加载类的具体实现。这个方法在自定义类加载器中尤其重要，因为它提供了一种机制来查找和加载类，特别是当类不在标准的类加载路径中时。
基本功能
findClass 方法被设计用来在类加载器的父级加载器都未能成功加载类时，查找并加载类。当一个类被加载时，ClassLoader 类的 loadClass 方法会首先调用父类加载器尝试加载该类。如果父类加载器无法加载该类（通常因为类不在它们的搜索路径中），loadClass 方法会调用 findClass 方法来尝试加载该类。
方法签名
findClass 方法通常如下定义：
protected Class<?> findClass(String name) throws ClassNotFoundException
参数说明：
name：需要加载的类的完全限定名。
使用场景
- 自定义类加载器：在创建自定义类加载器时，通常需要重写
findClass方法。这允许开发者定义自己的类查找逻辑，比如从特定的文件路径、数据库或其他来源加载类。 - 插件和模块化系统：在实现插件或模块化系统时，
findClass方法可以被用来从模块化的、分离的资源中加载类。
实现注意事项
- 重写
findClass：在自定义类加载器中，通常需要重写findClass方法以提供新的类查找和加载机制。 - 调用
defineClass：在findClass方法中，一旦类的字节码被找到和加载，通常会调用ClassLoader类的defineClass方法来将字节码转换成Class对象。 - 异常处理：如果
findClass无法找到或加载类，它应该抛出ClassNotFoundException。
示例
下面是一个简单的自定义类加载器示例，展示了如何重写 findClass 方法：
public class MyClassLoader extends ClassLoader {
@Override
protected Class<?> findClass(String name) throws ClassNotFoundException {
byte[] b = loadClassData(name);
return defineClass(name, b, 0, b.length);
}
private byte[] loadClassData(String name) {
// 实现从文件系统、网络或其他来源加载类字节码的逻辑
// ...
}
}
在这个例子中，MyClassLoader 类重写了 findClass 方法，以提供从特定来源加载类的逻辑。一旦类的字节码被加载，它使用 defineClass 方法来创建 Class 对象。
结论
findClass 方法是自定义类加载器实现中的关键部分，它提供了一种灵活的方式来扩展 Java 的类加载机制。通过重写 findClass，开发者可以控制如何查找和加载类，这在实现插件系统、应用服务器或处理非标准类加载请求时尤其有用。
defineClass方法
在 Java 中，defineClass 方法是 ClassLoader 类的一个关键方法，用于将字节数组转换成 Class 对象。这个方法在自定义类加载器中尤其重要，因为它允许开发者从非标准来源加载类，例如从网络、加密文件等。
基本功能
defineClass 方法的主要功能是将一个字节数组（包含类的字节码）转换成一个 Class 对象。这个方法通常在自定义的类加载器中被重写或调用，以实现特定的类加载机制。
方法签名
ClassLoader 类中的 defineClass 方法有几个重载版本。最常用的版本之一的签名如下：
protected final Class<?> defineClass(String name, byte[] b, int off, int len)
参数说明：
name：预期的类名，可以为null。b：包含类定义信息的字节数组。off：类定义的起始偏移量（在字节数组中）。len：类定义的长度。
使用场景
- 自定义类加载器：当开发者需要从非标准源加载类（如网络资源、加密文件）时，会创建自定义类加载器，并在其中使用
defineClass方法来实现类的加载。 - 动态类加载：在一些动态生成类的应用场景中（如某些框架或工具），
defineClass方法用于将运行时生成的字节码转换为Class对象。
安全和限制
- 安全检查：
defineClass方法在将字节数组转换为Class对象时，会执行安全检查，确保类的结构和行为符合 JVM 规范。 - 访问权限：由于这个方法被定义为
protected，因此只能在ClassLoader类或其子类中被调用。 - 类名限制：如果指定了类名（
name参数非null），那么加载的类名必须与此名称匹配。 - 封装性限制：在 Java 9 及以后版本中，模块系统的引入对类加载器的行为做了进一步的限制，特别是在封装性方面。
示例
下面是一个简单的示例，展示如何在自定义类加载器中使用 defineClass：
public class MyClassLoader extends ClassLoader {
public Class<?> defineClass(String name, byte[] b) {
return defineClass(name, b, 0, b.length);
}
}
在这个示例中，MyClassLoader 类扩展了 ClassLoader，并提供了一个方法来定义类。这个方法接受一个类名和一个字节数组，然后调用 defineClass 来创建 Class 对象。
结论
defineClass 方法是 Java 类加载机制的一个重要组成部分，它使得开发者可以在运行时动态地加载和定义类。这个方法的正确使用对于实现灵活且安全的类加载策略至关重要。
总结
在 Java 中，当使用 ClassLoader 类的 loadClass 方法加载一个类时，loadClass 方法内部会按照一定的逻辑来决定如何加载这个类。如果这个类之前没有被加载过，loadClass 方法会最终调用 findClass 方法来加载这个类。这是 ClassLoader 类的内部机制，因此在使用 loadClass 方法时，不需要直接调用 findClass 方法。下面是这个过程的简化描述：
-
调用
loadClass方法：当我们在main函数中调用myClassLoader.loadClass("your_class_name")时，实际上是调用了ClassLoader类的loadClass方法。 -
检查类是否已加载：
loadClass方法首先检查这个类是否已经被加载过。如果已经加载，它会直接返回这个类的Class对象。 -
委托给父类加载器：如果类还没有被加载，
loadClass方法会尝试让父类加载器去加载这个类。如果父类加载器不存在或无法加载该类，loadClass方法会调用findClass方法。 -
调用
findClass方法：findClass方法是一个protected方法，通常在自定义类加载器中被重写。它包含了从特定来源（如文件系统、网络等）加载类的具体逻辑。 -
返回
Class对象：一旦findClass方法成功加载了类，并返回了相应的Class对象，loadClass方法就会将这个Class对象返回给调用者。
一般在自定义类加载器的实现中，MyClassLoader 类会重写 findClass 方法以从特定路径加载类文件。当我们在 main 方法中调用 loadClass 时，如果 your_class_name 类之前未被加载，MyClassLoader 的 loadClass 方法会间接调用我们重写的 findClass 方法来加载这个类。这就是为什么在 main 函数中并没有显式调用 findClass 方法，但该方法仍然被执行的原因。
如下是一个测试代码：
package per.mjn.t3;
import java.io.ByteArrayOutputStream;
import java.io.IOException;
import java.nio.file.Files;
import java.nio.file.Paths;
public class Load7 {
public static void main(String[] args) throws ClassNotFoundException, InstantiationException, IllegalAccessException {
// 创建自定义类加载器对象
MyClassLoader myClassLoader = new MyClassLoader();
Class<?> c1 = myClassLoader.loadClass("Demo1_1");
Class<?> c2 = myClassLoader.loadClass("Demo1_1");
System.out.println(c1);
// 判断两次加载获得的类对象是否相同
System.out.println(c1 == c2); // true
// 即使多次执行loadClass方法，但实际上类文件只会加载一次，第一次加载后就会放在自定义类加载器的缓存中
// 下次再调用loadClass()时就可以在缓存中找到了，不会重复的进行类加载
// -------------------------------------------------------
MyClassLoader myClassLoader1 = new MyClassLoader();
Class<?> c3 = myClassLoader1.loadClass("Demo1_1");
// 唯一确定类的方式是，包名 类名相同，而且类加载器也是同一个，才认为这两个类才是完全一致的
// 虽然MapImpl1与刚才的包名类名一样，但是由于他俩的类加载器对象不是同一个，所以认为这两个类不是同一个类
// 也就是，这个类会被加载两次，因为是不同的类加载器，就认为他俩是相互隔离的，不会产生冲突
System.out.println(c1 == c3); // false
// 创建这个类的实例对象会触发静态代码块的执行
c1.newInstance(); // 会打印出"init..."(在静态代码块中提前写好的)
}
}
class MyClassLoader extends ClassLoader {
@Override // name 就是类名称
protected Class<?> findClass(String name) throws ClassNotFoundException {
String path = "D:\\ideaProject\\JVM_Detect\\src\\per\\mjn\\t1\\" + name + ".class";
ByteArrayOutputStream os = new ByteArrayOutputStream();
try {
Files.copy(Paths.get(path), os);
// 得到字节数组
byte[] bytes = os.toByteArray();
// byte[] -> *.class
Class<?> aClass = defineClass(name, bytes, 0, bytes.length);
return aClass;
} catch (IOException e) {
e.printStackTrace();
throw new ClassNotFoundException("类文件未找到", e);
}
}
}