Java类重新加载101：对象、类和类加载器，java101

来源： javaer 分享于 2019-04-09 点击 11954 次点评：185

Java类重新加载101：对象、类和类加载器，java101

欢迎来到ZeroTurnaround的Turnaround系列文章。

在这篇文章中，我们会回顾如何使用动态类加载器去重新加载一个Java类。在这个过程中，我们会看到对象、类和类加载器是怎么在一起配合的过程是怎样的。我们先来大概看一下问题，解释一下重新加载的过程，然后再以具体的示例来阐述典型的问题和解决方案。这个系列中的其他文章包括：

RJC101: 对象，类和类加载器
RJC201: 类加载器泄漏是怎么发生的？
RJC301: Web开发中的类加载器 — Tomcat, GlassFish, OSGi, Tapestry 5等等
RJC401: 深入HotSwap和JRebel
RJC501: Turnaround的损耗？

一个Jevgeni Kabanov的关于“你真的理解class loader吗？”的展示视频。

概述

当说到重新加载Java代码时，首先需要理清的是类和对象之间的关系。所有Java代码都跟类中的方法关联。很简单，你可以把类当成接收”this”为第一个参数的一系列方法的集合。这个类和它所有的方法被加载到内存，并且被分配得到一个唯一的标识符。在Java API中，这个标识符由java.lang.Class的一个实例来表示，而你可以通过MyObject.class表达式来访问它。

每一个创建的对象都可以通过Object.getClass()方法来获取指向这个标识的引用。当调用对象方法时，JVM会查看类引用并调用特定类的方法。实际上就是，当你调用mo.method()(mo是MyObject的实例)，JVM会调用mo.getClass().getDeclaredMethod("method").invoke(mo)（实际上JVM当然不是这样做的，但结果是一样的）。

每一个Class对象和它的相应的classloader(MyObject.class.getClassLoader())关联。类加载器的最主要作用就是定义一个类作用域 — 在哪里可见，哪里不可见。这个域概念允许相同名称的类存在，只要它们是通过不同的类加载器加载。它同样也允许不同的类加载器加载一个更新版本的类。

最主要的问题是：在Java的代码重新加载中，尽管你可以加载一个更新版本的类，但会得到一个完全不同的标识，而已存在的对象依然会指向之前版本的类。因此当调用那些对象方法时，它仍然执行的是老版本的。

让我们来假设一下，我们加载了一个新版本的MyObject类。假设老版本的为MyObject_1，新的那个为MyObject_2，同时假设MyObject_1中的MyObject.method()返回”1″，MyObject_2的返回”2″。如果mo2是MyObject_2的实例：

    mo.getClass() != mo2.getClass()
    mo.getClass().getDeclaredMethod("method").invoke(mo)
    != mo2.getClass().getDeclaredMethod("method").invoke(mo2)

mo.getClass().getDeclaredMethod("method").invoke(mo2) 抛出ClassCastException，因为mo和mo2的Class的标识不匹配。

这意味着任何有效的方法都必须创建一个新的mo2实例，而这个实例必须是mo的完全拷贝，并替换掉所有原有的mo的引用。想知道有多困难，试回想一下，你上次不得不换你的手机号码的时候。换号码本身很简单，但麻烦的是你需要确保你认识的每个人都知道用这个新号码。这跟对象一样复杂（实际上，除非你自己控制对象创建，否则是不可能的），而这里说的是你需要在同一个时间内更新很多个对象。

深入并尝试

让我们来看看代码层面会是怎样的。请记住，我们这里做的是通过另外一个类加载器加载一个新版本的类。我们使用的Example看起来就像这样：

    public class Example implements IExample {
      private int counter;
      public String message() {
        return "Version 1";
      }
      public int plusPlus() {
        return counter++;
      }
      public int counter() {
        return counter;
      }
    }

