Java编程的逻辑 (87) - 类加载机制

时间  2019-11-06
标签 java 编程 逻辑 加载 机制 栏目 Java 繁體版
原文   原文链接

本系列文章经补充和完善，已修订整理成书《Java编程的逻辑》，由机械工业出版社华章分社出版，于2018年1月上市热销，读者好评如潮！各大网店和书店有售，欢迎购买，京东自营连接：http://item.jd.com/12299018.htmlhtml

上节，咱们探讨了动态代理，在前几节中，咱们屡次提到了类加载器ClassLoader，本节就来详细讨论Java中的类加载机制与ClassLoader。java

类加载器ClassLoader就是加载其余类的类，它负责将字节码文件加载到内存，建立Class对象。与以前介绍的反射、注解、和动态代理同样，在大部分的应用编程中，咱们不太须要本身实现ClassLoader。git

不过，理解类加载的机制和过程，有助于咱们更好的理解以前介绍的内容，更好的理解Java。在反射一节，咱们介绍过Class的静态方法Class.forName，理解类加载器有助于咱们更好的理解该方法。程序员

ClassLoader通常是系统提供的，不须要本身实现，不过，经过建立自定义的ClassLoader，能够实现一些强大灵活的功能，好比：github

  • 热部署，在不重启Java程序的状况下，动态替换类的实现，好比Java Web开发中的JSP技术就利用自定义的ClassLoader实现修改JSP代码即生效，OSGI (Open Service Gateway Initiative)框架使用自定义ClassLoader实现动态更新。
  • 应用的模块化和相互隔离，不一样的ClassLoader能够加载相同的类但互相隔离、互不影响。Web应用服务器如Tomcat利用这一点在一个程序中管理多个Web应用程序，每一个Web应用使用本身的ClassLoader，这些Web应用互不干扰。OSGI利用这一点实现了一个动态模块化架构，每一个模块有本身的ClassLoader，不一样模块能够互不干扰。
  • 从不一样地方灵活加载，系统默认的ClassLoader通常从本地的.class文件或jar文件中加载字节码文件，经过自定义的ClassLoader，咱们能够从共享的Web服务器、数据库、缓存服务器等其余地方加载字节码文件。

理解自定义ClassLoader有助于咱们理解这些系统程序和框架，如Tomat, JSP, OSGI，在业务须要的时候，也能够借助自定义ClassLoader实现动态灵活的功能。正则表达式

下面，咱们首先来进一步理解Java加载类的过程，理解类ClassLoader和Class.forName，介绍一个简单的应用，而后咱们探讨如何实现自定义ClassLoader，演示如何利用它实现热部署。数据库

类加载的基本机制和过程编程

运行Java程序，就是执行java这个命令，指定包含main方法的完整类名，以及一个classpath，即类路径。类路径能够有多个，对于直接的class文件，路径是class文件的根目录，对于jar包，路径是jar包的完整名称（包括路径和jar包名）。swift

Java运行时，会根据类的彻底限定名寻找并加载类，寻找的方式基本就是在系统类和指定的类路径中寻找，若是是class文件的根目录，则直接查看是否有对应的子目录及文件，若是是jar文件，则首先在内存中解压文件，而后再查看是否有对应的类。设计模式

负责加载类的类就是类加载器，它的输入是彻底限定的类名，输出是Class对象。类加载器不是只有一个，通常程序运行时，都会有三个：

  1. 启动类加载器(Bootstrap ClassLoader)：这个加载器是Java虚拟机实现的一部分，不是Java语言实现的，通常是C++实现的，它负责加载Java的基础类，主要是<JAVA_HOME>/lib/rt.jar，咱们平常用的Java类库好比String, ArrayList等都位于该包内。
  2. 扩展类加载器(Extension ClassLoader)：这个加载器的实现类是sun.misc.Launcher$ExtClassLoader，它负责加载Java的一些扩展类，通常是<JAVA_HOME>/lib/ext目录中的jar包。
  3. 应用程序类加载器(Application ClassLoader)：这个加载器的实现类是sun.misc.Launcher$AppClassLoader，它负责加载应用程序的类，包括本身写的和引入的第三方法类库，即全部在类路径中指定的类。

