动态编译，自定义类加载器加载成功Demo

记录一个Demo，自定义编译器动态编译脚本成字节数组，再利用自定义类加载器加载进内存，最后反射创建对象。

Main函数

package org.example;

import java.io.IOException;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
import java.net.URISyntaxException;
import java.net.URL;

public class Main {
    public static void main(String[] args) throws IOException, ClassNotFoundException, NoSuchMethodException, InvocationTargetException, IllegalAccessException, URISyntaxException {
        String code = "public class HelloWorld {\n" +
                "    public static void main(String[] args) {\n" +
                "        System.out.println(\"I'm HelloWorld, i created!!!!\");\n" +
                "    }\n" +
                "}";
        byte[] byteCode = JDKCompiler.compile("HelloWorld", code);
        MyClassLoader myClassLoader = new MyClassLoader(
                new URL[]{new URL("file:")}
                , Thread.currentThread().getContextClassLoader());
        myClassLoader.extraClassDefs.put("HelloWorld", byteCode);
        Class<?> clazz = myClassLoader.loadClass("HelloWorld");
        Method method = clazz.getMethod("main", String[].class);
        method.invoke(null, new Object[]{null});
    }
}

自定义编译器

package org.example;

import javax.tools.Diagnostic;
import javax.tools.DiagnosticCollector;
import javax.tools.JavaCompiler;
import javax.tools.JavaFileManager;
import javax.tools.JavaFileObject;
import javax.tools.ToolProvider;
import java.util.Collections;

public class JDKCompiler {
    public static byte[] compile(String className, String source) {
        //1. 获取 `JavaCompiler` 实例
        JavaCompiler compiler = ToolProvider.getSystemJavaCompiler();
        //信息收集器
        DiagnosticCollector<JavaFileObject> collector = new DiagnosticCollector<>();
        //文件管理器，管理编译好后的文件
        JavaFileManager javaFileManager =
                new TmpJavaFileManager(compiler.getStandardFileManager(collector, null, null));
        // 把源码字符串构造成JavaFileObject，供编译使用
        JavaFileObject sourceJavaFileObject = new TmpJavaFileObject(className, source);
        //开始编译
        Boolean result = compiler.getTask(null, javaFileManager, collector,
                null, null, Collections.singletonList(sourceJavaFileObject)).call();
        //得到编译好后的JavaFileObject
        JavaFileObject bytesJavaFileObject = TmpJavaFileManager.fileObjectMap.get(className);
        if (result && bytesJavaFileObject != null) {
            return ((TmpJavaFileObject) bytesJavaFileObject).getCompiledBytes();
        } else {
            System.out.println("Compilation failed.");
            for (Diagnostic<? extends JavaFileObject> diagnostic : collector.getDiagnostics()) {
                System.out.println(diagnostic.getMessage(null));
            }
        }
        return null;
    }
}

自定义文件管理器

package org.example;

import javax.tools.FileObject;
import javax.tools.ForwardingJavaFileManager;
import javax.tools.JavaFileManager;
import javax.tools.JavaFileObject;
import java.io.IOException;
import java.util.Map;
import java.util.concurrent.ConcurrentHashMap;

public class TmpJavaFileManager extends ForwardingJavaFileManager<JavaFileManager> {
    public static Map<String, JavaFileObject> fileObjectMap = new ConcurrentHashMap<>();
    protected TmpJavaFileManager(JavaFileManager fileManager) {
        super(fileManager);
    }

    @Override
    public JavaFileObject getJavaFileForInput(JavaFileManager.Location location,
                                              String className,
                                              JavaFileObject.Kind kind) throws IOException {
        JavaFileObject javaFileObject = fileObjectMap.get(className);
        if (javaFileObject == null) {
            return super.getJavaFileForInput(location, className, kind);
        }
        return javaFileObject;
    }

    //编译好后返回编译好的对象为一个javafileObejct返回
    @Override
    public JavaFileObject getJavaFileForOutput(JavaFileManager.Location location,
                                               String className,
                                               JavaFileObject.Kind kind,
                                               FileObject sibling) throws IOException {
        JavaFileObject javaFileObject = null;
        javaFileObject = new TmpJavaFileObject(className, kind);
        fileObjectMap.put(className, javaFileObject);
        return javaFileObject;
    }
}

自定义JavaFileObject

package org.example;

import javax.tools.SimpleJavaFileObject;
import java.io.ByteArrayOutputStream;
import java.io.OutputStream;
import java.net.URI;

public class TmpJavaFileObject extends SimpleJavaFileObject {
    private String source;
    private ByteArrayOutputStream outputStream;

    /**
     * 构造用来存储源代码的JavaFileObject
     * 需要传入源码source，然后调用父类的构造方法创建kind = Kind.SOURCE的JavaFileObject对象，供我们自己创建源代码FileObject调用
     */
    public TmpJavaFileObject(String name, String source) {
        super(URI.create(name + Kind.SOURCE.extension), Kind.SOURCE);
        this.source = source;
    }

    /**
     * 构造用来存储字节码的JavaFileObject
     * 需要传入kind，即我们想要构建一个存储什么类型文件的JavaFileObject,供编译完后写入调用
     */
    public TmpJavaFileObject(String name, Kind kind) {
        super(URI.create(name + Kind.SOURCE.extension), kind);
        this.source = null;
    }

    //调用获取源码字符串
    @Override
    public CharSequence getCharContent(boolean ignoreEncodingErrors) {
        if (source == null) {
            throw new IllegalArgumentException("source == null");
        }
        return source;
    }
    //调用写入本类持有的ByteArrayOutputStream，这里是写入本javaFile层面的
    @Override
    public OutputStream openOutputStream(){
        outputStream = new ByteArrayOutputStream();
        return outputStream;
    }

    //获取编译好后的字节数组
    public byte[] getCompiledBytes() {
        return outputStream.toByteArray();
    }
}

自定义类加载器

package org.example;

import java.net.URL;
import java.net.URLClassLoader;
import java.net.URLStreamHandlerFactory;
import java.util.HashMap;
import java.util.Map;

public class MyClassLoader extends URLClassLoader {
    public Map<String, byte[]> extraClassDefs = new HashMap<>();
    public MyClassLoader(URL[] urls, ClassLoader parent) {
        super(urls, parent);
    }

    public MyClassLoader(URL[] urls) {
        super(urls);
    }

    public MyClassLoader(URL[] urls, ClassLoader parent, URLStreamHandlerFactory factory) {
        super(urls, parent, factory);
    }

    @Override
    protected synchronized Class<?> findClass(String qualifiedClassName)
            throws ClassNotFoundException {
        byte[] classBytes = this.extraClassDefs.remove(qualifiedClassName);
        if (classBytes != null) {
            return defineClass(qualifiedClassName, classBytes, 0, classBytes.length);
        }
        return Thread.currentThread().getContextClassLoader().loadClass(qualifiedClassName);
    }
}

自定义类加载器的时候，可以增加一个缓存，在findClass方法中，可以做如下改写：

1. 第一步看缓存有没有这个类，如果有就不用在此加载器加载。
2. 其次再通过defineClass构建类。
3. 如果构建失败，调用super.loadClass()。
4. 最后调用当前线程的上下文类加载器即可。（线程上下文加载器默认是程序类加载器，而程序类加载器继承于UrlClassLoader，因此可以通过把线程上下文类加载器强转成UrlClassLoader，再调用getUrls()方法获取该加载器的加载路径。）