Java类加载器介绍

1.类加载器介绍

类加载器负责将class文件加载到内存中，并为之生成对应的java.lang.Class对象。对于任意一个类，都需要加载它的类加载器和这个类本身来确定该类在JVM中唯一性，也就是说，同一个class文件用两个不同的类加载器加载并创建两个java.lang.Class对象，即使两个对象来源自同一个class文件，它们也是不相等的，这里“相等”包括Class对象的equals()方法、isAssignableFrom()方法、isInstance()方法，也包括使用instanceof关键字做对象所属关系判定情况。

验证代码如下：

public class ClassLoaderTest {
    public static void main(String[] args) throws ClassNotFoundException, IllegalAccessException, InstantiationException {
        // 自定义类加载器
        ClassLoader myLoader = new ClassLoader() {
            @Override
            public Class<?> loadClass(String name) throws ClassNotFoundException {
                String fileName = name.substring(name.lastIndexOf(".") + 1) + ".class";
                InputStream is = getClass().getResourceAsStream(fileName);
                if (is == null) {
                    return super.loadClass(name);
                }
                try {
                    byte[] buff = new byte[is.available()];
                    is.read(buff);
                    return defineClass(name, buff, 0, buff.length);
                } catch (IOException e) {
                    throw new ClassNotFoundException(name);
                }
            }
        };
        // 使用自定义的类加载加载classLoaderTest.ClassLoaderTest类
        Class clazz = myLoader.loadClass("classLoaderTest.ClassLoaderTest");
        Object obj = clazz.newInstance();
        /*
         创建obj对象的类实例是由自定义类加载器加载的，
         classLoaderTest.ClassLoaderTest使用的类加载器是系统类加载器，所属关系并不一致
         */
        System.out.println(obj instanceof classLoaderTest.ClassLoaderTest);
        /*
         clazz类实例是由自定义类加载器加载的，
         classLoaderTest.ClassLoaderTest.class使用的类加载器是系统类加载器
         */
        System.out.println(clazz.getClassLoader());
        System.out.println(classLoaderTest.ClassLoaderTest.class.getClassLoader());
        System.out.println(clazz.equals(classLoaderTest.ClassLoaderTest.class));
    }
}

输出结果：

false
classLoaderTest.ClassLoader[email protected]
[email protected]
false

2.类加载器分类

从Java虚拟机的角度来讲，只存在两种不同的类加载器：一种是启动类加载器（Bootstrap ClassLoader），这个类加载器是虚拟机的一部分；另一种就是所有其他的类加载器，这些类加载器都由Java语言实现，独立于虚拟机，并且全部继承自java.lang.ClassLoader。细分来看，类加载器还可以分为如下几类：

Bootstrap ClassLoader：根类加载器
Extension ClassLoader：扩展类加载器
System ClassLoader：应用程序类加载器
用户自定义类加载器

2.1 Bootstrap ClassLoader

Bootstrap ClassLoader被称为根类加载器，它负责加载Java的核心类。根类加载器并不是java.lang.ClassLoader的子类，而是由JVM自身实现的。在Sun的JVM中，当执行java.exe命令时，使用-Xbootclasspath选择或使用-D选项指定sun.boot.class.path系统属性值可以指定加载附加的类。

通过如下程序查看根类加载器加载的类的路径：

public class LoaderTest {
    public static void main(String[] args) throws IOException {
        // 获取根类加载器所加载的全部URL数组
        URL[] urls = Launcher.getBootstrapClassPath().getURLs();
        // 遍历、输出根类加载器加载的全部URL
        System.out.println("*********根类加载器加载的全部URL*************");
        for (URL url : urls) {
            System.out.println(url.toExternalForm());
        }
    }
}

输出结果：

*********根类加载器加载的全部URL*************
file:/D:/Java/jdk1.7.0_80/jre/lib/resources.jar
file:/D:/Java/jdk1.7.0_80/jre/lib/rt.jar
file:/D:/Java/jdk1.7.0_80/jre/lib/sunrsasign.jar
file:/D:/Java/jdk1.7.0_80/jre/lib/jsse.jar
file:/D:/Java/jdk1.7.0_80/jre/lib/jce.jar
file:/D:/Java/jdk1.7.0_80/jre/lib/charsets.jar
file:/D:/Java/jdk1.7.0_80/jre/lib/jfr.jar
file:/D:/Java/jdk1.7.0_80/jre/classes

2.2 Extension ClassLoader

