ClassWriter cw = new ClassWriter(ClassWriter.COMPUTE_MAXS); 
ClassReader cr = null;     
String enhancedClassName = classSource.getEnhancedName(); 
try { 
    cr = new ClassReader(new FileInputStream(classSource.getFile())); 
} catch (IOException e) { 
    e.printStackTrace(); 
    return null; 
} 
ClassVisitor cv = new EnhancedModifier(cw, 
        className.replace(".", "/"), 
        enhancedClassName.replace(".", "/")); 
cr.accept(cv, 0);

<?xml version="1.0" encoding="UTF-8"?>
<!--
  This is the JRebel configuration file. It maps the running application to your IDE workspace, enabling JRebel reloading for this project.
  Refer to https://manuals.jrebel.com/jrebel/standalone/config.html for more information.
-->
<application generated-by="intellij" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns="http://www.zeroturnaround.com" xsi:schemaLocation="http://www.zeroturnaround.com http://update.zeroturnaround.com/jrebel/rebel-2_3.xsd">
	<id>distribute-sale-service</id>
	<classpath>
		<dir name="${rebel.projectpath.distribute-sale-service}/target/classes">
		</dir>
	</classpath>
</application>

public class MyClasslLoader extends ClassLoader {
    /** 要加载的 Java 类的 classpath 路径 */
    private String classpath;

    public MyClasslLoader(String classpath) {
        //指定父加载器
        super(ClassLoader.getSystemClassLoader());
        this.classpath = classpath;
    }

    @Override
    protected Class<?> findClass(String name) throws ClassNotFoundException {
        byte[] data = this.loadClassData(name);
        return this.defineClass(name, data, 0, data.length);
    }

    /**
     * 加载 class 文件中的内容
     */
    private byte[] loadClassData(String name) {
        try {
            //传进来是带包名的
            name = name.replace(".", "//");
            FileInputStream inputStream = new FileInputStream(new File(classpath + name + ".class"));
            //定义字节数组输出流
            ByteArrayOutputStream baos = new ByteArrayOutputStream();
            int b = 0;
            while ((b = inputStream.read()) != -1) {
                baos.write(b);
            }
            inputStream.close();
            return baos.toByteArray();
        } catch (Exception e) {
            e.printStackTrace();
        }
        return null;
    }
}

public interface BaseManager {
    public void logic();
}

public class MyManager implements BaseManager {
    @Override
    public void logic() {
        System.out.println(LocalTime.now() + ": Java类的热加载");
    }
}

@Data
public class LoadInfo {
    /** 自定义的类加载器 */
    private MyClasslLoader myClasslLoader;
    /** 记录要加载的类的时间戳-->加载的时间 */
    private long loadTime;
    /** 需要被热加载的类 */
    private BaseManager manager;

    public LoadInfo(MyClasslLoader myClasslLoader, long loadTime) {
        this.myClasslLoader = myClasslLoader;
        this.loadTime = loadTime;
    }
}

public class ManagerFactory {
    /** 记录热加载类的加载信息 */
    //key-classNmae value-LoadInfo
    private static final Map<String, LoadInfo> loadTimeMap = new HashMap<>();
    /** 要加载的类的完整路径 classpath */
    public static final String CLASS_PATH = "/Users/sinxu/Documents/project/hot-deployment/target/classes/";
    /** 实现热加载的类的全名称(包名+类名 ) */
    public static final String MY_MANAGER = "com.test.classloader.MyManager";

    /** 通过类名获取类信息，没修改取缓存，新增或修改则加载并缓存 **/
    public static BaseManager getManager(String className) {
        File loadFile = new File(CLASS_PATH + className.replaceAll("\\\\.", "/") + ".class");
        // 获取最后一次修改时间
        long lastModified = loadFile.lastModified();
        System.out.println("当前的类时间：" + lastModified);
        // loadTimeMap 不包含 ClassName 为 key 的信息，证明这个类没有被加载，要加载到 JVM
        if (loadTimeMap.get(className) == null) {
            load(className, lastModified);
        } // 加载类的时间戳变化了，我们同样要重新加载这个类到 JVM。
        else if (loadTimeMap.get(className).getLoadTime() != lastModified) {
            load(className, lastModified);
        }
        return loadTimeMap.get(className).getManager();
    }

    /**
     * 加载 class ，缓存到 loadTimeMap
     */
    private static void load(String className, long lastModified) {
        MyClasslLoader myClasslLoader = new MyClasslLoader(className);
        Class loadClass = null;
        // 加载
        try {
            loadClass = myClasslLoader.loadClass(className);
        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        }

        BaseManager manager = newInstance(loadClass);
        LoadInfo loadInfo = new LoadInfo(myClasslLoader, lastModified);
        loadInfo.setManager(manager);
        loadTimeMap.put(className, loadInfo);
    }

    /**
     * 以反射的方式创建 BaseManager 的子类对象
     */
    private static BaseManager newInstance(Class loadClass) {
        try {
            return (BaseManager)loadClass.getConstructor(new Class[] {}).newInstance(new Object[] {});
        } catch (InstantiationException e) {
            e.printStackTrace();
        } catch (IllegalAccessException e) {
            e.printStackTrace();
        } catch (InvocationTargetException e) {
            e.printStackTrace();
        } catch (NoSuchMethodException e) {
            e.printStackTrace();
        }
        return null;
    }
}

