fork(2) download
copy 
  1. /* package whatever; // don't place package name! */
  2.  
  3. import javax.tools.*;
  4. import java.io.ByteArrayOutputStream;
  5. import java.io.IOException;
  6. import java.io.OutputStream;
  7. import java.lang.reflect.InvocationTargetException;
  8. import java.net.URI;
  9. import java.security.SecureClassLoader;
  10. import java.util.ArrayList;
  11. import java.util.List;
  12. import java.io.PrintWriter;
  13. import java.io.StringWriter;
  14. //import org.slf4j.Logger;
  15. //import org.slf4j.LoggerFactory;
  16.  
  17. class Ideone
  18. {
  19. 	// private static final Logger logger = LoggerFactory.getLogger(Main.class);
  20.  
  21. 	public static void main (String[] args) throws java.lang.Exception
  22. 	{
  23.         try {
  24.             StringWriter writer = new StringWriter();
  25.             PrintWriter out = new PrintWriter(writer);
  26.             out.println("package com.mycompany.scripts;");
  27.             out.println("");
  28.             out.println("public class HelloWorld {");
  29.             out.println("  public static void main(String args[]) {");
  30.             out.println("    System.out.println(\"This is in another java file\");");
  31.             out.println("  }");
  32.             out.println("}");
  33.             out.close();
  34.  
  35.             // Full name of the class that will be compiled.
  36.             // If class should be in some package,
  37.             // fullName should contain it too
  38.             // (ex. "testpackage.DynaClass")
  39.             String fullName = "com.mycompany.scripts.HelloWorld";
  40.  
  41.             // Here we get and specify the source code of the class to be compiled
  42.             String src = writer.toString();
  43.  
  44.             DynamicCompiler uCompiler = new DynamicCompiler(fullName, src);
  45.             uCompiler.compile();
  46.             uCompiler.run();
  47.  
  48.         } catch (Exception e) {
  49.         	// logger.error("Exception:", e);
  50.             System.out.print("Exception");
  51.         }
  52. 	}
  53. }
  54.  
  55. // Based on: http://j...content-available-to-author-only...t.cz/2011/06/dynamic-in-memory-compilation-using.html
  56. class DynamicCompiler {
  57.     private JavaFileManager fileManager;
  58.     private String fullName;
  59.     private String sourceCode;
  60.  
  61.     public DynamicCompiler(String fullName, String srcCode) {
  62.         this.fullName = fullName;
  63.         this.sourceCode = srcCode;
  64.         this.fileManager = initFileManager();
  65.     }
  66.  
  67.     public JavaFileManager initFileManager() {
  68.         if (fileManager != null)
  69.             return fileManager;
  70.         else {
  71.             JavaCompiler compiler = ToolProvider.getSystemJavaCompiler();
  72.             fileManager = new
  73.                     ClassFileManager(compiler
  74.                     .getStandardFileManager(null, null, null));
  75.             return fileManager;
  76.         }
  77.     }
  78.  
  79.     public void compile() {
  80.         // We get an instance of JavaCompiler. Then
  81.         // we create a file manager
  82.         // (our custom implementation of it)
  83.         JavaCompiler compiler = ToolProvider.getSystemJavaCompiler();
  84.  
  85.         // Dynamic compiling requires specifying
  86.         // a list of "files" to compile. In our case
  87.         // this is a list containing one "file" which is in our case
  88.         // our own implementation (see details below)
  89.         List<JavaFileObject> files = new ArrayList<>();
  90.         files.add(new CharSequenceJavaFileObject(fullName, sourceCode));
  91.  
  92.         // We specify a task to the compiler. Compiler should use our file
  93.         // manager and our list of "files".
  94.         // Then we run the compilation with call()
  95.         compiler.getTask(
  96.                 null,
  97.                 fileManager,
  98.                 null,
  99.                 null,
  100.                 null,
  101.                 files
  102.         ).call();
  103.     }
  104.  
  105.     public void run() throws InstantiationException, IllegalAccessException, ClassNotFoundException {
  106.         // Creating an instance of our compiled class and
  107.         // running its toString() method
  108.         try {
  109.             fileManager
  110.                     .getClassLoader(null)
  111.                     .loadClass(fullName)
  112.                     .getDeclaredMethod("main", new Class[]{String[].class})
  113.                     .invoke(null, new Object[]{null});
  114.         } catch (InvocationTargetException e) {
  115.             //logger.error("InvocationTargetException:", e);
  116.             System.out.print("InvocationTargetException");
  117.         } catch (NoSuchMethodException e) {
  118.             //logger.error("NoSuchMethodException:", e);
  119.             System.out.print("NoSuchMethodException");
  120.         }
  121.     }
  122.  
  123.     public class CharSequenceJavaFileObject extends SimpleJavaFileObject {
  124.  
  125.         /**
  126.          * CharSequence representing the source code to be compiled
  127.          */
  128.         private CharSequence content;
  129.  
  130.         /**
  131.          * This constructor will store the source code in the
  132.          * internal "content" variable and register it as a
  133.          * source code, using a URI containing the class full name
  134.          *
  135.          * @param className name of the public class in the source code
  136.          * @param content source code to compile
  137.          */
  138.         public CharSequenceJavaFileObject(String className, CharSequence content) {
  139.             super(URI.create("string:///" + className.replace('.', '/') + Kind.SOURCE.extension), Kind.SOURCE);
  140.             this.content = content;
  141.         }
  142.  
  143.         public CharSequence getCharContent(boolean ignoreEncodingErrors) {
  144.             return content;
  145.         }
  146.     }
  147.  
  148.     public class ClassFileManager extends ForwardingJavaFileManager {
  149.         private JavaClassObject javaClassObject;
  150.  
  151.         public ClassFileManager(StandardJavaFileManager standardManager) {
  152.             super(standardManager);
  153.         }
  154.  
  155.         /**
  156.          * Will be used by us to get the class loader for our
  157.          * compiled class. It creates an anonymous class
  158.          * extending the SecureClassLoader which uses the
  159.          * byte code created by the compiler and stored in
  160.          * the JavaClassObject, and returns the Class for it
  161.          */
  162.         @Override
  163.         public ClassLoader getClassLoader(Location location) {
  164.             return new SecureClassLoader() {
  165.                 @Override
  166.                 protected Class<?> findClass(String name) throws ClassNotFoundException {
  167.                     byte[] b = javaClassObject.getBytes();
  168.                     return super.defineClass(name, javaClassObject.getBytes(), 0, b.length);
  169.                 }
  170.             };
  171.         }
  172.  
  173.         public JavaFileObject getJavaFileForOutput(Location location, String className, JavaFileObject.Kind kind, FileObject sibling) throws IOException {
  174.             this.javaClassObject = new JavaClassObject(className, kind);
  175.             return this.javaClassObject;
  176.         }
  177.     }
  178.  
  179.     public class JavaClassObject extends SimpleJavaFileObject {
  180.         /**
  181.          * Byte code created by the compiler will be stored in this
  182.          * ByteArrayOutputStream so that we can later get the
  183.          * byte array out of it
  184.          * and put it in the memory as an instance of our class.
  185.          */
  186.         protected final ByteArrayOutputStream bos =
  187.                 new ByteArrayOutputStream();
  188.  
  189.         /**
  190.          * Registers the compiled class object under URI
  191.          * containing the class full name
  192.          *
  193.          * @param name
  194.          *            Full name of the compiled class
  195.          * @param kind
  196.          *            Kind of the data. It will be CLASS in our case
  197.          */
  198.         public JavaClassObject(String name, Kind kind) {
  199.             super(URI.create("string:///" + name.replace('.', '/')
  200.                     + kind.extension), kind);
  201.         }
  202.  
  203.         /**
  204.          * Will be used by our file manager to get the byte code that
  205.          * can be put into memory to instantiate our class
  206.          *
  207.          * @return compiled byte code
  208.          */
  209.         public byte[] getBytes() {
  210.             return bos.toByteArray();
  211.         }
  212.  
  213.         /**
  214.          * Will provide the compiler with an output stream that leads
  215.          * to our byte array. This way the compiler will write everything
  216.          * into the byte array that we will instantiate later
  217.          */
  218.         @Override
  219.         public OutputStream openOutputStream() throws IOException {
  220.             return bos;
  221.         }
  222.     }
  223. }
Success #stdin #stdout 0.38s 714752KB
comments (?)
stdin
copy 
Standard input is empty
stdout
copy 
This is in another java file
https://ideone.com/cu1GhE
language:
Java (HotSpot 12)
created:
7 years ago
visibility:
public

Share or Embed source code

Discover > Sphere Engine API

The brand new service which powers Ideone!

Discover > IDE Widget

Widget for compiling and running the source code in a web browser!