graph TD
    A[Java源代碼] --> B{編譯器處理}
    B --> C[詞法分析]
    C --> D[語法分析]
    D --> E[語義分析]
    E --> F[生成字節(jié)碼]
    F --> G[加載到JVM]

import javax.tools.JavaCompiler;
import javax.tools.ToolProvider;
public class DynamicCompileExample {
    public static void main(String[] args) {
        JavaCompiler compiler = ToolProvider.getSystemJavaCompiler();
        int result = compiler.run(null, null, null, "MyClass.java");
        System.out.println("編譯結(jié)果：" + (result == 0 ? "成功" : "失敗"));
    }
}

import org.codehaus.janino.ScriptEvaluator;
public class JaninoExample {
    public static void main(String[] args) throws Exception {
        ScriptEvaluator se = new ScriptEvaluator();
        se.cook("return a + b;");
        Object result = se.evaluate(new Object[]{5, 7});
        System.out.println("結(jié)果：" + result);  // 輸出：12
    }
}

JavaCompiler compiler = ToolProvider.getSystemJavaCompiler();
if (compiler == null) {
    System.err.println("無法獲取Java編譯器，請(qǐng)確保使用的是JDK而非JRE");
}

import javax.tools.*;
import java.io.*;
import java.net.URI;
import java.util.*;
public class InMemoryCompiler {
    public static void main(String[] args) throws Exception {
        JavaCompiler compiler = ToolProvider.getSystemJavaCompiler();
        DiagnosticCollector<JavaFileObject> diagnostics = new DiagnosticCollector<>();
        JavaFileObject file = new JavaSourceFromString("Hello", "public class Hello { public void say() { System.out.println(\"Hello World\"); } }");
        Iterable<? extends JavaFileObject> compilationUnits = Arrays.asList(file);
        JavaCompiler.CompilationTask task = compiler.getTask(null, null, diagnostics, null, null, compilationUnits);
        boolean success = task.call();
        System.out.println("編譯結(jié)果：" + (success ? "成功" : "失敗"));
    }
    static class JavaSourceFromString extends SimpleJavaFileObject {
        final String code;
        JavaSourceFromString(String name, String code) {
            super(URI.create("string:///" + name.replace('.', '/') + Kind.SOURCE.extension), Kind.SOURCE);
            this.code = code;
        }
        @Override
        public CharSequence getCharContent(boolean ignoreEncodingErrors) {
            return code;
        }
    }
}

DiagnosticCollector<JavaFileObject> diagnostics = new DiagnosticCollector<>();
// ... 編譯任務(wù)執(zhí)行后
for (Diagnostic<? extends JavaFileObject> diagnostic : diagnostics.getDiagnostics()) {
    System.err.println("錯(cuò)誤位置：" + diagnostic.getLineNumber());
    System.err.println("錯(cuò)誤信息：" + diagnostic.getMessage(null));
}

File sourceFile = new File("Hello.java");
try (FileWriter writer = new FileWriter(sourceFile)) {
    writer.write("public class Hello { public void say() { System.out.println(\"Hello World\"); } }");
}
JavaCompiler compiler = ToolProvider.getSystemJavaCompiler();
int result = compiler.run(null, null, null, sourceFile.getPath());
System.out.println("編譯結(jié)果：" + (result == 0 ? "成功" : "失敗"));

graph TD
    A[Java源碼字符串] --> B[封裝為JavaFileObject]
    B --> C[調(diào)用JavaCompiler]
    C --> D[生成字節(jié)碼]
    D --> E[加載到JVM]

