Is there a way to store code as variables in java?

Question

In Java, is there a way to store, edit, convert, print, access, evaluate and compare blocks of code (possibly user entered), while also being able to execute them?

An example for where this would be useful is if someone codes an software that is designed to teach people how to code, where the user would input code to the system, and the program would check if the user developed code is

I'm looking for something like this:

CodeBlock line20And21 = `String x = "hello"; System.out.println(x);`; // stores a block of code
line20And21.replace("ln",""); //edits the block of code
System.out.println(line20And21.toString()); // converts/prints the block of code
CodeBlock usersCode = Scanner.nextCodeBlock(); // accesses block of code
if(! line20And21.wouldThrowError()); // evaluates block of code
    if(line20And21.wouldDoTheSameThingAs(line18And19)) // compares blocks of code
        line20And21.execute(); // executes the block of code

The code I would be using is of course much more complicated than just defining a String and printing it, but I'm sure the idea would be the same. I really appriciate any help with this. Thanks!

Answer 1

Since Java 9, Java includes a shell to evaluate snippets, called JShell. JShell is programatically available via jdk.shell.

First you have to create an instance of the JShell via JShell js = JShell.create().
Evaluating a String as Java code (a so called code Snippet) is done via js.eval("System.out.println(/"Hello World/")");, which returns a list of SnippetEvents you can inspect to find out what effect the execution of the code snippet had.

Since the code is stored as a String, you can edit it as you would edit any String.

Here is an example of JShell taking user inputted code and storing/evaluating it, taken from the official java docs, where code is read as string from stdin and executed:

 import java.io.ByteArrayInputStream;
 import java.io.Console;
 import java.util.List;
 import jdk.jshell.*;
 import jdk.jshell.Snippet.Status;

 class ExampleJShell {
     public static void main(String[] args) {
         Console console = System.console();
         try (JShell js = JShell.create()) {
             do {
                 System.out.print("Enter some Java code: ");
                 String input = console.readLine();
                 if (input == null) {
                     break;
                 }
                 List<SnippetEvent> events = js.eval(input);
                 for (SnippetEvent e : events) {
                     StringBuilder sb = new StringBuilder();
                     if (e.causeSnippet == null) {
                         //  We have a snippet creation event
                         switch (e.status) {
                             case VALID:
                                 sb.append("Successful ");
                                 break;
                             case RECOVERABLE_DEFINED:
                                 sb.append("With unresolved references ");
                                 break;
                             case RECOVERABLE_NOT_DEFINED:
                                 sb.append("Possibly reparable, failed  ");
                                 break;
                             case REJECTED:
                                 sb.append("Failed ");
                                 break;
                         }
                         if (e.previousStatus == Status.NONEXISTENT) {
                             sb.append("addition");
                         } else {
                             sb.append("modification");
                         }
                         sb.append(" of ");
                         sb.append(e.snippet.source());
                         System.out.println(sb);
                         if (e.value != null) {
                             System.out.printf("Value is: %s\n", e.value);
                         }
                         System.out.flush();
                     }
                 }
             } while (true);
         }
         System.out.println("\nGoodbye");
     }
 }

Answer 2

You can do things like this with BeanShell, a Java interpreter written in Java:

import bsh.Interpreter;

class Test {
  public static void main(String[] args) throws Exception {
    String code = "String x = \"hello\"; System.out.println(x);";
    String newCode = code.replace("ln", "");

    System.out.println("Here's the result of running: " +newCode);

    Interpreter p = new Interpreter();
    p.eval(newCode);
  }
}

If compiled and built with the right dependencies, you can evaluate the snippet:

$ javac -cp bsh-2.0b4.jar:. Test.java && java -cp bsh-2.0b4.jar:. Test
Here's the result of running: String x = "hello"; System.out.print(x);
hello$

You can run the code and get its output or return values, or whether it throws an exception. Sandboxing and comparing the output of two snippets is up to you.

Answer 3

Mostly: No.

Java code goes through a compilation step, code needs to be in methods (which need to be in types), and the reasons for this take quite a while to explain. The compiler does not need to be there at runtime (and often isn't).

So, if you really want to do this:

1. Code has to be 'complete', including a package statement, a class declaration, a method, etc.
2. You need to ship the compiler with the app. For javac, that's tricky (GPL); you could ship ecj (eclipse's compiler) which is MIT licensed. It's quite a dep.
3. You can then 'store' code as strings.
4. ecj can then turn this into bytecode for you, but you'll have quite a time managing the classpath properly to make this code compile correctly.
5. You can then dynamically load this bytecode by using a classloader which has a learning curve of a few days all by itself.

In addition, looking at code without executing it to determine if it would throw an exception or not is literally impossible - this is called the halting problem. There exists proof that it is unsolvable. You can't go faster than light. You can't determine from arbitrary code written in a 'turing complete' language (and java is turing complete) if it halts or not (or in this case, if it throws or not).

Similar rules apply to 'would this do the same thing as'.