这三个类加载器有必定的关系，能够认为是父子关系，Application ClassLoader的父亲是Extension ClassLoader，Extension的父亲是Bootstrap ClassLoader，注意不是父子继承关系，而是父子委派关系，子ClassLoader有一个变量parent指向父ClassLoader，在子ClassLoader加载类时，通常会首先经过父ClassLoader加载，具体来讲，在加载一个类时，基本过程是：

  1. 判断是否已经加载过了，加载过了，直接返回Class对象，一个类只会被一个ClassLoader加载一次。
  2. 若是没有被加载，先让父ClassLoader去加载，若是加载成功，返回获得的Class对象。
  3. 在父ClassLoader没有加载成功的前提下，本身尝试加载类。

这个过程通常被称为"双亲委派"模型，即优先让父ClassLoader去加载。为何要先让父ClassLoader去加载呢？这样，能够避免Java类库被覆盖的问题，好比用户程序也定义了一个类java.lang.String，经过双亲委派，java.lang.String只会被Bootstrap ClassLoader加载，避免自定义的String覆盖Java类库的定义。

须要了解的是，"双亲委派"虽然是通常模型，但也有一些例外，好比：

  • 自定义的加载顺序：尽管不被建议，自定义的ClassLoader能够不听从"双亲委派"这个约定，不过，即便不听从，以"java"开头的类也不能被自定义类加载器加载，这是由Java的安全机制保证的，以免混乱。
  • 网状加载顺序：在OSGI框架中，类加载器之间的关系是一个网，每一个OSGI模块有一个类加载器，不一样模块之间可能有依赖关系，在一个模块加载一个类时，多是从本身模块加载，也多是委派给其余模块的类加载器加载。
  • 父加载器委派给子加载器加载：典型的例子有JNDI服务(Java Naming and Directory Interface)，它是Java企业级应用中的一项服务，具体咱们就不介绍了。

一个程序运行时，会建立一个Application ClassLoader，在程序中用到ClassLoader的地方，若是没有指定，通常用的都是这个ClassLoader，因此，这个ClassLoader也被称为系统类加载器(System ClassLoader)。

下面，咱们来具体看下表示类加载器的类 - ClassLoader。

理解ClassLoader

基本用法

类ClassLoader是一个抽象类，Application ClassLoader和Extension ClassLoader的具体实现类分别是sun.misc.Launcher$AppClassLoader和sun.misc.Launcher$ExtClassLoader，Bootstrap ClassLoader不是由Java实现的，没有对应的类。

每一个Class对象都有一个方法，能够获取实际加载它的ClassLoader，方法是： 

public ClassLoader getClassLoader()

ClassLoader有一个方法，能够获取它的父ClassLoader：

public final ClassLoader getParent()

若是ClassLoader是Bootstrap ClassLoader，返回值为null。

好比：

public class ClassLoaderDemo {
    public static void main(String[] args) {
        ClassLoader cl = ClassLoaderDemo.class.getClassLoader();
        while (cl != null) {
            System.out.println(cl.getClass().getName());
            cl = cl.getParent();
        }
        
        System.out.println(String.class.getClassLoader());
    }
}

输出为：

sun.misc.Launcher$AppClassLoader
sun.misc.Launcher$ExtClassLoader
null

ClassLoader有一个静态方法，能够获取默认的系统类加载器：

public static ClassLoader getSystemClassLoader()

ClassLoader中有一个主要方法，用于加载类：

public Class<?> loadClass(String name) throws ClassNotFoundException

好比：

ClassLoader cl = ClassLoader.getSystemClassLoader();
try {
    Class<?> cls = cl.loadClass("java.util.ArrayList");
    ClassLoader actualLoader = cls.getClassLoader();
    System.out.println(actualLoader);
} catch (ClassNotFoundException e) {
    e.printStackTrace();
}

须要说明的是，因为委派机制，Class的getClassLoader()方法返回的不必定是调用loadClass的ClassLoader，好比，上面代码中，java.util.ArrayList实际由BootStrap ClassLoader加载，因此返回值就是null。

ClassLoader vs Class.forName

在反射一节，咱们介绍过Class的两个静态方法forName：

public static Class<?> forName(String className)
public static Class<?> forName(String name, boolean initialize, ClassLoader loader)

第一个方法使用系统类加载器加载，第二个指定ClassLoader，参数initialize表示，加载后，是否执行类的初始化代码(如static语句块)，没有指定默认为true。

