Java动态编译与类加载实战详解

graph td
    a[java源代码] --> b{编译器处理}
    b --> c[词法分析]
    c --> d[语法分析]
    d --> e[语义分析]
    e --> f[生成字节码]
    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("编译结果：" + (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("结果：" + result);  // 输出：12
    }
}

javacompiler compiler = toolprovider.getsystemjavacompiler();
if (compiler == null) {
    system.err.println("无法获取java编译器，请确保使用的是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("编译结果：" + (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<>();
// ... 编译任务执行后
for (diagnostic<? extends javafileobject> diagnostic : diagnostics.getdiagnostics()) {
    system.err.println("错误位置：" + diagnostic.getlinenumber());
    system.err.println("错误信息：" + 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("编译结果：" + (result == 0 ? "成功" : "失败"));

graph td
    a[java源码字符串] --> b[封装为javafileobject]
    b --> c[调用javacompiler]
    c --> d[生成字节码]
    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[用户请求加载类] --> b[应用程序类加载器]
    b --> c[扩展类加载器]
    c --> d[启动类加载器]
    d --> e{是否能加载？}
    e -- 是 --> f[返回加载结果]
    e -- 否 --> g[尝试加载]
    g --> h{是否成功？}
    h -- 是 --> i[返回加载结果]
    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);  // 优先自己加载
        }
        return super.loadclass(name);  // 否则交给父类加载
    }
    @override
    protected class<?> findclass(string name) throws classnotfoundexception {
        byte[] classdata = loadclassdata(name);  // 自定义加载字节码
        if (classdata == null) {
            throw new classnotfoundexception();
        }
        return defineclass(name, classdata, 0, classdata.length);
    }
    private byte[] loadclassdata(string classname) {
        // 实现从特定路径或网络加载类字节码
        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("前置增强");
    object result = proxy.invokesuper(obj, args);
    system.out.println("后置增强");
    return result;
});
object proxyinstance = enhancer.create();
method method = proxyinstance.getclass().getmethod("sayhello", string.class);
method.invoke(proxyinstance, "java");

graph td
    a[插件调用入口] --> b(生成动态代理)
    b --> c{是否匹配切面规则}
    c -->|是| d[执行前置增强]
    d --> e[调用插件方法]
    e --> f[执行后置增强]
    c -->|否| g[直接调用插件方法]
    g --> h[返回结果]

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(触发classfiletransformer)
    b --> c{是否匹配增强规则}
    c -->|是| d[插入日志打印指令]
    d --> e[返回增强后的字节码]
    c -->|否| f[返回原字节码]
    e --> g[类加载器加载增强类]

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" +
                            "}";
        // 写入临时文件
        file tempfile = file.createtempfile("helloworld", ".java");
        try (filewriter writer = new filewriter(tempfile)) {
            writer.write(sourcecode);
        }
        // 获取系统java编译器
        javacompiler compiler = toolprovider.getsystemjavacompiler();
        int compilationresult = compiler.run(null, null, null, tempfile.getpath());
        if (compilationresult != 0) {
            throw new runtimeexception("compilation failed");
        }
        // 读取编译后的字节码文件
        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);
        // 反射调用方法
        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[动态编译]
    b --> c{是否编译成功?}
    c -->|是| d[读取字节码]
    c -->|否| e[记录错误日志]
    d --> f[调用defineclass加载类]
    f --> g[反射调用插件方法]
    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());

// 动态编译生成类
class<?> dynamicclass = compiledynamicclass("dynamicservice");
// 创建beandefinition
beandefinitionbuilder builder = beandefinitionbuilder.genericbeandefinition(dynamicclass);
builder.setscope(configurablebeanfactory.scope_singleton);
// 注册到spring容器
beanfactory.registerbeandefinition("dynamicservice", builder.getbeandefinition());
// 获取bean并调用
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);