Java has traditionally been a "heavyweight" language not well suited to quick, hacky scripting. That's changed with some of the features added in the last few releases. This is about scripting in Java - NOT Javascript.

Firstly, Jshell give us an easy way to try out small snippets of Java without ending up with a mass of tiny Test.java files scattered around our projects. Secondly, a neat little feature to compile-and-run those tiny test files if we still want to do that. Finally, the shebang feature, which allows Java to be treated as a first class scripting language by the operating system.

Jshell REPL

Jshell appeared in Java 9, giving Java a REPL (like pretty much every scripting language). Technically, this gave Java another REPL because BeanShell had been around for more than 10 years by then and was doing a pretty good job for those who knew about it (thanks JEdit!)

Anyway, Jshell exists now, is getting (some) support and development from the Oracle/OpenJDK team and gives us our first official way to use Java as a scripting language (ahem, thanks BeanShell).

Within JShell, we can list the history of all the code we've typed so far with /list, edit that code in a proper editor with /edit, and save all that stuff we've typed to a file with /save.

Most importantly, we can further edit that file outside Jshell with our proper editor again, and re-run it all as an input file to the jshell command - causing the contents to be run as if typed into the REPL - i.e. A SCRIPT - woo!

As a quick example, imagine we have a file named list-props.jshell, containing the following

// insert Unix shell style escape codes to make pretty colours
String red(String s) {return "\u001B[31m"+s+"\u001B[0m";}
String green(String s) {return "\u001B[32m"+s+"\u001B[0m";}
System.getProperties().forEach((k,v) -> { 
    System.out.println(red(k.toString())+": "+green(v.toString()));
});
/exit

We can run that with $ jshell list-props.shell to see a lovely multi-coloured display of all the default Java properties with their values for the current box:

arc@arc-pc:~/$ jshell list-props.jshell 
java.specification.version: 15
sun.management.compiler: HotSpot 64-Bit Tiered Compilers
sun.jnu.encoding: UTF-8
...you get the idea...

Compile and Run in one

Running code snippets from files via a REPL is ok, but it's not actually running real code, like a proper class definition and all that. So although Jshell code gives us an easy way to knock out quick examples and tests, it doesn't let us quickly knock together and run proper looking Java code. The next little feature helps speed up Java programs that are just a single (proper) Java source file.

Since Java 11, we've been able to do $ java blah.java to compile and run a single source file in one step. Saving you a whole $ javac blah.java; java blah.class worth of typing (I did say it was a little feature).

Now we can write something that looks like proper Java, with the following file named ListProps.java doing the same thing as our list-props.jshell example above:

public class ListProps {
  public static String red(String s) {return "\u001B[31m"+s+"\u001B[0m";}
  public static String green(String s) {return "\u001B[32m"+s+"\u001B[0m";}

  public static void main(String[] args) {
    System.getProperties().forEach((k,v) -> { 
      System.out.println(red(k.toString())+": "+green(v.toString()));
    });
  }
}

Running this with $ java ListProps.java gives us the same result as before, but it looks more like something we can include in a bigger program once we have it working.

#!/bin/java scripting

So a REPL is very nice for knocking out a line or two to check something.

We can string together a load more lines in a .jshell file to do something neat or prove an idea works.

And that single step compile-and-run trick is helpful for a first pass at classes we can start putting together into our real codebase - especially with that multi-class file trick.

So how about we just do that? Slap in a shebang line as the first thing in the same file as used above

#!/usr/bin/java --source 11
public class ListProps {
  public static String red(String s) {return "\u001B[31m"+s+"\u001B[0m";}
  public static String green(String s) {return "\u001B[32m"+s+"\u001B[0m";}

  public static void main(String[] args) {
    System.getProperties().forEach((k,v) -> { 
      System.out.println(red(k.toString())+": "+green(v.toString()));
    });
  }
}

Name that file anything that doesn't end in .java (to avoid confusing the java command when it sees our new scripting file) - maybe list-props or if you're a real Unix fan, shorten it to lp and expect everyone to just know what it means.

Then $ chmod u+x lp to let the shell know you really want to run it.

Finally, $ ./lp will give you the same glorious technicolour result as before

So in conclusion, I say welcome to Java 11's support for shebang script files - and with it, a place at the "well, it can be used as a scripting language if you really want to" table.

Previous Post