1、什么是热部署

相信大家在写代码的时候都有这个困扰，就是每次我改完代码之后都需要重启项目才能看到结果，小项目还好，启动不会占用太多时间，如果是一个大项目，每次重启都要耗费很多时间的情况下，这无疑对开发效率都会大幅下降，那么有没有这样一种技术？我修改后无需重启服务器，就可以马上看到效果？我可以很肯定地回答你：“有”，就是热部署技术，在你修改完代码之后，这项技术会自动帮你重新加载被修改后class文件，真正实现实时查看改动的结果；

2、准备

要知道热部署，就得先了解class加载机制，在我们启动项目的时候，首先编辑器会将后缀为.java的文件编译成.class文件，之后jvm虚拟机会把class文件转成二进制的字节码加载到内存里面，中间经过了一系列的链接过程，最后完成初始化，加载过程不是本文的重点，这里简单说明略过；

3、类加载器的分类

类加载器基类叫做 ClassLoader，这是一个抽象类，既然是抽象就代表着它是可扩展的，所以衍生出了不同种类的类加器

BootstrapClassLoader ：主要负责加载核心的类库(java.lang.*等)，构造ExtClassLoader和APPClassLoader。
ExtClassLoader ：主要负责加载 %JAVA_HOME%/jre/lib/ext 目录下的一些扩展的jar。
AppClassLoader：主要负责加载应用程序的主函数类，加载classPath目录
UserClassLoader：用户自定义类加载器，名字随便起，只需要继承ClassLoader类即可；

3.1、BootstrapClassLoader

BootStrapClassLoader 是一个纯的C++实现，没有对应的Java类。所以在Java中是取不到的。如果我们在 idea 编辑器中搜索BootStrapClassLoader，是找不到这个类的

如果一个类的classLoader是null。已经足可以证明他就是由BootStrapClassLoader 加载的，现在我们用一组代码测试下


  public static void main(String[] args) throws Exception {
 
        String str = new String("123");
 
        System.out.println("String类的类加载器为："+str.getClass().getClassLoader());
}

java.lang.String 这个类是系统的类，当我们获取这个类时，可以看到它的类加载器是null值，所以就可以断定，String 使用的是BootStrapClassLoader加载的；

3.2、ExtClassLoader

ExtClassLoader主要加载%JAVA_HOME%/jre/lib/ext，此路径下的所有classes目录以及java.ext.dirs系统变量指定的路径中类库，那么都有哪些类呢？看下图就知道啦，主要加载下图jar包中的类！此类继承ClassLoader加载器；

需要注意的是，ExtClassLoader这个类是在 Launcher 类里面的一个内部类

3.3、AppClassLoader

App就是应用程序的意思，所以这个类加载器就是用来加载我们用户自己写的java类；此类继承ClassLoader加载器，需要注意的是，这个类也是在 Launcher 类里面的一个内部类

接下来我们自己定义一个类 User.java ，然后在控制台打印一下这个类的类加载器；


package com;
public class User {
 
    public static void main(String[] args) {
 
        System.out.println("User类的类加载器为："+User.class.getClassLoader());
    }
}

通过控制台打印的结果可以得知，自定义的 User类使用的是AppClassLoader 类加载器；

3.5、关于类加载，还有2点需要注意：

1、同一个classLoader只会生成一个相同的class对象

2、不同的ClassLoader 加载相同的Class对象不能互相强转

为什么不能强转呢？我们来写一组代码测试下就知道啦

先定一个自动义类加载器 MyClassLoader.java


package com;
 
import java.io.InputStream;
 
public class MyClassLoader extends ClassLoader{
 
    /**
     * 加载class文件
     * 重写此方法的目的是为了能让此方法被外部调用，父类的 findClass 是 protected 修饰的，只能被子类调用
     * @param name   类的全类名 示例： com.xd.User
     * @return
     * @throws ClassNotFoundException
     */
    @Override
    public Class<?> findClass(String name) throws ClassNotFoundException {
 
 
        try {
 
            String fileName = name.replaceAll("\\.","/") + ".class";
            fileName = "/"+ fileName;
            // 获取文件输入流
            InputStream is = this.getClass().getResourceAsStream(fileName);
            // 读取字节
            byte[] b = new byte[is.available()];
            is.read(b);
            // 将byte字节流解析成jvm能够识别的Class对象
            return defineClass(name, b, 0, b.length);
        } catch (Exception e) {
            throw new ClassNotFoundException();
        }
    }
}

定义一个 HotUserModel.java 类，用来实例化用的


package com.hot.deploy.model;
 
 
public class HotUserModel {
 
}

主程序入口测试


    public static void main(String[] args) throws Exception {
 
        // 默认加载器加载的  HotUserModel
        HotUserModel hotUserModel = null;
 
        // 使用自定义加载器加载 HotUserModel
        MyClassLoader myClassLoader = new MyClassLoader();
        Class<?> aClass =myClassLoader.findClass("com.hot.deploy.model.HotUserModel");
        Object o = aClass.newInstance();
 
        System.out.println("普通 HotUserModel 使用的类加载器为：" + HotUserModel.class.getClassLoader());
        System.out.println();
        System.out.println("使用自动义类加载器的 HotUserModel 使用的加载器为：" + o.getClass().getClassLoader());
        System.out.println();
        // 以下语句赋值会报错
        hotUserModel = (HotUserModel) o;
 
    }

