类加载器的实现原理

1.什么是类加载器

将我们的class文件读取到内存中。

2.类加载器加载的过程

类加载器加载我们的class文件，并且经历过验证、准备、解析，在初始化我们该类。

图片均来自每特教育

3.Class文件的读取来源

1. 本地磁盘文件 java代码变为的class文件
2. 通过网络下载的class文件
3. War、jar 解压的class文件
4. 从专门的数据库中读取的class文件
5. 使用java cglib、动态代理生成的代理类class文件

4.类加载器的分类

1. 启动（Bootstrap）类加载器：加载JVM自身工作需要的类，它由JVM自己实现。它会加载$JAVA_HOME/jre/lib下的文件 底层是C语言实现。
2. 扩展（Extension）类加载器：它是JVM的一部分，由sun.misc.LauncherExtClassLoader实现，他会加载ExtClassLoader实现，他会加载ExtClassLoader实现，他会加载JAVA_HOME/jre/lib/ext目录中的文件（或由System.getProperty(“java.ext.dirs”)所指定的文件）。 底层是Java实现。
3. 应用AppClassLoader 类加载器：应用类加载器，我们工作中接触最多的也是这个类加载器，它由sun.misc.Launcher$AppClassLoader实现。他加载我们工程目录classpath下的class及jar包 底层是java实现。
4. 自定义类加载器：也就是用户自己定义的类加载器。

5.那些操作会初始化类加载器

类的主动使用：
5. 调用类的静态方法
6. invokeStatic 调用静态方法
7. Main
8. New
9. Class.formname
10. 子类初始化一定会初始化父类
初始化一个类，那么一定会触发类加载器但是类加载器加载了该类，但是该类不一定初始化。

6.类加载器的双亲委派机制

首先在我们类加载器分为四种 自定义类加载器、应用类加载器、扩展类加载器、启动类加载器。
当一个类加载器收到请求之后，首先会依次向上查找到最顶层类加载器（启动类加载器），依次向下加载class文件，如果已经加载到class文件，子加载器不会加继续加载该class文件。

7.双亲委派机制机制的好处

目的就是为了防御开发者为定义的类与jdk定义源码类产生冲突问题，保证该类在内存中的唯一性。

8.ClassLoader源码解读

Launcher 设定类加载器的依赖关系

9.如何破坏双亲委派机制

1. 重写classloade loadclass方法
2. 指定线程类加载器+spi机制，稍微classload loadclass方法

9.1 Spi机制的原理

Java SPI全称Service Provider Interface，是Java提供的一套用来被第三方实现或者扩展的API，它可以用来启用框架扩展和替换组件。实际上是“基于接口的编程＋策略模式＋配置文件”组合实现的动态加载机制.
实现方式：

1. 首先需要再resources目录下：创建文件夹META-INF services
2. 定义接口文件的名称：

D:\code\tostyle_jvm\src\main\resources\META-INF\services\com.tostyle.service.MyService

名称规范：包名+类名组成。

com.tostyle.service.impl.MyServiceImpl01
com.tostyle.service.impl.MyServiceImpl02

ServiceLoader<MyService> load = ServiceLoader.load(MyService.class);
load.forEach((t) -> {
    System.out.println(t.get());
});

9.2 自定义一个类加载器

package com.tostyle.classloader;

import java.io.ByteArrayOutputStream;
import java.io.File;
import java.io.FileInputStream;
import java.nio.ByteBuffer;
import java.nio.channels.Channels;
import java.nio.channels.FileChannel;
import java.nio.channels.WritableByteChannel;

/**
 * @ClassName MyClassLoader 
 * @Author tostyle
 * @Version V1.0
 **/
public class MyClassLoader extends ClassLoader {


    @Override
    protected Class<?> loadClass(String name, boolean resolve) throws ClassNotFoundException {
        try {
            byte[] data = getClassFileBytes(getFileObject());
            return defineClass(name, data, 0, data.length);
        } catch (Exception e) {
            e.printStackTrace();
            return null;
        }
    }

    private File fileObject;

    public void setFileObject(File fileObject) {
        this.fileObject = fileObject;
    }

    public File getFileObject() {
        return fileObject;
    }

    /**
     * 官方不建议重写该loadClass
     *
     * @param name
     * @return
     * @throws ClassNotFoundException
     */
//    @Override
//    protected Class<?> loadClass(String name, boolean resolve) throws ClassNotFoundException {
//        return super.loadClass(name, resolve);
//    }
    @Override
    protected Class<?> findClass(String name) throws ClassNotFoundException {
        // 读取我们硬盘上的class文件
        try {
            byte[] data = getClassFileBytes(getFileObject());
            return defineClass(name, data, 0, data.length);
        } catch (Exception e) {
            e.printStackTrace();
            return null;
        }

    }


    /**
     * 从文件中读取去class文件
     *
     * @throws Exception
     */
    private byte[] getClassFileBytes(File file) throws Exception {
        //采用NIO读取
        FileInputStream fis = new FileInputStream(file);
        FileChannel fileC = fis.getChannel();
        ByteArrayOutputStream baos = new ByteArrayOutputStream();
        WritableByteChannel outC = Channels.newChannel(baos);
        ByteBuffer buffer = ByteBuffer.allocateDirect(1024);
        while (true) {
            int i = fileC.read(buffer);
            if (i == 0 || i == -1) {
                break;
            }
            buffer.flip();
            outC.write(buffer);
            buffer.clear();
        }
        fis.close();
        return baos.toByteArray();
    }
}