詳解Java的類加載機制及熱部署的原理

package com.ys.classLoader;

public class FindClassLoaderTest {

    public static void main(String[] args) {
        ClassLoader classLoader = Thread.currentThread().getContextClassLoader();
        System.out.println(classLoader);
        System.out.println(classLoader.getParent());
        System.out.println(classLoader.getParent().getParent());
    }
}

package com.ys.classLoader;

public class LoadClassTest {
    public static void main(String[] args) throws Exception {
        ClassLoader classLoader = LoadClassTest.class.getClassLoader();
        System.out.println(classLoader);

        //使用ClassLoader.loadClass()來加載類，不會執行初始化代碼
        //classLoader.loadClass("com.ys.classLoader.Test1");

        //使用Class.forName()來加載類，會默認執行初始化代碼
        //Class.forName("com.ys.classLoader.Test1");

        //使用Class.forName()來加載類，並指定類加載器，不會執行初始化代碼
        Class.forName("com.ys.classLoader.Test1", false, classLoader);
    }
}

package com.ys.classLoader;

public class Test1 {
    static {
        System.out.println("靜態初始化代碼執行瞭....");
    }
}

public Class<?> loadClass(String name)throws ClassNotFoundException {
  return loadClass(name, false);
}
    
protected synchronized Class<?> loadClass(String name, boolean resolve)throws ClassNotFoundException {
  // 首先判斷該類型是否已經被加載
  Class c = findLoadedClass(name);
  if (c == null) {
    //如果沒有被加載，就委托給父類加載或者委派給啟動類加載器加載
    try {
      if (parent != null) {
        //如果存在父類加載器，就委派給父類加載器加載
        c = parent.loadClass(name, false);
      } else {
        //如果不存在父類加載器，就檢查是否是由啟動類加載器加載的類，通過調用本地方法native Class findBootstrapClass(String name)
        c = findBootstrapClass0(name);
      }
    } catch (ClassNotFoundException e) {
      // 如果父類加載器和啟動類加載器都不能完成加載任務，才調用自身的加載功能
      c = findClass(name);
    }
  }
  if (resolve) {
    resolveClass(c);
  }
  return c;
}

package com.classloader;

import com.Application;
import com.Test;

import java.io.File;
import java.io.FileInputStream;
import java.io.InputStream;
import java.util.ArrayList;
import java.util.List;

public class MyClassLoader extends ClassLoader {

    //目的 讓緩存裡面永遠能返回一個Class對象 這樣就不需要走父類加載器瞭
    //在構造方法裡面加載類  loadClass

    //項目的根路徑
    public String rootPath;

    //所有需要由我這個類加載器加載的類存在這個集合
    public List<String> clazzs;
    //兩個classloader  一個是負責加載 需要被熱部署的代碼的
    //一個是加載系統的一些類的

    //classPaths: 需要被熱部署的加載器去加載的目錄
    public MyClassLoader(String rootPath, String... classPaths) throws Exception {
        this.rootPath = rootPath;
        this.clazzs = new ArrayList<>();
        for (String classPath : classPaths) {
            scanClassPath(new File(classPath));
        }
    }


    //掃描項目裡面傳進來的一些class
    public void scanClassPath(File file) throws Exception {
        if (file.isDirectory()) {
            for (File file1 : file.listFiles()) {
                scanClassPath(file1);
            }
        } else {
            String fileName = file.getName();
            String filePath = file.getPath();
            String endName = fileName.substring(fileName.lastIndexOf(".") + 1);
            if (endName.equals("class")) {
                //現在我們加載到的是一個Class文件
                //如何吧一個Class文件 加載成一個Class對象？？？？
                InputStream inputStream = new FileInputStream(file);
                byte[] bytes = new byte[(int) file.length()];
                inputStream.read(bytes);

                //文件名轉類名
                String className = fileNameToClassName(filePath);

                //類名
                defineClass(className, bytes, 0, bytes.length);
                clazzs.add(className);
                //loadClass 是從當前ClassLoader裡面去獲取一個Class對象
            }
        }

    }

    //文件名轉類名，這兒操作系統不同可能文件的分隔符不一樣，所以這兒需要註意，筆者用的Mac。Windows操作需要自行修改。
    public String fileNameToClassName(String filePath) {
        String className = filePath.replace(rootPath, "").replaceAll("/", ".");
        className = className.substring(1, className.lastIndexOf("."));
        return className;
    }

    @Override
    public Class<?> loadClass(String name) throws ClassNotFoundException {
        Class<?> loadClass = findLoadedClass(name);
        //第一情況 這個類 不需要由我們加載
        //第二種情況 這個類需要由我們加載 但是 確實加載不到
        if (loadClass == null) {
            if (!clazzs.contains(name)) {
                loadClass = getSystemClassLoader().loadClass(name);
            } else {
                throw new ClassNotFoundException("沒有加載到類");
            }
        }
        return loadClass;
    }