import javax.tools.*;
import java.lang.reflect.Method;
import java.net.URI;
import java.util.*;
public class MemoryCompileAndLoad {
    public static void main(String[] args) throws Exception {
        JavaCompiler compiler = ToolProvider.getSystemJavaCompiler();
        ClassLoader loader = new ClassLoader() {
            Map<String, byte[]> classBytes = new HashMap<>();
            @Override
            protected Class<?> findClass(String name) throws ClassNotFoundException {
                byte[] buf = classBytes.get(name);
                if (buf == null) throw new ClassNotFoundException(name);
                return defineClass(name, buf, 0, buf.length);
            }
        };
        JavaCompiler.CompilationTask task = compiler.getTask(null, new JavaFileManager() {
            @Override
            public ClassLoader getClassLoader(Location location) { return loader; }
            @Override
            public Iterable<JavaFileObject> list(Location location, String packageName, Set<Kind> kinds, boolean recurse) throws IOException {
                return Collections.emptyList();
            }
            @Override
            public String inferBinaryName(Location loc, JavaFileObject file) {
                return file.getName();
            }
            @Override
            public boolean isSameFile(FileObject a, FileObject b) {
                return a.toUri().equals(b.toUri());
            }
            @Override
            public boolean handleOption(String current, Iterator<String> remaining) {
                return false;
            }
            @Override
            public boolean hasLocation(Location location) {
                return false;
            }
            @Override
            public JavaFileObject getJavaFileForInput(Location location, String className, JavaFileObject.Kind kind) throws IOException {
                return null;
            }
            @Override
            public JavaFileObject getJavaFileForOutput(Location location, String className, JavaFileObject.Kind kind, FileObject sibling) throws IOException {
                return new SimpleJavaFileObject(URI.create("string:///" + className + ".class"), kind) {
                    @Override
                    public OutputStream openOutputStream() {
                        return new ByteArrayOutputStream() {
                            @Override
                            public void close() {
                                loader.getClass().getField("classBytes").set(loader, Map.of(className, toByteArray()));
                            }
                        };
                    }
                };
            }
            @Override
            public FileObject getFileForInput(Location location, String packageName, String relativeName) throws IOException {
                return null;
            }
            @Override
            public FileObject getFileForOutput(Location location, String packageName, String relativeName, FileObject sibling) throws IOException {
                return null;
            }
            @Override
            public void flush() {}
            @Override
            public void close() {}
        }, null, null, null, Arrays.asList(new JavaSourceFromString("Hello", "public class Hello { public void say() { System.out.println(\"Hello World\"); } }")));
        task.call();
        Class<?> helloClass = loader.loadClass("Hello");
        Object instance = helloClass.getDeclaredConstructor().newInstance();
        Method method = helloClass.getMethod("say");
        method.invoke(instance);  // 輸出：Hello World
    }
    static class JavaSourceFromString extends SimpleJavaFileObject {
        final String code;
        JavaSourceFromString(String name, String code) {
            super(URI.create("string:///" + name.replace('.', '/') + Kind.SOURCE.extension), Kind.SOURCE);
            this.code = code;
        }
        @Override
        public CharSequence getCharContent(boolean ignoreEncodingErrors) {
            return code;
        }
    }
}

graph TD
    A[用戶請(qǐng)求加載類] --> B[應(yīng)用程序類加載器]
    B --> C[擴(kuò)展類加載器]
    C --> D[啟動(dòng)類加載器]
    D --> E{是否能加載？}
    E -- 是 --> F[返回加載結(jié)果]
    E -- 否 --> G[嘗試加載]
    G --> H{是否成功？}
    H -- 是 --> I[返回加載結(jié)果]
    H -- 否 --> J[拋出ClassNotFoundException]
    style A fill:#f9f,stroke:#333
    style J fill:#f66,stroke:#333

public class CustomClassLoader extends ClassLoader {
    @Override
    public Class<?> loadClass(String name) throws ClassNotFoundException {
        if (name.startsWith("com.example")) {
            return findClass(name);  // 優(yōu)先自己加載
        }
        return super.loadClass(name);  // 否則交給父類加載
    }
    @Override
    protected Class<?> findClass(String name) throws ClassNotFoundException {
        byte[] classData = loadClassData(name);  // 自定義加載字節(jié)碼
        if (classData == null) {
            throw new ClassNotFoundException();
        }
        return defineClass(name, classData, 0, classData.length);
    }
    private byte[] loadClassData(String className) {
        // 實(shí)現(xiàn)從特定路徑或網(wǎng)絡(luò)加載類字節(jié)碼
        return new byte[0];  // 示例占位
    }
}

public class URLClassLoaderExample {
    public static void main(String[] args) throws Exception {
        File file = new File("/path/to/classes/");
        URL url = file.toURI().toURL();
        URLClassLoader loader = new URLClassLoader(new URL[]{url});
        Class<?> clazz = loader.loadClass("com.example.MyDynamicClass");
        Object instance = clazz.getDeclaredConstructor().newInstance();
        Method method = clazz.getMethod("sayHello");
        method.invoke(instance);
    }
}

public class JarClassLoaderExample {
    public static void main(String[] args) throws Exception {
        File jarFile = new File("/path/to/plugin.jar");
        URLClassLoader loader = new URLClassLoader(new URL[]{jarFile.toURI().toURL()});
        Class<?> clazz = loader.loadClass("com.example.Plugin");
        Object instance = clazz.getDeclaredConstructor().newInstance();
        Method method = clazz.getMethod("execute");
        method.invoke(instance);
    }
}