运行后打印结果如下

通过打印的结果可以看到，相同的类无法强转，因为使用了不同的类加载器；

4、双亲委派加载机制

当类加载器在加载一个类的时候，它首先不会马上去加载这个类，而是先把这个请求委派给父类去完成，而父类接受到加载请求的时候也不会马上去加载这个类，而是在交给自己的父类去加载，每一个层次加载器都是如此，直到父类加载器无法加载的时候，子类才会自己去尝试完成加载，我们的要实现的热部署原理就是要打破双亲委派加载机制，直接由子类来加载；而不去请求父加载器；

加载流程如下

将自定义加载器挂载到应用程序加载器
应用程序加载器将类加载请求委托给扩展类加载器
扩展类加载器将类加载请求委托给启动类加载器
启动类加载器在加载路径下查找并加载Class文件，如果未找到目标Class文件，则交由扩展类加载器加载；
扩展类加载器在加载路径下未找到目标Class文件，交由应用程序类加载器加载
应用程序类加载器在加载路径下未找到目标Class文件，交由自定义加载器加载
自定义加载器在加载路径下未找到目标Class文件，抛出ClassNotFound异常

4.1、双亲委派的作用

1、通过以上的委托流程，双亲委派机制保障了类的唯一性，

2、保证核心.class不被篡改，即使被篡改也不会被加载，即使被加载也不会是同一个class对象，因为不同的加载器加载同一个.class也不是同一个Class对象。这样则保证了Class的执行安全。

5、全盘负责委托机制

当一个A加载器加载一个类的时候，除非显式地使用另一个加载器B，否则该类的所有依赖和引用都使用这个A加载器；也就是说，如果一个类为User类，这个User类的加载器是AppClassLoader加载器加载的，那么这个User类下面的所有引用类的加载器都是AppClassLoader；

接下来测试一把，先创建一个自定义类加载器 MyClassLoader.java


package com;
 
import java.io.InputStream;
import java.net.URL;
 
public class MyClassLoader extends ClassLoader{
 
    /**
     * 加载class文件
     * 重写此方法的目的是为了能让此方法被外部调用，父类的 findClass 是 protected 修饰的，只能被子类调用
     * @param name   类的全类名 示例： com.xd.User
     * @return
     * @throws ClassNotFoundException
     */
    @Override
    public Class<?> findClass(String name) throws ClassNotFoundException {
 
 
        try {
            // 获取class文件名称  去掉包路径
            String fileName = name.substring(name.lastIndexOf(".") + 1) + ".class";
            // 获取文件输入流
            InputStream is = this.getClass().getResourceAsStream(fileName);
            // 读取字节
            byte[] b = new byte[is.available()];
            is.read(b);
            // 将byte字节流解析成jvm能够识别的Class对象
            return defineClass(name, b, 0, b.length);
        } catch (Exception e) {
            throw new ClassNotFoundException();
        }
    }
}

用来创建对象的类 User.java

注意：在User的show方法里面创建了一个新的User对象，我们就是要测试这个新的User对象是否使用了全盘负责委托机制


package com;
 
public class User {
    
    public void  show(){
        System.out.println("当前User使用的类加载器为："+this.getClass().getClassLoader());
 
        User user = new User();
        System.out.println("新的User对象使用的类加载器为："+user.getClass().getClassLoader());
    }
}

创建main方法测试


 public static void main(String[] args) throws Exception {
        MyClassLoader myClassLoader = new MyClassLoader();
        Class<?> aClass = myClassLoader.findClass("com.User");
        // 实例化User对象
        Object o = aClass.newInstance();
        Method show = aClass.getDeclaredMethod("show");
        // 执行show方法
        show.invoke(o);
    }

运行后打印结果如下，很明显，全盘负责委托机制生效了，用的都是自定义加载类加载的class对象；


当前User使用的类加载器为：com.MyClassLoader@1d44bcfa
新的User对象使用的类加载器为：com.MyClassLoader@1d44bcfa
 
Process finished with exit code 0

6、热部署代码

实现热部署需要做2件事，一是打破双亲委派机制，二是使用全盘委托机制实现热部署（废话，默认是使用的）；废话不多说，上代码，需要注意的是，热部署的代码和上面5步的代码没有任何关系，请不要将其混淆

HotUserModel.java


package com.hot.deploy.model;
 
 
public class HotUserModel {
 
    // 用户名
    private String userName="yexindong";
 
    // 年龄
    private Integer age = 18;
 
 
    public void show(){
        System.out.println("大家好，我叫："+userName+"，我的年龄是："+age);
        System.out.println("当前使用的类加载器："+this.getClass().getClassLoader());
 
    }
}

自定义类加载器 HotClassLoader.java


package com.hot.deploy;
 
import java.io.File;
import java.io.FileInputStream;
import java.io.IOException;
import java.io.InputStream;
import java.util.ArrayList;
import java.util.List;
 
