Class.forName(String name)方法,到底会触发那个类加载器进行类加载行为?

4.2 在代码中直接调用Class.forName(String name)方法,到底会触发那个类加载器进行类加载行为?

  Class.forName(String name)默认会使用调用类的类加载器来进行类加载。我们直接来分析一下对应的jdk的代码:

[java] view plain copy

  1. //java.lang.Class.java
  2. publicstatic Class<?> forName(String className) throws ClassNotFoundException {
  3. return forName0(className, true, ClassLoader.getCallerClassLoader());
  4. }
  5. //java.lang.ClassLoader.java
  6. // Returns the invoker‘s class loader, or null if none.
  7. static ClassLoader getCallerClassLoader() {
  8. // 获取调用类(caller)的类型
  9. Class caller = Reflection.getCallerClass(3);
  10. // This can be null if the VM is requesting it
  11. if (caller == null) {
  12. return null;
  13. }
  14. // 调用java.lang.Class中本地方法获取加载该调用类(caller)的ClassLoader
  15. return caller.getClassLoader0();
  16. }
  17. //java.lang.Class.java
  18. //虚拟机本地实现,获取当前类的类加载器,前面介绍的Class的getClassLoader()也使用此方法
  19. native ClassLoader getClassLoader0();

5 开发自己的类加载器

  在前面介绍类加载器的代理委派模式的时候,提到过类加载器会首先代理给其它类加载器来尝试加载某个类。这就意味着真正完成类的加载工作的类加载器和启动这个加载过程的类加载器,有可能不是同一个。真正完成类的加载工作是通过调用defineClass来实现的;而启动类的加载过程是通过调用loadClass来实现的。前者称为一个类的定义加载器(defining loader),后者称为初始加载器(initiating loader)。在Java虚拟机判断两个类是否相同的时候,使用的是类的定义加载器。也就是说,哪个类加载器启动类的加载过程并不重要,重要的是最终定义这个类的加载器。两种类加载器的关联之处在于:一个类的定义加载器是它引用的其它类的初始加载器。如类 com.example.Outer引用了类 com.example.Inner,则由类 com.example.Outer的定义加载器负责启动类 com.example.Inner的加载过程。
  方法 loadClass()抛出的是 java.lang.ClassNotFoundException异常;方法 defineClass()抛出的是 java.lang.NoClassDefFoundError异常。
  类加载器在成功加载某个类之后,会把得到的 java.lang.Class类的实例缓存起来。下次再请求加载该类的时候,类加载器会直接使用缓存的类的实例,而不会尝试再次加载。也就是说,对于一个类加载器实例来说,相同全名的类只加载一次,即 loadClass方法不会被重复调用。

  在绝大多数情况下,系统默认提供的类加载器实现已经可以满足需求。但是在某些情况下,您还是需要为应用开发出自己的类加载器。比如您的应用通过网络来传输Java类的字节代码,为了保证安全性,这些字节代码经过了加密处理。这个时候您就需要自己的类加载器来从某个网络地址上读取加密后的字节代码,接着进行解密和验证,最后定义出要在Java虚拟机中运行的类来。下面将通过两个具体的实例来说明类加载器的开发。

5.1 文件系统类加载器

  第一个类加载器用来加载存储在文件系统上的Java字节代码。完整的实现如下所示。