/**
 * 后台启动一条线程，不断检测是否要刷新重新加载，实现了热加载的类
 */
public class MsgHandle implements Runnable {
    @Override
    public void run() {
        while (true) {
            BaseManager manager = ManagerFactory.getManager(ManagerFactory.MY_MANAGER);
            manager.logic();
            try {
                Thread.sleep(2000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}

public class ClassLoadTest {
    public static void main(String[] args) {
        new Thread(new MsgHandle()).start();
    }
}

public Class<?> redefineClass(String className){ 
       ClassWriter cw = new ClassWriter(ClassWriter.COMPUTE_MAXS); 
       ClassReader cr = null; 
       ClassSource cs = classFiles.get(className); 
       if(cs==null){ 
           return null; 
       } 
       try { 
           //load 原始类的 class 文件
           cr = new ClassReader(new FileInputStream(cs.getFile())); 
       } catch (IOException e) { 
           e.printStackTrace(); 
           return null; 
       } 
       //增强组件 ClassModifier，作用是修改原始类的类型，将它转换成接口，原始类的所有方法逻辑都会被去掉
       ClassModifier cm = new ClassModifier(cw); 
       cr.accept(cm, 0); 
       byte[] code = cw.toByteArray(); 
       return defineClass(className, code, 0, code.length); 
}

// 在 class 文件发生改变时重新定义这个类
private Class<?> redefineClass(String className, ClassSource classSource){ 
       ClassWriter cw = new ClassWriter(ClassWriter.COMPUTE_MAXS); 
       ClassReader cr = null; 
       classSource.update(); 
       String enhancedClassName = classSource.getEnhancedName();       

       try { 
           cr = new ClassReader(new FileInputStream(classSource.getFile())); 
       } catch (IOException e) { 
           e.printStackTrace(); 
           return null; 
       } 
 
       //EnhancedModifier，这个增强组件的作用是改变原有的类名
       EnhancedModifier em = new EnhancedModifier(cw, className.replace(".", "/"), 
               enhancedClassName.replace(".", "/")); 
       //ExtendModifier，改变原有类的父类，让这个修改后的派生类能够实现同一个原始类（此时原始类已经转成接口了）
       ExtendModifier exm = new ExtendModifier(em, className.replace(".", "/"), 
               enhancedClassName.replace(".", "/")); 

       cr.accept(exm, 0); 
       byte[] code = cw.toByteArray(); 
       classSource.setByteCopy(code); 
       Class<?> clazz = defineClass(enhancedClassName, code, 0, code.length); 
       classSource.setClassCopy(clazz); 
       return clazz; 
}

ITestClass testClass = (ITestClass)MyClassLoader.getInstance().
findClass("com.example.TestClass").newInstance();

@Override 
public void visitTypeInsn(int opcode, String type) { 
    if (opcode==Opcodes.NEW && type.equals(className)) { 
        List<LocalVariableNode> variables = node.localVariables; 
        String compileType = null; 
        for(int i = 0; i < variables.size(); i++){ 
            LocalVariableNode localVariable = variables.get(i); 
            compileType = formType(localVariable.desc); 
            if(matchType(compileType) && !valiableIndexUsed[i]) { 
                valiableIndexUsed[i] = true; 
                break; 
            }
        } 

    mv.visitMethodInsn(Opcodes.INVOKESTATIC, CLASSLOAD_TYPE, "getInstance", "()L" + CLASSLOAD_TYPE + ";"); 
    mv.visitLdcInsn(type.replace("/", ".")); 
    mv.visitMethodInsn(Opcodes.INVOKEVIRTUAL, CLASSLOAD_TYPE, "findClass", "(Ljava/lang/String;)Ljava/lang/Class;"); 
    mv.visitMethodInsn(Opcodes.INVOKEVIRTUAL, "java/lang/Class", "newInstance", "()Ljava/lang/Object;"); 
    mv.visitTypeInsn(Opcodes.CHECKCAST, compileType); 
    flag = true; 
    } else { 
        mv.visitTypeInsn(opcode, type); 
    } 
 }

java.lang.LinkageError 
attempted duplicate class definition

public class ReloadAgent { 
   public static void premain(String agentArgs, Instrumentation inst){ 
       GeneralTransformer trans = new GeneralTransformer(); 
       inst.addTransformer(trans); 
   } 
}

manifest-Version: 1.0 
Premain-Class: com.example.ReloadAgent 
Can-Redefine-Classes: true

@Override 
public byte [] transform(ClassLoader paramClassLoader, String paramString, 
                         Class<?> paramClass, ProtectionDomain paramProtectionDomain, 
                         byte [] paramArrayOfByte) throws IllegalClassFormatException { 
    String className = paramString.replace("/", "."); 
    if(className.equals("com.example.TestClass")){ 
        MyClassLoader cl = MyClassLoader.getInstance(); 
        cl.redefineClass(className); 
        return cl.getByteCode(className); 
    } 

    return null; 
 }