java实现动态编译并动态加载

最新推荐文章于 2024-08-10 20:17:39 发布

Leonarde_WP

最新推荐文章于 2024-08-10 20:17:39 发布

阅读量491

点赞数

原文链接：https://blog.csdn.net/zhoufanyang_china/article/details/82767406

版权

例：（如果发生异常ClassNotFoundException: com.sun.tools.javac.processing.JavacProcessingEnvironment；是jre里面没有tools的jar包，本地可以引入jar包 compile files(org.gradle.internal.jvm.Jvm.current().toolsJar)）或者换一个版本的jdk

package test;

import javax.tools.*;
import java.io.ByteArrayOutputStream;
import java.io.IOException;
import java.io.OutputStream;
import java.io.Writer;
import java.net.URI;
import java.nio.charset.StandardCharsets;
import java.util.Arrays;
import java.util.Set;
import java.util.concurrent.ConcurrentSkipListSet;

public class DynamicTest {
    private final Writer out;
    private final JavaFileManager fileManager;
    private final DiagnosticListener<? super JavaFileObject> diagnosticListener;
    private final Iterable<String> options;
    private final Iterable<String> classes;
    private final Iterable<? extends JavaFileObject> compilationUnits;
    private final static JavaCompiler COMPILER = ToolProvider.getSystemJavaCompiler();

    public DynamicTest(Writer out, JavaFileManager fileManager, DiagnosticListener<? super JavaFileObject> diagnosticListener, Iterable<String> options, Iterable<String> classes, Iterable<? extends JavaFileObject> compilationUnits) {
        this.out = out;
        this.fileManager = fileManager;
        this.diagnosticListener = diagnosticListener;
        this.options = options;
        this.classes = classes;
        this.compilationUnits = compilationUnits;
    }

    public boolean compile() {
        JavaCompiler.CompilationTask task = COMPILER.getTask(out, fileManager, diagnosticListener, options, classes, compilationUnits);
        // 同步调用
        return task.call();
    }

    public static void main(String[] args) throws IOException {
        //我们文件路径
//        String path = "C:\\CalledClass.java";
//        String content = readContext(path);
        String content = "package test;\n" +
                "\n" +
                "public class CalledClass {\n" +
                "    public static void main(String args[]) {\n" +
                "        TestParam param = new TestParam();\n" +
                "        param.setId(1L);\n" +
                "        param.setName(\"wp\");\n" +
                "        System.out.println(\"wp This is in another java file\" + param.getName() + param.getId());\n" +
                "    }\n" +
                "}";
        // 自定义 JavaFileManager 方便自定义输入和输出
        MyJavaFileManager myJavaFileManager = new MyJavaFileManager(COMPILER.getStandardFileManager(null, null, StandardCharsets.UTF_8));
        DynamicTest dynamicTest = new DynamicTest(null
                , myJavaFileManager
                , System.out::println, null, null, Arrays.asList(new StringJavaFileObject(content, "CalledClass")));
        boolean b = dynamicTest.compile();
        myJavaFileManager.getByteArrayJavaFileObjects().forEach(b1 -> {
            try {
                ByteArrayOutputStream o = (ByteArrayOutputStream) b1.openOutputStream();
                // 获取字节码
                byte[] classByteArray = o.toByteArray();
                // 加载对象
                ClassLoader loader = new ClassLoader(Thread.currentThread().getContextClassLoader()) {
                    @Override
                    protected Class<?> findClass(String name) throws ClassNotFoundException {
                        return defineClass(name, classByteArray, 0, classByteArray.length);
                    }
                };
                Class<?> clazz = loader.loadClass("test.CalledClass");
                Class.forName("test.CalledClass", true, loader).getDeclaredMethod("main", new Class[]{String[].class}).invoke(null, new Object[]{null});
            } catch (IOException e) {
                e.printStackTrace();
            } catch (ReflectiveOperationException e) {
                e.printStackTrace();
            }
        });
        System.out.println(b ? "成功" : "失败");
    }

//    private static String readContext(String path) throws IOException {
//        byte[] bytes = Files.readAllBytes(Paths.get(path));
//        return new String(bytes);
//    }

    //输入对象
    static class StringJavaFileObject extends SimpleJavaFileObject {

        private String content;

        /**
         * Construct a SimpleJavaFileObject of the given kind and with the
         * given URI.
         */
        public StringJavaFileObject(String content, String className) {
            super(URI.create("string:///" + className.replace(".", "/") + ".java"), Kind.SOURCE);
            this.content = content;
        }

        @Override
        public CharSequence getCharContent(boolean ignoreEncodingErrors) throws IOException {
            return content;
        }
    }

    // 输出对象
    static class ByteArrayJavaFileObject extends SimpleJavaFileObject {

        /**
         * Construct a SimpleJavaFileObject of the given kind and with the
         * given URI.
         */
        private final ByteArrayOutputStream outputStream = new ByteArrayOutputStream();

        public ByteArrayJavaFileObject(String name) {
            super(URI.create("bytes:///" + name.replace(".", "/") + ".class"), Kind.CLASS);
        }

        @Override
        public OutputStream openOutputStream() throws IOException {
            return outputStream;
        }
    }

    static class MyJavaFileManager extends ForwardingJavaFileManager<JavaFileManager> {
        // 就是一个装饰着模式  ForwardingJavaFileManager

        /**
         * Creates a new instance of ForwardingJavaFileManager.
         *
         * @param fileManager delegate to this file manager
         */
        public MyJavaFileManager(JavaFileManager fileManager) {
            super(fileManager);
        }

        private final Set<ByteArrayJavaFileObject> byteArrayJavaFileObjects = new ConcurrentSkipListSet();

