Java中的双亲委派机制（Parent Delegation Model）是一种类加载机制，它是保证Java应用程序的安全性和稳定性的关键所在。本文将详细介绍双亲委派机制的原理和作用，并且附上相关的Java代码和注释，能更好地理解这个机制。
双亲委派机制的原理
双亲委派机制是Java类加载器的一种工作模式。当一个Java类需要被加载时，Java虚拟机会先将加载请求传递给它的父类加载器，如果父类加载器无法找到该类，才会将加载请求传递给子类加载器。这个过程就像一个向上查找的层级结构，直到被找到或者抛出ClassNotFoundException异常。
在Java中，有三种类加载器：启动类加载器（Bootstrap Class Loader）、扩展类加载器（Extension Class Loader）和应用程序类加载器（Application Class Loader）。
启动类加载器：Java虚拟机内置的类加载器，它负责加载Java核心类库，例如java.lang包中的类。
扩展类加载器：负责加载Java的扩展类，例如Java扩展API中的类。
应用程序类加载器：负责加载应用程序的类和用户自定义类。
通过双亲委派机制，一个类的加载请求会被传递给父类加载器，这样可以避免同一类被多次加载，从而保证Java应用程序的安全性和稳定性。
双亲委派机制的作用
避免类的冲突和数据不一致：双亲委派机制的作用在于避免同一类被多次加载，这样可以避免类的冲突和数据不一致问题。例如，在一个Java应用程序中，如果同一个类被不同的类加载器加载，可能会导致不同的版本存在，从而导致运行时错误。通过双亲委派机制，Java虚拟机会保证同一个类只会被加载一次，这样可以避免这种错误的发生。
提高类加载的效率：因为在加载一个类时，Java虚拟机会优先查找父类加载器中是否已经加载了该类，如果已经加载，则直接返回已经加载的类对象。这样可以减少重复加载的开销，提高类加载的效率。
Java代码
下面是一个简单的Java程序，演示了双亲委派机制的工作原理。
public class ClassLoaderDemo {
public static void main(String[] args) throws ClassNotFoundException {
// 获取应用程序类加载器
ClassLoader appClassLoader = ClassLoader.getSystemClassLoader();
System.out.println("应用程序类加载器：" + appClassLoader);
// 获取扩展类加载器
ClassLoader extClassLoader = appClassLoader.getParent();
System.out.println("扩展类加载器：" + extClassLoader);
// 获取启动类加载器
ClassLoader bootstrapClassLoader = extClassLoader.getParent();
System.out.println("启动类加载器：" + bootstrapClassLoader);
// 加载自定义类
Class<?> customClass = appClassLoader.loadClass("com.example.CustomClass");
System.out.println("自定义类加载器：" + customClass.getClassLoader());
// 加载Java核心类库中的类
Class<?> objectClass = appClassLoader.loadClass("java.lang.Object");
System.out.println("Java核心类库中的类加载器：" + objectClass.getClassLoader());
// 加载Java扩展API中的类
Class<?> dateClass = extClassLoader.loadClass("java.util.Date");
System.out.println("Java扩展API中的类加载器：" + dateClass.getClassLoader());
// 加载Java核心类库中的类，使用启动类加载器
Class<?> stringClass = bootstrapClassLoader.loadClass("java.lang.String");
System.out.println("Java核心类库中的类加载器：" + stringClass.getClassLoader());
}运行上述程序，输出结果如下：
应用程序类加载器：sun.misc.Launcher$AppClassLoader@4e25154f
扩展类加载器：sun.misc.Launcher$ExtClassLoader@3d4eac69
启动类加载器：null
自定义类加载器：sun.misc.Launcher$AppClassLoader@4e25154f
Java核心类库中的类加载器：null
Java扩展API中的类加载器：sun.misc.Launcher$ExtClassLoader@3d4eac69
Java核心类库中的类加载器：null从上述输出结果可以看出，自定义类是由应用程序类加载器加载的，Java核心类库中的类是由Bootstrap Class Loader加载的，Java扩展API中的类是由Extension Class Loader加载的。
由于双亲委派机制的存在，Java虚拟机会优先查找父类加载器中是否已经加载了该类。因此，应用程序类加载器在加载自定义类时，首先会将该请求传递给其父类加载器，即扩展类加载器，如果扩展类加载器无法找到该类，则再将该请求传递给其父类加载器，即启动类加载器。最终，Java核心类库中的类是由Bootstrap Class Loader加载的，因为在Java虚拟机启动时，Bootstrap Class Loader已经将Java核心类库中的类加载到了内存中。
总之，双亲委派机制是Java应用程序的重要特性之一，它保证了Java应用程序的安全性和稳定性，同时还可以提高类加载的效率。理解双亲委派机制的原理和作用，可以帮助开发者更好地编写Java应用程序，避免一些潜在的问题。
打破双亲委派机制
当然，双亲委派机制并不是万无一失的。有时候，我们可能需要打破双亲委派机制，自己定义类加载器来加载类。例如，我们可能需要加载一些特殊的类，这些类并不在系统的类路径中，或者需要动态生成类，或者需要从不同的位置加载同名的类等等。此时，我们可以自己定义类加载器来完成类的加载任务。
下面是一个简单的自定义类加载器示例，演示了如何实现一个自定义类加载器来加载一个指定目录下的class文件，并打破双亲委派机制，让自定义类加载器来加载指定的类。
public class CustomClassLoader extends ClassLoader {
private String classPath;
public CustomClassLoader(String classPath) {
this.classPath = classPath;
}
@Override
protected Class<?> findClass(String name) throws ClassNotFoundException {
// 获取.class文件的字节码
byte[] classBytes = getClassBytes(name);
if (classBytes == null) {
throw new ClassNotFoundException();
}
// 将字节码转换为Class对象
Class<?> clazz = defineClass(name, classBytes, 0, classBytes.length);
if (clazz == null) {
throw new ClassNotFoundException();
}
return clazz;
}
/**
* 获取指定类的字节码
* @param name 类名
* @return 字节码
*/
private byte[] getClassBytes(String name) {
String fileName = classPath + File.separatorChar + name.replace('.', File.separatorChar) + ".class";
File file = new File(fileName);
if (!file.exists()) {
return null;
}
ByteArrayOutputStream baos = new ByteArrayOutputStream();
try (InputStream inputStream = new FileInputStream(file)) {
byte[] buffer = new byte[1024];
int length;
while ((length = inputStream.read(buffer)) != -1) {
baos.write(buffer, 0, length);
}
} catch (IOException e) {
e.printStackTrace();
}
return baos.toByteArray();
}
public static void main(String[] args) throws ClassNotFoundException, IllegalAccessException, InstantiationException {
// 创建自定义类加载器实例
CustomClassLoader classLoader = new CustomClassLoader("/path/to/classes");
// 加载HelloWorld类
Class<?> clazz = classLoader.loadClass("com.example.HelloWorld");
// 创建HelloWorld类实例
Object instance = clazz.newInstance();
// 调用HelloWorld类的sayHello方法
Method method = clazz.getMethod("sayHello");
method.invoke(instance);
}
}这个示例中，我们创建了一个名为CustomClassLoader的自定义类加载器。在CustomClassLoader的构造方法中，我们传入了.class文件所在的目录，然后在findClass()方法中，根据类名获取指定的.class文件的字节码，最后调用defineClass()方法将字节码转换为Class对象。
在main()方法中，我们创建了CustomClassLoader实例，并使用loadClass()方法加载了一个名为com.example.HelloWorld的类。然后我们使用反射创建HelloWorld类实例，并调用sayHello方法。需要注意的是，这个示例是打破了双亲委派机制的，即在CustomClassLoader中并没有调用父类加载器的loadClass()方法。这样做的目的是为了演示如何打破双亲委派机制，实现自己的类加载策略。在实际应用中，我们应该谨慎打破双亲委派机制，确保类的安全性和稳定。但是，在自定义类加载器时，我们需要遵循一定的规则和约定，否则会带来潜在的问题和风险。
以下是一些注意事项：
- 遵循命名规范：自定义类加载器的类名应该以ClassLoader结尾，例如CustomClassLoader。
- 重写findClass()方法：自定义类加载器必须重写findClass()方法来加载类。
- 调用defineClass()方法：在重写findClass()方法时，需要调用defineClass()方法来定义Class对象。
- 不打破双亲委派机制的情况下，可以使用getParent()方法来获取父类加载器，并在findClass()方法中调用父类加载器的loadClass()方法来实现委派机制。
- 在自定义类加载器中，可以使用类路径（class path）或者URL来指定.class文件所在的位置。
- 注意类的安全性：自定义类加载器在加载类时，需要确保该类的安全性，避免类的重复加载和类的篡改。
双亲委派机制是Java应用程序的核心特性之一，通过委派机制，保证了Java应用程序的安全性和稳定性，并提高了类加载的效率。在某些特殊情况下，我们可以打破双亲委派机制，自定义类加载器来实现一些特殊的需求，但是需要遵循一定的规则和约定，确保类的安全性和稳定性。
总结
双亲委派机制是Java中的一个重要特性，它通过一层层向上委派的方式保证了类的加载顺序和安全性。通过自定义类加载器，我们可以打破双亲委派机制，实现自己的类加载策略，但是需要注意类的安全性和稳定性。在实际应用中，我们应该谨慎使用自定义类加载器，避免不必要的安全问题。
扫一扫
427
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