    //當文件被修改的時候再進行熱部署
    public static void main(String[] args) throws Exception {
        //雙親委派機制
        Application.run(MyClassLoader.class);
    }
}

package com;

import com.classloader.MyClassLoader;
import org.apache.commons.io.monitor.FileAlterationMonitor;
import org.apache.commons.io.monitor.FileAlterationObserver;

import java.io.File;

public class Application {

    public static String rootPath;

    public static void run(Class<?> clazz) throws Exception {
        String rootPath = MyClassLoader.class.getResource("/").getPath().replaceAll("%20", " ");
        rootPath = new File(rootPath).getPath();
        Application.rootPath = rootPath;
        MyClassLoader myClassLoader = new MyClassLoader(rootPath, rootPath + "/com");
        //用我們自己的類加載器加載程序入口
        startFileListener(rootPath);
        start0(myClassLoader);
    }

  //開啟文件監聽器
    public static void startFileListener(String rootPath) throws Exception {
        FileAlterationObserver fileAlterationObserver = new FileAlterationObserver(rootPath);
        fileAlterationObserver.addListener(new FileListener());
        FileAlterationMonitor fileAlterationMonitor = new FileAlterationMonitor(500);
        fileAlterationMonitor.addObserver(fileAlterationObserver);
        fileAlterationMonitor.start();
        //要實現文件監聽：  寫一個線程 去定時監聽某個路徑下所有的文件
        //如果文件發生改動 就回調監聽器
    }

    //新的classLoader
    public static void start() {
        System.out.println("啟動我們的應用程序");
        new Test().test();
    }

    public static void stop() {
        System.out.println("程序退出");
        //告訴jvm需要gc瞭
        System.gc();
        //告訴jvm可以清除對象引用
        System.runFinalization();
    }

    public static void start0(MyClassLoader classLoader) throws Exception {
      //全盤委托的機制，通過自定義的類加載加載，然後start方法中的new Test()也會通過自定義的類加載器加載
        Class<?> aClass = classLoader.loadClass("com.Application");
        aClass.getMethod("start").invoke(aClass.newInstance());
    }

}

package com;

import com.classloader.MyClassLoader;
import org.apache.commons.io.monitor.FileAlterationListenerAdaptor;

import java.io.File;

public class FileListener extends FileAlterationListenerAdaptor {

    @Override
    public void onFileChange(File file) {
        if (file.getName().indexOf(".class") != -1) {
            try {
                MyClassLoader myClassLoader = new MyClassLoader(Application.rootPath, Application.rootPath + "/com");
                Application.stop();
                Application.start0(myClassLoader);
            } catch (Exception e) {
                e.printStackTrace();
            }
        }
    }
}

package com;

public class Test {

    public void test() {
        System.out.println("當前版本:version 1.0");
        System.out.println(this.getClass().getClassLoader());
    }
}

package com.ys.classloader;

import java.io.*;


public class MyClassLoader extends ClassLoader {

    private String root;

    protected Class<?> findClass(String name) throws ClassNotFoundException {
        byte[] classData = loadClassData(name);
        if (classData == null) {
            throw new ClassNotFoundException();
        } else {
            return defineClass(name, classData, 0, classData.length);
        }
    }

    private byte[] loadClassData(String className) {
        String fileName = root + File.separatorChar
                + className.replace('.', File.separatorChar) + ".class";
        try {
            InputStream ins = new FileInputStream(fileName);
            ByteArrayOutputStream baos = new ByteArrayOutputStream();
            int bufferSize = 1024;
            byte[] buffer = new byte[bufferSize];
            int length = 0;
            while ((length = ins.read(buffer)) != -1) {
                baos.write(buffer, 0, length);
            }
            return baos.toByteArray();
        } catch (IOException e) {
            e.printStackTrace();
        }
        return null;
    }

    public String getRoot() {
        return root;
    }

    public void setRoot(String root) {
        this.root = root;
    }

    public static void main(String[] args)  {

        MyClassLoader classLoader = new MyClassLoader();
        classLoader.setRoot("/User/king/temp");

        Class<?> testClass = null;
        try {
            testClass = classLoader.loadClass("com.ys.classloader.Test2");
            Object object = testClass.newInstance();
            System.out.println(object.getClass().getClassLoader());
        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        } catch (InstantiationException e) {
            e.printStackTrace();
        } catch (IllegalAccessException e) {
            e.printStackTrace();
        }
    }
}