ClassLoader的loadClass方法与forName方法均可以加载类，它们有什么不一样呢？基本是同样的，不过，有一个不一样，ClassLoader的loadClass不会执行类的初始化代码，看个例子：

public class CLInitDemo {
    public static class Hello {
        static {
            System.out.println("hello");
        }
    };

    public static void main(String[] args) {
        ClassLoader cl = ClassLoader.getSystemClassLoader();
        String className = CLInitDemo.class.getName() + "$Hello";
        try {
            Class<?> cls = cl.loadClass(className);
        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        }
    }
}

使用ClassLoader加载静态内部类Hello，Hello有一个static语句块，输出"hello"，运行该程序，类被加载了，但没有任何输出，即static语句块没有被执行。若是将loadClass的语句换为：

Class<?> cls = Class.forName(className);

则static语句块会被执行，屏幕将输出"hello"。

实现代码

咱们来看下ClassLoader的loadClass代码，以进一步理解其行为：

public Class<?> loadClass(String name) throws ClassNotFoundException {
    return loadClass(name, false);
}

它调用了另外一个loadClass方法，其主要代码为(省略了一些代码，加了注释，以便于理解)：

protected Class<?> loadClass(String name, boolean resolve)
        throws ClassNotFoundException {
    synchronized (getClassLoadingLock(name)) {
        // 首先，检查类是否已经被加载了
        Class c = findLoadedClass(name);
        if (c == null) {
            //没被加载，先委派父ClassLoader或BootStrap ClassLoader去加载
            try {
                if (parent != null) {
                    //委派父ClassLoader，resolve参数固定为false
                    c = parent.loadClass(name, false);
                } else {
                    c = findBootstrapClassOrNull(name);
                }
            } catch (ClassNotFoundException e) {
                //没找到，捕获异常，以便尝试本身加载                
            }
            if (c == null) {
                // 本身去加载，findClass才是当前ClassLoader的真正加载方法
                c = findClass(name);
            }
        }
        if (resolve) {
            // 连接，执行static语句块
            resolveClass(c);
        }
        return c;
    }
}

参数resolve相似Class.forName中的参数initialize，能够看出，其默认值为false，即便经过自定义ClassLoader重写loadClass，设置resolve为true，它调用父ClassLoader的时候，传递的也是固定的false。

findClass是一个protected方法，类ClassLoader的默认实现就是抛出ClassNotFoundException，子类应该重写该方法，实现本身的加载逻辑，后文咱们会看个具体例子。

类加载应用 - 可配置的策略

能够经过ClassLoader的loadClass或Class.forName本身加载类，但什么状况须要本身加载类呢？

不少应用使用面向接口的编程，接口具体的实现类可能有不少，适用于不一样的场合，具体使用哪一个实现类在配置文件中配置，经过更改配置，不用改变代码，就能够改变程序的行为，在设计模式中，这是一种策略模式，咱们看个简单的示例。

定义一个服务接口IService：

public interface IService {
    public void action();
}

客户端经过该接口访问其方法，怎么得到IService实例呢？查看配置文件，根据配置的实现类，本身加载，使用反射建立实例对象，示例代码为：

public class ConfigurableStrategyDemo {
    public static IService createService() {
        try {
            Properties prop = new Properties();
            String fileName = "data/c87/config.properties";
            prop.load(new FileInputStream(fileName));
            String className = prop.getProperty("service");
            Class<?> cls = Class.forName(className);
            return (IService) cls.newInstance();
        } catch (Exception e) {
            throw new RuntimeException(e);
        }
    }

    public static void main(String[] args) {
        IService service = createService();
        service.action();
    }
}

config.properties的内容示例为：

service=shuo.laoma.dynamic.c87.ServiceB

代码比较简单，就不赘述了。

自定义ClassLoader

基本用法

Java类加载机制的强大之处在于，咱们能够建立自定义的ClassLoader，自定义ClassLoader是Tomcat实现应用隔离、支持JSP，OSGI实现动态模块化的基础。 

怎么自定义呢？通常而言，继承类ClassLoader，重写findClass就能够了。怎么实现findClass呢？使用本身的逻辑寻找class文件字节码的字节形式，找到后，使用以下方法转换为Class对象：