Method method = URLClassLoader.class.getDeclaredMethod("addURL", URL.class);
method.setAccessible(true);
method.invoke(loader, new File("/another/path/plugin2.jar").toURI().toURL());

URLClassLoader loader1 = new URLClassLoader(new URL[]{new File("v1.jar").toURI().toURL()});
URLClassLoader loader2 = new URLClassLoader(new URL[]{new File("v2.jar").toURI().toURL()});
Class<?> clazz1 = loader1.loadClass("com.example.MyClass");
Class<?> clazz2 = loader2.loadClass("com.example.MyClass");
System.out.println(clazz1 == clazz2);  // 輸出 false

ClassLoader classLoader = new MyClassLoader();
Class<?> dynamicClass = classLoader.loadClass("com.example.DynamicClass");
Object instance = dynamicClass.getDeclaredConstructor().newInstance();

Method method = dynamicClass.getMethod("sayHello", String.class);
method.invoke(instance, "World");

InvocationHandler handler = (proxy, method, args) -> {
    System.out.println("Before method call");
    Object result = method.invoke(instance, args);
    System.out.println("After method call");
    return result;
};
Object proxy = Proxy.newProxyInstance(
    classLoader,
    new Class[]{MyInterface.class},
    handler
);

Enhancer enhancer = new Enhancer();
enhancer.setSuperclass(DynamicClass.class);
enhancer.setCallback((MethodInterceptor) (obj, method, args, proxy) -> {
    System.out.println("前置增強(qiáng)");
    Object result = proxy.invokeSuper(obj, args);
    System.out.println("后置增強(qiáng)");
    return result;
});
Object proxyInstance = enhancer.create();
Method method = proxyInstance.getClass().getMethod("sayHello", String.class);
method.invoke(proxyInstance, "Java");

graph TD
    A[插件調(diào)用入口] --> B(生成動(dòng)態(tài)代理)
    B --> C{是否匹配切面規(guī)則}
    C -->|是| D[執(zhí)行前置增強(qiáng)]
    D --> E[調(diào)用插件方法]
    E --> F[執(zhí)行后置增強(qiáng)]
    C -->|否| G[直接調(diào)用插件方法]
    G --> H[返回結(jié)果]

Instrumentation inst = ...; // 通過Agent獲取
inst.addTransformer((loader, className, classBeingRedefined,
                     protectionDomain, classfileBuffer) -> {
    if (className.equals("com/example/MyClass")) {
        return modifyBytecode(classfileBuffer);
    }
    return null;
});

ClassReader reader = new ClassReader(classfileBuffer);
ClassWriter writer = new ClassWriter(reader, ClassWriter.COMPUTE_FRAMES);
ClassVisitor visitor = new ClassVisitor(ASM9, writer) {
    @Override
    public MethodVisitor visitMethod(int access, String name, String descriptor, String signature, String[] exceptions) {
        MethodVisitor mv = super.visitMethod(access, name, descriptor, signature, exceptions);
        return new MethodVisitor(ASM9, mv) {
            @Override
            public void visitInsn(int opcode) {
                if (opcode >= IRETURN && opcode <= RETURN) {
                    mv.visitMethodInsn(INVOKESTATIC, "java/lang/System", "nanoTime", "()J", false);
                    mv.visitMethodInsn(INVOKESTATIC, "java/lang/System", "out", "Ljava/io/PrintStream;", false);
                    mv.visitMethodInsn(INVOKEVIRTUAL, "java/io/PrintStream", "println", "(J)V", false);
                }
                super.visitInsn(opcode);
            }
        };
    }
};
reader.accept(visitor, ClassReader.EXPAND_FRAMES);
return writer.toByteArray();

DynamicType.Unloaded<?> dynamicType = new ByteBuddy()
    .subclass(Object.class)
    .name("com.example.MyDynamicClass")
    .method(named("toString"))
    .intercept(FixedValue.value("Hello from ByteBuddy!"))
    .make();
Class<?> dynamicClass = dynamicType.load(classLoader, ClassLoadingStrategy.Default.WRAPPER)
                                  .getLoaded();

ClassDefinition def = new ClassDefinition(MyClass.class, modifiedBytecode);
inst.redefineClasses(def);