public class HotClassLoader extends ClassLoader{
 
    // 项目目录
    private String projectPath;
 
    // class的包路径列表  格式： [com.xxx.App.class]
    private List<String> classList;
 
 
    /**
     *
     * @param projectPath 项目绝对路径
     * @param classPaths class文件的完整路径列表
     * @throws IOException
     */
    public HotClassLoader(String projectPath,String... classPaths) throws IOException {
        // 空格解码
        this.projectPath = projectPath.replaceAll("%20"," ");
 
        classList = new ArrayList<String>();
 
        // 扫描包路径，并加载类，打破双亲委派机制
        for (String classPath : classPaths) {
            // 转为路径
            classPath = classPath.replaceAll("\\.", "/");
            // 空格解码
            classPath.replaceAll("%20"," ");
            File file = new File(classPath);
            readFile(file);
        }
    }
 
 
 
    public void readFile(File file) throws IOException {
 
        if (file.isDirectory()) {
            for (File child : file.listFiles()) {
                readFile(child);
            }
        } else {
            // 加载类
 
            String fileName = file.getName();
            String suffix = fileName.substring(fileName.lastIndexOf(".")+1);
 
            if(!"class".equals(suffix)){
                return;
            }
            //将class文件转为字节码
            InputStream inputStream = new FileInputStream(file);
            byte[] classByte = new byte[(int)file.length()];
            inputStream.read(classByte);
 
            // 获取全类名 com.xx.xx.class
            String className = this.getClassName(file);
 
            // 记录已被加载过的class文件
            classList.add(className);
 
            // 加载class到jvm虚拟机
            defineClass(className,classByte,  0,classByte.length);
        }
    }
 
    /**
     *  获取全类名 com.xx.xx.class
     * @param file
     * @return
     */
    public String getClassName(File file){
 
        String className = file.getPath().replace(projectPath, "");
        // 去掉.class
        className = className.substring(1,className.indexOf("."));
        // 将斜杠转为.
        className = className.replaceAll("/",".");
        return className;
    }
 
    // 这个方法可改可不改
    @Override
    public Class<?> loadClass(String name) throws ClassNotFoundException {
 
        Class<?> loadedClass = findLoadedClass(name);
        if(loadedClass == null ){
            if(classList.contains(name)){
                throw new ClassNotFoundException("找不到类");
            }
 
            // 调用系统类加载器
            loadedClass = getSystemClassLoader().loadClass(name);
        }
        return loadedClass;
//        return super.loadClass(name);
    }
 
 
}

Application.java


package com.hot.deploy;
 
import com.hot.deploy.model.HotUserModel;
 
import java.io.File;
import java.lang.reflect.Method;
 
public class Application {
 
    
    public void showApplication(){
        // 创建新对象，这个创建对象时使用的类加载器也是自定义的加载器
        new HotUserModel().show();
    }
 
 
    /**
     * 开始加载
     * @param classLoader
     * @throws Exception
     */
    public static void start0(HotClassLoader classLoader) throws Exception {
 
            // 加载当前类Application
            Class<?> aClass = classLoader.loadClass("com.hot.deploy.Application");
            // 调用showApplication方法
            Method show = aClass.getDeclaredMethod("showApplication");
            Object o = aClass.newInstance();
            Object invoke = show.invoke(o);
            
            //  延时一秒
            Thread.sleep(1000);
 
 
    }
 
    /**
     * 使用死循环来重新加载class，每次循环加载的class都是new出来的新对象
     * @throws Exception
     */
    public static void run() throws Exception {
        for(;;){
            // 获取项目的目录
            String projectPath = HotClassLoader.class.getResource("/").getPath().replaceAll("%20"," ");
            projectPath = new File(projectPath).getPath();
            
            // 使用自定义加载器加载所有的对象
            HotClassLoader hotClassLoader = new HotClassLoader(projectPath, projectPath + "/com");
            // 开始加载
            start0(hotClassLoader);
 
        }
 
 
    }
}

创建一个启动类来运行 MainApp.java


package com.hot.deploy;
 
public class MainApp {
 
 
    /**
     * 运行main 方法后，修改 HotUserModel 类的System.out.println()打印的内容，然后按一下右上角的绿色锤子（Build Project）就可以看到效果了
     *
     *  热部署实现原理： 是因为打破了双亲委派机制 和 全盘委托 机制；
     * @param args
     * @throws Exception
     */
    public static void main(String[] args) throws Exception {
 
        Application.run();
    }
}

先运行main方法，在运行的同时，先修改HotUserModel类的userName属性

然后点击idea 右上角的绿色的锤子进行手动编译

编译完成后，马上就可以在控制台看到修改的内容了

完

热部署这块确实有些晦涩难懂，但是只要认真学习，多去网上找找资料学习，总会茅塞顿开的，俗话说，难的不会，会的不难，说的就是这个道理，当你不知道的时候，你会觉得好复杂，当你学会之后会觉得也就那样！也希望童鞋们不要停下学习的脚步，向着诗和远方，我们一起出发！！

原来类加载器这么简单，手把手教你用纯java代码实现热部署