protected final Class<?> defineClass(String name, byte[] b, int off, int len)

name表示类名，b是存放字节码数据的字节数组，有效数据从off开始，长度为len。

看个例子：

public class MyClassLoader extends ClassLoader {

    private static final String BASE_DIR = "data/c87/";

    @Override
    protected Class<?> findClass(String name) throws ClassNotFoundException {
        String fileName = name.replaceAll("\\.", "/");
        fileName = BASE_DIR + fileName + ".class";
        try {
            byte[] bytes = BinaryFileUtils.readFileToByteArray(fileName);
            return defineClass(name, bytes, 0, bytes.length);
        } catch (IOException ex) {
            throw new ClassNotFoundException("failed to load class " + name, ex);
        }
    }
}

MyClassLoader从BASE_DIR下的路径中加载类，它使用了咱们在57节介绍的BinaryFileUtils读取文件，转换为byte数组。MyClassLoader没有指定父ClassLoader，默认是系统类加载器，即ClassLoader.getSystemClassLoader()的返回值，不过，ClassLoader有一个可重写的构造方法，能够指定父ClassLoader：

protected ClassLoader(ClassLoader parent)

用途

MyClassLoader有什么用呢？将BASE_DIR加到classpath中不就好了，确实能够，这里主要是演示基本用法，实际中，能够从Web服务器、数据库或缓存服务器获取bytes数组，这就不是系统类加载器能作到的了。

不过，不把BASE_DIR放到classpath中，而是使用MyClassLoader加载，确实有一个很大的好处，能够建立多个MyClassLoader，对同一个类，每一个MyClassLoader均可以加载一次，获得同一个类的不一样Class对象，好比：

MyClassLoader cl1 = new MyClassLoader();
String className = "shuo.laoma.dynamic.c87.HelloService";
Class<?> class1 = cl1.loadClass(className);

MyClassLoader cl2 = new MyClassLoader();
Class<?> class2 = cl2.loadClass(className);

if (class1 != class2) {
    System.out.println("different classes");
}

cl1和cl2是两个不一样的ClassLoader，class1和class2对应的类名同样，但它们是不一样的对象。

这到底有什么用呢？

  • 能够实现隔离，一个复杂的程序，内部可能按模块组织，不一样模块可能使用同一个类，但使用的是不一样版本，若是使用同一个类加载器，它们是没法共存的，不一样模块使用不一样的类加载器就能够实现隔离，Tomcat使用它隔离不一样的Web应用，OSGI使用它隔离不一样模块。
  • 能够实现热部署，使用同一个ClassLoader，类只会被加载一次，加载后，即便class文件已经变了，再次加载，获得的也仍是原来的Class对象，而使用MyClassLoader，则能够先建立一个新的ClassLoader，再用它加载Class，获得的Class对象就是新的，从而实现动态更新。

下面，咱们来具体看热部署的示例。

自定义ClassLoader的应用 - 热部署

所谓热部署，就是在不重启应用的状况下，当类的定义，即字节码文件修改后，可以替换该Class建立的对象，怎么作到这一点呢？咱们利用MyClassLoader，看个简单的示例。

咱们使用面向接口的编程，定义一个接口IHelloService：

public interface IHelloService {
    public void sayHello();
}

实现类是shuo.laoma.dynamic.c87.HelloImpl，class文件放到MyClassLoader的加载目录中。

演示类是HotDeployDemo，它定义了如下静态变量：

private static final String CLASS_NAME = "shuo.laoma.dynamic.c87.HelloImpl";
private static final String FILE_NAME = "data/c87/"
            +CLASS_NAME.replaceAll("\\.", "/")+".class";
private static volatile IHelloService helloService;

CLASS_NAME表示实现类名称，FILE_NAME是具体的class文件路径，helloService是IHelloService实例。

当CLASS_NAME表明的类字节码改变后，咱们但愿从新建立helloService，反映最新的代码，怎么作呢？先看用户端获取IHelloService的方法：

public static IHelloService getHelloService() {
    if (helloService != null) {
        return helloService;
    }
    synchronized (HotDeployDemo.class) {
        if (helloService == null) {
            helloService = createHelloService();
        }
        return helloService;
    }
}

这是一个单例模式，createHelloService()的代码为：