graph LR
    A[原始類加載] --> B(觸發(fā)ClassFileTransformer)
    B --> C{是否匹配增強(qiáng)規(guī)則}
    C -->|是| D[插入日志打印指令]
    D --> E[返回增強(qiáng)后的字節(jié)碼]
    C -->|否| F[返回原字節(jié)碼]
    E --> G[類加載器加載增強(qiáng)類]

import javax.tools.JavaCompiler;
import javax.tools.ToolProvider;
import java.io.*;
import java.lang.reflect.Method;
import java.net.URL;
import java.net.URLClassLoader;
public class DynamicCompiler {
    public static void main(String[] args) throws Exception {
        // 源代碼字符串
        String className = "HelloWorld";
        String sourceCode = "public class " + className + " {\n" +
                            "    public String sayHello() {\n" +
                            "        return \"Hello from dynamic class!\";\n" +
                            "    }\n" +
                            "}";
        // 寫入臨時(shí)文件
        File tempFile = File.createTempFile("HelloWorld", ".java");
        try (FileWriter writer = new FileWriter(tempFile)) {
            writer.write(sourceCode);
        }
        // 獲取系統(tǒng)Java編譯器
        JavaCompiler compiler = ToolProvider.getSystemJavaCompiler();
        int compilationResult = compiler.run(null, null, null, tempFile.getPath());
        if (compilationResult != 0) {
            throw new RuntimeException("Compilation failed");
        }
        // 讀取編譯后的字節(jié)碼文件
        File compiledFile = new File(tempFile.getParent(), className + ".class");
        URLClassLoader classLoader = URLClassLoader.newInstance(new URL[]{new File(tempFile.getParent()).toURI().toURL()});
        Class<?> dynamicClass = Class.forName(className, true, classLoader);
        // 反射調(diào)用方法
        Object instance = dynamicClass.getDeclaredConstructor().newInstance();
        Method method = dynamicClass.getMethod("sayHello");
        String result = (String) method.invoke(instance);
        System.out.println(result);
    }
}

public class PluginClassLoader extends ClassLoader {
    public Class<?> defineClassFromByteCode(byte[] byteCode, String className) {
        return defineClass(className, byteCode, 0, byteCode.length);
    }
}

graph TD
    A[讀取插件源碼] --> B[動(dòng)態(tài)編譯]
    B --> C{是否編譯成功?}
    C -->|是| D[讀取字節(jié)碼]
    C -->|否| E[記錄錯(cuò)誤日志]
    D --> F[調(diào)用defineClass加載類]
    F --> G[反射調(diào)用插件方法]
    G --> H[等待插件更新]
    H --> I[重新讀取源碼]
    I --> B

import javax.tools.Diagnostic;
import javax.tools.DiagnosticCollector;
import javax.tools.JavaFileObject;
DiagnosticCollector<JavaFileObject> diagnostics = new DiagnosticCollector<>();
JavaCompiler.CompilationTask task = compiler.getTask(null, null, diagnostics, null, null, Arrays.asList(javaFile));
boolean success = task.call();
for (Diagnostic<? extends JavaFileObject> diagnostic : diagnostics.getDiagnostics()) {
    System.err.println("Error: " + diagnostic.getMessage(null));
}

DefaultListableBeanFactory beanFactory = (DefaultListableBeanFactory) applicationContext.getAutowireCapableBeanFactory();
BeanDefinitionBuilder builder = BeanDefinitionBuilder.genericBeanDefinition(MyDynamicBean.class);
builder.setScope(ConfigurableBeanFactory.SCOPE_SINGLETON);
beanFactory.registerBeanDefinition("myDynamicBean", builder.getBeanDefinition());

// 動(dòng)態(tài)編譯生成類
Class<?> dynamicClass = compileDynamicClass("DynamicService");
// 創(chuàng)建BeanDefinition
BeanDefinitionBuilder builder = BeanDefinitionBuilder.genericBeanDefinition(dynamicClass);
builder.setScope(ConfigurableBeanFactory.SCOPE_SINGLETON);
// 注冊(cè)到Spring容器
beanFactory.registerBeanDefinition("dynamicService", builder.getBeanDefinition());
// 獲取Bean并調(diào)用
Object dynamicBean = beanFactory.getBean("dynamicService");
Method method = dynamicBean.getClass().getMethod("execute");
method.invoke(dynamicBean);

System.setSecurityManager(new SecurityManager());

Permission permission = new FilePermission("/tmp/*", "read");
AccessController.checkPermission(permission);