[java] view plain copy

  1. package classloader;
  2. import java.io.ByteArrayOutputStream;
  3. import java.io.File;
  4. import java.io.FileInputStream;
  5. import java.io.IOException;
  6. import java.io.InputStream;
  7. // 文件系统类加载器
  8. public class FileSystemClassLoader extends ClassLoader {
  9. private String rootDir;
  10. public FileSystemClassLoader(String rootDir) {
  11. this.rootDir = rootDir;
  12. }
  13. // 获取类的字节码
  14. @Override
  15. protected Class<?> findClass(String name) throws ClassNotFoundException {
  16. byte[] classData = getClassData(name);  // 获取类的字节数组
  17. if (classData == null) {
  18. throw new ClassNotFoundException();
  19. } else {
  20. return defineClass(name, classData, 0, classData.length);
  21. }
  22. }
  23. private byte[] getClassData(String className) {
  24. // 读取类文件的字节
  25. String path = classNameToPath(className);
  26. try {
  27. InputStream ins = new FileInputStream(path);
  28. ByteArrayOutputStream baos = new ByteArrayOutputStream();
  29. int bufferSize = 4096;
  30. byte[] buffer = new byte[bufferSize];
  31. int bytesNumRead = 0;
  32. // 读取类文件的字节码
  33. while ((bytesNumRead = ins.read(buffer)) != -1) {
  34. baos.write(buffer, 0, bytesNumRead);
  35. }
  36. return baos.toByteArray();
  37. } catch (IOException e) {
  38. e.printStackTrace();
  39. }
  40. return null;
  41. }
  42. private String classNameToPath(String className) {
  43. // 得到类文件的完全路径
  44. return rootDir + File.separatorChar
  45. + className.replace(‘.‘, File.separatorChar) + ".class";
  46. }
  47. }

  如上所示,类 FileSystemClassLoader继承自类java.lang.ClassLoader。在java.lang.ClassLoader类的常用方法中,一般来说,自己开发的类加载器只需要覆写 findClass(String name)方法即可。java.lang.ClassLoader类的方法loadClass()封装了前面提到的代理模式的实现。该方法会首先调用findLoadedClass()方法来检查该类是否已经被加载过;如果没有加载过的话,会调用父类加载器的loadClass()方法来尝试加载该类;如果父类加载器无法加载该类的话,就调用findClass()方法来查找该类。因此,为了保证类加载器都正确实现代理模式,在开发自己的类加载器时,最好不要覆写 loadClass()方法,而是覆写 findClass()方法。
  类 FileSystemClassLoader的 findClass()方法首先根据类的全名在硬盘上查找类的字节代码文件(.class 文件),然后读取该文件内容,最后通过defineClass()方法来把这些字节代码转换成 java.lang.Class类的实例。

  加载本地文件系统上的类,示例如下:

[java] view plain copy

  1. package com.example;
  2. public class Sample {
  3. private Sample instance;
  4. public void setSample(Object instance) {
  5. System.out.println(instance.toString());
  6. this.instance = (Sample) instance;
  7. }
  8. }

[java] view plain copy

  1. package classloader;
  2. import java.lang.reflect.Method;
  3. public class ClassIdentity {
  4. public static void main(String[] args) {
  5. new ClassIdentity().testClassIdentity();
  6. }
  7. public void testClassIdentity() {
  8. String classDataRootPath = "C:\\Users\\JackZhou\\Documents\\NetBeansProjects\\classloader\\build\\classes";
  9. FileSystemClassLoader fscl1 = new FileSystemClassLoader(classDataRootPath);
  10. FileSystemClassLoader fscl2 = new FileSystemClassLoader(classDataRootPath);
  11. String className = "com.example.Sample";
  12. try {
  13. Class<?> class1 = fscl1.loadClass(className);  // 加载Sample类
  14. Object obj1 = class1.newInstance();  // 创建对象
  15. Class<?> class2 = fscl2.loadClass(className);
  16. Object obj2 = class2.newInstance();
  17. Method setSampleMethod = class1.getMethod("setSample", java.lang.Object.class);
  18. setSampleMethod.invoke(obj1, obj2);
  19. } catch (Exception e) {
  20. e.printStackTrace();
  21. }
  22. }
  23. }

  运行输出:[email protected]

5.2 网络类加载器

  下面将通过一个网络类加载器来说明如何通过类加载器来实现组件的动态更新。即基本的场景是:Java 字节代码(.class)文件存放在服务器上,客户端通过网络的方式获取字节代码并执行。当有版本更新的时候,只需要替换掉服务器上保存的文件即可。通过类加载器可以比较简单的实现这种需求。
  类 NetworkClassLoader负责通过网络下载Java类字节代码并定义出Java类。它的实现与FileSystemClassLoader类似。