Extension ClassLoader是扩展类加载器，它负责加载JRE的扩展目录中JAR包的类，或者被java.ext.dirs系统变量所指定的路径中的所有类库，开发者可以直接使用扩展类加载器。

2.3 Application ClassLoader

Application ClassLoader是应用程序类加载器，由sun.misc.Launcher$AppClassLoader实现，可以通过ClassLoader.getSystemClassLoader()方法获取，因此也被称为系统类加载器。它负责加载用户类路径(ClassPath)上指定的类库，开发者可以直接使用这个类加载器，如果应用程序没有自定义类加载器，一般情况下这个就是程序中默认的类加载器。

2.4 自定义类加载器器

为了实现类加载的个性化定制，我们可以通过扩展java.lang.ClassLoader类来实现自定义类加载器，详细的实现随后描述。

我们的应用程序一般都是由这几种类加载器相互配合进行加载的，类加载器之间的关系如图：

Java类加载器介绍

类加载器之间的关系并非是类继承性质的父子关系，而是一种组合关系。

3.类加载器加载类的步骤

类加载器在加载一个类时会先把加载的请求委托给父加载器加载，如果父类加载器仍有父加载器（只有根加载器没有父加载器），则再次委托给其父加载器，最后所有的加载请求都会传送给根类加载器，只有当父类加载器中无法完成对委托的类的加载时，该类才会被子加载器加载。这样的加载方式显著的好处就是：在一个运行的JVM中，所有的类都不会被不同的类加载器，某个类在各个加载器环境中看到的都是同一个Class对象。

另外，当一个类加载器负责加载某个Class时，该Class所引用的其他Class也会被该类加载器载入，除非显式使用另外一个类加载器加载。

JVM的类加载有一种缓存机制，如果一个类已经被加载过，那么在程序中再次用到这个类时，会直接从缓存中获取该类，只有在缓存中不存在该类时，类加载器才会读取该类的二进制数据并创建该类的Class对象。这也很好地解释了为什么修改了Java代码之后需要重启JVM修改才能生效。不过，现在已经有技术能够做到修改Java代码后不重启JVM仍可生效。

4.创建自定义的类加载器

在日常的程序开发中，出于某种需要，我们可能要自定义一些类加载器。通常推荐扩展ClassLoader类并重写findClass方法来实现自定义类加载器。

接下来我们自定义实现一个可以直接加载源代码的加载类，实现的原理很简单，把对源码的编译放在类加载器中执行：

import java.io.File;
import java.io.FileInputStream;
import java.io.IOException;
import java.lang.reflect.Method;

/**
 * author:xszhaobo
 * <p/>
 * date:2016/5/7
 * <p/>
 * package_name:JVMTest.myclassloader
 * <p/>
 * project: _darksiderg
 */
public class CompileClassLoader extends ClassLoader {

    public static void main(String[] args) throws Exception {
        if (args.length < 1) {
            System.out.println("缺少目标类：");
            System.out.println("java CompileClassLoader ClassName");
        }
        // 第一个参数指定需要运行的类名
        String progClass = args[0];
        // 其他的一些参数
        String[] progArgs = new String[args.length - 1];
        System.arraycopy(args,1,progArgs,0,progArgs.length);
        // 指定类加载器
        CompileClassLoader loader = new CompileClassLoader();
        Class clazz = loader.loadClass(progClass);
        // main指方法名称 
        // new String[0]).getClass()表示main的形参类型对应Class
        Method main = clazz.getMethod("main",(new String[0]).getClass());
        Object[] argsArray = {progArgs};
        // 第一个参数表示需要调用的方法所属的对象，如果调用静态方法，那么可以设置为null
        // 第二个以及以后的参数表示该方法传入的参数
        main.invoke(null,argsArray);
     }