我们使用无限循环并打印出Example类信息的的main()方法。我们同样需要Example类的两个实例：example1在开始的时候创建一次，example2在每一次循环都重新创建：

    public class Main {
      private static IExample example1;
      private static IExample example2;
     
      public static void main(String[] args)  {
        example1 = ExampleFactory.newInstance();
     
        while (true) {
          example2 = ExampleFactory.newInstance();
     
          System.out.println("1) " +
            example1.message() + " = " + example1.plusPlus());
          System.out.println("2) " +
            example2.message() + " = " + example2.plusPlus());
          System.out.println();
     
          Thread.currentThread().sleep(3000);
        }
      }
    }

IExample是一个拥有Example所有方法的接口。这是必须的，因为我们通过另外一个隔离的类加载器加载Example，所以Main不能直接使用它（否则会有ClassCastException）。

    public interface IExample {
      String message();
      int plusPlus();
    }

从这个例子中，你也许会惊讶创建动态类加载器怎么这么简单。如果我们去掉异常处理代码，精简后的代码如下：

    public class ExampleFactory {
      public static IExample newInstance() {
        URLClassLoader tmp =
          new URLClassLoader(new URL[] {getClassPath()}) {
            public Class loadClass(String name) {
              if ("example.Example".equals(name))
                return findClass(name);
              return super.loadClass(name);
            }
          };
     
        return (IExample)
          tmp.loadClass("example.Example").newInstance();
      }
    }

由于例子需要，方法getClassPath()可以返回一个固定的类路径(hardcoded classpath)。然而，在完整的代码中（参见后面的资源章节），你可以看到我们怎么使用ClassLoader.getResource()来做到自动适配的。

现在让我们来执行Main.main，在几个循环后，我们可以看到输出：

    1) Version 1 = 3
    2) Version 1 = 0

如我们所期望的，虽然第一个实例的counter被更新了，但第二个还是维持为”0″。如果我们修改Exampler.message()方法，使它返回”Version 2″。输出如下：

    1) Version 1 = 4
    2) Version 2 = 0

我们看到，第一个实例继续增加counter，但使用旧版本的类来输出版本信息。而第二个实例已经被更新，但所有的状态都已经丢失了。

为了改进这个，我们尝试为第二个实例重新构造状态。我们只需从前一个迭代中复制它即可。

首先我们为Example类添加一个新的copy方法(和对象的接口方法)：

    public IExample copy(IExample example) {
      if (example != null)
        counter = example.counter();
      return this;
    }

接着我们更新Main.main()方法中创建第二个对象的那行代码：

    example2 = ExampleFactory.newInstance().copy(example2);

等几个迭代后可以看到：

    1) Version 1 = 3
    2) Version 1 = 3

修改Example.message()方法使它返回”Version 2″输出：

    1) Version 1 = 4
    2) Version 2 = 4

你可以看到尽管用户可以看到第二个实例被更新，并且所有状态都被保留，但它涉及到手动进行状态的管理。不幸的是，Java API中没办法只更新现存的对象或者可以保存它的状态，因此我们只能求助于这种复制的解决方案了。

在接下来的文章中，我们会回顾OSGi, Tapestry 5, Grails和其他的web容器是怎么面对在重新加载类时的状态处理问题的，之后我们会深入HotSwap, 动态语言和Instrumentation API是怎么工作的，同样也会深入JRebel。

资源

Java类加载机制
下载完整源代码

其他关于重新加载Java类系列文章

RJC101:对象，类和类加载器
RJC201:类加载器泄露是怎么发生的？
RJC301:web开发中的类加载器 — Tomcat, GlassFish, OSGi, Tapestry 5等
RJC401:深入HotSwap和JRebel
RJC501:Turnaround的损耗？

原文链接： zeroturnaround 翻译： Wld5.com - 陈晓舜
译文链接： http://www.wld5.com/12198.html
[ 转载请保留原文出处、译者和译文链接。]

Java类重新加载101：对象、类和类加载器，java101