private static IHelloService createHelloService() {
    try {
        MyClassLoader cl = new MyClassLoader();
        Class<?> cls = cl.loadClass(CLASS_NAME);
        if (cls != null) {
            return (IHelloService) cls.newInstance();
        }
    } catch (Exception e) {
        e.printStackTrace();
    }
    return null;
}

它使用MyClassLoader加载类，并利用反射建立实例，它假定实现类有一个public无参构造方法。

在调用IHelloService的方法时，客户端老是先经过getHelloService获取实例对象，咱们模拟一个客户端线程，它不停的获取IHelloService对象，并调用其方法，而后睡眠1秒钟，其代码为：

public static void client() {
    Thread t = new Thread() {
        @Override
        public void run() {
            try {
                while (true) {
                    IHelloService helloService = getHelloService();
                    helloService.sayHello();
                    Thread.sleep(1000);
                }
            } catch (InterruptedException e) {
            }
        }
    };
    t.start();
}

怎么知道类的class文件发生了变化，并从新建立helloService对象呢？咱们使用一个单独的线程模拟这一过程，代码为：

public static void monitor() {
    Thread t = new Thread() {
        private long lastModified = new File(FILE_NAME).lastModified();

        @Override
        public void run() {
            try {
                while (true) {
                    Thread.sleep(100);
                    long now = new File(FILE_NAME).lastModified();
                    if (now != lastModified) {
                        lastModified = now;
                        reloadHelloService();
                    }
                }
            } catch (InterruptedException e) {
            }
        }
    };
    t.start();
}

咱们使用文件的最后修改时间来跟踪文件是否发生了变化，当文件修改后，调用reloadHelloService()来从新加载，其代码为：

public static void reloadHelloService() {
    helloService = createHelloService();
}

就是利用MyClassLoader从新建立HelloService，建立后，赋值给helloService，这样，下次getHelloService()获取到的就是最新的了。

在主程序中启动client和monitor线程，代码为：

public static void main(String[] args) {
    monitor();
    client();
}

在运行过程当中，替换HelloImpl.class，能够看到行为会变化，为便于演示，咱们在data/c87/shuo/laoma/dynamic/c87/目录下准备了两个不一样的实现类HelloImpl_origin.class和HelloImpl_revised.class，在运行过程当中替换，会看到输出不同，以下图所示：

使用cp命令修改HelloImpl.class，若是其内容与HelloImpl_origin.class同样，输出为"hello"，若是与HelloImpl_revised.class同样，输出为"hello revised"。

完整的代码和数据在github上，文末有连接。

小结

本节探讨了Java中的类加载机制，包括Java加载类的基本过程，类ClassLoader的用法，以及如何建立自定义的ClassLoader，探讨了两个简单应用示例，一个经过动态加载实现可配置的策略，另外一个经过自定义ClassLoader实现热部署。

从84节到本节，咱们探讨了Java中的多个动态特性，包括反射、注解、动态代理和类加载器，做为应用程序员，大部分用的都比较少，用的较多的就是使用框架和库提供的各类注解了，但这些特性大量应用于各类系统程序、框架、和库中，理解这些特性有助于咱们更好的理解它们，也能够在须要的时候本身实现动态、通用、灵活的功能。

在注解一节，咱们提到，注解是一种声明式编程风格，它提升了Java语言的表达能力，平常编程中一种常见的需求是文本处理，在计算机科学中，有一种技术大大提升了文本处理的表达能力，那就是正则表达式，大部分编程语言都有对它的支持，它有什么强大功能呢？

(与其余章节同样，本节全部代码位于 https://github.com/swiftma/program-logic，位于包shuo.laoma.dynamic.c87下)

----------------

未完待续，查看最新文章，敬请关注微信公众号“老马说编程”(扫描下方二维码)，从入门到高级，深刻浅出，老马和你一块儿探索Java编程及计算机技术的本质。用心原创，保留全部版权。

相关文章
相关标签/搜索
每日一句
    每一个你不满意的现在，都有一个你没有努力的曾经。
本站公众号
   欢迎关注本站公众号,获取更多信息
联系我们 最近搜索 最新文章 沪ICP备13005482号-10 MyBatis教程 SQL 教程 MySQL教程 Java 教程 Thymeleaf 教程 Hibernate教程 Spring教程 Redis教程