        public Set<ByteArrayJavaFileObject> getByteArrayJavaFileObjects() {
            return byteArrayJavaFileObjects;
        }

        // 有字节码的输出的时候 我们自定义一个JavaFileObject 来接受输出了
        @Override
        public JavaFileObject getJavaFileForOutput(Location location, String className, JavaFileObject.Kind kind, FileObject sibling) throws IOException {
            if (JavaFileObject.Kind.CLASS == kind) {
                ByteArrayJavaFileObject byteArrayJavaFileObject = new ByteArrayJavaFileObject(className);
                byteArrayJavaFileObjects.add(byteArrayJavaFileObject);
                return byteArrayJavaFileObject;
            } else {
                return super.getJavaFileForOutput(location, className, kind, sibling);
            }
        }
    }
}

package test;

import lombok.Data;

@Data
public class TestParam {

    private Long id;

    private String name;

}

在D盘test目录下有个java文件：AlTest.java

 
public class AlTest {
 
	public String sayHello(){
		System.out.println("AlTest类 sayHello()方法正在执行....");
		return "hello word";
	}
}

现需要实现在工程已经运行过程中，进行java文件到class文件的编译操作，并运行AlTest类的方法

package com.piao.job;
 
import java.lang.reflect.Method;
import javax.tools.JavaCompiler;
import javax.tools.ToolProvider;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Configurable;
import org.springframework.scheduling.annotation.EnableScheduling;
import org.springframework.scheduling.annotation.Scheduled;
import org.springframework.stereotype.Component;
 
@Component
@Configurable
@EnableScheduling
public class CompilerJob {
 
  private static final Logger logger = LoggerFactory.getLogger(CompilerJob.class);
 
  private static boolean isExecute = false;
 
  /**
   * 任务：job test
   */
  @Scheduled(cron = "*/10 * * * * * ")
  public void test2() {
    try {
       if (isExecute) {
         return;
       }
       isExecute = true;		//只是测试，所以只执行一次
			
	   complierAndRun();
	} catch (Exception e) {
	   logger.error("test", e);
	}
  }
	
 public void complierAndRun(){
   try {
			
	 System.out.println(System.getProperty("user.dir"));
	 //动态编译
	 JavaCompiler javac = ToolProvider.getSystemJavaCompiler();
	 int status = javac.run(null, null, null, "-d", System.getProperty("user.dir")+"\\target\\classes","D:/test/AlTest.java");
	 if(status!=0){
		 System.out.println("没有编译成功！");
	 }
			
	 //动态执行
	 Class clz = Class.forName("AlTest");//返回与带有给定字符串名的类 或接口相关联的 Class 对象。
	 Object o = clz.newInstance();
	 Method method = clz.getDeclaredMethod("sayHello");//返回一个 Method 对象，该对象反映此 Class 对象所表示的类或接口的指定已声明方法
	 String result= (String)method.invoke(o);//静态方法第一个参数可为null,第二个参数为实际传参
	 System.out.println(result);
	 } catch (Exception e) {
		 logger.error("test", e);
	 }
  }
}

运行结果：

E:\zhoufy\small\piao-admin
AlTest类 sayHello()方法正在执行....
hello word

其中代码：

int status = javac.run(null, null, null, "-d", System.getProperty("user.dir")+"\\target\\classes","D:/test/AlTest.java");

把class文件生成到了当前工程目录下的classes目录（E:\zhoufy\small\piao-admin\target\classess）所以classloader是可以加载到的，如果想知道是哪个类加载器：

Class clz = Class.forName("AlTest");//返回与带有给定字符串名的类 或接口相关联的 Class 对象。
Object o = clz.newInstance();
System.out.println(clz.getClassLoader().getSystemClassLoader());

打印的是： sun.misc.Launcher$AppClassLoader@4e0e2f2a 说明使用的是AppClassLoader

当然也可以生成到Bootstrap ClassLoader可加载的目录下

//生成到工程classes下
//int status = javac.run(null, null, null, "-d", System.getProperty("user.dir")+"\\target\\classes","D:/test/AlTest.java");

//生成到BootStrap ClassLoader可加载目录下
int status = javac.run(null, null, null, "-d", "C:\\Program Files\\Java\\jdk1.8.0_65\\jre\\classes","D:/test/AlTest.java");

当然也可以自定义类加载器，把文件生成在指定的外部目录：

public void complierAndRun(){
		try {
			
			System.out.println(System.getProperty("user.dir"));
			 //动态编译
			JavaCompiler javac = ToolProvider.getSystemJavaCompiler();
			int status = javac.run(null, null, null, "-d", "D:\\","D:/test/AlTest.java");
			if(status!=0){
				System.out.println("没有编译成功！");
			}
			
			//动态执行
			//Class clz = Class.forName("AlTest");//返回与带有给定字符串名的类 或接口相关联的 Class 对象。
			//自定义类加载器的加载路径
			MyClassLoader myClassLoader = new MyClassLoader("D:\\");
			//包名+类名
			Class clz = myClassLoader.loadClass("AlTest");
			Object o = clz.newInstance();
			Method method = clz.getDeclaredMethod("sayHello");//返回一个 Method 对象，该对象反映此 Class 对象所表示的类或接口的指定已声明方法
			String result= (String)method.invoke(o);//静态方法第一个参数可为null,第二个参数为实际传参
			System.out.println(result);
		} catch (Exception e) {
			logger.error("test", e);
		}
	}

————————————————
版权声明：本文为CSDN博主「扬帆舟」的原创文章，遵循CC 4.0 BY-SA版权协议，转载请附上原文出处链接及本声明。
原文链接：https://blog.csdn.net/zhoufanyang_china/article/details/82767406