[java] view plain copy

  1. package classloader;
  2. import java.io.ByteArrayOutputStream;
  3. import java.io.InputStream;
  4. import java.net.URL;
  5. public class NetworkClassLoader extends ClassLoader {
  6. private String rootUrl;
  7. public NetworkClassLoader(String rootUrl) {
  8. // 指定URL
  9. this.rootUrl = rootUrl;
  10. }
  11. // 获取类的字节码
  12. @Override
  13. protected Class<?> findClass(String name) throws ClassNotFoundException {
  14. byte[] classData = getClassData(name);
  15. if (classData == null) {
  16. throw new ClassNotFoundException();
  17. } else {
  18. return defineClass(name, classData, 0, classData.length);
  19. }
  20. }
  21. private byte[] getClassData(String className) {
  22. // 从网络上读取的类的字节
  23. String path = classNameToPath(className);
  24. try {
  25. URL url = new URL(path);
  26. InputStream ins = url.openStream();
  27. ByteArrayOutputStream baos = new ByteArrayOutputStream();
  28. int bufferSize = 4096;
  29. byte[] buffer = new byte[bufferSize];
  30. int bytesNumRead = 0;
  31. // 读取类文件的字节
  32. while ((bytesNumRead = ins.read(buffer)) != -1) {
  33. baos.write(buffer, 0, bytesNumRead);
  34. }
  35. return baos.toByteArray();
  36. } catch (Exception e) {
  37. e.printStackTrace();
  38. }
  39. return null;
  40. }
  41. private String classNameToPath(String className) {
  42. // 得到类文件的URL
  43. return rootUrl + "/"
  44. + className.replace(‘.‘, ‘/‘) + ".class";
  45. }
  46. }

  在通过NetworkClassLoader加载了某个版本的类之后,一般有两种做法来使用它。第一种做法是使用Java反射API。另外一种做法是使用接口。需要注意的是,并不能直接在客户端代码中引用从服务器上下载的类,因为客户端代码的类加载器找不到这些类。使用Java反射API可以直接调用Java类的方法。而使用接口的做法则是把接口的类放在客户端中,从服务器上加载实现此接口的不同版本的类。在客户端通过相同的接口来使用这些实现类。我们使用接口的方式。示例如下:

  客户端接口:

[java] view plain copy

  1. package classloader;
  2. public interface Versioned {
  3. String getVersion();
  4. }

[java] view plain copy

  1. package classloader;
  2. public interface ICalculator extends Versioned {
  3. String calculate(String expression);
  4. }

  网络上的不同版本的类:

[java] view plain copy

  1. package com.example;
  2. import classloader.ICalculator;
  3. public class CalculatorBasic implements ICalculator {
  4. @Override
  5. public String calculate(String expression) {
  6. return expression;
  7. }
  8. @Override
  9. public String getVersion() {
  10. return "1.0";
  11. }
  12. }

[java] view plain copy

  1. package com.example;
  2. import classloader.ICalculator;
  3. public class CalculatorAdvanced implements ICalculator {
  4. @Override
  5. public String calculate(String expression) {
  6. return "Result is " + expression;
  7. }
  8. @Override
  9. public String getVersion() {
  10. return "2.0";
  11. }
  12. }

  在客户端加载网络上的类的过程:

[java] view plain copy

  1. package classloader;
  2. public class CalculatorTest {
  3. public static void main(String[] args) {
  4. String url = "http://localhost:8080/ClassloaderTest/classes";
  5. NetworkClassLoader ncl = new NetworkClassLoader(url);
  6. String basicClassName = "com.example.CalculatorBasic";
  7. String advancedClassName = "com.example.CalculatorAdvanced";
  8. try {
  9. Class<?> clazz = ncl.loadClass(basicClassName);  // 加载一个版本的类
  10. ICalculator calculator = (ICalculator) clazz.newInstance();  // 创建对象
  11. System.out.println(calculator.getVersion());
  12. clazz = ncl.loadClass(advancedClassName);  // 加载另一个版本的类
  13. calculator = (ICalculator) clazz.newInstance();
  14. System.out.println(calculator.getVersion());
  15. } catch (Exception e) {
  16. e.printStackTrace();
  17. }
  18. }
  19. }
时间: 2024-10-29 09:58:51

Class.forName(String name)方法,到底会触发那个类加载器进行类加载行为?的相关文章

java.lang.Class.forName(String name, boolean initialize, ClassLoader loader)方法

描述 Java.lang.Class.forName(String name, boolean initialize, ClassLoader loader) 方法返回与给定字符串名的类或接口的Class对象,使用给定的类加载器. 指定的类加载器加载的类或接口.如果该参数加载器loader 为空,通过引导类加载器加载类.当类被初始化的初始化initialize参数为true,如果它没有被初始化. 声明 以下是java.lang.Class.forName()方法的声明 [java] view p

