JVM之ClassLoader

前言

刚在学习Java的过程中，是否曾经有疑惑：你写的代码是如何运行起来的，计算机怎么就知道你想干嘛？我们知道计算机的世界都是0和1，所以最终你写的所有代码都会被编译、解释成计算机能理解的语言。
Java之所以能够一次编写到处运行，是因为class文件，class文件的字节码是与任何环境和操作系统都无关的中间代码，最后由各种JVM解释运行。

加载过程

加载(loading)-链接(linking)【校验(verification)、准备(preparation)、解析(resolution)】-初始化(initializing)
以上是类在虚拟机中的创建？流程，我们先来说一下加载
先来看下JVM入口代码，Launcher

红框中发现ClassLoader塞了null，然后接着看ClassLoader，2、3点说明父加载器是Ext时的流程


这就是经典的类加载双亲委派模型
为啥需要用这么繁琐的方式来先查找在加载?主要是为了安全，其次才是避免重复加载。举个例子,我自己写了一个String类，交给自定义ClassLoader加载进内存，打包给客户，把定义成String类型的敏感信息传出去，这就不安全了。
而双亲委派的模型来看，一个String要加载，就先去查查看有没有被加载过，如果有就直接返回给你，不会再去加载。

自定义类加载器

首先我们看想把一个类加载进内存是不是这么做，然后来看这个loadClass方法，是不是就是上面讲过的双亲委派模型。

然后我们打印这么几行代码，看看父加载器到底是谁，我们会发现类TestLoadClass的加载器是AppClassLoader，而AppClassLoader的加载器是ExtClassLoader，ExtClassLoader加载器是null，为啥是空上面有说过了。

所以我们小总结一下：
我把类加载器分为四个层次：
1、BootStrap最顶层，他负责加载lib中最核心的jar如rt.jar,charset.jar
2、Extension第二层，主要负责加载扩展包各种jar，目录jre/lib/ext/*.jar
3、application第三层，加载classpath指定的内容
4、自定义加载器，加载自己定义的类
CustomClassLoader的父类加载器>>AppClassLoader父类加载器>>
Extension>>Bootstrap
不要和继承混淆了

接着来我们回到loadClass，这时候我要加载com.liyu.jvm.TestLoadClass，是不是他就会去执行AppClassLoader继承的URLClassLoader的findClass方法


好到这里，如果要自定义一个类加载器，是不是只需要
1、继承ClassLoader；2、重写findClass
小总结：
ClassLoader源码的思路：findInCache -> parent.loadclass -> findclass()[defineClass【这个方法下面说】]
这个就是设计模式中的模板模式

自定义类加载器用途

1、加密
2、防篡改
…
下面是自定义类加载器+加密的代码示意

package com.liyu.jvm;

import java.io.ByteArrayOutputStream;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.lang.reflect.Method;

public class TestCustomClassLoader extends ClassLoader {

    private static final int key = 0B10101010;


    @Override
    public Class<?> loadClass(String name) throws ClassNotFoundException {
        if ("Hello".equals(name)) {
            return this.findClass(name);
        }
        return super.loadClass(name);
    }

    /**
     * 这里用^来进行一个简单加密
     * 1、先看看defineClass需要个啥参数
     * @param name
     * @return
     * @throws ClassNotFoundException
     */
    @Override
    protected Class<?> findClass(String name) throws ClassNotFoundException {
        File file = new File("/Users/apple/java/workspace",
                name.replace('.', '/').concat(".lyclass"));

        try {
            FileInputStream fis = new FileInputStream(file);
            ByteArrayOutputStream baos = new ByteArrayOutputStream();
            int b = 0;
            while ((b = fis.read()) != -1) {
                //第2次异或key相当于解密
                baos.write(b ^ key);
            }
            byte[] bytes = baos.toByteArray();

            fis.close();
            baos.close();

            return defineClass("com.liyu.jvm.Hello", bytes, 0, bytes.length);
        } catch (Exception e) {
            e.printStackTrace();
        }
        return super.findClass(name);
    }

    /**
     * 主要的加密块
     * @param name
     * @throws Exception
     */
    private static void compileLYFile(String name) throws Exception {
        File f = new File("/Users/apple/java/workspace",
                name.replace('.', '/').concat(".class"));
        FileInputStream fis = new FileInputStream(f);
        FileOutputStream fos = new FileOutputStream(new File("/Users/apple/java/workspace",
                name.replaceAll(".", "/").concat(".lyclass")));
        int b = 0;
        while((b = fis.read()) != -1) {
            //第一次异或加密
            fos.write(b ^ key);
        }
        fis.close();
        fos.close();
    }

    public static void main(String[] args) throws Exception {
        //把Hello编译成lyclass
        compileLYFile("Hello");
        ClassLoader load = new TestCustomClassLoader();
        //通过反射调用say方法
        Class clazz = load.loadClass("Hello");
        Method method = clazz.getDeclaredMethod("say",null);
        Object obj = clazz.newInstance();
        method.invoke(obj,null);
        System.out.println(load.getClass().getClassLoader());
        System.out.println(load.getParent());
    }
}

LazyLoading

JVM虚拟机实现都是用的懒加载，并没有规定什么时候进行加载，但是严格规定了什么时候必须初始化，以下五种简单理解一下就行了
–new getstatic putstatic invokestatic指令，访问final变量除外
–java.lang.reflect对类进行反射调用时
–初始化子类的时候，父类首先初始化
–虚拟机启动时，被执行的主类必须初始化
–动态语言支持java.lang.invoke.MethodHandle解析的结果为REF_getstatic REF_putstatic REF_invokestatic的方法句柄时，该类必须初始化

编译器&解释器

java语言是解释执行的，一个class文件load进内存中，通过java的解释器来执行。JIT的编译器指的是把某些代码编译成本地代码。那java中采用的是混合模式，更详细一点呢就是解释器+热点编译。
热点编译的意思是，有一段代码，一开始使用解释器来执行，但是这段代码被使用的频率特别高，这时候就回去编译成本地代码以提升效率。具体实现其实就是一个计数器执行一次就累加，到某个界限后我就编译成本地代码。
设定热点代码阈值：-XX:CompileThreshold = 10000