    @Override
    protected Class<?> findClass(String name) throws ClassNotFoundException {
        System.out.println("加载类：" + name + ".java");
        Class clazz = null;
        String fileStub = name.replaceAll("\\.", "/");
        String javaFileName = fileStub + ".java";
        String classFileName = fileStub + ".class";
        File javaFile = new File(javaFileName);
        File classFile = new File(classFileName);
        // java源文件存在而class文件不存在，或者java源文件修改时间晚于class文件
        if (javaFile.exists() && (!classFile.exists()
                || javaFile.lastModified() > classFile.lastModified())) {
            try {
                if (!compile(javaFileName) || !classFile.exists()) {
                    throw new ClassNotFoundException("ClassNotFoundException:" + javaFileName);
                }
            } catch (IOException e) {
                e.printStackTrace();
            }

            if (classFile.exists()) {
                try {
                    byte[] raw = getBytes(classFileName);
                    clazz = this.defineClass(name,raw,0,raw.length);
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
        if (clazz == null) {
            throw new ClassNotFoundException(name);
        }
        return clazz;
    }

    private boolean compile(String javaFile) throws IOException {
        System.out.println("CompileClassLoader编译" + javaFile + "...");
        Process p = Runtime.getRuntime().exec("javac -encoding utf-8 " + javaFile);
        try {
            p.waitFor();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        int ret = p.exitValue();
        return ret == 0;
    }

    private byte[] getBytes(String fileName) throws IOException {
        File file = new File(fileName);
        long length = file.length();
        byte[] bytes = new byte[(int) length];
        // 使用Java 7的特性：具有资源管理的try语句
        try (FileInputStream fis = new FileInputStream(file)) {
            int readLen = fis.read(bytes);
            if (readLen != length) {
                throw new IOException("无法读文件的全部内容：" + fileName);
            }
            return bytes;
        }

        // Java 7之前的版本使用这种资源管理方式
        /*try {
            int readLen = fis.read(bytes);
            if (readLen != length) {
                throw new IOException("无法读文件的全部内容：" + fileName);
            }
            return bytes;
        } finally {
            fis.close();
        }*/
    }
}

编译该类：

javac -encoding utf-8 -Xlint:unchecked CompileClassLoader.java

指令的含义

javac是编译命令；

-encoding utf-8指定编码是utf-8；

-Xlint:unchecked指由于CompileClassLoader.java使用了未经检查或不安全的操作，需要指定-Xlint:unchecked编译；

CompileClassLoader.java指需要编译的文件。

在相同的文件夹下面随便写一个测试主类：

/**
 * author:xszhaobo
 * <p/>
 * date:2016/5/9
 * <p/>
 * package_name:JVMTest.myclassloader
 * <p/>
 * project: _darksiderg
 */
public class HelloTest {
    public static void main(String[] args) {
            System.out.println("参数 ：" + args[0]);
    }
}

此时在命令行中使用CompileClassLoader作为类加载器直接使用java命令运行源代码：

java CompileClassLoader HelloTest 这是一个参数

首次加载时输出结果：

CompileClassLoader编译HelloTest.java...
参数：这是一个参数

可以看出这是此时先编译了HelloTest.java文件，然后运行该类中的main方法。

但是这里有一个问题，如果此时修改HelloTest.java源代码，重新执行如下命令：

java CompileClassLoader HelloTest 这是一个参数

输出的结果：

参数：这是一个参数

此时的输出已经不包含“CompileClassLoader编译HelloTest.java...”这一句，说明这一次并没有重新编译源代码，该问题的原因尚未找到，如果你知道答案，不妨告诉我。

还需要注意的地方：

1.执行命令时所处的目录应当是java源文件所在的目录；

2.源代码中类的定义不要指定包，如果你指定了包，在编译源代码和指定加载器时需要做进一步处理。

Java类加载器介绍

1.类加载器介绍

2.类加载器分类

2.1 Bootstrap ClassLoader

2.2 Extension ClassLoader

2.3 Application ClassLoader

2.4 自定义类加载器器

3.类加载器加载类的步骤

4.创建自定义的类加载器

继续阅读

关于Gradle配置的小结

Java小案例——随机数猜测随机数猜测

nginx location中斜线的位置的重要性

27 Best Free Eclipse Plug-ins for Java Developer to be ProductiveCode Quality PluginsText Editor PluginsDependency ManagementVersion Control Integration PluginsFramework Development Continuous Integration Related PluginsOther Utility Plugins

Java String.format方法的简单使用

neo4j之cypher使用文档

GitHub连夜封杀！这份阿里 10W 字内部 Java 字面试手册到底有多强？

spark/scala关于【资源文件】加载方法概述外部文件加载方案测试资源文件打包入jar包中小结

mybatis_入门程序Mybatis入门

AOP编程_Android优雅权限框架(1)概念基础，2021金三银四前言正文大纲正文

Effective Java 8:通用程序设计

OOM三种类型

工厂模式-三种类型

【递归】高效率求2的n次幂

win10本地scala和spark安装安装scala安装spark

scala (3) Function 和 Method