Class和 forName(String className)的作用

在Java语言当中,有一个java.lang.Class类,这个类有点"特殊".不可否认,java.lang.Class类是一种类型:但是,java.lang.Class类与普通类(例如Integer.String等)是不同的. 在本文当中,对java.lang.Class类的讨论分为4个部分:前2个部分是讲java.lang.Class与普通类的区别,第3个部分是如何获取java.lang.Class类的对象和简单的使用,第4部分是对于java.lang.Class类的forClas

String,你到底创建了几个对象????

Java代码   String str=new String("aaa"); 这行代码究竟创建了几个String对象呢?答案是2个,而不是3个.由于 new String("aaa")相当于"aaa"与一个就是创建出来的放在堆时原实例对象,而另一个就是放在常量池中的 "aaa" 对象,当然这里的str本身只是一个引用,放在栈里,用来指向堆中创建出来的对象. 常量池(constant pool)指的是在编译期被确定,并被保存在已

String作为方法参数传递 与 引用传递

String作为方法参数传递 String 和 StringBuffer的区别见这里: http://wenku.baidu.com/view/bb670f2abd64783e09122bcd.html 一. 最开始的示例写代码最重要的就是实践,不经过反复试验而得出的说辞只能说是凭空遐想罢了.所以,在本文中首先以一个简单示例来抛出核心话题: public class StringAsParamOfMethodDemo { public static void main(String[] args

Mina和QuickServer中为什么服务器接收数据的方法不被触发

如果骚年你在客户端发消息服务端接收数据的方法不被触发,也就是Mina中的messageReceived(IoSession session, Object message)方法,和QuickServer中的handleCommand(ClientHandler handler, String command)方法没有被调用,欲哭无泪中发现要加上这一句代码: outputStream.write("\r\n".getBytes());//发送完数据加上这一句就可以了 原因是他们只有在收到

基类中的虚方法到底有什么作用?

只有基类的方法加上关键字virtual后才可以被override,从而实现面向对象最重要的特征--多态性,即基类可以使用派生类的方法. C#中指出:普通的方法重载:指的是类中两个以上的方法(包括隐藏的,继承而来的方法)取的名字相同,只要使用的参数类型或者参数个数不同,编译器便知道在何种情况下应该调用哪个方法.   而在派生类中重新定义此虚函数时要求的是:方法名称.返回值类型.参数表中的参数个数.类型.顺序都必须与基类中的虚函数完全一致. 简单一点说就是子类中override的方法能够覆盖积累中的

【转】String hashCode 方法为什么选择数字31作为乘子

某天,我在写代码的时候,无意中点开了 String hashCode 方法.然后大致看了一下 hashCode 的实现,发现并不是很复杂.但是我从源码中发现了一个奇怪的数字,也就是本文的主角31.这个数字居然不是用常量声明的,所以没法从字面意思上推断这个数字的用途.后来带着疑问和好奇心,到网上去找资料查询一下.在看完资料后,默默的感叹了一句,原来是这样啊.那么到底是哪样呢?在接下来章节里,请大家带着好奇心和我揭开数字31的用途之谜. 2. 选择数字31的原因 在详细说明 String hashC

String hashCode 方法为什么选择数字31作为乘子

1. 背景 某天,我在写代码的时候,无意中点开了 String hashCode 方法.然后大致看了一下 hashCode 的实现,发现并不是很复杂.但是我从源码中发现了一个奇怪的数字,也就是本文的主角31.这个数字居然不是用常量声明的,所以没法从字面意思上推断这个数字的用途.后来带着疑问和好奇心,到网上去找资料查询一下.在看完资料后,默默的感叹了一句,原来是这样啊.那么到底是哪样呢?在接下来章节里,请大家带着好奇心和我揭开数字31的用途之谜. 2. 选择数字31的原因 在详细说明 String

String.format()方法使用说明

JDK1.5开始String类中提供了一个非常有用的方法String.format(String format, Object ... args) 查看源码得知其实是调用了Java.util.Formatter.format(String, Object...)方法 [java] view plain copy print? public static String format(String format, Object ... args) { return new Formatter().f